libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #1024 from uestczyh222/master 

[Components][Drivers][USB] Add CDC-ECM class (LWIP on USB)
This commit is contained in:
Bernard Xiong 2017-11-22 09:13:06 +08:00 committed by GitHub
parent 334da974c3 bd566e6a37
commit 3be8cfa2ab
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 686 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
components/drivers/KConfig
View File

@ -132,6 +132,10 @@ menu "Using USB"
config _RT_USB_DEVICE_HID
bool "Enable to use device as HID device"
select RT_USB_DEVICE_HID
config _RT_USB_DEVICE_ECM
bool "Enable to use device as ecm device"
select RT_USB_DEVICE_ECM
depends on RT_USING_LWIP
endchoice
if RT_USB_DEVICE_COMPOSITE
config RT_USB_DEVICE_CDC
@ -143,6 +147,10 @@ menu "Using USB"
config RT_USB_DEVICE_HID
bool "Enable to use device as HID device"
default n
config RT_USB_DEVICE_ECM
bool "Enable to use device as ecm device"
default n
depends on RT_USING_LWIP
endif
if RT_USB_DEVICE_HID

3
components/drivers/usb/usbdevice/SConscript
View File

@ -16,6 +16,9 @@ if GetDepend('RT_USB_DEVICE_HID'):
if GetDepend('RT_USB_DEVICE_MSTORAGE'):
src += Glob('class/mstorage.c')
if GetDepend('RT_USB_DEVICE_ECM'):
src += Glob('class/ecm.c')
CPPPATH = [cwd]
group = DefineGroup('rt_usbd', src, depend = ['RT_USING_USB_DEVICE'], CPPPATH = CPPPATH)

64
components/drivers/usb/usbdevice/class/cdc.h
View File

@ -31,6 +31,7 @@
#define USB_CDC_CLASS_COMM 0x02
#define USB_CDC_CLASS_DATA 0x0A
#define USB_CDC_SUBCLASS_NONE 0x00
#define USB_CDC_SUBCLASS_DLCM 0x01
#define USB_CDC_SUBCLASS_ACM 0x02
#define USB_CDC_SUBCLASS_TCM 0x03
@ -38,9 +39,10 @@
#define USB_CDC_SUBCLASS_CCM 0x05
#define USB_CDC_SUBCLASS_ETH 0x06
#define USB_CDC_SUBCLASS_ATM 0x07
#define USB_CDC_SUBCLASS_EEM 0x0C
#define USB_CDC_PROTOCOL_NONE 0x00
#define USB_CDC_PROTOCOL_V25TER 0x01
#define USB_CDC_PROTOCOL_I430 0x30
#define USB_CDC_PROTOCOL_HDLC 0x31
#define USB_CDC_PROTOCOL_TRANS 0x32
@ -54,6 +56,7 @@
#define USB_CDC_PROTOCOL_HOST 0xFD
#define USB_CDC_PROTOCOL_PUFD 0xFE
#define USB_CDC_PROTOCOL_VENDOR 0xFF
#define USB_CDC_PROTOCOL_EEM 0x07
#define USB_CDC_CS_INTERFACE 0x24
#define USB_CDC_CS_ENDPOINT 0x25
@ -62,6 +65,7 @@
#define USB_CDC_SCS_CALL_MGMT 0x01
#define USB_CDC_SCS_ACM 0x02
#define USB_CDC_SCS_UNION 0x06
#define USB_CDC_SCS_ETH 0x0F
#define CDC_SEND_ENCAPSULATED_COMMAND 0x00
#define CDC_GET_ENCAPSULATED_RESPONSE 0x01
@ -153,6 +157,30 @@ struct ucdc_comm_descriptor
};
typedef struct ucdc_comm_descriptor* ucdc_comm_desc_t;
struct ucdc_enet_descriptor
{
rt_uint8_t bFunctionLength;
rt_uint8_t bDescriptorType;
rt_uint8_t bDescriptorSubtype;
rt_uint8_t iMACAddress;
rt_uint8_t bmEthernetStatistics[4];
rt_uint16_t wMaxSegmentSize;
rt_uint16_t wMCFilters;
rt_uint8_t bNumberPowerFilters;
};
struct ucdc_eth_descriptor
{
#ifdef RT_USB_DEVICE_COMPOSITE
struct uiad_descriptor iad_desc;
#endif
struct uinterface_descriptor intf_desc;
struct ucdc_header_descriptor hdr_desc;
struct ucdc_union_descriptor union_desc;
struct ucdc_enet_descriptor enet_desc;
struct uendpoint_descriptor ep_desc;
};
typedef struct ucdc_eth_descriptor* ucdc_eth_desc_t;
struct ucdc_data_descriptor
{
struct uinterface_descriptor intf_desc;
@ -177,7 +205,39 @@ struct cdc_eps
uep_t ep_cmd;
};
typedef struct cdc_eps* cdc_eps_t;
struct ucdc_management_element_notifications
{
rt_uint8_t bmRequestType;
rt_uint8_t bNotificatinCode;
rt_uint16_t wValue;
rt_uint16_t wIndex;
rt_uint16_t wLength;
};
typedef struct ucdc_management_element_notifications * ucdc_mg_notifications_t;
struct ucdc_connection_speed_change_data
{
rt_uint32_t down_bit_rate;
rt_uint32_t up_bit_rate;
};
typedef struct connection_speed_change_data * connect_speed_data_t;
enum ucdc_notification_code
{
UCDC_NOTIFI_NETWORK_CONNECTION = 0x00,
UCDC_NOTIFI_RESPONSE_AVAILABLE = 0x01,
UCDC_NOTIFI_AUX_JACK_HOOK_STATE = 0x08,
UCDC_NOTIFI_RING_DETECT = 0x09,
UCDC_NOTIFI_SERIAL_STATE = 0x20,
UCDC_NOTIFI_CALL_STATE_CHANGE = 0x28,
UCDC_NOTIFI_LINE_STATE_CHANGE = 0x29,
UCDC_NOTIFI_CONNECTION_SPEED_CHANGE = 0x2A,
};
typedef enum ucdc_notification_code ucdc_notification_code_t;
#pragma pack()
#endif

