Merge pull request #68 from stm32-rs/ptp-pps

datdenkikniet · web-flow · commit b0131e7b6582 · 2023-01-31T13:59:06.000+01:00
Ptp pps
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -132,6 +132,8 @@ jobs:
             features: ""
           - example: rtic-echo
             features: smoltcp-phy
+          - example: rtic-timestamp
+            features: ""
         mcu:
           - stm32f107
           - stm32f429
@@ -143,19 +145,23 @@ jobs:
         pins:
           - nucleo
           - default
+        pps:
+          - default
+          - alternate
+
     steps:
       - name: Checkout
         uses: actions/checkout@v3
 
-      - name: Install Rust ${{ matrix.toolchain }} with target (${{ matrix.target }}) and pins ${{ matrix.pins }}
+      - name: Install Rust ${{ matrix.toolchain }} with target (${{ matrix.target }})
         run: |
           rustup set profile minimal
           rustup override set ${{ matrix.toolchain }}
           rustup target add ${{ matrix.target }}
 
-      - name: Build example ${{ matrix.example.example }} for ${{ matrix.mcu }}
+      - name: Build example ${{ matrix.example.example }} for ${{ matrix.mcu }}, eth pins ${{ matrix.pins }}, pps pin ${{ matrix.pps }}
         run: |
-          STM32_ETH_EXAMPLE_PINS=${{ matrix.pins }} cargo build --release --target=${{ matrix.target }} --example ${{ matrix.example.example}} --features ${{ matrix.mcu }},${{ matrix.example.features }}
+          STM32_ETH_EXAMPLE_PPS=${{ matrix.pps }} STM32_ETH_EXAMPLE_PINS=${{ matrix.pins }} cargo build --release --target=${{ matrix.target }} --example ${{ matrix.example.example}} --features ${{ matrix.mcu }},${{ matrix.example.features }}
 
   # Refs: https://github.com/rust-lang/crater/blob/9ab6f9697c901c4a44025cf0a39b73ad5b37d198/.github/workflows/bors.yml#L125-L149
   #
diff --git a/README.md b/README.md
@@ -98,12 +98,14 @@ The examples should run and compile on any MCU that has an 802.3 compatible PHY
 
 The examples use `defmt` and `defmt_rtt` for logging, and `panic_probe` over `defmt_rtt` for printing panic backtraces.
 
-##### Alternative pin configuration & HSE
+##### Alternative pin configuration, HSE & PPS
 
 If the board you're developing for has a High Speed External oscillator connected to the correct pins, the HSE configuration can be activated by setting the `STM32_ETH_EXAMPLE_HSE` environment variable to one of `oscillator` or `bypass` when compiling.
 
 If the board you're developing for uses the nucleo pinout (PG11 and PG13 instead of PB11 and PB12), the pin configuration can be changed by setting the `STM32_ETH_EXAMPLE_PINS` environment variable to `nucleo` when compiling.
 
