add usb net under idf platform

This commit is contained in:
马龙伟
2025-06-14 15:58:10 +08:00
committed by sakumisu
parent 7f3ddf5d83
commit 8df2be2a52
3 changed files with 414 additions and 2 deletions

View File

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

View File

@@ -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)

408
platform/idf/usbh_net.c Normal file
View File

@@ -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