Merge branch 'master' into stm32f1

Author: franeklubi

.travis.yml

@@ -1,6 +1,8 @@
 language: rust
 matrix:
   include:
+    - rust: nightly
+      env: FEATURES='stm32f107'
     - rust: nightly
       env: FEATURES='stm32f407'
     - rust: nightly
@@ -39,6 +41,6 @@ matrix:
       env: FEATURES='stm32f778'
     - rust: nightly
       env: FEATURES='stm32f779'
-      
+
 script:
   - "cargo build --target=`uname -m`-unknown-linux-gnu --no-default-features --features \"$FEATURES\""

Cargo.toml

@@ -15,28 +15,27 @@ travis-ci = { repository = "astro/stm32-eth", branch = "master" }
 maintenance = { status = "experimental" }
 
 [package.metadata.docs.rs]
-features = [ "smoltcp-phy", "stm32f429" ]
+features = [ "smi", "smoltcp-phy", "stm32f429", "smoltcp/socket-tcp" ]
 
 [dependencies]
 volatile-register = "0.2.1"
 aligned = "0.4.0"
-stm32f1xx-hal = { version = "0.9.0", optional = true }
-stm32f7xx-hal = { version = "0.6.0", optional = true }
+stm32f7xx-hal = { git = "https://github.com/stm32-rs/stm32f7xx-hal", rev = "7099b07", optional = true }
 stm32f4xx-hal = { version = "0.12.0", optional = true }
+stm32f1xx-hal = { version = "0.9.0", optional = true }
 cortex-m = "0.7.4"
 log = { version = "0.4.14", optional = true }
 
 [dependencies.smoltcp]
 version = "0.8.0"
-# git = "https://github.com/smoltcp-rs/smoltcp"
-# branch = "master"
 default-features = false
 features = ["medium-ethernet", "proto-ipv4"]
 optional = true
 
 [features]
 device-selected = []
 fence = []
+smi = []
 
 stm32f107 = ["stm32f1xx-hal/stm32f107", "device-selected"]
 
@@ -65,15 +64,13 @@ smoltcp-phy = ["smoltcp"]
 cortex-m = "0.7.4"
 cortex-m-rt = "0.7.1"
 panic-itm = "0.4.2"
-panic-rtt-target = { version = "0.1.2", features = ["cortex-m"] }
-rtt-target = { version = "0.3.1", features = ["cortex-m"] }
 cortex-m-semihosting = "0.3.7"
+stm32f4xx-hal = { version = "0.12.0", features = ["rt"] }
 stm32f1xx-hal = { version = "0.9.0", features = ["rt"] }
-#stm32f4xx-hal = {version = "0.8.3", features = ["rt"] }
 
 [[example]]
 name = "pktgen"
-required-features = ["stm32f429"]
+required-features = ["smi", "stm32f429"]
 
 [[example]]
 name = "ip"
