summaryrefslogtreecommitdiff
path: root/src/class
diff options
context:
space:
mode:
Diffstat (limited to 'src/class')
-rw-r--r--src/class/cdc/cdc_device.c12
-rw-r--r--src/class/cdc/cdc_host.c2
-rw-r--r--src/class/dfu/dfu_rt_device.c4
-rw-r--r--src/class/dfu/dfu_rt_device.h2
-rw-r--r--src/class/hid/hid_device.c2
-rw-r--r--src/class/midi/midi_device.c46
-rw-r--r--src/class/msc/msc_device.c3
-rw-r--r--src/class/net/net_device.c361
-rw-r--r--src/class/usbtmc/usbtmc_device.c8
-rw-r--r--src/class/vendor/vendor_device.c2
10 files changed, 277 insertions, 165 deletions
diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index 14b9a3153..95b14ba54 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -223,11 +223,11 @@ void cdcd_reset(uint8_t rhport)
bool cdcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
{
// Only support ACM subclass
- TU_ASSERT ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass);
+ TU_VERIFY ( TUSB_CLASS_CDC == itf_desc->bInterfaceClass &&
+ CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass);
- // Only support AT commands, no protocol and vendor specific commands.
- TU_ASSERT(tu_within(CDC_COMM_PROTOCOL_NONE, itf_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||
- itf_desc->bInterfaceProtocol == 0xff);
+ // Note: 0xFF can be used with RNDIS
+ TU_VERIFY(tu_within(CDC_COMM_PROTOCOL_NONE, itf_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA));
// Find available interface
cdcd_interface_t * p_cdc = NULL;
@@ -262,12 +262,12 @@ bool cdcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t
p_cdc->ep_notif = ((tusb_desc_endpoint_t const *) p_desc)->bEndpointAddress;
- (*p_length) += p_desc[DESC_OFFSET_LEN];
+ (*p_length) += tu_desc_len(p_desc);
p_desc = tu_desc_next(p_desc);
}
//------------- Data Interface (if any) -------------//
- if ( (TUSB_DESC_INTERFACE == p_desc[DESC_OFFSET_TYPE]) &&
+ if ( (TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
(TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass) )
{
// next to endpoint descriptor
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 595e7fd62..5e45e8f6b 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -86,7 +86,7 @@ bool tuh_cdc_serial_is_mounted(uint8_t dev_addr)
{
// TODO consider all AT Command as serial candidate
return tuh_cdc_mounted(dev_addr) &&
- (CDC_COMM_PROTOCOL_ATCOMMAND <= cdch_data[dev_addr-1].itf_protocol) &&
+ (CDC_COMM_PROTOCOL_NONE <= cdch_data[dev_addr-1].itf_protocol) &&
(cdch_data[dev_addr-1].itf_protocol <= CDC_COMM_PROTOCOL_ATCOMMAND_CDMA);
}
diff --git a/src/class/dfu/dfu_rt_device.c b/src/class/dfu/dfu_rt_device.c
index ad1871dad..0ef5fe63f 100644
--- a/src/class/dfu/dfu_rt_device.c
+++ b/src/class/dfu/dfu_rt_device.c
@@ -61,8 +61,8 @@ bool dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
(void) rhport;
// Ensure this is DFU Runtime
- TU_ASSERT(itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS);
- TU_ASSERT(itf_desc->bInterfaceProtocol == DFU_PROTOCOL_RT);
+ TU_VERIFY(itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS);
+ TU_VERIFY(itf_desc->bInterfaceProtocol == DFU_PROTOCOL_RT);
uint8_t const * p_desc = tu_desc_next( itf_desc );
(*p_length) = sizeof(tusb_desc_interface_t);
diff --git a/src/class/dfu/dfu_rt_device.h b/src/class/dfu/dfu_rt_device.h
index 4348a0f3a..294d993e3 100644
--- a/src/class/dfu/dfu_rt_device.h
+++ b/src/class/dfu/dfu_rt_device.h
@@ -58,7 +58,7 @@ typedef enum
//--------------------------------------------------------------------+
// Invoked when received new data
-TU_ATTR_WEAK void tud_dfu_rt_reboot_to_dfu(void);
+TU_ATTR_WEAK void tud_dfu_rt_reboot_to_dfu(void); // TODO rename to _cb convention
//--------------------------------------------------------------------+
// Internal Class Driver API
diff --git a/src/class/hid/hid_device.c b/src/class/hid/hid_device.c
index 7cb35f1ce..cbdc5bece 100644
--- a/src/class/hid/hid_device.c
+++ b/src/class/hid/hid_device.c
@@ -160,6 +160,8 @@ void hidd_reset(uint8_t rhport)
bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_len)
{
+ TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass);
+
uint8_t const *p_desc = (uint8_t const *) desc_itf;
// Find available interface
diff --git a/src/class/midi/midi_device.c b/src/class/midi/midi_device.c
index ae6e3afe1..6eb522380 100644
--- a/src/class/midi/midi_device.c
+++ b/src/class/midi/midi_device.c
@@ -253,21 +253,31 @@ void midid_reset(uint8_t rhport)
}
}
-bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length)
+bool midid_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_length)
{
- // For now handle the audio control interface as well.
- if ( AUDIO_SUBCLASS_CONTROL == p_interface_desc->bInterfaceSubClass) {
- uint8_t const * p_desc = tu_desc_next ( (uint8_t const *) p_interface_desc );
- (*p_length) = sizeof(tusb_desc_interface_t);
- // Skip over the class specific descriptor.
- (*p_length) += tu_desc_len(p_desc);
+ // 1st Interface is Audio Control v1
+ TU_VERIFY(TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass &&
+ AUDIO_SUBCLASS_CONTROL == desc_itf->bInterfaceSubClass &&
+ AUDIO_PROTOCOL_V1 == desc_itf->bInterfaceProtocol);
+
+ uint16_t drv_len = tu_desc_len(desc_itf);
+ uint8_t const * p_desc = tu_desc_next(desc_itf);
+
+ // Skip Class Specific descriptors
+ while ( TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc) )
+ {
+ drv_len += tu_desc_len(p_desc);
p_desc = tu_desc_next(p_desc);
- return true;
}
- TU_VERIFY(AUDIO_SUBCLASS_MIDI_STREAMING == p_interface_desc->bInterfaceSubClass &&
- AUDIO_PROTOCOL_V1 == p_interface_desc->bInterfaceProtocol );
+ // 2nd Interface is MIDI Streaming
+ TU_VERIFY(TUSB_DESC_INTERFACE == tu_desc_type(p_desc));
+ tusb_desc_interface_t const * desc_midi = (tusb_desc_interface_t const *) p_desc;
+
+ TU_VERIFY(TUSB_CLASS_AUDIO == desc_midi->bInterfaceClass &&
+ AUDIO_SUBCLASS_MIDI_STREAMING == desc_midi->bInterfaceSubClass &&
+ AUDIO_PROTOCOL_V1 == desc_midi->bInterfaceProtocol );
// Find available interface
midid_interface_t * p_midi = NULL;
@@ -280,13 +290,15 @@ bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc,
}
}
- p_midi->itf_num = p_interface_desc->bInterfaceNumber;
+ p_midi->itf_num = desc_midi->bInterfaceNumber;
- uint8_t const * p_desc = tu_desc_next( (uint8_t const *) p_interface_desc );
- (*p_length) = sizeof(tusb_desc_interface_t);
+ // next descriptor
+ drv_len += tu_desc_len(p_desc);
+ p_desc = tu_desc_next(p_desc);
+ // Find and open endpoint descriptors
uint8_t found_endpoints = 0;
- while (found_endpoints < p_interface_desc->bNumEndpoints)
+ while (found_endpoints < desc_midi->bNumEndpoints)
{
if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
{
@@ -298,14 +310,16 @@ bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc,
p_midi->ep_out = ep_addr;
}
- (*p_length) += p_desc[DESC_OFFSET_LEN];
+ drv_len += p_desc[DESC_OFFSET_LEN];
p_desc = tu_desc_next(p_desc);
found_endpoints += 1;
}
- (*p_length) += p_desc[DESC_OFFSET_LEN];
+ drv_len += p_desc[DESC_OFFSET_LEN];
p_desc = tu_desc_next(p_desc);
}
+ *p_length = drv_len;
+
// Prepare for incoming data
TU_ASSERT( usbd_edpt_xfer(rhport, p_midi->ep_out, p_midi->epout_buf, CFG_TUD_MIDI_EPSIZE), false);
diff --git a/src/class/msc/msc_device.c b/src/class/msc/msc_device.c
index 06cc9dbb6..68f5587fd 100644
--- a/src/class/msc/msc_device.c
+++ b/src/class/msc/msc_device.c
@@ -157,7 +157,8 @@ void mscd_reset(uint8_t rhport)
bool mscd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_len)
{
// only support SCSI's BOT protocol
- TU_ASSERT(MSC_SUBCLASS_SCSI == itf_desc->bInterfaceSubClass &&
+ TU_VERIFY(TUSB_CLASS_MSC == itf_desc->bInterfaceClass &&
+ MSC_SUBCLASS_SCSI == itf_desc->bInterfaceSubClass &&
MSC_PROTOCOL_BOT == itf_desc->bInterfaceProtocol);
mscd_interface_t * p_msc = &_mscd_itf;
diff --git a/src/class/net/net_device.c b/src/class/net/net_device.c
index 68520625a..0f2ccbd44 100644
--- a/src/class/net/net_device.c
+++ b/src/class/net/net_device.c
@@ -27,7 +27,7 @@
#include "tusb_option.h"
-#if ( TUSB_OPT_DEVICE_ENABLED && (CFG_TUD_NET != OPT_NET_NONE) )
+#if ( TUSB_OPT_DEVICE_ENABLED && CFG_TUD_NET )
#include "net_device.h"
#include "device/usbd_pvt.h"
@@ -40,40 +40,60 @@ void rndis_class_set_handler(uint8_t *data, int size); /* found in ./misc/networ
//--------------------------------------------------------------------+
typedef struct
{
- uint8_t itf_num;
+ uint8_t itf_num; // Index number of Management Interface, +1 for Data Interface
+ uint8_t itf_data_alt; // Alternate setting of Data Interface. 0 : inactive, 1 : active
+
uint8_t ep_notif;
uint8_t ep_in;
uint8_t ep_out;
+
+ bool ecm_mode;
+
+ // Endpoint descriptor use to open/close when receving SetInterface
+ // TODO since configuration descriptor may not be long-lived memory, we should
+ // keep a copy of endpoint attribute instead
+ uint8_t const * ecm_desc_epdata;
+
} netd_interface_t;
-#if CFG_TUD_NET == OPT_NET_ECM
- #define CFG_TUD_NET_PACKET_PREFIX_LEN 0
- #define CFG_TUD_NET_PACKET_SUFFIX_LEN 0
- #define CFG_TUD_NET_INTERFACESUBCLASS CDC_COMM_SUBCLASS_ETHERNET_NETWORKING_CONTROL_MODEL
-#elif CFG_TUD_NET == OPT_NET_RNDIS
- #define CFG_TUD_NET_PACKET_PREFIX_LEN sizeof(rndis_data_packet_t)
- #define CFG_TUD_NET_PACKET_SUFFIX_LEN 0
- #define CFG_TUD_NET_INTERFACESUBCLASS TUD_RNDIS_ITF_SUBCLASS
-#elif CFG_TUD_NET == OPT_NET_EEM
- #define CFG_TUD_NET_PACKET_PREFIX_LEN 2
- #define CFG_TUD_NET_PACKET_SUFFIX_LEN 4
- #define CFG_TUD_NET_INTERFACESUBCLASS CDC_COMM_SUBCLASS_ETHERNET_EMULATION_MODEL
-#endif
+#define CFG_TUD_NET_PACKET_PREFIX_LEN sizeof(rndis_data_packet_t)
+#define CFG_TUD_NET_PACKET_SUFFIX_LEN 0
CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static uint8_t received[CFG_TUD_NET_PACKET_PREFIX_LEN + CFG_TUD_NET_MTU + CFG_TUD_NET_PACKET_PREFIX_LEN];
CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static uint8_t transmitted[CFG_TUD_NET_PACKET_PREFIX_LEN + CFG_TUD_NET_MTU + CFG_TUD_NET_PACKET_PREFIX_LEN];
-#if CFG_TUD_NET == OPT_NET_ECM
- CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static tusb_control_request_t notify =
- {
- .bmRequestType = 0x21,
- .bRequest = 0 /* NETWORK_CONNECTION */,
+struct ecm_notify_struct
+{
+ tusb_control_request_t header;
+ uint32_t downlink, uplink;
+};
+
+static const struct ecm_notify_struct ecm_notify_nc =
+{
+ .header = {
+ .bmRequestType = 0xA1,
+ .bRequest = 0 /* NETWORK_CONNECTION aka NetworkConnection */,
.wValue = 1 /* Connected */,
.wLength = 0,
- };
-#elif CFG_TUD_NET == OPT_NET_RNDIS
- CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static uint8_t rndis_buf[120];
-#endif
+ },
+};
+
+static const struct ecm_notify_struct ecm_notify_csc =
+{
+ .header = {
+ .bmRequestType = 0xA1,
+ .bRequest = 0x2A /* CONNECTION_SPEED_CHANGE aka ConnectionSpeedChange */,
+ .wLength = 8,
+ },
+ .downlink = 9728000,
+ .uplink = 9728000,
+};
+
+CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static union
+{
+ uint8_t rndis_buf[120];
+ struct ecm_notify_struct ecm_buf;
+} notify;
//--------------------------------------------------------------------+
// INTERNAL OBJECT & FUNCTION DECLARATION
@@ -115,19 +135,28 @@ void netd_reset(uint8_t rhport)
bool netd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
{
- // sanity check the descriptor
- TU_ASSERT (CFG_TUD_NET_INTERFACESUBCLASS == itf_desc->bInterfaceSubClass);
+ bool const is_rndis = (TUD_RNDIS_ITF_CLASS == itf_desc->bInterfaceClass &&
+ TUD_RNDIS_ITF_SUBCLASS == itf_desc->bInterfaceSubClass &&
+ TUD_RNDIS_ITF_PROTOCOL == itf_desc->bInterfaceProtocol);
+
+ bool const is_ecm = (TUSB_CLASS_CDC == itf_desc->bInterfaceClass &&
+ CDC_COMM_SUBCLASS_ETHERNET_NETWORKING_CONTROL_MODEL == itf_desc->bInterfaceSubClass &&
+ 0x00 == itf_desc->bInterfaceProtocol);
+
+ TU_VERIFY ( is_rndis || is_ecm );
// confirm interface hasn't already been allocated
- TU_ASSERT(0 == _netd_itf.ep_in);
+ TU_ASSERT(0 == _netd_itf.ep_notif);
- //------------- first Interface -------------//
+ // sanity check the descriptor
+ _netd_itf.ecm_mode = is_ecm;
+
+ //------------- Management Interface -------------//
_netd_itf.itf_num = itf_desc->bInterfaceNumber;
- uint8_t const * p_desc = tu_desc_next( itf_desc );
(*p_length) = sizeof(tusb_desc_interface_t);
+ uint8_t const * p_desc = tu_desc_next( itf_desc );
-#if CFG_TUD_NET != OPT_NET_EEM
// Communication Functional Descriptors
while ( TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc) )
{
@@ -142,35 +171,49 @@ bool netd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t
_netd_itf.ep_notif = ((tusb_desc_endpoint_t const *) p_desc)->bEndpointAddress;
- (*p_length) += p_desc[DESC_OFFSET_LEN];
+ (*p_length) += tu_desc_len(p_desc);
p_desc = tu_desc_next(p_desc);
}
- //------------- second Interface -------------//
- if ( (TUSB_DESC_INTERFACE == p_desc[DESC_OFFSET_TYPE]) &&
- (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass) )
+ //------------- Data Interface -------------//
+ // - RNDIS Data followed immediately by a pair of endpoints
+ // - CDC-ECM data interface has 2 alternate settings
+ // - 0 : zero endpoints for inactive (default)
+ // - 1 : IN & OUT endpoints for active networking
+ TU_ASSERT(TUSB_DESC_INTERFACE == tu_desc_type(p_desc));
+
+ do
{
- // next to endpoint descriptor
+ tusb_desc_interface_t const * data_itf_desc = (tusb_desc_interface_t const *) p_desc;
+ TU_ASSERT(TUSB_CLASS_CDC_DATA == data_itf_desc->bInterfaceClass);
+
+ (*p_length) += tu_desc_len(p_desc);
p_desc = tu_desc_next(p_desc);
- (*p_length) += sizeof(tusb_desc_interface_t);
- }
-#endif
+ }while( _netd_itf.ecm_mode && (TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) );
+
+ // Pair of endpoints
+ TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc));
- if (TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
+ if ( _netd_itf.ecm_mode )
+ {
+ // ECM by default is in-active, save the endpoint attribute
+ // to open later when received setInterface
+ _netd_itf.ecm_desc_epdata = p_desc;
+ }else
{
- // Open endpoint pair
+ // Open endpoint pair for RNDIS
TU_ASSERT( usbd_open_edpt_pair(rhport, p_desc, 2, TUSB_XFER_BULK, &_netd_itf.ep_out, &_netd_itf.ep_in) );
- (*p_length) += 2*sizeof(tusb_desc_endpoint_t);
- }
+ tud_network_init_cb();
- tud_network_init_cb();
+ // we are ready to transmit a packet
+ can_xmit = true;
- // we are ready to transmit a packet
- can_xmit = true;
+ // prepare for incoming packets
+ tud_network_recv_renew();
+ }
- // prepare for incoming packets
- tud_network_recv_renew();
+ (*p_length) += 2*sizeof(tusb_desc_endpoint_t);
return true;
}
@@ -181,116 +224,167 @@ bool netd_control_complete(uint8_t rhport, tusb_control_request_t const * reques
{
(void) rhport;
- // Handle class request only
- TU_VERIFY (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
-
- TU_VERIFY (_netd_itf.itf_num == request->wIndex);
-
-#if CFG_TUD_NET == OPT_NET_RNDIS
- if (request->bmRequestType_bit.direction == TUSB_DIR_OUT)
+ // Handle RNDIS class control OUT only
+ if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS &&
+ request->bmRequestType_bit.direction == TUSB_DIR_OUT &&
+ _netd_itf.itf_num == request->wIndex)
{
- rndis_class_set_handler(rndis_buf, request->wLength);
+ if ( !_netd_itf.ecm_mode )
+ {
+ rndis_class_set_handler(notify.rndis_buf, request->wLength);
+ }
}
-#endif
return true;
}
+static void ecm_report(bool nc)
+{
+ notify.ecm_buf = (nc) ? ecm_notify_nc : ecm_notify_csc;
+ notify.ecm_buf.header.wIndex = _netd_itf.itf_num;
+ netd_report((uint8_t *)&notify.ecm_buf, (nc) ? sizeof(notify.ecm_buf.header) : sizeof(notify.ecm_buf));
+}
+
// Handle class control request
// return false to stall control endpoint (e.g unsupported request)
bool netd_control_request(uint8_t rhport, tusb_control_request_t const * request)
{
- // Handle class request only
- TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
+ switch ( request->bmRequestType_bit.type )
+ {
+ case TUSB_REQ_TYPE_STANDARD:
+ switch ( request->bRequest )
+ {
+ case TUSB_REQ_GET_INTERFACE:
+ {
+ uint8_t const req_itfnum = (uint8_t) request->wIndex;
+ TU_VERIFY(_netd_itf.itf_num+1 == req_itfnum);
- TU_VERIFY (_netd_itf.itf_num == request->wIndex);
+ tud_control_xfer(rhport, request, &_netd_itf.itf_data_alt, 1);
+ }
+ break;
-#if CFG_TUD_NET == OPT_NET_ECM
- /* the only required CDC-ECM Management Element Request is SetEthernetPacketFilter */
- if (0x43 /* SET_ETHERNET_PACKET_FILTER */ == request->bRequest)
- {
- tud_control_xfer(rhport, request, NULL, 0);
- notify.wIndex = request->wIndex;
- usbd_edpt_xfer(TUD_OPT_RHPORT, _netd_itf.ep_notif, (uint8_t *)&notify, sizeof(notify));
- }
-#elif CFG_TUD_NET == OPT_NET_RNDIS
- if (request->bmRequestType_bit.direction == TUSB_DIR_IN)
- {
- rndis_generic_msg_t *rndis_msg = (rndis_generic_msg_t *)rndis_buf;
- uint32_t msglen = tu_le32toh(rndis_msg->MessageLength);
- TU_ASSERT(msglen <= sizeof(rndis_buf));
- tud_control_xfer(rhport, request, rndis_buf, msglen);
- }
- else
- {
- tud_control_xfer(rhport, request, rndis_buf, sizeof(rndis_buf));
+ case TUSB_REQ_SET_INTERFACE:
+ {
+ uint8_t const req_itfnum = (uint8_t) request->wIndex;
+ uint8_t const req_alt = (uint8_t) request->wValue;
+
+ // Only valid for Data Interface with Alternate is either 0 or 1
+ TU_VERIFY(_netd_itf.itf_num+1 == req_itfnum && req_alt < 2);
+
+ // ACM-ECM only: qequest to enable/disable network activities
+ TU_VERIFY(_netd_itf.ecm_mode);
+
+ _netd_itf.itf_data_alt = req_alt;
+
+ if ( _netd_itf.itf_data_alt )
+ {
+ // TODO since we don't actually close endpoint
+ // hack here to not re-open it
+ if ( _netd_itf.ep_in == 0 && _netd_itf.ep_out == 0 )
+ {
+ TU_ASSERT(_netd_itf.ecm_desc_epdata);
+ TU_ASSERT( usbd_open_edpt_pair(rhport, _netd_itf.ecm_desc_epdata, 2, TUSB_XFER_BULK, &_netd_itf.ep_out, &_netd_itf.ep_in) );
+
+ // TODO should be merge with RNDIS's after endpoint opened
+ // Also should have opposite callback for application to disable network !!
+ tud_network_init_cb();
+ can_xmit = true; // we are ready to transmit a packet
+ tud_network_recv_renew(); // prepare for incoming packets
+ }
+ }else
+ {
+ // TODO close the endpoint pair
+ // For now pretend that we did, this should have no harm since host won't try to
+ // communicate with the endpoints again
+ // _netd_itf.ep_in = _netd_itf.ep_out = 0
+ }
+
+ tud_control_status(rhport, request);
+ }
+ break;
+
+ // unsupported request
+ default: return false;
+ }
+ break;
+
+ case TUSB_REQ_TYPE_CLASS:
+ TU_VERIFY (_netd_itf.itf_num == request->wIndex);
+
+ if (_netd_itf.ecm_mode)
+ {
+ /* the only required CDC-ECM Management Element Request is SetEthernetPacketFilter */
+ if (0x43 /* SET_ETHERNET_PACKET_FILTER */ == request->bRequest)
+ {
+ tud_control_xfer(rhport, request, NULL, 0);
+ ecm_report(true);
+ }
+ }
+ else
+ {
+ if (request->bmRequestType_bit.direction == TUSB_DIR_IN)
+ {
+ rndis_generic_msg_t *rndis_msg = (rndis_generic_msg_t *)notify.rndis_buf;
+ uint32_t msglen = tu_le32toh(rndis_msg->MessageLength);
+ TU_ASSERT(msglen <= sizeof(notify.rndis_buf));
+ tud_control_xfer(rhport, request, notify.rndis_buf, msglen);
+ }
+ else
+ {
+ tud_control_xfer(rhport, request, notify.rndis_buf, sizeof(notify.rndis_buf));
+ }
+ }
+ break;
+
+ // unsupported request
+ default: return false;
}
-#else
- (void)rhport;
-#endif
return true;
}
-struct cdc_eem_packet_header
-{
- uint16_t length:14;
- uint16_t bmCRC:1;
- uint16_t bmType:1;
-};
-
static void handle_incoming_packet(uint32_t len)
{
uint8_t *pnt = received;
uint32_t size = 0;
-#if CFG_TUD_NET == OPT_NET_ECM
- size = len;
-#elif CFG_TUD_NET == OPT_NET_RNDIS
- rndis_data_packet_t *r = (rndis_data_packet_t *)pnt;
- if (len >= sizeof(rndis_data_packet_t))
- if ( (r->MessageType == REMOTE_NDIS_PACKET_MSG) && (r->MessageLength <= len))
- if ( (r->DataOffset + offsetof(rndis_data_packet_t, DataOffset) + r->DataLength) <= len)
- {
- pnt = &received[r->DataOffset + offsetof(rndis_data_packet_t, DataOffset)];
- size = r->DataLength;
- }
-#elif CFG_TUD_NET == OPT_NET_EEM
- struct cdc_eem_packet_header *hdr = (struct cdc_eem_packet_header *)pnt;
-
- (void)len;
-
- if (hdr->bmType)
+ if (_netd_itf.ecm_mode)
{
- /* EEM Control Packet: discard it */
- tud_network_recv_renew();
+ size = len;
}
else
{
- /* EEM Data Packet */
- pnt += CFG_TUD_NET_PACKET_PREFIX_LEN;
- size = hdr->length - 4; /* discard the unused CRC-32 */
+ rndis_data_packet_t *r = (rndis_data_packet_t *)pnt;
+ if (len >= sizeof(rndis_data_packet_t))
+ if ( (r->MessageType == REMOTE_NDIS_PACKET_MSG) && (r->MessageLength <= len))
+ if ( (r->DataOffset + offsetof(rndis_data_packet_t, DataOffset) + r->DataLength) <= len)
+ {
+ pnt = &received[r->DataOffset + offsetof(rndis_data_packet_t, DataOffset)];
+ size = r->DataLength;
+ }
}
-#endif
+
+ bool accepted = false;
if (size)
{
struct pbuf *p = pbuf_alloc(PBUF_RAW, size, PBUF_POOL);
- bool accepted = true;
if (p)
{
memcpy(p->payload, pnt, size);
p->len = size;
accepted = tud_network_recv_cb(p);
- }
- if (!p || !accepted)
- {
- /* if a buffer couldn't be allocated or accepted by the callback, we must discard this packet */
- tud_network_recv_renew();
+ if (!accepted) pbuf_free(p);
}
}
+
+ if (!accepted)
+ {
+ /* if a buffer was never handled by user code, we must renew on the user's behalf */
+ tud_network_recv_renew();
+ }
}
bool netd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
@@ -320,6 +414,11 @@ bool netd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_
}
}
+ if ( _netd_itf.ecm_mode && (ep_addr == _netd_itf.ep_notif) )
+ {
+ if (sizeof(notify.ecm_buf.header) == xferred_bytes) ecm_report(false);
+ }
+
return true;
}
@@ -337,7 +436,7 @@ void tud_network_xmit(struct pbuf *p)
if (!can_xmit)
return;
- len = CFG_TUD_NET_PACKET_PREFIX_LEN;
+ len = (_netd_itf.ecm_mode) ? 0 : CFG_TUD_NET_PACKET_PREFIX_LEN;
data = transmitted + len;
for(q = p; q != NULL; q = q->next)
@@ -347,23 +446,15 @@ void tud_network_xmit(struct pbuf *p)
len += q->len;
}
-#if CFG_TUD_NET == OPT_NET_RNDIS
- rndis_data_packet_t *hdr = (rndis_data_packet_t *)transmitted;
- memset(hdr, 0, sizeof(rndis_data_packet_t));
- hdr->MessageType = REMOTE_NDIS_PACKET_MSG;
- hdr->MessageLength = len;
- hdr->DataOffset = sizeof(rndis_data_packet_t) - offsetof(rndis_data_packet_t, DataOffset);
- hdr->DataLength = len - sizeof(rndis_data_packet_t);
-#elif CFG_TUD_NET == OPT_NET_EEM
- struct cdc_eem_packet_header *hdr = (struct cdc_eem_packet_header *)transmitted;
- /* append a fake CRC-32; the standard allows 0xDEADBEEF, which takes less CPU time */
- data[0] = 0xDE; data[1] = 0xAD; data[2] = 0xBE; data[3] = 0xEF;
- /* adjust length to reflect added fake CRC-32 */
- len += 4;
- hdr->bmType = 0; /* EEM Data Packet */
- hdr->length = len - sizeof(struct cdc_eem_packet_header);
- hdr->bmCRC = 0; /* Ethernet Frame CRC-32 set to 0xDEADBEEF */
-#endif
+ if (!_netd_itf.ecm_mode)
+ {
+ rndis_data_packet_t *hdr = (rndis_data_packet_t *)transmitted;
+ memset(hdr, 0, sizeof(rndis_data_packet_t));
+ hdr->MessageType = REMOTE_NDIS_PACKET_MSG;
+ hdr->MessageLength = len;
+ hdr->DataOffset = sizeof(rndis_data_packet_t) - offsetof(rndis_data_packet_t, DataOffset);
+ hdr->DataLength = len - sizeof(rndis_data_packet_t);
+ }
do_in_xfer(transmitted, len);
}
diff --git a/src/class/usbtmc/usbtmc_device.c b/src/class/usbtmc/usbtmc_device.c
index 92d8d34ef..abe26ced3 100644
--- a/src/class/usbtmc/usbtmc_device.c
+++ b/src/class/usbtmc/usbtmc_device.c
@@ -263,17 +263,19 @@ void usbtmcd_init_cb(void)
bool usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
{
(void)rhport;
- TU_ASSERT(usbtmc_state.state == STATE_CLOSED);
uint8_t const * p_desc;
uint8_t found_endpoints = 0;
+ TU_VERIFY(itf_desc->bInterfaceClass == TUD_USBTMC_APP_CLASS);
+ TU_VERIFY(itf_desc->bInterfaceSubClass == TUD_USBTMC_APP_SUBCLASS);
+
#ifndef NDEBUG
- TU_ASSERT(itf_desc->bInterfaceClass == TUD_USBTMC_APP_CLASS);
- TU_ASSERT(itf_desc->bInterfaceSubClass == TUD_USBTMC_APP_SUBCLASS);
// Only 2 or 3 endpoints are allowed for USBTMC.
TU_ASSERT((itf_desc->bNumEndpoints == 2) || (itf_desc->bNumEndpoints ==3));
#endif
+ TU_ASSERT(usbtmc_state.state == STATE_CLOSED);
+
// Interface
(*p_length) = 0u;
p_desc = (uint8_t const *) itf_desc;
diff --git a/src/class/vendor/vendor_device.c b/src/class/vendor/vendor_device.c
index 8db5005f4..7f2fe9793 100644
--- a/src/class/vendor/vendor_device.c
+++ b/src/class/vendor/vendor_device.c
@@ -168,6 +168,8 @@ void vendord_reset(uint8_t rhport)
bool vendord_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_len)
{
+ TU_VERIFY(TUSB_CLASS_VENDOR_SPECIFIC == itf_desc->bInterfaceClass);
+
// Find available interface
vendord_interface_t* p_vendor = NULL;
for(uint8_t i=0; i<CFG_TUD_VENDOR; i++)
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-20 22:51:13 +0000