Add target time configuration with atomic accesses to MACIMR register

Author: datdenkikniet

Cargo.toml

@@ -25,7 +25,7 @@ stm32f7xx-hal = { version = "0.7.0", optional = true }
 stm32f4xx-hal = { version = "0.14", optional = true }
 stm32f4 = { version = "0.15", optional = true }
 stm32f1xx-hal = { version = "0.10", optional = true }
-ieee802_3_miim = "0.7"
+ieee802_3_miim = "0.8"
 cortex-m = "0.7"
 log = { version = "0.4", optional = true }
 defmt = { version = "0.3", optional = true }

examples/common.rs

@@ -312,15 +312,19 @@ impl<M: Miim> EthernetPhy<M> {
     ///
     /// Returns an error if the PHY does not support the extended register
     /// set, or if the PHY's identifier does not correspond to a known PHY.
-    pub fn from_miim(miim: M, phy_addr: u8) -> Result<Self, ()> {
+    pub fn from_miim(miim: M, phy_addr: u8) -> Result<Self, M> {
         let mut bare = BarePhy::new(miim, phy_addr, Pause::NoPause);
-        let phy_ident = bare.phy_ident().ok_or(())?;
+        let phy_ident = if let Some(id) = bare.phy_ident() {
+            id.raw_u32()
+        } else {
+            return Err(bare.release());
+        };
         let miim = bare.release();
         match phy_ident & 0xFFFFFFF0 {
             0x0007C0F0 => Ok(Self::LAN8720A(LAN8720A::new(miim, phy_addr))),
             0x0007C130 => Ok(Self::LAN8742A(LAN8742A::new(miim, phy_addr))),
             0x00221560 => Ok(Self::KSZ8081R(KSZ8081R::new(miim, phy_addr))),
-            _ => Err(()),
+            _ => Err(miim),
         }
     }
 
@@ -352,4 +356,13 @@ impl<M: Miim> EthernetPhy<M> {
             EthernetPhy::KSZ8081R(phy) => phy.link_speed(),
         }
     }
+
+    #[allow(dead_code)]
+    pub fn release(self) -> M {
+        match self {
+            EthernetPhy::LAN8720A(phy) => phy.release(),
+            EthernetPhy::LAN8742A(phy) => phy.release(),
+            EthernetPhy::KSZ8081R(phy) => phy.release(),
+        }
+    }
 }

examples/rtic-timestamp.rs

@@ -45,7 +45,7 @@ mod app {
     use stm32_eth::{
         dma::{EthernetDMA, PacketId, RxRingEntry, TxRingEntry},
         mac::Speed,
-        ptp::{EthernetPTP, Timestamp},
+        ptp::{EthernetPTP, Subseconds, Timestamp},
         Parts,
     };
 
@@ -57,6 +57,7 @@ mod app {
         dma: EthernetDMA<'static, 'static>,
         ptp: EthernetPTP,
         tx_id: Option<(u32, Timestamp)>,
+        scheduled_time: Option<Timestamp>,
     }
 
     #[monotonic(binds = SysTick, default = true)]
@@ -88,57 +89,74 @@ mod app {
         defmt::info!("Enabling interrupts");
         dma.enable_interrupt();
 
-        if let Ok(mut phy) = EthernetPhy::from_miim(mac, 0) {
-            defmt::info!(
-                "Resetting PHY as an extra step. Type: {}",
-                phy.ident_string()
-            );
+        match EthernetPhy::from_miim(mac, 0) {
+            Ok(mut phy) => {
+                defmt::info!(
+                    "Resetting PHY as an extra step. Type: {}",
+                    phy.ident_string()
+                );
 
-            phy.phy_init();
+                phy.phy_init();
 
-            defmt::info!("Waiting for link up.");
+                defmt::info!("Waiting for link up.");
 
-            while !phy.phy_link_up() {}
+                while !phy.phy_link_up() {}
 
-            defmt::info!("Link up.");
+                defmt::info!("Link up.");
 
-            if let Some(speed) = phy.speed().map(|s| match s {
-                PhySpeed::HalfDuplexBase10T => Speed::HalfDuplexBase10T,
-                PhySpeed::FullDuplexBase10T => Speed::FullDuplexBase10T,
-                PhySpeed::HalfDuplexBase100Tx => Speed::HalfDuplexBase100Tx,
-                PhySpeed::FullDuplexBase100Tx => Speed::FullDuplexBase100Tx,
-            }) {
-                phy.get_miim().set_speed(speed);
-                defmt::info!("Detected link speed: {}", speed);
-            } else {
-                defmt::warn!("Failed to detect link speed.");
+                if let Some(speed) = phy.speed().map(|s| match s {
+                    PhySpeed::HalfDuplexBase10T => Speed::HalfDuplexBase10T,
+                    PhySpeed::FullDuplexBase10T => Speed::FullDuplexBase10T,
+                    PhySpeed::HalfDuplexBase100Tx => Speed::HalfDuplexBase100Tx,
+                    PhySpeed::FullDuplexBase100Tx => Speed::FullDuplexBase100Tx,
+                }) {
+                    phy.get_miim().set_speed(speed);
+                    defmt::info!("Detected link speed: {}", speed);
+                } else {
+                    defmt::warn!("Failed to detect link speed.");
+                }
+            }
+            Err(_) => {
+                defmt::info!("Not resetting unsupported PHY. Cannot detect link speed.");
             }
-        } else {
-            defmt::info!("Not resetting unsupported PHY. Cannot detect link speed.");
-        }
+        };
 
         sender::spawn().ok();
 
         (
             Shared {
                 dma,
                 tx_id: None,
+                scheduled_time: None,
                 ptp,
             },
             Local {},
             init::Monotonics(mono),
         )
     }
 
-    #[task(shared = [dma, tx_id, ptp], local = [tx_id_ctr: u32 = 0x8000_0000])]
-    fn sender(mut cx: sender::Context) {
+    #[task(shared = [dma, tx_id, ptp, scheduled_time], local = [tx_id_ctr: u32 = 0x8000_0000])]
+    fn sender(cx: sender::Context) {
         sender::spawn_after(1u64.secs()).ok();
 
         const SIZE: usize = 42;
 
         // Obtain the current time to use as the "TX time" of our frame. It is clearly
         // incorrect, but works well enough in low-activity systems (such as this example).
-        let now = cx.shared.ptp.lock(|ptp| ptp.get_time());
+        let now = (cx.shared.ptp, cx.shared.scheduled_time).lock(|ptp, sched_time| {
+            let now = ptp.get_time();
+            let in_half_sec = now
+                + Timestamp::new(
+                    false,
+                    0,
+                    Subseconds::new_from_nanos(500_000_000).unwrap().raw(),
+                )
+                .unwrap();
+            ptp.configure_target_time_interrupt(in_half_sec);
+            *sched_time = Some(now);
+
+            now
+        });
 
         const DST_MAC: [u8; 6] = [0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56];
         const SRC_MAC: [u8; 6] = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
@@ -162,77 +180,94 @@ mod app {
         });
     }
 
-    #[task(binds = ETH, shared = [dma, tx_id, ptp], priority = 2)]
+    #[task(binds = ETH, shared = [dma, tx_id, ptp, scheduled_time], priority = 2)]
     fn eth_interrupt(cx: eth_interrupt::Context) {
-        (cx.shared.dma, cx.shared.tx_id, cx.shared.ptp).lock(|dma, tx_id, ptp| {
-            dma.interrupt_handler();
+        (
+            cx.shared.dma,
+            cx.shared.tx_id,
+            cx.shared.ptp,
+            cx.shared.scheduled_time,
+        )
+            .lock(|dma, tx_id, ptp, sched_time| {
+                dma.interrupt_handler();
+
+                if ptp.interrupt_handler() {
+                    if let Some(sched_time) = sched_time.take() {
+                        let now = ptp.get_time();
+                        defmt::info!(
+                            "Got a timestamp interrupt {} seconds after scheduling",
+                            now - sched_time
+                        );
+                    }
+                }
 
-            let mut packet_id = 0;
+                let mut packet_id = 0;
 
-            while let Ok(packet) = dma.recv_next(Some(packet_id.into())) {
-                let mut dst_mac = [0u8; 6];
-                dst_mac.copy_from_slice(&packet[..6]);
+                while let Ok(packet) = dma.recv_next(Some(packet_id.into())) {
+                    let mut dst_mac = [0u8; 6];
+                    dst_mac.copy_from_slice(&packet[..6]);
 
-                // Note that, instead of grabbing the timestamp from the `RxPacket` directly, it
-                // is also possible to retrieve a cached version of the timestamp using
-                // `EthernetDMA::get_timestamp_for_id` (in the same way as for TX timestamps).
-                let ts = if let Some(timestamp) = packet.timestamp() {
-                    timestamp
-                } else {
-                    continue;
-                };
+                    // Note that, instead of grabbing the timestamp from the `RxPacket` directly, it
+                    // is also possible to retrieve a cached version of the timestamp using
+                    // `EthernetDMA::get_timestamp_for_id` (in the same way as for TX timestamps).
+                    let ts = if let Some(timestamp) = packet.timestamp() {
+                        timestamp
+                    } else {
+                        continue;
+                    };
 
-                let timestamp = if dst_mac == [0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56] {
-                    let mut timestamp_data = [0u8; 8];
-                    timestamp_data.copy_from_slice(&packet[14..22]);
-                    let raw = i64::from_be_bytes(timestamp_data);
+                    defmt::debug!("RX timestamp: {}", ts);
 
-                    let timestamp = Timestamp::new_raw(raw);
-                    timestamp
-                } else {
-                    continue;
-                };
+                    let timestamp = if dst_mac == [0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56] {
+                        let mut timestamp_data = [0u8; 8];
+                        timestamp_data.copy_from_slice(&packet[14..22]);
+                        let raw = i64::from_be_bytes(timestamp_data);
 
-                defmt::debug!("RX timestamp: {}", ts);
-                defmt::debug!("Contained TX timestamp: {}", ts);
+                        let timestamp = Timestamp::new_raw(raw);
+                        timestamp
+                    } else {
+                        continue;
+                    };
+
+                    defmt::debug!("Contained TX timestamp: {}", ts);
 
-                let diff = timestamp - ts;
+                    let diff = timestamp - ts;
 
-                defmt::info!("Difference between TX and RX time: {}", diff);
+                    defmt::info!("Difference between TX and RX time: {}", diff);
 
-                let addend = ptp.addend();
-                let nanos = diff.nanos() as u64;
+                    let addend = ptp.addend();
+                    let nanos = diff.nanos() as u64;
 
-                if nanos <= 20_000 {
-                    let p1 = ((nanos * addend as u64) / 1_000_000_000) as u32;
+                    if nanos <= 20_000 {
+                        let p1 = ((nanos * addend as u64) / 1_000_000_000) as u32;
 
-                    defmt::debug!("Addend correction value: {}", p1);
+                        defmt::debug!("Addend correction value: {}", p1);
 
-                    if diff.is_negative() {
-                        ptp.set_addend(addend - p1 / 2);
+                        if diff.is_negative() {
+                            ptp.set_addend(addend - p1 / 2);
+                        } else {
+                            ptp.set_addend(addend + p1 / 2);
+                        };
                     } else {
-                        ptp.set_addend(addend + p1 / 2);
-                    };
-                } else {
-                    defmt::warn!("Updated time.");
-                    ptp.update_time(diff);
-                }
+                        defmt::warn!("Updated time.");
+                        ptp.update_time(diff);
+                    }
 
-                packet_id += 1;
-                packet_id &= !0x8000_0000;
-            }
+                    packet_id += 1;
+                    packet_id &= !0x8000_0000;
+                }
 
-            if let Some((tx_id, sent_time)) = tx_id.take() {
-                if let Ok(ts) = dma.get_timestamp_for_id(PacketId(tx_id)) {
-                    defmt::info!("TX timestamp: {}", ts);
-                    defmt::debug!(
+                if let Some((tx_id, sent_time)) = tx_id.take() {
+                    if let Ok(ts) = dma.get_timestamp_for_id(PacketId(tx_id)) {
+                        defmt::info!("TX timestamp: {}", ts);
+                        defmt::debug!(
                         "Diff between TX timestamp and the time that was put into the packet: {}",
                         ts - sent_time
                     );
-                } else {
-                    defmt::warn!("Failed to retrieve TX timestamp");
+                    } else {
+                        defmt::warn!("Failed to retrieve TX timestamp");
+                    }
                 }
-            }
-        });
+            });
     }
 }

src/lib.rs

@@ -101,15 +101,15 @@ where
 
     let eth_mac = parts.mac.into();
 
-    // Configure the ethernet PTP
-    #[cfg(feature = "ptp")]
-    let ptp = EthernetPTP::new(&eth_mac, parts.ptp.into(), clocks);
-
     // Congfigure and start up the ethernet DMA.
     let dma = EthernetDMA::new(parts.dma.into(), rx_buffer, tx_buffer);
 
+    // Configure the ethernet PTP
+    #[cfg(feature = "ptp")]
+    let ptp = EthernetPTP::new(&eth_mac, parts.ptp.into(), clocks, &dma);
+
     // Configure the ethernet MAC
-    let mac = EthernetMAC::new(eth_mac, parts.mmc, clocks, Speed::FullDuplexBase100Tx)?;
+    let mac = EthernetMAC::new(eth_mac, parts.mmc, clocks, Speed::FullDuplexBase100Tx, &dma)?;
 
     let parts = Parts {
         mac,
@@ -170,15 +170,15 @@ where
 
     let eth_mac = parts.mac.into();
 
-    // Configure the ethernet PTP
-    #[cfg(feature = "ptp")]
-    let ptp = EthernetPTP::new(&eth_mac, parts.ptp.into(), clocks);
-
     // Congfigure and start up the ethernet DMA.
     let dma = EthernetDMA::new(parts.dma.into(), rx_buffer, tx_buffer);
 
+    // Configure the ethernet PTP
+    #[cfg(feature = "ptp")]
+    let ptp = EthernetPTP::new(&eth_mac, parts.ptp.into(), clocks, &dma);
+
     // Configure the ethernet MAC
-    let mac = EthernetMAC::new(eth_mac, parts.mmc, clocks, Speed::FullDuplexBase100Tx)?
+    let mac = EthernetMAC::new(eth_mac, parts.mmc, clocks, Speed::FullDuplexBase100Tx, &dma)?
         .with_mii(mdio, mdc);
 
     let parts = Parts {