+If you wish to use the alternative PPS output pin (PG8 instead of PB5) for the `rtic-timestamp` example, the pin configuration can be changed by setting the `STM32_ETH_EXAMPLE_PPS_PIN` environment variable to `alternate` when compiling.
+
 ### Building examples
 To build an example, run the following command:
 ```bash
diff --git a/build.rs b/build.rs
@@ -24,6 +24,17 @@ fn main() {
         }
     }
 
+    let pps_pin = std::env::var("STM32_ETH_EXAMPLE_PPS_PIN");
+
+    if let Ok(pps_pin) = pps_pin {
+        if pps_pin == "alternate" {
+            println!("cargo:rustc-cfg=pps=\"alternate\"")
+        } else if pps_pin != "default" {
+            panic!("Invalid STM32_ETH_EXAMPLE_PPS_PIN value. Allowed values: alternate, default");
+        }
+    }
+
+    println!("cargo:rerun-if-env-changed=STM32_ETH_EXAMPLE_PPS_PIN");
     println!("cargo:rerun-if-env-changed=STM32_ETH_EXAMPLE_HSE");
     println!("cargo:rerun-if-env-changed=STM32_ETH_EXAMPLE_PINS");
 }
diff --git a/examples/arp.rs b/examples/arp.rs
@@ -41,7 +41,7 @@ fn main() -> ! {
 
     defmt::info!("Enabling ethernet...");
 
-    let (eth_pins, mdio, mdc) = common::setup_pins(gpio);
+    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();
diff --git a/examples/common.rs b/examples/common.rs
@@ -133,12 +133,19 @@ mod pins {
     pub type Mdio = PA2<Alternate<11>>;
     pub type Mdc = PC1<Alternate<11>>;
 
+    #[cfg(not(pps = "alternate"))]
+    pub type Pps = PB5<Output<PushPull>>;
+
+    #[cfg(pps = "alternate")]
+    pub type Pps = PG8<Output<PushPull>>;
+
     pub fn setup_pins(
         gpio: Gpio,
     ) -> (
         EthPins<RefClk, Crs, TxEn, TxD0, TxD1, RxD0, RxD1>,
         Mdio,
         Mdc,
+        Pps,
     ) {
         #[allow(unused_variables)]
         let Gpio {
@@ -183,6 +190,11 @@ mod pins {
             gpioc.pc1.into_alternate().set_speed(Speed::VeryHigh),
         );
 
+        #[cfg(not(pps = "alternate"))]
+        let pps = gpiob.pb5.into_push_pull_output();
+        #[cfg(pps = "alternate")]
+        let pps = gpiog.pg8.into_push_pull_output();
+
         (
             EthPins {
                 ref_clk,
@@ -195,6 +207,7 @@ mod pins {
             },
             mdio,
             mdc,
+            pps,
         )
     }
 }
@@ -223,12 +236,15 @@ mod pins {
     pub type Mdio = PA2<Alternate<PushPull>>;
     pub type Mdc = PC1<Alternate<PushPull>>;
 
+    pub type Pps = PB5<Output<PushPull>>;
+
     pub fn setup_pins(
         gpio: Gpio,
     ) -> (
         EthPins<RefClk, Crs, TxEn, TxD0, TxD1, RxD0, RxD1>,
         Mdio,
         Mdc,
+        Pps,
     ) {
         let Gpio {
             mut gpioa,
@@ -248,6 +264,8 @@ mod pins {
         let tx_d0 = gpiob.pb12.into_alternate_push_pull(&mut gpiob.crh);
         let tx_d1 = gpiob.pb13.into_alternate_push_pull(&mut gpiob.crh);
 
+        let pps = gpiob.pb5.into_push_pull_output(&mut gpiob.crl);
+
         let pins = EthPins {
             ref_clk,
             crs,
@@ -258,7 +276,7 @@ mod pins {
             rx_d1,
         };
 
-        (pins, mdio, mdc)
+        (pins, mdio, mdc, pps)
     }
 }
 
diff --git a/examples/ip.rs b/examples/ip.rs
@@ -43,7 +43,7 @@ fn main() -> ! {
 
     defmt::info!("Enabling ethernet...");
 
-    let (eth_pins, _mdio, _mdc) = common::setup_pins(gpio);
+    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();
diff --git a/examples/pktgen.rs b/examples/pktgen.rs
@@ -40,7 +40,7 @@ fn main() -> ! {
     setup_systick(&mut cp.SYST);
 
     defmt::info!("Enabling ethernet...");
-    let (eth_pins, mdio, mdc) = common::setup_pins(gpio);
+    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();
diff --git a/examples/rtic-echo.rs b/examples/rtic-echo.rs
@@ -78,7 +78,7 @@ mod app {
         let mono = Systick::new(core.SYST, clocks.hclk().raw());
 
         defmt::info!("Setting up pins");
-        let (pins, mdio, mdc) = crate::common::setup_pins(gpio);
+        let (pins, mdio, mdc, _) = crate::common::setup_pins(gpio);
 
         defmt::info!("Configuring ethernet");
 
diff --git a/examples/rtic-timestamp.rs b/examples/rtic-timestamp.rs
@@ -79,13 +79,15 @@ mod app {
         let mono = Systick::new(core.SYST, clocks.hclk().raw());
 
         defmt::info!("Setting up pins");
-        let (pins, mdio, mdc) = crate::common::setup_pins(gpio);
+        let (pins, mdio, mdc, pps) = crate::common::setup_pins(gpio);
 
         defmt::info!("Configuring ethernet");
 
-        let Parts { dma, mac, ptp } =
+        let Parts { dma, mac, mut ptp } =
             stm32_eth::new_with_mii(ethernet, rx_ring, tx_ring, clocks, pins, mdio, mdc).unwrap();
 
+        ptp.enable_pps(pps);
+
         defmt::info!("Enabling interrupts");
         dma.enable_interrupt();
 
diff --git a/src/ptp/mod.rs b/src/ptp/mod.rs
@@ -10,6 +10,9 @@ pub use timestamp::Timestamp;
 mod subseconds;
 pub use subseconds::{Subseconds, NANOS_PER_SECOND, SUBSECONDS_PER_SECOND, SUBSECONDS_TO_SECONDS};
 
+mod pps_pin;
+pub use pps_pin::PPSPin;
+
 /// Access to the IEEE 1508v2 PTP peripheral present on the ethernet peripheral.
 ///
 /// On STM32FXXX's, the PTP peripheral has/uses the following important parts:
@@ -191,6 +194,14 @@ impl EthernetPTP {
             }
         }
     }
+
+    /// Enable the PPS output on the provided pin.
+    pub fn enable_pps<P>(&mut self, pin: P) -> P::Output
+    where
+        P: PPSPin,
+    {
+        pin.enable()
+    }
 }
 
 /// Setting and configuring target time interrupts on the STM32F107 does not
@@ -230,6 +241,22 @@ impl EthernetPTP {
         }
         is_tsint
     }
+
+    /// Configure the PPS output frequency.
+    ///
+    /// The PPS output frequency becomes `2 ^ pps_freq`. `pps_freq` is
+    /// clamped to `[0..31]`.
+    pub fn set_pps_freq(&mut self, pps_freq: u8) {
+        let pps_freq = pps_freq.max(31);
+
+        // SAFETY: we atomically write to the PTPPPSCR register, which is
+        // not read or written to anywhere else. The SVD files are incorrectly
+        // saying that the bits in this register are read-only.
+        unsafe {
+            let ptpppscr = self.eth_ptp.ptpppscr.as_ptr() as *mut u32;
+            core::ptr::write_volatile(ptpppscr, pps_freq as u32);
+        }
+    }
 }
 
 #[cfg(all(test, not(target_os = "none")))]
diff --git a/src/ptp/pps_pin.rs b/src/ptp/pps_pin.rs
@@ -0,0 +1,65 @@
+/// Pins that can be used as PPS output
+///
+/// SAFETY: only pins that are capable of being a PPS output according
+/// to the datasheets of respective parts may implement this trait.
+pub unsafe trait PPSPin {
+    /// The output type of this pin, in which it acts as a PPS output.
+    type Output;
+
+    /// Enable the PPS output.
+    fn enable(self) -> Self::Output;
+}
+
+#[allow(unused_macros)]
+macro_rules! impl_pps_pin {
+    ($([$name:ty, $output:ty]),*) => {
+        $(
+            unsafe impl super::PPSPin for $name {
+                type Output = $output;
+
+                fn enable(self) -> Self::Output {
+                    self.into_alternate()
+                }
+            }
+        )*
+    };
+}
+
+#[cfg(feature = "stm32f4xx-hal")]
+mod impl_pps_pin {
+    use crate::hal::gpio::{Alternate, Output, PushPull, PB5, PG8};
+
+    impl_pps_pin!([PG8<Output<PushPull>>, PG8<Alternate<11>>], [PB5<Output<PushPull>>, PB5<Alternate<11>>]);
+}
+
+#[cfg(feature = "stm32f7xx-hal")]
+mod impl_pps_pin {
+    use crate::hal::gpio::{Alternate, Output, PushPull, PB5, PG8};
+
+    impl_pps_pin!([PG8<Output<PushPull>>, PG8<Alternate<11>>], [PB5<Output<PushPull>>, PB5<Alternate<11>>]);
+}
+
+#[cfg(feature = "stm32f1xx-hal")]
+mod impl_pps_pin {
+    use crate::hal::gpio::{Alternate, Output, PushPull, PB5};
+
+    unsafe impl super::PPSPin for PB5<Output<PushPull>> {
+        type Output = PB5<Alternate<PushPull>>;
+
+        fn enable(self) -> Self::Output {
+            // Within this critical section, modifying the `CRL` register can
+            // only be unsound if this critical section preempts other code
+            // that is modifying the same register
+            cortex_m::interrupt::free(|_| {
+                // SAFETY: this is sound as long as the API of the HAL and structure of the CRL
+                // struct does not change. In case the size of the `CRL` struct is changed, compilation
+                // will fail as `mem::transmute` can only convert between types of the same size.
+                //
+                // This guards us from unsound behaviour introduced by point releases of the f1 hal
+                let cr: &mut _ = &mut unsafe { core::mem::transmute(()) };
+                // The speed can only be changed on output pins
+                self.into_alternate_push_pull(cr)
+            })
+        }
+    }
+}
diff --git a/src/setup.rs b/src/setup.rs
@@ -305,10 +305,7 @@ macro_rules! impl_pins {
     };
 }
 
-#[cfg(all(
-    feature = "device-selected",
-    any(feature = "stm32f4xx-hal", feature = "stm32f7xx-hal")
-))]
+#[cfg(any(feature = "stm32f4xx-hal", feature = "stm32f7xx-hal"))]
 impl_pins!(
     RmiiRefClk: [
         PA1<Input>,

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,17 @@ fn main() {`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
	`27`	`+ let pps_pin = std::env::var("STM32_ETH_EXAMPLE_PPS_PIN");`
	`28`	`+`
	`29`	`+ if let Ok(pps_pin) = pps_pin {`
	`30`	`+ if pps_pin == "alternate" {`
	`31`	`+ println!("cargo:rustc-cfg=pps=\"alternate\"")`
	`32`	`+ } else if pps_pin != "default" {`
	`33`	`+ panic!("Invalid STM32_ETH_EXAMPLE_PPS_PIN value. Allowed values: alternate, default");`
	`34`	`+ }`
	`35`	`+ }`
	`36`	`+`
	`37`	`+ println!("cargo:rerun-if-env-changed=STM32_ETH_EXAMPLE_PPS_PIN");`
`27`	`38`	`println!("cargo:rerun-if-env-changed=STM32_ETH_EXAMPLE_HSE");`
`28`	`39`	`println!("cargo:rerun-if-env-changed=STM32_ETH_EXAMPLE_PINS");`
`29`	`40`	`}`