fix(eppp): Cleanup the Ethernet transport

Author: david-cermak

components/eppp_link/CMakeLists.txt

@@ -29,6 +29,5 @@ idf_component_register(SRCS eppp_link.c ${transport_src} ${netif_src}
                     PRIV_REQUIRES esp_netif esp_timer esp_eth ${driver_deps})
 
 if(CONFIG_EPPP_LINK_DEVICE_ETH)
-    idf_component_get_property(ethernet_init espressif__ethernet_init COMPONENT_LIB)
-    target_link_libraries(${COMPONENT_LIB} PRIVATE ${ethernet_init})
+    idf_component_optional_requires(PRIVATE ethernet_init espressif__ethernet_init)
 endif()

components/eppp_link/README.md

@@ -1,7 +1,8 @@
 # ESP PPP Link component (eppp_link)
 
 The component provides a general purpose connectivity engine between two microcontrollers, one acting as PPP server (slave), the other one as PPP client (host).
-This component could be used for extending network using physical serial connection. Applications could vary from providing PRC engine for multiprocessor solutions to serial connection to POSIX machine. This uses a standard PPP protocol to negotiate IP addresses and networking, so standard PPP toolset could be used, e.g. a `pppd` service on linux. Typical application is a WiFi connectivity provider for chips that do not have WiFi
+This component could be used for extending network using physical serial connection. Applications could vary from providing PRC engine for multiprocessor solutions to serial connection to POSIX machine. This uses a standard PPP protocol (if enabled) to negotiate IP addresses and networking, so standard PPP toolset could be used, e.g. a `pppd` service on linux. Typical application is a WiFi connectivity provider for chips that do not have WiFi.
+Uses simplified TUN network interface by default to enable faster data transfer on non-UART transports.
 
 ## Typical application
 
