OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

USB CDC NCM errata updates for cdc_ncm host driver 

Specification links:
- CDC NCM errata link:
  http://www.usb.org/developers/devclass_docs/NCM10_012011.zip
- CDC and WMC errata link:
  http://www.usb.org/developers/devclass_docs/CDC1.2_WMC1.1_012011.zip

Changes:
- driver updated to match cdc.h header with errata changes
- added support for USB_CDC_SET_NTB_INPUT_SIZE control request with
  8 byte length
- fixes to comply with specification: send only control requests supported by
  device, set number of datagrams for IN direction, connection speed structure
  update, etc.
- packet loss fixed for tx direction; misleading flag renamed.
- adjusted hard_mtu value.

Signed-off-by: Alexey Orishko <alexey.orishko@stericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Alexey Orishko 2011-02-07 09:45:10 +00:00 committed by David S. Miller
parent 3a9dda7602
commit 84e77a8bc7
1 changed files with 146 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

225
drivers/net/usb/cdc_ncm.c
View File

@ -1,7 +1,7 @@
/* /*
* cdc_ncm.c * cdc_ncm.c
* *
* Copyright (C) ST-Ericsson 2010 * Copyright (C) ST-Ericsson 2010-2011
* Contact: Alexey Orishko <alexey.orishko@stericsson.com> * Contact: Alexey Orishko <alexey.orishko@stericsson.com>
* Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com> * Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com>
* *
@ -54,7 +54,7 @@
#include <linux/usb/usbnet.h> #include <linux/usb/usbnet.h>
#include <linux/usb/cdc.h> #include <linux/usb/cdc.h>
#define DRIVER_VERSION "17-Jan-2011" #define DRIVER_VERSION "7-Feb-2011"
/* CDC NCM subclass 3.2.1 */ /* CDC NCM subclass 3.2.1 */
#define USB_CDC_NCM_NDP16_LENGTH_MIN 0x10 #define USB_CDC_NCM_NDP16_LENGTH_MIN 0x10
@ -77,6 +77,9 @@
*/ */
#define CDC_NCM_DPT_DATAGRAMS_MAX 32 #define CDC_NCM_DPT_DATAGRAMS_MAX 32
/* Maximum amount of IN datagrams in NTB */
#define CDC_NCM_DPT_DATAGRAMS_IN_MAX 0 /* unlimited */
/* Restart the timer, if amount of datagrams is less than given value */ /* Restart the timer, if amount of datagrams is less than given value */
#define CDC_NCM_RESTART_TIMER_DATAGRAM_CNT 3 #define CDC_NCM_RESTART_TIMER_DATAGRAM_CNT 3
@ -85,11 +88,6 @@
(sizeof(struct usb_cdc_ncm_nth16) + sizeof(struct usb_cdc_ncm_ndp16) + \ (sizeof(struct usb_cdc_ncm_nth16) + sizeof(struct usb_cdc_ncm_ndp16) + \
(CDC_NCM_DPT_DATAGRAMS_MAX + 1) * sizeof(struct usb_cdc_ncm_dpe16)) (CDC_NCM_DPT_DATAGRAMS_MAX + 1) * sizeof(struct usb_cdc_ncm_dpe16))
struct connection_speed_change {
__le32 USBitRate; /* holds 3GPP downlink value, bits per second */
__le32 DSBitRate; /* holds 3GPP uplink value, bits per second */
} __attribute__ ((packed));
struct cdc_ncm_data { struct cdc_ncm_data {
struct usb_cdc_ncm_nth16 nth16; struct usb_cdc_ncm_nth16 nth16;
struct usb_cdc_ncm_ndp16 ndp16; struct usb_cdc_ncm_ndp16 ndp16;
@ -198,10 +196,10 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
{ {
struct usb_cdc_notification req; struct usb_cdc_notification req;
u32 val; u32 val;
__le16 max_datagram_size;
u8 flags; u8 flags;
u8 iface_no; u8 iface_no;
int err; int err;
u16 ntb_fmt_supported;
iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
@ -223,6 +221,9 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder); ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder);
ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor); ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor);
ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment); ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment);
/* devices prior to NCM Errata shall set this field to zero */
ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams);
ntb_fmt_supported = le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported);
if (ctx->func_desc != NULL) if (ctx->func_desc != NULL)
flags = ctx->func_desc->bmNetworkCapabilities; flags = ctx->func_desc->bmNetworkCapabilities;
@ -231,22 +232,58 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u " pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u "
"wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u " "wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u "
"wNdpOutAlignment=%u flags=0x%x\n", "wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n",
ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus, ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus,
ctx->tx_ndp_modulus, flags); ctx->tx_ndp_modulus, ctx->tx_max_datagrams, flags);
/* max count of tx datagrams without terminating NULL entry */ /* max count of tx datagrams */
ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX; if ((ctx->tx_max_datagrams == 0) ||
(ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX))
ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX;
/* verify maximum size of received NTB in bytes */ /* verify maximum size of received NTB in bytes */
if ((ctx->rx_max < if (ctx->rx_max < USB_CDC_NCM_NTB_MIN_IN_SIZE) {
(CDC_NCM_MIN_HDR_SIZE + CDC_NCM_MIN_DATAGRAM_SIZE)) || pr_debug("Using min receive length=%d\n",
(ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX)) { USB_CDC_NCM_NTB_MIN_IN_SIZE);
ctx->rx_max = USB_CDC_NCM_NTB_MIN_IN_SIZE;
}
if (ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX) {
pr_debug("Using default maximum receive length=%d\n", pr_debug("Using default maximum receive length=%d\n",
CDC_NCM_NTB_MAX_SIZE_RX); CDC_NCM_NTB_MAX_SIZE_RX);
ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX; ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX;
} }
/* inform device about NTB input size changes */
if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) {
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
USB_RECIP_INTERFACE;
req.bNotificationType = USB_CDC_SET_NTB_INPUT_SIZE;
req.wValue = 0;
req.wIndex = cpu_to_le16(iface_no);
if (flags & USB_CDC_NCM_NCAP_NTB_INPUT_SIZE) {
struct usb_cdc_ncm_ndp_input_size ndp_in_sz;
req.wLength = 8;
ndp_in_sz.dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
ndp_in_sz.wNtbInMaxDatagrams =
cpu_to_le16(CDC_NCM_DPT_DATAGRAMS_MAX);
ndp_in_sz.wReserved = 0;
err = cdc_ncm_do_request(ctx, &req, &ndp_in_sz, 0, NULL,
1000);
} else {
__le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
req.wLength = 4;
err = cdc_ncm_do_request(ctx, &req, &dwNtbInMaxSize, 0,
NULL, 1000);
}
if (err)
pr_debug("Setting NTB Input Size failed\n");
}
/* verify maximum size of transmitted NTB in bytes */ /* verify maximum size of transmitted NTB in bytes */
if ((ctx->tx_max < if ((ctx->tx_max <
(CDC_NCM_MIN_HDR_SIZE + CDC_NCM_MIN_DATAGRAM_SIZE)) || (CDC_NCM_MIN_HDR_SIZE + CDC_NCM_MIN_DATAGRAM_SIZE)) ||
@ -297,47 +334,84 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
/* additional configuration */ /* additional configuration */
/* set CRC Mode */ /* set CRC Mode */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE; if (flags & USB_CDC_NCM_NCAP_CRC_MODE) {
req.bNotificationType = USB_CDC_SET_CRC_MODE; req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
req.wValue = cpu_to_le16(USB_CDC_NCM_CRC_NOT_APPENDED); USB_RECIP_INTERFACE;
req.wIndex = cpu_to_le16(iface_no); req.bNotificationType = USB_CDC_SET_CRC_MODE;
req.wLength = 0; req.wValue = cpu_to_le16(USB_CDC_NCM_CRC_NOT_APPENDED);
req.wIndex = cpu_to_le16(iface_no);
req.wLength = 0;
err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000); err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000);
if (err) if (err)
pr_debug("Setting CRC mode off failed\n"); pr_debug("Setting CRC mode off failed\n");
}
/* set NTB format */ /* set NTB format, if both formats are supported */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE; if (ntb_fmt_supported & USB_CDC_NCM_NTH32_SIGN) {
req.bNotificationType = USB_CDC_SET_NTB_FORMAT; req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
req.wValue = cpu_to_le16(USB_CDC_NCM_NTB16_FORMAT); USB_RECIP_INTERFACE;
req.wIndex = cpu_to_le16(iface_no); req.bNotificationType = USB_CDC_SET_NTB_FORMAT;
req.wLength = 0; req.wValue = cpu_to_le16(USB_CDC_NCM_NTB16_FORMAT);
req.wIndex = cpu_to_le16(iface_no);
req.wLength = 0;
err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000); err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000);
if (err) if (err)
pr_debug("Setting NTB format to 16-bit failed\n"); pr_debug("Setting NTB format to 16-bit failed\n");
}
ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
/* set Max Datagram Size (MTU) */ /* set Max Datagram Size (MTU) */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE; if (flags & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE) {
req.bNotificationType = USB_CDC_GET_MAX_DATAGRAM_SIZE; __le16 max_datagram_size;
req.wValue = 0; u16 eth_max_sz = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
req.wIndex = cpu_to_le16(iface_no);
req.wLength = cpu_to_le16(2);
err = cdc_ncm_do_request(ctx, &req, &max_datagram_size, 0, NULL, 1000); req.bmRequestType = USB_TYPE_CLASS | USB_DIR_IN |
if (err) { USB_RECIP_INTERFACE;
pr_debug(" GET_MAX_DATAGRAM_SIZE failed, using size=%u\n", req.bNotificationType = USB_CDC_GET_MAX_DATAGRAM_SIZE;
CDC_NCM_MIN_DATAGRAM_SIZE); req.wValue = 0;
/* use default */ req.wIndex = cpu_to_le16(iface_no);
ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE; req.wLength = cpu_to_le16(2);
} else {
ctx->max_datagram_size = le16_to_cpu(max_datagram_size); err = cdc_ncm_do_request(ctx, &req, &max_datagram_size, 0, NULL,
1000);
if (err) {
pr_debug("GET_MAX_DATAGRAM_SIZE failed, use size=%u\n",
CDC_NCM_MIN_DATAGRAM_SIZE);
} else {
ctx->max_datagram_size = le16_to_cpu(max_datagram_size);
/* Check Eth descriptor value */
if (eth_max_sz < CDC_NCM_MAX_DATAGRAM_SIZE) {
if (ctx->max_datagram_size > eth_max_sz)
ctx->max_datagram_size = eth_max_sz;
} else {
if (ctx->max_datagram_size >
CDC_NCM_MAX_DATAGRAM_SIZE)
ctx->max_datagram_size =
CDC_NCM_MAX_DATAGRAM_SIZE;
}
if (ctx->max_datagram_size < CDC_NCM_MIN_DATAGRAM_SIZE)
ctx->max_datagram_size =
CDC_NCM_MIN_DATAGRAM_SIZE;
/* if value changed, update device */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
USB_RECIP_INTERFACE;
req.bNotificationType = USB_CDC_SET_MAX_DATAGRAM_SIZE;
req.wValue = 0;
req.wIndex = cpu_to_le16(iface_no);
req.wLength = 2;
max_datagram_size = cpu_to_le16(ctx->max_datagram_size);
err = cdc_ncm_do_request(ctx, &req, &max_datagram_size,
0, NULL, 1000);
if (err)
pr_debug("SET_MAX_DATAGRAM_SIZE failed\n");
}
if (ctx->max_datagram_size < CDC_NCM_MIN_DATAGRAM_SIZE)
ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
else if (ctx->max_datagram_size > CDC_NCM_MAX_DATAGRAM_SIZE)
ctx->max_datagram_size = CDC_NCM_MAX_DATAGRAM_SIZE;
} }
if (ctx->netdev->mtu != (ctx->max_datagram_size - ETH_HLEN)) if (ctx->netdev->mtu != (ctx->max_datagram_size - ETH_HLEN))
@ -466,19 +540,13 @@ static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf)
ctx->ether_desc = ctx->ether_desc =
(const struct usb_cdc_ether_desc *)buf; (const struct usb_cdc_ether_desc *)buf;
dev->hard_mtu = dev->hard_mtu =
le16_to_cpu(ctx->ether_desc->wMaxSegmentSize); le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
if (dev->hard_mtu < if (dev->hard_mtu < CDC_NCM_MIN_DATAGRAM_SIZE)
(CDC_NCM_MIN_DATAGRAM_SIZE - ETH_HLEN)) dev->hard_mtu = CDC_NCM_MIN_DATAGRAM_SIZE;
dev->hard_mtu = else if (dev->hard_mtu > CDC_NCM_MAX_DATAGRAM_SIZE)
CDC_NCM_MIN_DATAGRAM_SIZE - ETH_HLEN; dev->hard_mtu = CDC_NCM_MAX_DATAGRAM_SIZE;
else if (dev->hard_mtu >
(CDC_NCM_MAX_DATAGRAM_SIZE - ETH_HLEN))
dev->hard_mtu =
CDC_NCM_MAX_DATAGRAM_SIZE - ETH_HLEN;
break; break;
case USB_CDC_NCM_TYPE: case USB_CDC_NCM_TYPE:
@ -628,13 +696,13 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
u32 offset; u32 offset;
u32 last_offset; u32 last_offset;
u16 n = 0; u16 n = 0;
u8 timeout = 0; u8 ready2send = 0;
/* if there is a remaining skb, it gets priority */ /* if there is a remaining skb, it gets priority */
if (skb != NULL) if (skb != NULL)
swap(skb, ctx->tx_rem_skb); swap(skb, ctx->tx_rem_skb);
else else
timeout = 1; ready2send = 1;
/* /*
* +----------------+ * +----------------+
@ -682,9 +750,10 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
for (; n < ctx->tx_max_datagrams; n++) { for (; n < ctx->tx_max_datagrams; n++) {
/* check if end of transmit buffer is reached */ /* check if end of transmit buffer is reached */
if (offset >= ctx->tx_max) if (offset >= ctx->tx_max) {
ready2send = 1;
break; break;
}
/* compute maximum buffer size */ /* compute maximum buffer size */
rem = ctx->tx_max - offset; rem = ctx->tx_max - offset;
@ -711,9 +780,7 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
} }
ctx->tx_rem_skb = skb; ctx->tx_rem_skb = skb;
skb = NULL; skb = NULL;
ready2send = 1;
/* loop one more time */
timeout = 1;
} }
break; break;
} }
@ -756,7 +823,7 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
ctx->tx_curr_last_offset = last_offset; ctx->tx_curr_last_offset = last_offset;
goto exit_no_skb; goto exit_no_skb;
} else if ((n < ctx->tx_max_datagrams) && (timeout == 0)) { } else if ((n < ctx->tx_max_datagrams) && (ready2send == 0)) {
/* wait for more frames */ /* wait for more frames */
/* push variables */ /* push variables */
ctx->tx_curr_skb = skb_out; ctx->tx_curr_skb = skb_out;
@ -813,7 +880,7 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
cpu_to_le16(sizeof(ctx->tx_ncm.nth16)); cpu_to_le16(sizeof(ctx->tx_ncm.nth16));
ctx->tx_ncm.nth16.wSequence = cpu_to_le16(ctx->tx_seq); ctx->tx_ncm.nth16.wSequence = cpu_to_le16(ctx->tx_seq);
ctx->tx_ncm.nth16.wBlockLength = cpu_to_le16(last_offset); ctx->tx_ncm.nth16.wBlockLength = cpu_to_le16(last_offset);
ctx->tx_ncm.nth16.wFpIndex = ALIGN(sizeof(struct usb_cdc_ncm_nth16), ctx->tx_ncm.nth16.wNdpIndex = ALIGN(sizeof(struct usb_cdc_ncm_nth16),
ctx->tx_ndp_modulus); ctx->tx_ndp_modulus);
memcpy(skb_out->data, &(ctx->tx_ncm.nth16), sizeof(ctx->tx_ncm.nth16)); memcpy(skb_out->data, &(ctx->tx_ncm.nth16), sizeof(ctx->tx_ncm.nth16));
@ -825,13 +892,13 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
rem = sizeof(ctx->tx_ncm.ndp16) + ((ctx->tx_curr_frame_num + 1) * rem = sizeof(ctx->tx_ncm.ndp16) + ((ctx->tx_curr_frame_num + 1) *
sizeof(struct usb_cdc_ncm_dpe16)); sizeof(struct usb_cdc_ncm_dpe16));
ctx->tx_ncm.ndp16.wLength = cpu_to_le16(rem); ctx->tx_ncm.ndp16.wLength = cpu_to_le16(rem);
ctx->tx_ncm.ndp16.wNextFpIndex = 0; /* reserved */ ctx->tx_ncm.ndp16.wNextNdpIndex = 0; /* reserved */
memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wFpIndex, memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wNdpIndex,
&(ctx->tx_ncm.ndp16), &(ctx->tx_ncm.ndp16),
sizeof(ctx->tx_ncm.ndp16)); sizeof(ctx->tx_ncm.ndp16));
memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wFpIndex + memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wNdpIndex +
sizeof(ctx->tx_ncm.ndp16), sizeof(ctx->tx_ncm.ndp16),
&(ctx->tx_ncm.dpe16), &(ctx->tx_ncm.dpe16),
(ctx->tx_curr_frame_num + 1) * (ctx->tx_curr_frame_num + 1) *
@ -961,7 +1028,7 @@ static int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
goto error; goto error;
} }
temp = le16_to_cpu(ctx->rx_ncm.nth16.wFpIndex); temp = le16_to_cpu(ctx->rx_ncm.nth16.wNdpIndex);
if ((temp + sizeof(ctx->rx_ncm.ndp16)) > actlen) { if ((temp + sizeof(ctx->rx_ncm.ndp16)) > actlen) {
pr_debug("invalid DPT16 index\n"); pr_debug("invalid DPT16 index\n");
goto error; goto error;
@ -1048,10 +1115,10 @@ error:
static void static void
cdc_ncm_speed_change(struct cdc_ncm_ctx *ctx, cdc_ncm_speed_change(struct cdc_ncm_ctx *ctx,
struct connection_speed_change *data) struct usb_cdc_speed_change *data)
{ {
uint32_t rx_speed = le32_to_cpu(data->USBitRate); uint32_t rx_speed = le32_to_cpu(data->DLBitRRate);
uint32_t tx_speed = le32_to_cpu(data->DSBitRate); uint32_t tx_speed = le32_to_cpu(data->ULBitRate);
/* /*
* Currently the USB-NET API does not support reporting the actual * Currently the USB-NET API does not support reporting the actual
@ -1092,7 +1159,7 @@ static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
/* test for split data in 8-byte chunks */ /* test for split data in 8-byte chunks */
if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) { if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
cdc_ncm_speed_change(ctx, cdc_ncm_speed_change(ctx,
(struct connection_speed_change *)urb->transfer_buffer); (struct usb_cdc_speed_change *)urb->transfer_buffer);
return; return;
} }
@ -1120,12 +1187,12 @@ static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
break; break;
case USB_CDC_NOTIFY_SPEED_CHANGE: case USB_CDC_NOTIFY_SPEED_CHANGE:
if (urb->actual_length < if (urb->actual_length < (sizeof(*event) +
(sizeof(*event) + sizeof(struct connection_speed_change))) sizeof(struct usb_cdc_speed_change)))
set_bit(EVENT_STS_SPLIT, &dev->flags); set_bit(EVENT_STS_SPLIT, &dev->flags);
else else
cdc_ncm_speed_change(ctx, cdc_ncm_speed_change(ctx,
(struct connection_speed_change *) &event[1]); (struct usb_cdc_speed_change *) &event[1]);
break; break;
default: default: