stm32/eth: Permanently register netif with lwip during startup.

pi-anl · pi-anl · commit cb3833e900b3 · 2025-07-18T08:18:38.000+10:00
This restructures LWIP initialization and removes blocking PHY loops
to support static IP configuration before active(True) and eliminate
timeouts when starting without cable.

Changes:
- Split netif init into eth_netif_init_early() and eth_lwip_init()
- Initialize netif structure in eth_init() for early IP config
- Move netif stack registration to eth_start()
- Remove blocking PHY autonegotiation loop from eth_mac_init()
- Add eth_phy_configure_autoneg() for non-blocking setup
- Add eth_phy_link_status_poll() for link state management
- Only start DHCP if no static IP configured (0.0.0.0)
- Use default MAC speed/duplex config until autoneg completes

Benefits:
- Static IP can be configured before active(True)
- active(True) succeeds immediately without cable
- No more 10-second timeout on startup
- Link detection works properly when cable plugged later

Signed-off-by: Andrew Leech &lt;andrew.leech@planetinnovation.com.au&gt;
diff --git a/ports/stm32/eth.c b/ports/stm32/eth.c
@@ -129,6 +129,9 @@ eth_t eth_instance;
 
 static void eth_mac_deinit(eth_t *self);
 static void eth_process_frame(eth_t *self, size_t len, const uint8_t *buf);
