From 8df2be2a5237c193ba12d1dec80b0bd0523cd557 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=A9=AC=E9=BE=99=E4=BC=9F?= <2544047213@qq.com> Date: Sat, 14 Jun 2025 15:58:10 +0800 Subject: [PATCH] add usb net under idf platform --- CMakeLists.txt | 2 +- cherryusb.cmake | 6 +- platform/idf/usbh_net.c | 408 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 414 insertions(+), 2 deletions(-) create mode 100644 platform/idf/usbh_net.c diff --git a/CMakeLists.txt b/CMakeLists.txt index be61060b..0205fb10 100644 --- a/CMakeLists.txt +++ b/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} ) diff --git a/cherryusb.cmake b/cherryusb.cmake index 15e040e4..1175d881 100644 --- a/cherryusb.cmake +++ b/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) diff --git a/platform/idf/usbh_net.c b/platform/idf/usbh_net.c new file mode 100644 index 00000000..222cf1eb --- /dev/null +++ b/platform/idf/usbh_net.c @@ -0,0 +1,408 @@ +/* + * Copyright (c) 2025, Loogg + * + * SPDX-License-Identifier: Apache-2.0 + */ +#include +#include +#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