@@ -19,6 +20,23 @@ brings in the WiFi connectivity from the "SLAVE" microcontroller.
          +----------------+                               +----------------+
 ```
 
+## Configuration
+
+### Choose the transport layer
+
+* `CONFIG_EPPP_LINK_UART` -- Use UART transport layer
+* `CONFIG_EPPP_LINK_SPI` -- Use SPI transport layer
+* `CONFIG_EPPP_LINK_SDIO` -- Use SDIO transport layer
+* `CONFIG_EPPP_LINK_ETHERNET` -- Use Ethernet transport
+  - Note: Ethernet creates it's own task, so calling `eppp_perform()` would not work
+  - Note: Add dependency to ethernet_init component to use other Ethernet drivers
+  - Note: You can override functions `eppp_transport_ethernet_deinit()` and `eppp_transport_ethernet_init()` to use your own Ethernet driver
+
+### Choose the network interface
+
+Use PPP netif for UART; Keep the default (TUN) for others
+
+
 ## API
 
 ### Client

components/eppp_link/eppp_eth.c

@@ -11,12 +11,18 @@
 #include "esp_check.h"
 #include "esp_event.h"
 #include "esp_mac.h"
+#include "esp_idf_version.h"
 #include "eppp_link.h"
 #include "eppp_transport.h"
 #include "esp_eth_driver.h"
-#include "ethernet_init.h"
 #include "esp_eth_spec.h"
 #include "eppp_transport_eth.h"
+// Use Ethernet Init component if available
+// (otherwise use just simple init/deinit with generic MAC/PHY)
+#if __has_include("ethernet_init.h")
+#define USE_ETHERNET_INIT_COMPONENT
+#include "ethernet_init.h"
+#endif
 
 typedef struct header {
     uint8_t dst[ETH_ADDR_LEN];
@@ -30,6 +36,52 @@ static esp_eth_handle_t *s_eth_handles = NULL;
 static uint8_t s_their_mac[ETH_ADDR_LEN];
 static uint8_t s_our_mac[ETH_ADDR_LEN];
 
+#ifndef USE_ETHERNET_INIT_COMPONENT
+static esp_err_t simple_init_deinit(bool init, struct eppp_config_ethernet_s *config, esp_eth_handle_t *handle_array[])
+{
+    static esp_eth_handle_t handles[1] = { NULL };
+    static esp_eth_mac_t *mac = NULL;
+    static esp_eth_phy_t *phy = NULL;
+    esp_err_t ret = ESP_OK;
+    if (!init) {
+        if (handles[0] != NULL) {
+            esp_eth_driver_uninstall(handles[0]);
+            handles[0] = NULL;
+        }
+        if (mac != NULL) {
+            mac->del(mac);
+            mac = NULL;
+        }
+        if (phy != NULL) {
+            phy->del(phy);
+            phy = NULL;
+        }
+        return ESP_OK;
+    }
+
+    eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
+    eth_esp32_emac_config_t esp32_emac_config = ETH_ESP32_EMAC_DEFAULT_CONFIG();
+    esp32_emac_config.smi_gpio.mdc_num = config->mdc_io;
+    esp32_emac_config.smi_gpio.mdio_num = config->mdio_io;
+    mac = esp_eth_mac_new_esp32(&esp32_emac_config, &mac_config);
+    eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
+    phy_config.phy_addr = config->phy_addr;
+    phy_config.reset_gpio_num = config->rst_io;
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 0)
+    phy = esp_eth_phy_new_generic(&phy_config);
+#else
+    phy = esp_eth_phy_new_ip101(&phy_config);
+#endif
+    esp_eth_config_t eth_config = ETH_DEFAULT_CONFIG(mac, phy);
+    ESP_GOTO_ON_ERROR(esp_eth_driver_install(&eth_config, &handles[0]), err, TAG, "Ethernet driver install failed");
+    *handle_array = handles;
+    return ESP_OK;
+err:
+    simple_init_deinit(false, config, handle_array); // call recursively to deinit and free
+    return ret;
+}
+#endif // USE_ETHERNET_INIT_COMPONENT
+
 static void event_handler(void *arg, esp_event_base_t event_base,
                           int32_t event_id, void *event_data)
 {
@@ -65,39 +117,25 @@ static esp_err_t receive(esp_eth_handle_t h, uint8_t *buffer, uint32_t len, void
     return ESP_FAIL;
 }
 
-__attribute__((weak)) esp_err_t eppp_transport_ethernet_init(esp_eth_handle_t *handle_array[])
+__attribute__((weak)) esp_err_t eppp_transport_ethernet_init(struct eppp_config_ethernet_s *config, esp_eth_handle_t *handle_array[])
 {
+#ifdef USE_ETHERNET_INIT_COMPONENT
     uint8_t eth_port_cnt = 0;
     ESP_RETURN_ON_ERROR(ethernet_init_all(handle_array, &eth_port_cnt), TAG, "Failed to init common eth drivers");
     ESP_RETURN_ON_FALSE(eth_port_cnt == 1, ESP_ERR_INVALID_ARG, TAG, "multiple Ethernet devices detected, please init only one");
     return ESP_OK;
+#else
+    return simple_init_deinit(true, config, handle_array);
+#endif
 }
 
-__attribute__((weak)) void eppp_transport_ethernet_deinit(esp_eth_handle_t *handle_array)
+__attribute__((weak)) void eppp_transport_ethernet_deinit(esp_eth_handle_t *handle_array[])
 {
+#ifdef USE_ETHERNET_INIT_COMPONENT
     ethernet_deinit_all(s_eth_handles);
-}
-
-
-esp_err_t eppp_transport_init(eppp_config_t *config, esp_netif_t *esp_netif)
-{
-    ESP_RETURN_ON_ERROR(eppp_transport_ethernet_init(&s_eth_handles), TAG, "Failed to initialize Ethernet driver");
-    ESP_RETURN_ON_ERROR(esp_eth_update_input_path(s_eth_handles[0], receive, esp_netif), TAG, "Failed to set Ethernet Rx callback");
-    sscanf(CONFIG_EPPP_LINK_ETHERNET_OUR_ADDRESS, "%2" PRIu8 ":%2" PRIu8 ":%2" PRIi8 ":%2" PRIu8 ":%2" PRIu8 ":%2" PRIu8,
-           &s_our_mac[0], &s_our_mac[1], &s_our_mac[2], &s_our_mac[3], &s_our_mac[4], &s_our_mac[5]);
-
-    sscanf(CONFIG_EPPP_LINK_ETHERNET_THEIR_ADDRESS, "%2" PRIu8 ":%2" PRIu8 ":%2" PRIi8 ":%2" PRIu8 ":%2" PRIu8 ":%2" PRIu8,
-           &s_their_mac[0], &s_their_mac[1], &s_their_mac[2], &s_their_mac[3], &s_their_mac[4], &s_their_mac[5]);
-    esp_eth_ioctl(s_eth_handles[0], ETH_CMD_S_MAC_ADDR, s_our_mac);
-    ESP_RETURN_ON_ERROR(esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, event_handler, NULL), TAG, "Failed to register Ethernet handlers");
-    ESP_RETURN_ON_ERROR(esp_eth_start(s_eth_handles[0]), TAG, "Failed to start Ethernet driver");
-    return ESP_OK;
-}
-
-void eppp_transport_deinit(void)
-{
-    esp_eth_stop(s_eth_handles[0]);
-    eppp_transport_ethernet_deinit(s_eth_handles);
+#else
+    simple_init_deinit(false, NULL, handle_array);
+#endif
 }
 
 esp_err_t eppp_transport_tx(void *h, void *buffer, size_t len)
@@ -121,7 +159,6 @@ esp_err_t eppp_transport_tx(void *h, void *buffer, size_t len)
 
 static esp_err_t start_driver(esp_netif_t *esp_netif)
 {
-    ESP_RETURN_ON_ERROR(eppp_transport_ethernet_init(&s_eth_handles), TAG, "Failed to initialize Ethernet driver");
     ESP_RETURN_ON_ERROR(esp_eth_update_input_path(s_eth_handles[0], receive, esp_netif), TAG, "Failed to set Ethernet Rx callback");
     sscanf(CONFIG_EPPP_LINK_ETHERNET_OUR_ADDRESS, "%2" PRIu8 ":%2" PRIu8 ":%2" PRIi8 ":%2" PRIu8 ":%2" PRIu8 ":%2" PRIu8,
            &s_our_mac[0], &s_our_mac[1], &s_our_mac[2], &s_our_mac[3], &s_our_mac[4], &s_our_mac[5]);
@@ -153,14 +190,18 @@ static esp_err_t post_attach(esp_netif_t *esp_netif, void *args)
 
 eppp_transport_handle_t eppp_eth_init(struct eppp_config_ethernet_s *config)
 {
+    __attribute__((unused)) esp_err_t ret = ESP_OK;
     eppp_transport_handle_t h = calloc(1, sizeof(struct eppp_handle));
     ESP_RETURN_ON_FALSE(h, NULL, TAG, "Failed to allocate eppp_handle");
+    ESP_GOTO_ON_ERROR(eppp_transport_ethernet_init(config, &s_eth_handles), err, TAG, "Failed to init Ethernet transport");
     h->base.post_attach = post_attach;
     return h;
+err:
+    return NULL;
 }
 
 void eppp_eth_deinit(eppp_transport_handle_t h)
 {
     esp_eth_stop(s_eth_handles[0]);
-    eppp_transport_ethernet_deinit(s_eth_handles);
+    eppp_transport_ethernet_deinit(&s_eth_handles);
 }

components/eppp_link/examples/host/main/app_main.c

@@ -117,6 +117,8 @@ void app_main(void)
     config.uart.tx_io = 17;
     config.uart.rx_io = 18;
 //    config.uart.baud = CONFIG_EXAMPLE_UART_BAUDRATE;
+#elif CONFIG_EPPP_LINK_DEVICE_ETH
+    config.transport = EPPP_TRANSPORT_ETHERNET;
 #else
     config.transport = EPPP_TRANSPORT_SDIO;
     config.sdio.is_host = true;

components/eppp_link/idf_component.yml

@@ -4,4 +4,3 @@ description: The component provides a general purpose PPP connectivity, typicall
 dependencies:
   idf: '>=5.2'
   espressif/esp_serial_slave_link: "^1.1.0"
-  espressif/ethernet_init: '>=0.0.7'

components/eppp_link/include/eppp_link.h

@@ -45,6 +45,10 @@
 
 #define EPPP_DEFAULT_ETH_CONFIG()   \
     .ethernet = {                   \
+        .mdc_io = 23,               \
+        .mdio_io = 18,              \
+        .phy_addr = 1,              \
+        .rst_io= 5,                 \
     },                              \
 
 #if CONFIG_EPPP_LINK_DEVICE_SPI
@@ -142,6 +146,10 @@ typedef struct eppp_config_t {
         } sdio;
 
         struct eppp_config_ethernet_s {
+            int mdc_io;
+            int mdio_io;
+            int phy_addr;
+            int rst_io;
         } ethernet;
 
     };