+static void eth_netif_init_early(eth_t *self);
+static void eth_phy_link_status_poll(eth_t *self);
+static void eth_phy_configure_autoneg(eth_t *self);
 
 void eth_phy_write(uint32_t phy_addr, uint32_t reg, uint32_t val) {
     #if defined(STM32H5) || defined(STM32H7)
@@ -223,6 +226,10 @@ int eth_init(eth_t *self, int mac_idx, uint32_t phy_addr, int phy_type) {
     #else
     __HAL_RCC_ETH_CLK_ENABLE();
     #endif
+
+    // Initialize netif structure early so static IP can be configured before active(True)
+    eth_netif_init_early(self);
+
     return 0;
 }
 
@@ -253,6 +260,7 @@ static int eth_mac_init(eth_t *self) {
     #if defined(STM32H5)
     __HAL_RCC_SBS_CLK_ENABLE();
     SBS->PMCR = (SBS->PMCR & ~SBS_PMCR_ETH_SEL_PHY_Msk) | SBS_PMCR_ETH_SEL_PHY_2;
+    HAL_SBS_ETHInterfaceSelect(SBS_ETH_RMII);
     #elif defined(STM32H7)
     SYSCFG->PMCR = (SYSCFG->PMCR & ~SYSCFG_PMCR_EPIS_SEL_Msk) | SYSCFG_PMCR_EPIS_SEL_2;
     #else
@@ -262,22 +270,10 @@ static int eth_mac_init(eth_t *self) {
 
     #if defined(STM32H5)
     __HAL_RCC_ETH_RELEASE_RESET();
-
-    __HAL_RCC_ETH_CLK_SLEEP_ENABLE();
-    __HAL_RCC_ETHTX_CLK_SLEEP_ENABLE();
-    __HAL_RCC_ETHRX_CLK_SLEEP_ENABLE();
     #elif defined(STM32H7)
     __HAL_RCC_ETH1MAC_RELEASE_RESET();
-
-    __HAL_RCC_ETH1MAC_CLK_SLEEP_ENABLE();
-    __HAL_RCC_ETH1TX_CLK_SLEEP_ENABLE();
-    __HAL_RCC_ETH1RX_CLK_SLEEP_ENABLE();
     #else
     __HAL_RCC_ETHMAC_RELEASE_RESET();
-
-    __HAL_RCC_ETHMAC_CLK_SLEEP_ENABLE();
-    __HAL_RCC_ETHMACTX_CLK_SLEEP_ENABLE();
-    __HAL_RCC_ETHMACRX_CLK_SLEEP_ENABLE();
     #endif
 
     // Do a soft reset of the MAC core
@@ -353,57 +349,30 @@ static int eth_mac_init(eth_t *self) {
     ETH->DMACCR &= ~(ETH_DMACCR_DSL_Msk);
     #endif
 
-    // Reset the PHY
+    // Reset the PHY and wait for reset to complete
     eth_phy_write(self->phy_addr, PHY_BCR, PHY_BCR_SOFT_RESET);
     mp_hal_delay_ms(50);
 
-    // Wait for the PHY link to be established
-    int phy_state = 0;
+    // Wait for PHY reset to complete (but don't wait for link)
     t0 = mp_hal_ticks_ms();
-    while (phy_state != 3) {
-        if (mp_hal_ticks_ms() - t0 > PHY_INIT_TIMEOUT_MS) {
+    while (eth_phy_read(self->phy_addr, PHY_BCR) & PHY_BCR_SOFT_RESET) {
+        if (mp_hal_ticks_ms() - t0 > 1000) {  // 1 second timeout for reset
             eth_mac_deinit(self);
             return -MP_ETIMEDOUT;
         }
-        uint16_t bcr = eth_phy_read(self->phy_addr, PHY_BCR);
-        uint16_t bsr = eth_phy_read(self->phy_addr, PHY_BSR);
-        switch (phy_state) {
-            case 0:
-                if (!(bcr & PHY_BCR_SOFT_RESET)) {
-                    phy_state = 1;
-                }
-                break;
-            case 1:
-                if (bsr & PHY_BSR_LINK_STATUS) {
-                    // Announce all modes
-                    eth_phy_write(self->phy_addr, PHY_ANAR,
-                        PHY_ANAR_SPEED_10HALF |
-                        PHY_ANAR_SPEED_10FULL |
-                        PHY_ANAR_SPEED_100HALF |
-                        PHY_ANAR_SPEED_100FULL |
-                        PHY_ANAR_IEEE802_3);
-                    // Start autonegotiate.
-                    eth_phy_write(self->phy_addr, PHY_BCR, PHY_BCR_AUTONEG_EN);
-                    phy_state = 2;
-                }
-                break;
-            case 2:
-                if ((bsr & (PHY_BSR_AUTONEG_DONE | PHY_BSR_LINK_STATUS))
-                    == (PHY_BSR_AUTONEG_DONE | PHY_BSR_LINK_STATUS)) {
-                    phy_state = 3;
-                }
-                break;
-        }
         mp_hal_delay_ms(2);
     }
 
-    // Get register with link status
-    uint16_t phy_scsr = self->phy_get_link_status(self->phy_addr);
-
-    // Initialize link status tracking
+    // Initialize link status tracking (current state, whatever it is)
     uint16_t bsr = eth_phy_read(self->phy_addr, PHY_BSR);
     self->last_link_status = (bsr & PHY_BSR_LINK_STATUS) != 0;
 
+    // Configure autonegotiation if link is already up, otherwise it will be
+    // configured when link comes up via the polling function
+    if (self->last_link_status) {
+        eth_phy_configure_autoneg(self);
+    }
+
     // Enable PHY link change interrupts (for future use if PHY interrupt pin available)
     eth_phy_enable_link_interrupts(self->phy_addr);
 
@@ -512,13 +481,9 @@ static int eth_mac_init(eth_t *self) {
     ETH->MACA0LR = mac[3] << 24 | mac[2] << 16 | mac[1] << 8 | mac[0];
     mp_hal_delay_ms(2);
 
-    // Set main MAC control register
-    ETH->MACCR =
-        phy_scsr == PHY_SPEED_10FULL ? ETH_MACCR_DM
-        : phy_scsr == PHY_SPEED_100HALF ? ETH_MACCR_FES
-        : phy_scsr == PHY_SPEED_100FULL ? (ETH_MACCR_FES | ETH_MACCR_DM)
-        : 0
-    ;
+    // Set main MAC control register with default configuration
+    // The PHY speed/duplex will be auto-detected and updated via autonegotiation
+    ETH->MACCR = ETH_MACCR_FES | ETH_MACCR_DM;  // Default: 100Mbps, Full Duplex
     mp_hal_delay_ms(2);
 
     // Start MAC layer
@@ -730,29 +695,7 @@ void ETH_IRQHandler(void) {
     static uint32_t link_check_counter = 0;
     if (++link_check_counter >= 100) { // Check every ~100 RX interrupts
         link_check_counter = 0;
-
-        // Read current PHY link status
-        uint16_t bsr = eth_phy_read(eth_instance.phy_addr, PHY_BSR);
-        bool current_link_status = (bsr & PHY_BSR_LINK_STATUS) != 0;
-
-        // Check if link status changed
-        if (current_link_status != eth_instance.last_link_status) {
-            eth_instance.last_link_status = current_link_status;
-
-            // Update LWIP netif link status to reflect physical cable connection
-            struct netif *netif = &eth_instance.netif;
-            if (current_link_status) {
-                // Cable is physically connected
-                netif_set_link_up(netif);
-                // Restart DHCP if interface is up and DHCP is enabled
-                if (netif_is_up(netif) && netif_dhcp_data(netif)) {
-                    dhcp_renew(netif);
-                }
-            } else {
-                // Cable is physically disconnected
-                netif_set_link_down(netif);
-            }
-        }
+        eth_phy_link_status_poll(&eth_instance);
     }
 }
 
@@ -815,39 +758,127 @@ static err_t eth_netif_init(struct netif *netif) {
     return ERR_OK;
 }
 
-static void eth_lwip_init(eth_t *self) {
+static void eth_netif_init_early(eth_t *self) {
+    // Initialize netif structure but don't add to network stack yet
+    struct netif *n = &self->netif;
+    n->name[0] = 'e';
+    n->name[1] = '0';
+    n->state = self;
+
+    // Set default IP configuration (0.0.0.0 = use DHCP)
     ip_addr_t ipconfig[4];
-    IP4_ADDR(&ipconfig[0], 0, 0, 0, 0);
-    IP4_ADDR(&ipconfig[2], 192, 168, 0, 1);
-    IP4_ADDR(&ipconfig[1], 255, 255, 255, 0);
-    IP4_ADDR(&ipconfig[3], 8, 8, 8, 8);
+    IP_ADDR4(&ipconfig[0], 0, 0, 0, 0);        // IP: 0.0.0.0 (DHCP)
+    IP_ADDR4(&ipconfig[1], 255, 255, 255, 0);  // Netmask
+    IP_ADDR4(&ipconfig[2], 192, 168, 0, 1);    // Gateway
+    IP_ADDR4(&ipconfig[3], 8, 8, 8, 8);        // DNS
+
+    netif_set_addr(n, ip_2_ip4(&ipconfig[0]), ip_2_ip4(&ipconfig[1]), ip_2_ip4(&ipconfig[2]));
+
+    // Initialize DHCP structure
+    dhcp_set_struct(n, &self->dhcp_struct);
+}
 
+static void eth_lwip_init(eth_t *self) {
     MICROPY_PY_LWIP_ENTER
 
     struct netif *n = &self->netif;
-    n->name[0] = 'e';
-    n->name[1] = '0';
-    netif_add(n, &ipconfig[0], &ipconfig[1], &ipconfig[2], self, eth_netif_init, ethernet_input);
-    netif_set_hostname(n, mod_network_hostname_data);
-    netif_set_default(n);
-    netif_set_up(n);
 
-    dns_setserver(0, &ipconfig[3]);
-    dhcp_set_struct(n, &self->dhcp_struct);
-    dhcp_start(n);
+    // Add netif to network stack (only if not already added)
+    if (netif_find(n->name) == NULL) {
+        ip_addr_t dns_addr;
+        IP_ADDR4(&dns_addr, 8, 8, 8, 8);
 
-    netif_set_link_up(n);
+        netif_add(n, netif_ip4_addr(n), netif_ip4_netmask(n), netif_ip4_gw(n), self, eth_netif_init, ethernet_input);
+        netif_set_hostname(n, mod_network_hostname_data);
+        netif_set_default(n);
+        netif_set_up(n);
+
+        dns_setserver(0, &dns_addr);
+
+        #if LWIP_IPV6
+        netif_create_ip6_linklocal_address(n, 1);
+        #endif
+    }
 
     MICROPY_PY_LWIP_EXIT
 }
 
+static void eth_start_dhcp_if_needed(eth_t *self) {
+    MICROPY_PY_LWIP_ENTER
+    struct netif *netif = &self->netif;
+
+    // Check if a static IP address has been configured
+    if (ip4_addr_isany_val(*netif_ip4_addr(netif))) {
+        // No static IP configured, start DHCP
+        dhcp_start(netif);
+    }
+    // If static IP is already configured, don't start DHCP
+
+    MICROPY_PY_LWIP_EXIT
+}
+
+static void eth_phy_configure_autoneg(eth_t *self) {
+    // Configure PHY for autonegotiation (non-blocking)
+    // This sets up the PHY but doesn't wait for link establishment
+
+    // Announce all supported modes
+    eth_phy_write(self->phy_addr, PHY_ANAR,
+        PHY_ANAR_SPEED_10HALF |
+        PHY_ANAR_SPEED_10FULL |
+        PHY_ANAR_SPEED_100HALF |
+        PHY_ANAR_SPEED_100FULL |
+        PHY_ANAR_IEEE802_3);
+
+    // Start autonegotiation
+    eth_phy_write(self->phy_addr, PHY_BCR, PHY_BCR_AUTONEG_EN);
+}
+
+static void eth_phy_link_status_poll(eth_t *self) {
+    // Poll PHY link status and handle state changes
+    uint16_t bsr = eth_phy_read(self->phy_addr, PHY_BSR);
+    bool current_link_status = (bsr & PHY_BSR_LINK_STATUS) != 0;
+
+    // Check if link status changed
+    if (current_link_status != self->last_link_status) {
+        self->last_link_status = current_link_status;
+
+        // Update LWIP netif link status to reflect physical cable connection
+        struct netif *netif = &self->netif;
+        if (current_link_status) {
+            // Cable is physically connected
+            netif_set_link_up(netif);
+
+            // If this is a new connection, configure autonegotiation
+            uint16_t bcr = eth_phy_read(self->phy_addr, PHY_BCR);
+            if (!(bcr & PHY_BCR_AUTONEG_EN)) {
+                eth_phy_configure_autoneg(self);
+            }
+
+            // Restart DHCP if interface is up and DHCP is enabled
+            if (netif_is_up(netif) && netif_dhcp_data(netif)) {
+                dhcp_renew(netif);
+            }
+        } else {
+            // Cable is physically disconnected
+            netif_set_link_down(netif);
+        }
+    }
+}
+
 static void eth_lwip_deinit(eth_t *self) {
     MICROPY_PY_LWIP_ENTER
-    for (struct netif *netif = netif_list; netif != NULL; netif = netif->next) {
-        if (netif == &self->netif) {
-            netif_remove(netif);
-            netif->ip_addr.addr = 0;
-            netif->flags = 0;
+    struct netif *netif = &self->netif;
+
+    // Stop DHCP if running
+    if (netif_dhcp_data(netif)) {
+        dhcp_stop(netif);
+    }
+
+    // Remove from network stack but keep netif structure for reuse
+    for (struct netif *n = netif_list; n != NULL; n = n->next) {
+        if (n == netif) {
+            netif_remove(n);
+            break;
         }
     }
     MICROPY_PY_LWIP_EXIT
@@ -895,16 +926,23 @@ bool eth_is_enabled(eth_t *self) {
 }
 
 int eth_start(eth_t *self) {
-    eth_lwip_deinit(self);
-
     // Make sure Eth is Not in low power mode.
     eth_low_power_mode(self, false);
 
     int ret = eth_mac_init(self);
     if (ret < 0) {
         return ret;
     }
+
+    // Initialize LWIP netif (only once, safe to call multiple times)
     eth_lwip_init(self);
+
+    // Start DHCP if no static IP has been configured
+    eth_start_dhcp_if_needed(self);
+
+    // Do an initial link status poll
+    eth_phy_link_status_poll(self);
+
     self->enabled = true;
     return 0;
 }
