add usb net under idf platform

CMakeLists.txt

@@ -71,7 +71,7 @@ elseif(ESP_PLATFORM)
         ${cherryusb_incs}
         ${freertos_include}
         PRIV_REQUIRES
-        usb esp_mm
+        usb esp_mm esp_netif
         LDFRAGMENTS
         ${ldfragments}
     )

cherryusb.cmake

@@ -257,7 +257,11 @@ if(CONFIG_CHERRYUSB_HOST)
     OR CONFIG_CHERRYUSB_HOST_RTL8152
     OR CONFIG_CHERRYUSB_HOST_BL616
     )
-        list(APPEND cherryusb_srcs platform/lwip/usbh_lwip.c)
+        if("${CONFIG_CHERRYUSB_OSAL}" STREQUAL "idf")
+            list(APPEND cherryusb_srcs ${CMAKE_CURRENT_LIST_DIR}/platform/idf/usbh_net.c)
+        else()
+            list(APPEND cherryusb_srcs ${CMAKE_CURRENT_LIST_DIR}/platform/lwip/usbh_lwip.c)
+        endif()
     endif()
 
     if(CONFIG_CHERRYUSB_HOST_EHCI_BL)

platform/idf/usbh_net.c

@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) 2025, Loogg
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdlib.h>
+#include <inttypes.h>
+#include "lwip/netif.h"
+#include "esp_log.h"
+#include "esp_event.h"
+#include "esp_check.h"
+#include "esp_netif.h"
+#include "usbh_core.h"
+
+#if TCPIP_THREAD_STACKSIZE < 1024
+#error TCPIP_THREAD_STACKSIZE must be >= 1024
+#endif
+
+// #define CONFIG_USBHOST_PLATFORM_CDC_ECM
+// #define CONFIG_USBHOST_PLATFORM_CDC_RNDIS
+// #define CONFIG_USBHOST_PLATFORM_CDC_NCM
+// #define CONFIG_USBHOST_PLATFORM_ASIX
+// #define CONFIG_USBHOST_PLATFORM_RTL8152
+// #define CONFIG_USBHOST_PLATFORM_BL616
+
+struct usbh_net_netif_glue {
+    esp_netif_driver_base_t base;
+    esp_event_handler_instance_t ins_got_ip;
+    void *usbh_class;
+    esp_err_t (*transmit)(void *h, void *buffer, size_t len);
+};
+
+static void usbh_net_input_common(struct usbh_net_netif_glue *netif_glue, uint8_t *buf, uint32_t len)
+{
+    uint8_t *input_buf = buf;
+
+#if !LWIP_TCPIP_CORE_LOCKING_INPUT
+    input_buf = usb_osal_malloc(len);
+    if (input_buf == NULL) {
+        USB_LOG_ERR("No memory to alloc input buffer\r\n");
+        return;
+    }
+    usb_memcpy(input_buf, buf, len);
+#endif
+
+    esp_netif_receive(netif_glue->base.netif, input_buf, len, NULL);
+}
+
+static void usbh_net_free(void *h, void *buffer)
+{
+#if !LWIP_TCPIP_CORE_LOCKING_INPUT
+    usb_osal_free(buffer);
+#endif
+}
+
+static esp_err_t usbh_net_post_attach(esp_netif_t *esp_netif, void *args)
+{
+    struct usbh_net_netif_glue *netif_glue = (struct usbh_net_netif_glue *)args;
+
+    netif_glue->base.netif = esp_netif;
+
+    // set driver related config to esp-netif
+    esp_netif_driver_ifconfig_t driver_ifconfig = {
+        .handle = netif_glue,
+        .transmit = netif_glue->transmit,
+        .driver_free_rx_buffer = usbh_net_free,
+    };
+
+    ESP_ERROR_CHECK(esp_netif_set_driver_config(esp_netif, &driver_ifconfig));
+
+    return ESP_OK;
+}
+
+static void usbh_net_action_got_ip(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    struct usbh_net_netif_glue *netif_glue = (struct usbh_net_netif_glue *)handler_args;
+    ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
+    const esp_netif_ip_info_t *ip_info = &event->ip_info;
+    USB_LOG_INFO("NETIF %s Got IP Address\r\n", esp_netif_get_ifkey(netif_glue->base.netif));
+    USB_LOG_INFO("IP:" IPSTR "\r\n", IP2STR(&ip_info->ip));
+    USB_LOG_INFO("MASK:" IPSTR "\r\n", IP2STR(&ip_info->netmask));
+    USB_LOG_INFO("GW:" IPSTR "\r\n\r\n", IP2STR(&ip_info->gw));
+}
+
+static esp_err_t usbh_net_netif_glue_init_common(struct usbh_net_netif_glue *netif_glue, void *usbh_class, esp_err_t (*transmit)(void *h, void *buffer, size_t len))
+{
+    netif_glue->usbh_class = usbh_class;
+    netif_glue->transmit = transmit;
+    netif_glue->base.post_attach = usbh_net_post_attach;
+
+    return esp_event_handler_instance_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, usbh_net_action_got_ip, netif_glue, &netif_glue->ins_got_ip);
+}
+
+static esp_err_t usbh_net_netif_glue_deinit_common(struct usbh_net_netif_glue *netif_glue)
+{
+    return esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_ETH_GOT_IP, netif_glue->ins_got_ip);
+}
+
+#ifdef CONFIG_USBHOST_PLATFORM_CDC_ECM
+#include "usbh_cdc_ecm.h"
+
+struct usbh_net_netif_glue g_cdc_ecm_netif_glue;
+
+static esp_err_t usbh_cdc_ecm_transmit(void *h, void *buffer, size_t len)
+{
+    int ret;
+    (void)h;
+
+    usb_memcpy(usbh_cdc_ecm_get_eth_txbuf(), buffer, len);
+    ret = usbh_cdc_ecm_eth_output(len);
+    if (ret < 0) {
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+void usbh_cdc_ecm_eth_input(uint8_t *buf, uint32_t buflen)
+{
+    usbh_net_input_common(&g_cdc_ecm_netif_glue, buf, buflen);
+}
+
+void usbh_cdc_ecm_run(struct usbh_cdc_ecm *cdc_ecm_class)
+{
+    memset(&g_cdc_ecm_netif_glue, 0, sizeof(struct usbh_net_netif_glue));
+
+    esp_netif_inherent_config_t base_cfg = ESP_NETIF_INHERENT_DEFAULT_ETH();
+    base_cfg.if_key = "u0";
+    base_cfg.if_desc = "usbh cdc ecm";
+
+    esp_netif_config_t netif_cfg = ESP_NETIF_DEFAULT_ETH();
+    netif_cfg.base = &base_cfg;
+    esp_netif_t *esp_netif = esp_netif_new(&netif_cfg);
+
+    usbh_net_netif_glue_init_common(&g_cdc_ecm_netif_glue, cdc_ecm_class, usbh_cdc_ecm_transmit);
+    esp_netif_attach(esp_netif, &g_cdc_ecm_netif_glue.base);
+
+    esp_netif_set_mac(esp_netif, cdc_ecm_class->mac);
+
+    esp_netif_action_start(esp_netif, NULL, 0, NULL);
+    esp_netif_action_connected(esp_netif, NULL, 0, NULL);
+
+    usb_osal_thread_create("usbh_cdc_ecm_rx", 2048, CONFIG_USBHOST_PSC_PRIO + 1, usbh_cdc_ecm_rx_thread, NULL);
+}
+
+void usbh_cdc_ecm_stop(struct usbh_cdc_ecm *cdc_ecm_class)
+{
+    (void)cdc_ecm_class;
+
+    usbh_net_netif_glue_deinit_common(&g_cdc_ecm_netif_glue);
+    esp_netif_action_stop(g_cdc_ecm_netif_glue.base.netif, NULL, 0, NULL);
+    esp_netif_destroy(g_cdc_ecm_netif_glue.base.netif);
+}
+#endif
+
+#ifdef CONFIG_USBHOST_PLATFORM_CDC_RNDIS
+#include "usbh_rndis.h"
+
+struct usb_osal_timer *timer_handle;
+
+static void rndis_dev_keepalive_timeout(void *arg)
+{
+    struct usbh_rndis *rndis_class = (struct usbh_rndis *)arg;
+    usbh_rndis_keepalive(rndis_class);
+}
+
+void timer_init(struct usbh_rndis *rndis_class)
+{
+    timer_handle = usb_osal_timer_create("rndis_keepalive", 5000, rndis_dev_keepalive_timeout, rndis_class, true);
+    if (NULL != timer_handle) {
+        usb_osal_timer_start(timer_handle);
+    } else {
+        USB_LOG_ERR("timer creation failed! \r\n");
+        for (;;) {
+            ;
+        }
+    }
+}
+
+struct usbh_net_netif_glue g_rndis_netif_glue;
+
+static esp_err_t usbh_rndis_transmit(void *h, void *buffer, size_t len)
+{
+    int ret;
+    (void)h;
+
+    usb_memcpy(usbh_rndis_get_eth_txbuf(), buffer, len);
+    ret = usbh_rndis_eth_output(len);
+    if (ret < 0) {
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+void usbh_rndis_eth_input(uint8_t *buf, uint32_t buflen)
+{
+    usbh_net_input_common(&g_rndis_netif_glue, buf, buflen);
+}
+
+void usbh_rndis_run(struct usbh_rndis *rndis_class)
+{
+    memset(&g_rndis_netif_glue, 0, sizeof(struct usbh_net_netif_glue));
+
+    esp_netif_inherent_config_t base_cfg = ESP_NETIF_INHERENT_DEFAULT_ETH();
+    base_cfg.if_key = "u2";
+    base_cfg.if_desc = "usbh rndis";
+
+    esp_netif_config_t netif_cfg = ESP_NETIF_DEFAULT_ETH();
+    netif_cfg.base = &base_cfg;
+    esp_netif_t *esp_netif = esp_netif_new(&netif_cfg);
+
+    usbh_net_netif_glue_init_common(&g_rndis_netif_glue, rndis_class, usbh_rndis_transmit);
+    esp_netif_attach(esp_netif, &g_rndis_netif_glue.base);
+
+    esp_netif_set_mac(esp_netif, rndis_class->mac);
+
+    esp_netif_action_start(esp_netif, NULL, 0, NULL);
+    esp_netif_action_connected(esp_netif, NULL, 0, NULL);
+
+    usb_osal_thread_create("usbh_rndis_rx", 2048, CONFIG_USBHOST_PSC_PRIO + 1, usbh_rndis_rx_thread, NULL);
+
+    //timer_init(rndis_class);
+}
+
+void usbh_rndis_stop(struct usbh_rndis *rndis_class)
+{
+    (void)rndis_class;
+
+    usbh_net_netif_glue_deinit_common(&g_rndis_netif_glue);
+    esp_netif_action_stop(g_rndis_netif_glue.base.netif, NULL, 0, NULL);
+    esp_netif_destroy(g_rndis_netif_glue.base.netif);
+
+    // xTimerStop(timer_handle, 0);
+    // xTimerDelete(timer_handle, 0);
+}
+#endif
+
+#ifdef CONFIG_USBHOST_PLATFORM_CDC_NCM
+#include "usbh_cdc_ncm.h"
+
+struct usbh_net_netif_glue g_cdc_ncm_netif_glue;
+
+static esp_err_t usbh_cdc_ncm_transmit(void *h, void *buffer, size_t len)
+{
+    int ret;
+    (void)h;
+
+    usb_memcpy(usbh_cdc_ncm_get_eth_txbuf(), buffer, len);
+    ret = usbh_cdc_ncm_eth_output(len);
+    if (ret < 0) {
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+void usbh_cdc_ncm_eth_input(uint8_t *buf, uint32_t buflen)
+{
+    usbh_net_input_common(&g_cdc_ncm_netif_glue, buf, buflen);
+}
+
+void usbh_cdc_ncm_run(struct usbh_cdc_ncm *cdc_ncm_class)
+{
+    memset(&g_cdc_ncm_netif_glue, 0, sizeof(struct usbh_net_netif_glue));
+
+    esp_netif_inherent_config_t base_cfg = ESP_NETIF_INHERENT_DEFAULT_ETH();
+    base_cfg.if_key = "u1";
+    base_cfg.if_desc = "usbh cdc ncm";
+
+    esp_netif_config_t netif_cfg = ESP_NETIF_DEFAULT_ETH();
+    netif_cfg.base = &base_cfg;
+    esp_netif_t *esp_netif = esp_netif_new(&netif_cfg);
+
+    usbh_net_netif_glue_init_common(&g_cdc_ncm_netif_glue, cdc_ncm_class, usbh_cdc_ncm_transmit);
+    esp_netif_attach(esp_netif, &g_cdc_ncm_netif_glue.base);
+
+    esp_netif_set_mac(esp_netif, cdc_ncm_class->mac);
+
+    esp_netif_action_start(esp_netif, NULL, 0, NULL);
+    esp_netif_action_connected(esp_netif, NULL, 0, NULL);
+
+    usb_osal_thread_create("usbh_cdc_ncm_rx", 2048, CONFIG_USBHOST_PSC_PRIO + 1, usbh_cdc_ncm_rx_thread, NULL);
+}
+
+void usbh_cdc_ncm_stop(struct usbh_cdc_ncm *cdc_ncm_class)
+{
+    (void)cdc_ncm_class;
+
+    usbh_net_netif_glue_deinit_common(&g_cdc_ncm_netif_glue);
+    esp_netif_action_stop(g_cdc_ncm_netif_glue.base.netif, NULL, 0, NULL);
+    esp_netif_destroy(g_cdc_ncm_netif_glue.base.netif);
+}
+#endif
+
+#ifdef CONFIG_USBHOST_PLATFORM_ASIX
+#include "usbh_asix.h"
+
+struct usbh_net_netif_glue g_asix_netif_glue;
+
+static esp_err_t usbh_asix_transmit(void *h, void *buffer, size_t len)
+{
+    int ret;
+    (void)h;
+
+    usb_memcpy(usbh_asix_get_eth_txbuf(), buffer, len);
+    ret = usbh_asix_eth_output(len);
+    if (ret < 0) {
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+void usbh_asix_eth_input(uint8_t *buf, uint32_t buflen)
+{
+    usbh_net_input_common(&g_asix_netif_glue, buf, buflen);
+}
+
+void usbh_asix_run(struct usbh_asix *asix_class)
+{
+    memset(&g_asix_netif_glue, 0, sizeof(struct usbh_net_netif_glue));
+
+    esp_netif_inherent_config_t base_cfg = ESP_NETIF_INHERENT_DEFAULT_ETH();
+    base_cfg.if_key = "u3";
+    base_cfg.if_desc = "usbh asix";
+
+    esp_netif_config_t netif_cfg = ESP_NETIF_DEFAULT_ETH();
+    netif_cfg.base = &base_cfg;
+    esp_netif_t *esp_netif = esp_netif_new(&netif_cfg);
+
+    usbh_net_netif_glue_init_common(&g_asix_netif_glue, asix_class, usbh_asix_transmit);
+    esp_netif_attach(esp_netif, &g_asix_netif_glue.base);
+
+    esp_netif_set_mac(esp_netif, asix_class->mac);
+
+    esp_netif_action_start(esp_netif, NULL, 0, NULL);
+    esp_netif_action_connected(esp_netif, NULL, 0, NULL);
+
+    usb_osal_thread_create("usbh_asix_rx", 2048, CONFIG_USBHOST_PSC_PRIO + 1, usbh_asix_rx_thread, NULL);
+}
+
+void usbh_asix_stop(struct usbh_asix *asix_class)
+{
+    (void)asix_class;
+
+    usbh_net_netif_glue_deinit_common(&g_asix_netif_glue);
+    esp_netif_action_stop(g_asix_netif_glue.base.netif, NULL, 0, NULL);
+    esp_netif_destroy(g_asix_netif_glue.base.netif);
+}
+#endif
+
+#ifdef CONFIG_USBHOST_PLATFORM_RTL8152
+#include "usbh_rtl8152.h"
+
+struct usbh_net_netif_glue g_rtl8152_netif_glue;
+
+static esp_err_t usbh_rtl8152_transmit(void *h, void *buffer, size_t len)
+{
+    int ret;
+    (void)h;
+
+    usb_memcpy(usbh_rtl8152_get_eth_txbuf(), buffer, len);
+    ret = usbh_rtl8152_eth_output(len);
+    if (ret < 0) {
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+void usbh_rtl8152_eth_input(uint8_t *buf, uint32_t buflen)
+{
+    usbh_net_input_common(&g_rtl8152_netif_glue, buf, buflen);
+}
+
+void usbh_rtl8152_run(struct usbh_rtl8152 *rtl8152_class)
+{
+    memset(&g_rtl8152_netif_glue, 0, sizeof(struct usbh_net_netif_glue));
+
+    esp_netif_inherent_config_t base_cfg = ESP_NETIF_INHERENT_DEFAULT_ETH();
+    base_cfg.if_key = "u4";
+    base_cfg.if_desc = "usbh rtl8152";
+
+    esp_netif_config_t netif_cfg = ESP_NETIF_DEFAULT_ETH();
+    netif_cfg.base = &base_cfg;
+    esp_netif_t *esp_netif = esp_netif_new(&netif_cfg);
+
+    usbh_net_netif_glue_init_common(&g_rtl8152_netif_glue, rtl8152_class, usbh_rtl8152_transmit);
+    esp_netif_attach(esp_netif, &g_rtl8152_netif_glue.base);
+
+    esp_netif_set_mac(esp_netif, rtl8152_class->mac);
+
+    esp_netif_action_start(esp_netif, NULL, 0, NULL);
+    esp_netif_action_connected(esp_netif, NULL, 0, NULL);
+
+    usb_osal_thread_create("usbh_rtl8152_rx", 2048, CONFIG_USBHOST_PSC_PRIO + 1, usbh_rtl8152_rx_thread, NULL);
+}
+
+void usbh_rtl8152_stop(struct usbh_rtl8152 *rtl8152_class)
+{
+    (void)rtl8152_class;
+
+    usbh_net_netif_glue_deinit_common(&g_rtl8152_netif_glue);
+    esp_netif_action_stop(g_rtl8152_netif_glue.base.netif, NULL, 0, NULL);
+    esp_netif_destroy(g_rtl8152_netif_glue.base.netif);
+}
+#endif