602
components/drivers/usb/usbdevice/class/ecm.c Normal file
View File

@ -0,0 +1,602 @@
/*
* File : ecm.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006-2013, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2017-11-19 ZYH first version
*/
#include <rtdevice.h>
#include "cdc.h"
#ifdef ECM_DEBUG
#define ECM_PRINTF rt_kprintf("[ECM] "); rt_kprintf
#else
#define ECM_PRINTF(...)
#endif /* ECM_DEBUG */
/* RT-Thread LWIP ethernet interface */
#include <netif/ethernetif.h>
#ifndef USB_ETH_MTU
#define USB_ETH_MTU 1514
#endif
#define MAX_ADDR_LEN 6
struct rt_ecm_eth
{
/* inherit from ethernet device */
struct eth_device parent;
struct ufunction * func;
struct cdc_eps eps;
/* interface address info */
rt_uint8_t host_addr[MAX_ADDR_LEN];
rt_uint8_t dev_addr[MAX_ADDR_LEN];
ALIGN(4)
rt_uint8_t rx_pool[64];
ALIGN(4)
rt_size_t rx_size;
ALIGN(4)
rt_size_t rx_offset;
ALIGN(4)
char rx_buffer[USB_ETH_MTU];
char tx_buffer[USB_ETH_MTU];
struct rt_semaphore tx_buffer_free;
};
typedef struct rt_ecm_eth * rt_ecm_eth_t;
ALIGN(4)
static struct udevice_descriptor _dev_desc =
{
USB_DESC_LENGTH_DEVICE, /* bLength */
USB_DESC_TYPE_DEVICE, /* type */
USB_BCD_VERSION, /* bcdUSB */
USB_CLASS_CDC, /* bDeviceClass */
USB_CDC_SUBCLASS_ETH, /* bDeviceSubClass */
USB_CDC_PROTOCOL_NONE, /* bDeviceProtocol */
0x40, /* bMaxPacketSize0 */
_VENDOR_ID, /* idVendor */
_PRODUCT_ID, /* idProduct */
USB_BCD_DEVICE, /* bcdDevice */
USB_STRING_MANU_INDEX, /* iManufacturer */
USB_STRING_PRODUCT_INDEX, /* iProduct */
USB_STRING_SERIAL_INDEX, /* iSerialNumber */
USB_DYNAMIC /* bNumConfigurations */
};
/* communcation interface descriptor */
ALIGN(4)
const static struct ucdc_eth_descriptor _comm_desc =
{
#ifdef RT_USB_DEVICE_COMPOSITE
/* Interface Association Descriptor */
USB_DESC_LENGTH_IAD,
USB_DESC_TYPE_IAD,
USB_DYNAMIC,
0x02,
USB_CDC_CLASS_COMM,
USB_CDC_SUBCLASS_ETH,
USB_CDC_PROTOCOL_NONE,
0x00,
#endif
/* Interface Descriptor */
USB_DESC_LENGTH_INTERFACE,
USB_DESC_TYPE_INTERFACE,
USB_DYNAMIC,
0x00,
0x01,
USB_CDC_CLASS_COMM,
USB_CDC_SUBCLASS_ETH,
USB_CDC_PROTOCOL_NONE,
0x00,
/* Header Functional Descriptor */
sizeof(struct ucdc_header_descriptor),
USB_CDC_CS_INTERFACE,
USB_CDC_SCS_HEADER,
0x0110,
/* Union Functional Descriptor */
sizeof(struct ucdc_union_descriptor),
USB_CDC_CS_INTERFACE,
USB_CDC_SCS_UNION,
USB_DYNAMIC,
USB_DYNAMIC,
/* Abstract Control Management Functional Descriptor */
sizeof(struct ucdc_enet_descriptor),
USB_CDC_CS_INTERFACE,
USB_CDC_SCS_ETH,
USB_STRING_SERIAL_INDEX,
{0,0,0,0},
USB_ETH_MTU,
0x00,
0x00,
/* Endpoint Descriptor */
USB_DESC_LENGTH_ENDPOINT,
USB_DESC_TYPE_ENDPOINT,
USB_DIR_IN | USB_DYNAMIC,
USB_EP_ATTR_INT,
0x08,
0xFF,
};
/* data interface descriptor */
ALIGN(4)
const static struct ucdc_data_descriptor _data_desc =
{
/* interface descriptor */
USB_DESC_LENGTH_INTERFACE,
USB_DESC_TYPE_INTERFACE,
USB_DYNAMIC,
0x00,
0x02,
USB_CDC_CLASS_DATA,
USB_CDC_SUBCLASS_ETH,
0x00,
0x00,
/* endpoint, bulk out */
USB_DESC_LENGTH_ENDPOINT,
USB_DESC_TYPE_ENDPOINT,
USB_DIR_OUT | USB_DYNAMIC,
USB_EP_ATTR_BULK,
USB_CDC_BUFSIZE,
0x00,
/* endpoint, bulk in */
USB_DESC_LENGTH_ENDPOINT,
USB_DESC_TYPE_ENDPOINT,
USB_DYNAMIC | USB_DIR_IN,
USB_EP_ATTR_BULK,
USB_CDC_BUFSIZE,
0x00,
};
ALIGN(4)
const static char* _ustring[] =
{
"Language", /* LANGID */
"RT-Thread Team.", /* MANU */
"RT-Thread ECM device", /* PRODUCT */
"3497F694ECAB", /* SERIAL (MAC)*/
"Configuration", /* CONFIG */
"Interface", /* INTERFACE */
};
ALIGN(4)
static struct usb_qualifier_descriptor dev_qualifier =
{
sizeof(dev_qualifier),
USB_DESC_TYPE_DEVICEQUALIFIER,
0x0200,
USB_CLASS_CDC,
0x00,
64,
0x01,
0,
};
static rt_err_t _cdc_send_notifi(ufunction_t func,ucdc_notification_code_t notifi,rt_uint16_t wValue,rt_uint16_t wLength)
{
static struct ucdc_management_element_notifications _notifi;
cdc_eps_t eps;
RT_ASSERT(func!=RT_NULL)
eps = &((rt_ecm_eth_t)func->user_data)->eps;
_notifi.bmRequestType = 0xA1;
_notifi.bNotificatinCode = notifi;
_notifi.wValue = wValue;
_notifi.wLength = wLength;
eps->ep_cmd->request.buffer = (void *)&_notifi;
eps->ep_cmd->request.size = 8;
eps->ep_cmd->request.req_type = UIO_REQUEST_WRITE;
rt_usbd_io_request(func->device, eps->ep_cmd, &eps->ep_cmd->request);
return RT_EOK;
}
static rt_err_t _ecm_set_eth_packet_filter(ufunction_t func, ureq_t setup)
{
rt_ecm_eth_t _ecm_eth = (rt_ecm_eth_t)func->user_data;
dcd_ep0_send_status(func->device->dcd);
/* send link up. */
eth_device_linkchange(&_ecm_eth->parent, RT_TRUE);
_cdc_send_notifi(func,UCDC_NOTIFI_NETWORK_CONNECTION,1,0);
return RT_EOK;
}
/**
* This function will handle rndis interface request.
*
* @param device the usb device object.
* @param setup the setup request.
*
* @return RT_EOK on successful.
*/
static rt_err_t _interface_handler(ufunction_t func, ureq_t setup)
{
RT_ASSERT(func != RT_NULL);
RT_ASSERT(setup != RT_NULL);
switch(setup->bRequest)
{
case CDC_SET_ETH_PACKET_FILTER:
_ecm_set_eth_packet_filter(func, setup);
break;
default:
rt_kprintf("setup->bRequest:0x%02X",setup->bRequest);
break;
}
return RT_EOK;
}
/**
* This function will handle rndis bulk in endpoint request.
*
* @param device the usb device object.
* @param size request size.
*
* @return RT_EOK.
*/
static rt_err_t _ep_in_handler(ufunction_t func, rt_size_t size)
{
rt_ecm_eth_t ecm_device = (rt_ecm_eth_t)func->user_data;
rt_sem_release(&ecm_device->tx_buffer_free);
return RT_EOK;
}
/**
* This function will handle RNDIS bulk out endpoint request.
*
* @param device the usb device object.
* @param size request size.
*
* @return RT_EOK.
*/
static rt_err_t _ep_out_handler(ufunction_t func, rt_size_t size)
{
rt_ecm_eth_t ecm_device = (rt_ecm_eth_t)func->user_data;
rt_memcpy((void *)(ecm_device->rx_buffer + ecm_device->rx_offset),ecm_device->rx_pool,size);
ecm_device->rx_offset += size;
if(size < EP_MAXPACKET(ecm_device->eps.ep_out))
{
ecm_device->rx_size = ecm_device->rx_offset;
ecm_device->rx_offset = 0;
eth_device_ready(&ecm_device->parent);
}else
{
ecm_device->eps.ep_out->request.buffer = ecm_device->eps.ep_out->buffer;
ecm_device->eps.ep_out->request.size = EP_MAXPACKET(ecm_device->eps.ep_out);
ecm_device->eps.ep_out->request.req_type = UIO_REQUEST_READ_BEST;
rt_usbd_io_request(ecm_device->func->device, ecm_device->eps.ep_out, &ecm_device->eps.ep_out->request);
}
return RT_EOK;
}
static rt_err_t rt_ecm_eth_init(rt_device_t dev)
{
return RT_EOK;
}
static rt_err_t rt_ecm_eth_open(rt_device_t dev, rt_uint16_t oflag)
{
return RT_EOK;
}
static rt_err_t rt_ecm_eth_close(rt_device_t dev)
{
return RT_EOK;
}
static rt_size_t rt_ecm_eth_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
rt_set_errno(-RT_ENOSYS);
return 0;
}
static rt_size_t rt_ecm_eth_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
rt_set_errno(-RT_ENOSYS);
return 0;
}
static rt_err_t rt_ecm_eth_control(rt_device_t dev, int cmd, void *args)
{
rt_ecm_eth_t ecm_eth_dev = (rt_ecm_eth_t)dev;
switch(cmd)
{
case NIOCTL_GADDR:
/* get mac address */
if(args) rt_memcpy(args, ecm_eth_dev->dev_addr, MAX_ADDR_LEN);
else return -RT_ERROR;
break;
default :
break;
}
return RT_EOK;
}
struct pbuf *rt_ecm_eth_rx(rt_device_t dev)
{
struct pbuf* p = RT_NULL;
rt_uint32_t offset = 0;
rt_ecm_eth_t ecm_eth_dev = (rt_ecm_eth_t)dev;
if(ecm_eth_dev->rx_size != 0)
{
/* allocate buffer */
p = pbuf_alloc(PBUF_RAW, ecm_eth_dev->rx_size, PBUF_RAM);
if (p != RT_NULL)
{
struct pbuf* q;
for (q = p; q != RT_NULL; q= q->next)
{
/* Copy the received frame into buffer from memory pointed by the current ETHERNET DMA Rx descriptor */
rt_memcpy(q->payload,
(rt_uint8_t *)((ecm_eth_dev->rx_buffer) + offset),
q->len);
offset += q->len;
}
}
}
{
if(ecm_eth_dev->func->device->state == USB_STATE_CONFIGURED)
{
ecm_eth_dev->rx_size = 0;
ecm_eth_dev->rx_offset = 0;
ecm_eth_dev->eps.ep_out->request.buffer = ecm_eth_dev->eps.ep_out->buffer;
ecm_eth_dev->eps.ep_out->request.size = EP_MAXPACKET(ecm_eth_dev->eps.ep_out);
ecm_eth_dev->eps.ep_out->request.req_type = UIO_REQUEST_READ_BEST;
rt_usbd_io_request(ecm_eth_dev->func->device, ecm_eth_dev->eps.ep_out, &ecm_eth_dev->eps.ep_out->request);
}
}
return p;
}
rt_err_t rt_ecm_eth_tx(rt_device_t dev, struct pbuf* p)
{
struct pbuf* q;
char * pbuffer;
rt_err_t result = RT_EOK;
rt_ecm_eth_t ecm_eth_dev = (rt_ecm_eth_t)dev;
if(!ecm_eth_dev->parent.link_status)
{
ECM_PRINTF("linkdown, drop pkg\r\n");
return RT_EOK;
}
// RT_ASSERT(p->tot_len < USB_ETH_MTU);
if(p->tot_len > USB_ETH_MTU)
{
ECM_PRINTF("RNDIS MTU is:%d, but the send packet size is %d\r\n",
USB_ETH_MTU, p->tot_len);
p->tot_len = USB_ETH_MTU;
}
result = rt_sem_take(&ecm_eth_dev->tx_buffer_free, RT_WAITING_FOREVER);
if(result != RT_EOK)
{
return result;
}
pbuffer = (char *)&ecm_eth_dev->tx_buffer;
for (q = p; q != NULL; q = q->next)
{
rt_memcpy(pbuffer, q->payload, q->len);
pbuffer += q->len;
}
{
if(ecm_eth_dev->func->device->state == USB_STATE_CONFIGURED)
{
ecm_eth_dev->eps.ep_in->request.buffer = (void *)&ecm_eth_dev->tx_buffer;
ecm_eth_dev->eps.ep_in->request.size = p->tot_len;
ecm_eth_dev->eps.ep_in->request.req_type = UIO_REQUEST_WRITE;
rt_usbd_io_request(ecm_eth_dev->func->device, ecm_eth_dev->eps.ep_in, &ecm_eth_dev->eps.ep_in->request);
}
}
return result;
}
/**
* This function will handle RNDIS interrupt in endpoint request.
*
* @param device the usb device object.
* @param size request size.
*
* @return RT_EOK.
*/
static rt_err_t _ep_cmd_handler(ufunction_t func, rt_size_t size)
{
return RT_EOK;
}
/**
* This function will run cdc class, it will be called on handle set configuration request.
*
* @param device the usb device object.
*
* @return RT_EOK on successful.
*/
static rt_err_t _function_enable(ufunction_t func)
{
cdc_eps_t eps;
rt_ecm_eth_t ecm_device = (rt_ecm_eth_t)func->user_data;
eps = (cdc_eps_t)&ecm_device->eps;
eps->ep_out->buffer = ecm_device->rx_pool;
ecm_device->rx_size = 0;
ecm_device->rx_offset = 0;
eps->ep_out->request.buffer = (void *)eps->ep_out->buffer;
eps->ep_out->request.size = EP_MAXPACKET(eps->ep_out);
eps->ep_out->request.req_type = UIO_REQUEST_READ_BEST;
rt_usbd_io_request(func->device, eps->ep_out, &eps->ep_out->request);
return RT_EOK;
}
/**
* This function will stop cdc class, it will be called on handle set configuration request.
*
* @param device the usb device object.
*
* @return RT_EOK on successful.
*/
static rt_err_t _function_disable(ufunction_t func)
{
eth_device_linkchange(&((rt_ecm_eth_t)func->user_data)->parent, RT_FALSE);
return RT_EOK;
}
static struct ufunction_ops ops =
{
_function_enable,
_function_disable,
RT_NULL,
};
/**
* This function will configure cdc descriptor.
*
* @param comm the communication interface number.
* @param data the data interface number.
*
* @return RT_EOK on successful.
*/
static rt_err_t _cdc_descriptor_config(ucdc_comm_desc_t comm, rt_uint8_t cintf_nr, ucdc_data_desc_t data, rt_uint8_t dintf_nr)
{
comm->call_mgmt_desc.data_interface = dintf_nr;
comm->union_desc.master_interface = cintf_nr;
comm->union_desc.slave_interface0 = dintf_nr;
#ifdef RT_USB_DEVICE_COMPOSITE
comm->iad_desc.bFirstInterface = cintf_nr;
#endif
return RT_EOK;
}
/**
* This function will create a cdc ecm class instance.
*
* @param device the usb device object.
*
* @return RT_EOK on successful.
*/
ufunction_t rt_usbd_function_ecm_create(udevice_t device)
{
ufunction_t cdc;
rt_ecm_eth_t _ecm_eth;
cdc_eps_t eps;
uintf_t intf_comm, intf_data;
ualtsetting_t comm_setting, data_setting;
ucdc_data_desc_t data_desc;
ucdc_eth_desc_t comm_desc;
/* parameter check */
RT_ASSERT(device != RT_NULL);
/* set usb device string description */
rt_usbd_device_set_string(device, _ustring);
/* create a cdc class */
cdc = rt_usbd_function_new(device, &_dev_desc, &ops);
rt_usbd_device_set_qualifier(device, &dev_qualifier);
_ecm_eth= rt_malloc(sizeof(struct rt_ecm_eth));
rt_memset(_ecm_eth, 0, sizeof(struct rt_ecm_eth));
cdc->user_data = _ecm_eth;
_ecm_eth->func = cdc;
/* create a cdc class endpoints collection */
eps = &_ecm_eth->eps;
/* create a cdc communication interface and a cdc data interface */
intf_comm = rt_usbd_interface_new(device, _interface_handler);
intf_data = rt_usbd_interface_new(device, _interface_handler);
/* create a communication alternate setting and a data alternate setting */
comm_setting = rt_usbd_altsetting_new(sizeof(struct ucdc_eth_descriptor));
data_setting = rt_usbd_altsetting_new(sizeof(struct ucdc_data_descriptor));
/* config desc in alternate setting */
rt_usbd_altsetting_config_descriptor(comm_setting, &_comm_desc,
(rt_off_t)&((ucdc_eth_desc_t)0)->intf_desc);
rt_usbd_altsetting_config_descriptor(data_setting, &_data_desc, 0);
/* configure the cdc interface descriptor */
_cdc_descriptor_config(comm_setting->desc, intf_comm->intf_num, data_setting->desc, intf_data->intf_num);
/* create a command endpoint */
comm_desc = (ucdc_eth_desc_t)comm_setting->desc;
eps->ep_cmd = rt_usbd_endpoint_new(&comm_desc->ep_desc, _ep_cmd_handler);
/* add the command endpoint to the cdc communication interface */
rt_usbd_altsetting_add_endpoint(comm_setting, eps->ep_cmd);
/* add the communication alternate setting to the communication interface,
then set default setting of the interface */
rt_usbd_interface_add_altsetting(intf_comm, comm_setting);
rt_usbd_set_altsetting(intf_comm, 0);
/* add the communication interface to the cdc class */
rt_usbd_function_add_interface(cdc, intf_comm);
/* create a bulk in and a bulk out endpoint */
data_desc = (ucdc_data_desc_t)data_setting->desc;
eps->ep_out = rt_usbd_endpoint_new(&data_desc->ep_out_desc, _ep_out_handler);
eps->ep_in = rt_usbd_endpoint_new(&data_desc->ep_in_desc, _ep_in_handler);
/* add the bulk out and bulk in endpoints to the data alternate setting */
rt_usbd_altsetting_add_endpoint(data_setting, eps->ep_in);
rt_usbd_altsetting_add_endpoint(data_setting, eps->ep_out);
/* add the data alternate setting to the data interface
then set default setting of the interface */
rt_usbd_interface_add_altsetting(intf_data, data_setting);
rt_usbd_set_altsetting(intf_data, 0);
/* add the cdc data interface to cdc class */
rt_usbd_function_add_interface(cdc, intf_data);
rt_sem_init(&_ecm_eth->tx_buffer_free, "ue_tx", 1, RT_IPC_FLAG_FIFO);
/* OUI 00-00-00, only for test. */
_ecm_eth->dev_addr[0] = 0x34;
_ecm_eth->dev_addr[1] = 0x97;
_ecm_eth->dev_addr[2] = 0xF6;
/* generate random MAC. */
_ecm_eth->dev_addr[3] = 0x94;//*(const rt_uint8_t *)(0x1fff7a10);
_ecm_eth->dev_addr[4] = 0xEC;//*(const rt_uint8_t *)(0x1fff7a14);
_ecm_eth->dev_addr[5] = 0xAC;//(const rt_uint8_t *)(0x1fff7a18);
/* OUI 00-00-00, only for test. */
_ecm_eth->host_addr[0] = 0x34;
_ecm_eth->host_addr[1] = 0x97;
_ecm_eth->host_addr[2] = 0xF6;
/* generate random MAC. */
_ecm_eth->host_addr[3] = 0x94;//*(const rt_uint8_t *)(0x1fff7a10);
_ecm_eth->host_addr[4] = 0xEC;//*(const rt_uint8_t *)(0x1fff7a14);
_ecm_eth->host_addr[5] = 0xAB;//*(const rt_uint8_t *)(0x1fff7a18);
_ecm_eth->parent.parent.init = rt_ecm_eth_init;
_ecm_eth->parent.parent.open = rt_ecm_eth_open;
_ecm_eth->parent.parent.close = rt_ecm_eth_close;
_ecm_eth->parent.parent.read = rt_ecm_eth_read;
_ecm_eth->parent.parent.write = rt_ecm_eth_write;
_ecm_eth->parent.parent.control = rt_ecm_eth_control;
_ecm_eth->parent.parent.user_data = device;
_ecm_eth->parent.eth_rx = rt_ecm_eth_rx;
_ecm_eth->parent.eth_tx = rt_ecm_eth_tx;
/* register eth device */
eth_device_init(&_ecm_eth->parent, "u0");
/* send link up. */
eth_device_linkchange(&_ecm_eth->parent, RT_FALSE);
return cdc;
}

11
components/drivers/usb/usbdevice/core/usbdevice.c
View File

@ -132,6 +132,17 @@ rt_err_t rt_usb_device_init(void)
}
#endif
#ifdef RT_USB_DEVICE_ECM
{
extern ufunction_t rt_usbd_function_ecm_create(udevice_t device);
/* create a rndis function object */
func = rt_usbd_function_ecm_create(udevice);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
}
#endif
/* set device descriptor to the device */
#ifdef RT_USB_DEVICE_COMPOSITE
rt_usbd_device_set_descriptor(udevice, &compsit_desc);