@@ -85,6 +82,13 @@ required-features = [
 [[example]]
 name = "ip-f107"
 required-features = ["stm32f107", "smoltcp-phy", "log", "smoltcp/socket-tcp"]
+[[example]]
+name = "arp"
+required-features = ["stm32f407", "smi"]
+
+[[example]]
+name = "arp-smoltcp"
+required-features = ["stm32f407", "smi", "smoltcp-phy", "smoltcp/socket-icmp"]
 
 [profile.release]
 debug = 2

README.md

@@ -22,14 +22,14 @@ cargo build --example="ip-f107" --features="stm32f107 smoltcp-phy log smoltcp/so
 Add to the `[dependencies]` section in your `Cargo.toml`:
 
 ```rust
-stm32f4xx-hal = { version = "0.8.3", features = ["stm32f429"] }
+stm32f4xx-hal = { version = "0.10.1", features = ["stm32f429"] }
 stm32-eth = { version = "0.2.0", features = ["stm32f429"] }
 ```
 
 or
 
 ```rust
-stm32f7xx-hal = { version = "0.2.0", features = ["stm32f767"] }
+stm32f7xx-hal = { version = "0.6.0", features = ["stm32f767"] }
 stm32-eth = { version = "0.2.0", features = ["stm32f767"]}
 ```
 
@@ -76,7 +76,6 @@ fn main() {
         p.ETHERNET_DMA,
         &mut rx_ring[..],
         &mut tx_ring[..],
-        PhyAddress::_0,
         clocks,
         eth_pins,
     )

examples/arp-smoltcp.rs

@@ -0,0 +1,189 @@
+// cargo build --example arp-smoltcp --features=stm32f407,smi,smoltcp-phy,smoltcp/socket-tcp,smoltcp/socket-icmp
+// This example uses the STM32F407 and the KSZ8051R as PHY. If necessary the pins,
+// the PHY register addresses and masks have to be adapted, as well as the IPs.
+// With Wireshark, you can see the ARP packets, which should look like this:
+// No.  Time        Source          Destination     Protocol    Length  Info
+// 1	0.000000000	Cetia_ad:be:ef	Broadcast	    ARP	        60	    Who has 10.0.0.2? Tell 10.0.0.10
+
+#![no_std]
+#![no_main]
+
+extern crate panic_itm;
+
+use core::cell::RefCell;
+use core::default::Default;
+use cortex_m_rt::{entry, exception};
+
+use cortex_m::asm;
+use cortex_m::interrupt::Mutex;
+use stm32_eth::{
+    hal::gpio::{GpioExt, Speed},
+    hal::rcc::RccExt,
+    hal::time::U32Ext,
+    smi,
+    stm32::{interrupt, CorePeripherals, Peripherals, SYST},
+};
+
+use cortex_m_semihosting::hprintln;
+
+use smoltcp::wire::{
+    ArpOperation, ArpPacket, ArpRepr, EthernetAddress, EthernetFrame, EthernetProtocol,
+    EthernetRepr, Ipv4Address,
+};
+use stm32_eth::{Eth, EthPins, RingEntry, TxError};
+
+const PHY_REG_BSR: u8 = 0x01;
+const PHY_REG_BSR_UP: u16 = 1 << 2;
+
+const PHY_ADDR: u8 = 0;
+
+static TIME: Mutex<RefCell<usize>> = Mutex::new(RefCell::new(0));
+static ETH_PENDING: Mutex<RefCell<bool>> = Mutex::new(RefCell::new(false));
+
+#[entry]
+fn main() -> ! {
+    let p = Peripherals::take().unwrap();
+    let mut cp = CorePeripherals::take().unwrap();
+
+    let rcc = p.RCC.constrain();
+    // HCLK must be at least 25MHz to use the ethernet peripheral
+    let clocks = rcc.cfgr.sysclk(32.mhz()).hclk(32.mhz()).freeze();
+
+    setup_systick(&mut cp.SYST);
+
+    hprintln!("Enabling ethernet...").unwrap();
+    let gpioa = p.GPIOA.split();
+    let gpiob = p.GPIOB.split();
+    let gpioc = p.GPIOC.split();
+    let gpiog = p.GPIOG.split();
+
+    let eth_pins = EthPins {
+        ref_clk: gpioa.pa1,
+        crs: gpioa.pa7,
+        tx_en: gpiob.pb11,
+        tx_d0: gpiog.pg13,
+        tx_d1: gpiog.pg14,
+        rx_d0: gpioc.pc4,
+        rx_d1: gpioc.pc5,
+    };
+
+    let mut mdio = gpioa.pa2.into_alternate().set_speed(Speed::VeryHigh);
+    let mut mdc = gpioc.pc1.into_alternate().set_speed(Speed::VeryHigh);
+
+    // ETH_PHY_RESET(RST#) PB2 Chip Reset (active-low)
+    let _eth_reset = gpiob.pb2.into_push_pull_output().set_high();
+
+    let mut rx_ring: [RingEntry<_>; 16] = Default::default();
+    let mut tx_ring: [RingEntry<_>; 8] = Default::default();
+    let mut eth = Eth::new(
+        p.ETHERNET_MAC,
+        p.ETHERNET_DMA,
+        &mut rx_ring[..],
+        &mut tx_ring[..],
+        clocks,
+        eth_pins,
+    )
+    .unwrap();
+    eth.enable_interrupt();
+
+    let mut last_link_up = false;
+
+    loop {
+        let link_up = link_detected(eth.smi(&mut mdio, &mut mdc));
+
+        if link_up != last_link_up {
+            if link_up {
+                hprintln!("Ethernet: link detected").unwrap();
+            } else {
+                hprintln!("Ethernet: no link detected").unwrap();
+            }
+            last_link_up = link_up;
+        }
+
+        if link_up {
+            const SIZE: usize = 14 + 28; // ETH + ARP
+
+            let src_mac = EthernetAddress::from_bytes(&[0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]);
+
+            let arp_buffer = [0; 28];
+            let mut packet =
+                ArpPacket::new_checked(arp_buffer).expect("ArpPacket: buffer size is not correct");
+            let arp = ArpRepr::EthernetIpv4 {
+                operation: ArpOperation::Request,
+                source_hardware_addr: src_mac,
+                source_protocol_addr: Ipv4Address::new(10, 0, 0, 10),
+                target_hardware_addr: EthernetAddress::from_bytes(&[0x00; 6]),
+                target_protocol_addr: Ipv4Address::new(10, 0, 0, 2),
+            };
+            arp.emit(&mut packet);
+
+            let eth_buffer = [0; SIZE]; // ETH + ARP
+            let mut frame = EthernetFrame::new_checked(eth_buffer)
+                .expect("EthernetFrame: buffer size is not correct");
+            let header = EthernetRepr {
+                src_addr: src_mac,
+                dst_addr: EthernetAddress::BROADCAST,
+                ethertype: EthernetProtocol::Arp,
+            };
+            header.emit(&mut frame);
+            frame.payload_mut().copy_from_slice(&packet.into_inner());
+
+            let r = eth.send(SIZE, |buf| {
+                buf[0..SIZE].copy_from_slice(&frame.into_inner());
+            });
+
+            match r {
+                Ok(()) => {
+                    hprintln!("ARP-smoltcp sent").unwrap();
+                }
+                Err(TxError::WouldBlock) => hprintln!("ARP failed").unwrap(),
+            }
+        } else {
+            hprintln!("Down").unwrap();
+        }
+
+        cortex_m::interrupt::free(|cs| {
+            let mut eth_pending = ETH_PENDING.borrow(cs).borrow_mut();
+            *eth_pending = false;
+
+            if !*eth_pending {
+                asm::wfi();
+            }
+        });
+    }
+}
+
+fn setup_systick(syst: &mut SYST) {
+    syst.set_reload(100 * SYST::get_ticks_per_10ms());
+    syst.enable_counter();
+    syst.enable_interrupt();
+}
+
+#[exception]
+fn SysTick() {
+    cortex_m::interrupt::free(|cs| {
+        let mut time = TIME.borrow(cs).borrow_mut();
+        *time += 1;
+    })
+}
+
+#[interrupt]
+fn ETH() {
+    cortex_m::interrupt::free(|cs| {
+        let mut eth_pending = ETH_PENDING.borrow(cs).borrow_mut();
+        *eth_pending = true;
+    });
+
+    // Clear interrupt flags
+    let p = unsafe { Peripherals::steal() };
+    stm32_eth::eth_interrupt_handler(&p.ETHERNET_DMA);
+}
+
+fn link_detected<Mdio, Mdc>(smi: smi::Smi<Mdio, Mdc>) -> bool
+where
+    Mdio: smi::MdioPin,
+    Mdc: smi::MdcPin,
+{
+    let status = smi.read(PHY_ADDR, PHY_REG_BSR);
+    (status & PHY_REG_BSR_UP) == PHY_REG_BSR_UP
+}