1 /* 2 * cdc_ncm.c 3 * 4 * Copyright (C) ST-Ericsson 2010-2012 5 * Contact: Alexey Orishko <alexey.orishko@stericsson.com> 6 * Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com> 7 * 8 * USB Host Driver for Network Control Model (NCM) 9 * http://www.usb.org/developers/docs/devclass_docs/NCM10_012011.zip 10 * 11 * The NCM encoding, decoding and initialization logic 12 * derives from FreeBSD 8.x. if_cdce.c and if_cdcereg.h 13 * 14 * This software is available to you under a choice of one of two 15 * licenses. You may choose this file to be licensed under the terms 16 * of the GNU General Public License (GPL) Version 2 or the 2-clause 17 * BSD license listed below: 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions 21 * are met: 22 * 1. Redistributions of source code must retain the above copyright 23 * notice, this list of conditions and the following disclaimer. 24 * 2. Redistributions in binary form must reproduce the above copyright 25 * notice, this list of conditions and the following disclaimer in the 26 * documentation and/or other materials provided with the distribution. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 */ 40 41 #include <linux/module.h> 42 #include <linux/netdevice.h> 43 #include <linux/ctype.h> 44 #include <linux/etherdevice.h> 45 #include <linux/ethtool.h> 46 #include <linux/kstrtox.h> 47 #include <linux/workqueue.h> 48 #include <linux/mii.h> 49 #include <linux/crc32.h> 50 #include <linux/usb.h> 51 #include <linux/hrtimer.h> 52 #include <linux/atomic.h> 53 #include <linux/usb/usbnet.h> 54 #include <linux/usb/cdc.h> 55 #include <linux/usb/cdc_ncm.h> 56 57 #if IS_ENABLED(CONFIG_USB_NET_CDC_MBIM) 58 static bool prefer_mbim = true; 59 #else 60 static bool prefer_mbim; 61 #endif 62 module_param(prefer_mbim, bool, 0644); 63 MODULE_PARM_DESC(prefer_mbim, "Prefer MBIM setting on dual NCM/MBIM functions"); 64 65 static void cdc_ncm_txpath_bh(struct tasklet_struct *t); 66 static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx); 67 static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *hr_timer); 68 static struct usb_driver cdc_ncm_driver; 69 70 struct cdc_ncm_stats { 71 char stat_string[ETH_GSTRING_LEN]; 72 int sizeof_stat; 73 int stat_offset; 74 }; 75 76 #define CDC_NCM_STAT(str, m) { \ 77 .stat_string = str, \ 78 .sizeof_stat = sizeof(((struct cdc_ncm_ctx *)0)->m), \ 79 .stat_offset = offsetof(struct cdc_ncm_ctx, m) } 80 #define CDC_NCM_SIMPLE_STAT(m) CDC_NCM_STAT(__stringify(m), m) 81 82 static const struct cdc_ncm_stats cdc_ncm_gstrings_stats[] = { 83 CDC_NCM_SIMPLE_STAT(tx_reason_ntb_full), 84 CDC_NCM_SIMPLE_STAT(tx_reason_ndp_full), 85 CDC_NCM_SIMPLE_STAT(tx_reason_timeout), 86 CDC_NCM_SIMPLE_STAT(tx_reason_max_datagram), 87 CDC_NCM_SIMPLE_STAT(tx_overhead), 88 CDC_NCM_SIMPLE_STAT(tx_ntbs), 89 CDC_NCM_SIMPLE_STAT(rx_overhead), 90 CDC_NCM_SIMPLE_STAT(rx_ntbs), 91 }; 92 93 #define CDC_NCM_LOW_MEM_MAX_CNT 10 94 95 static int cdc_ncm_get_sset_count(struct net_device __always_unused *netdev, int sset) 96 { 97 switch (sset) { 98 case ETH_SS_STATS: 99 return ARRAY_SIZE(cdc_ncm_gstrings_stats); 100 default: 101 return -EOPNOTSUPP; 102 } 103 } 104 105 static void cdc_ncm_get_ethtool_stats(struct net_device *netdev, 106 struct ethtool_stats __always_unused *stats, 107 u64 *data) 108 { 109 struct usbnet *dev = netdev_priv(netdev); 110 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 111 int i; 112 char *p = NULL; 113 114 for (i = 0; i < ARRAY_SIZE(cdc_ncm_gstrings_stats); i++) { 115 p = (char *)ctx + cdc_ncm_gstrings_stats[i].stat_offset; 116 data[i] = (cdc_ncm_gstrings_stats[i].sizeof_stat == sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 117 } 118 } 119 120 static void cdc_ncm_get_strings(struct net_device __always_unused *netdev, u32 stringset, u8 *data) 121 { 122 u8 *p = data; 123 int i; 124 125 switch (stringset) { 126 case ETH_SS_STATS: 127 for (i = 0; i < ARRAY_SIZE(cdc_ncm_gstrings_stats); i++) { 128 memcpy(p, cdc_ncm_gstrings_stats[i].stat_string, ETH_GSTRING_LEN); 129 p += ETH_GSTRING_LEN; 130 } 131 } 132 } 133 134 static void cdc_ncm_update_rxtx_max(struct usbnet *dev, u32 new_rx, u32 new_tx); 135 136 static const struct ethtool_ops cdc_ncm_ethtool_ops = { 137 .get_link = usbnet_get_link, 138 .nway_reset = usbnet_nway_reset, 139 .get_drvinfo = usbnet_get_drvinfo, 140 .get_msglevel = usbnet_get_msglevel, 141 .set_msglevel = usbnet_set_msglevel, 142 .get_ts_info = ethtool_op_get_ts_info, 143 .get_sset_count = cdc_ncm_get_sset_count, 144 .get_strings = cdc_ncm_get_strings, 145 .get_ethtool_stats = cdc_ncm_get_ethtool_stats, 146 .get_link_ksettings = usbnet_get_link_ksettings_internal, 147 .set_link_ksettings = NULL, 148 }; 149 150 static u32 cdc_ncm_check_rx_max(struct usbnet *dev, u32 new_rx) 151 { 152 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 153 u32 val, max, min; 154 155 /* clamp new_rx to sane values */ 156 min = USB_CDC_NCM_NTB_MIN_IN_SIZE; 157 max = min_t(u32, CDC_NCM_NTB_MAX_SIZE_RX, le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)); 158 159 /* dwNtbInMaxSize spec violation? Use MIN size for both limits */ 160 if (max < min) { 161 dev_warn(&dev->intf->dev, "dwNtbInMaxSize=%u is too small. Using %u\n", 162 le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize), min); 163 max = min; 164 } 165 166 val = clamp_t(u32, new_rx, min, max); 167 if (val != new_rx) 168 dev_dbg(&dev->intf->dev, "rx_max must be in the [%u, %u] range\n", min, max); 169 170 return val; 171 } 172 173 static u32 cdc_ncm_check_tx_max(struct usbnet *dev, u32 new_tx) 174 { 175 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 176 u32 val, max, min; 177 178 /* clamp new_tx to sane values */ 179 if (ctx->is_ndp16) 180 min = ctx->max_datagram_size + ctx->max_ndp_size + sizeof(struct usb_cdc_ncm_nth16); 181 else 182 min = ctx->max_datagram_size + ctx->max_ndp_size + sizeof(struct usb_cdc_ncm_nth32); 183 184 if (le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize) == 0) 185 max = CDC_NCM_NTB_MAX_SIZE_TX; /* dwNtbOutMaxSize not set */ 186 else 187 max = clamp_t(u32, le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize), 188 USB_CDC_NCM_NTB_MIN_OUT_SIZE, 189 CDC_NCM_NTB_MAX_SIZE_TX); 190 191 /* some devices set dwNtbOutMaxSize too low for the above default */ 192 min = min(min, max); 193 194 val = clamp_t(u32, new_tx, min, max); 195 if (val != new_tx) 196 dev_dbg(&dev->intf->dev, "tx_max must be in the [%u, %u] range\n", min, max); 197 198 return val; 199 } 200 201 static ssize_t min_tx_pkt_show(struct device *d, 202 struct device_attribute *attr, char *buf) 203 { 204 struct usbnet *dev = netdev_priv(to_net_dev(d)); 205 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 206 207 return sprintf(buf, "%u\n", ctx->min_tx_pkt); 208 } 209 210 static ssize_t rx_max_show(struct device *d, 211 struct device_attribute *attr, char *buf) 212 { 213 struct usbnet *dev = netdev_priv(to_net_dev(d)); 214 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 215 216 return sprintf(buf, "%u\n", ctx->rx_max); 217 } 218 219 static ssize_t tx_max_show(struct device *d, 220 struct device_attribute *attr, char *buf) 221 { 222 struct usbnet *dev = netdev_priv(to_net_dev(d)); 223 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 224 225 return sprintf(buf, "%u\n", ctx->tx_max); 226 } 227 228 static ssize_t tx_timer_usecs_show(struct device *d, 229 struct device_attribute *attr, char *buf) 230 { 231 struct usbnet *dev = netdev_priv(to_net_dev(d)); 232 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 233 234 return sprintf(buf, "%u\n", ctx->timer_interval / (u32)NSEC_PER_USEC); 235 } 236 237 static ssize_t min_tx_pkt_store(struct device *d, 238 struct device_attribute *attr, 239 const char *buf, size_t len) 240 { 241 struct usbnet *dev = netdev_priv(to_net_dev(d)); 242 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 243 unsigned long val; 244 245 /* no need to restrict values - anything from 0 to infinity is OK */ 246 if (kstrtoul(buf, 0, &val)) 247 return -EINVAL; 248 249 ctx->min_tx_pkt = val; 250 return len; 251 } 252 253 static ssize_t rx_max_store(struct device *d, 254 struct device_attribute *attr, 255 const char *buf, size_t len) 256 { 257 struct usbnet *dev = netdev_priv(to_net_dev(d)); 258 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 259 unsigned long val; 260 261 if (kstrtoul(buf, 0, &val) || cdc_ncm_check_rx_max(dev, val) != val) 262 return -EINVAL; 263 264 cdc_ncm_update_rxtx_max(dev, val, ctx->tx_max); 265 return len; 266 } 267 268 static ssize_t tx_max_store(struct device *d, 269 struct device_attribute *attr, 270 const char *buf, size_t len) 271 { 272 struct usbnet *dev = netdev_priv(to_net_dev(d)); 273 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 274 unsigned long val; 275 276 if (kstrtoul(buf, 0, &val) || cdc_ncm_check_tx_max(dev, val) != val) 277 return -EINVAL; 278 279 cdc_ncm_update_rxtx_max(dev, ctx->rx_max, val); 280 return len; 281 } 282 283 static ssize_t tx_timer_usecs_store(struct device *d, 284 struct device_attribute *attr, 285 const char *buf, size_t len) 286 { 287 struct usbnet *dev = netdev_priv(to_net_dev(d)); 288 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 289 ssize_t ret; 290 unsigned long val; 291 292 ret = kstrtoul(buf, 0, &val); 293 if (ret) 294 return ret; 295 if (val && (val < CDC_NCM_TIMER_INTERVAL_MIN || val > CDC_NCM_TIMER_INTERVAL_MAX)) 296 return -EINVAL; 297 298 spin_lock_bh(&ctx->mtx); 299 ctx->timer_interval = val * NSEC_PER_USEC; 300 if (!ctx->timer_interval) 301 ctx->tx_timer_pending = 0; 302 spin_unlock_bh(&ctx->mtx); 303 return len; 304 } 305 306 static DEVICE_ATTR_RW(min_tx_pkt); 307 static DEVICE_ATTR_RW(rx_max); 308 static DEVICE_ATTR_RW(tx_max); 309 static DEVICE_ATTR_RW(tx_timer_usecs); 310 311 static ssize_t ndp_to_end_show(struct device *d, struct device_attribute *attr, char *buf) 312 { 313 struct usbnet *dev = netdev_priv(to_net_dev(d)); 314 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 315 316 return sprintf(buf, "%c\n", ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END ? 'Y' : 'N'); 317 } 318 319 static ssize_t ndp_to_end_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 320 { 321 struct usbnet *dev = netdev_priv(to_net_dev(d)); 322 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 323 bool enable; 324 325 if (kstrtobool(buf, &enable)) 326 return -EINVAL; 327 328 /* no change? */ 329 if (enable == (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END)) 330 return len; 331 332 if (enable) { 333 if (ctx->is_ndp16 && !ctx->delayed_ndp16) { 334 ctx->delayed_ndp16 = kzalloc(ctx->max_ndp_size, GFP_KERNEL); 335 if (!ctx->delayed_ndp16) 336 return -ENOMEM; 337 } 338 if (!ctx->is_ndp16 && !ctx->delayed_ndp32) { 339 ctx->delayed_ndp32 = kzalloc(ctx->max_ndp_size, GFP_KERNEL); 340 if (!ctx->delayed_ndp32) 341 return -ENOMEM; 342 } 343 } 344 345 /* flush pending data before changing flag */ 346 netif_tx_lock_bh(dev->net); 347 usbnet_start_xmit(NULL, dev->net); 348 spin_lock_bh(&ctx->mtx); 349 if (enable) 350 ctx->drvflags |= CDC_NCM_FLAG_NDP_TO_END; 351 else 352 ctx->drvflags &= ~CDC_NCM_FLAG_NDP_TO_END; 353 spin_unlock_bh(&ctx->mtx); 354 netif_tx_unlock_bh(dev->net); 355 356 return len; 357 } 358 static DEVICE_ATTR_RW(ndp_to_end); 359 360 #define NCM_PARM_ATTR(name, format, tocpu) \ 361 static ssize_t cdc_ncm_show_##name(struct device *d, struct device_attribute *attr, char *buf) \ 362 { \ 363 struct usbnet *dev = netdev_priv(to_net_dev(d)); \ 364 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; \ 365 return sprintf(buf, format "\n", tocpu(ctx->ncm_parm.name)); \ 366 } \ 367 static DEVICE_ATTR(name, 0444, cdc_ncm_show_##name, NULL) 368 369 NCM_PARM_ATTR(bmNtbFormatsSupported, "0x%04x", le16_to_cpu); 370 NCM_PARM_ATTR(dwNtbInMaxSize, "%u", le32_to_cpu); 371 NCM_PARM_ATTR(wNdpInDivisor, "%u", le16_to_cpu); 372 NCM_PARM_ATTR(wNdpInPayloadRemainder, "%u", le16_to_cpu); 373 NCM_PARM_ATTR(wNdpInAlignment, "%u", le16_to_cpu); 374 NCM_PARM_ATTR(dwNtbOutMaxSize, "%u", le32_to_cpu); 375 NCM_PARM_ATTR(wNdpOutDivisor, "%u", le16_to_cpu); 376 NCM_PARM_ATTR(wNdpOutPayloadRemainder, "%u", le16_to_cpu); 377 NCM_PARM_ATTR(wNdpOutAlignment, "%u", le16_to_cpu); 378 NCM_PARM_ATTR(wNtbOutMaxDatagrams, "%u", le16_to_cpu); 379 380 static struct attribute *cdc_ncm_sysfs_attrs[] = { 381 &dev_attr_min_tx_pkt.attr, 382 &dev_attr_ndp_to_end.attr, 383 &dev_attr_rx_max.attr, 384 &dev_attr_tx_max.attr, 385 &dev_attr_tx_timer_usecs.attr, 386 &dev_attr_bmNtbFormatsSupported.attr, 387 &dev_attr_dwNtbInMaxSize.attr, 388 &dev_attr_wNdpInDivisor.attr, 389 &dev_attr_wNdpInPayloadRemainder.attr, 390 &dev_attr_wNdpInAlignment.attr, 391 &dev_attr_dwNtbOutMaxSize.attr, 392 &dev_attr_wNdpOutDivisor.attr, 393 &dev_attr_wNdpOutPayloadRemainder.attr, 394 &dev_attr_wNdpOutAlignment.attr, 395 &dev_attr_wNtbOutMaxDatagrams.attr, 396 NULL, 397 }; 398 399 static const struct attribute_group cdc_ncm_sysfs_attr_group = { 400 .name = "cdc_ncm", 401 .attrs = cdc_ncm_sysfs_attrs, 402 }; 403 404 /* handle rx_max and tx_max changes */ 405 static void cdc_ncm_update_rxtx_max(struct usbnet *dev, u32 new_rx, u32 new_tx) 406 { 407 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 408 u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; 409 u32 val; 410 411 val = cdc_ncm_check_rx_max(dev, new_rx); 412 413 /* inform device about NTB input size changes */ 414 if (val != ctx->rx_max) { 415 __le32 dwNtbInMaxSize = cpu_to_le32(val); 416 417 dev_info(&dev->intf->dev, "setting rx_max = %u\n", val); 418 419 /* tell device to use new size */ 420 if (usbnet_write_cmd(dev, USB_CDC_SET_NTB_INPUT_SIZE, 421 USB_TYPE_CLASS | USB_DIR_OUT 422 | USB_RECIP_INTERFACE, 423 0, iface_no, &dwNtbInMaxSize, 4) < 0) 424 dev_dbg(&dev->intf->dev, "Setting NTB Input Size failed\n"); 425 else 426 ctx->rx_max = val; 427 } 428 429 /* usbnet use these values for sizing rx queues */ 430 if (dev->rx_urb_size != ctx->rx_max) { 431 dev->rx_urb_size = ctx->rx_max; 432 if (netif_running(dev->net)) 433 usbnet_unlink_rx_urbs(dev); 434 } 435 436 val = cdc_ncm_check_tx_max(dev, new_tx); 437 if (val != ctx->tx_max) 438 dev_info(&dev->intf->dev, "setting tx_max = %u\n", val); 439 440 /* Adding a pad byte here if necessary simplifies the handling 441 * in cdc_ncm_fill_tx_frame, making tx_max always represent 442 * the real skb max size. 443 * 444 * We cannot use dev->maxpacket here because this is called from 445 * .bind which is called before usbnet sets up dev->maxpacket 446 */ 447 if (val != le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize) && 448 val % usb_maxpacket(dev->udev, dev->out) == 0) 449 val++; 450 451 /* we might need to flush any pending tx buffers if running */ 452 if (netif_running(dev->net) && val > ctx->tx_max) { 453 netif_tx_lock_bh(dev->net); 454 usbnet_start_xmit(NULL, dev->net); 455 /* make sure tx_curr_skb is reallocated if it was empty */ 456 if (ctx->tx_curr_skb) { 457 dev_kfree_skb_any(ctx->tx_curr_skb); 458 ctx->tx_curr_skb = NULL; 459 } 460 ctx->tx_max = val; 461 netif_tx_unlock_bh(dev->net); 462 } else { 463 ctx->tx_max = val; 464 } 465 466 dev->hard_mtu = ctx->tx_max; 467 468 /* max qlen depend on hard_mtu and rx_urb_size */ 469 usbnet_update_max_qlen(dev); 470 471 /* never pad more than 3 full USB packets per transfer */ 472 ctx->min_tx_pkt = clamp_t(u16, ctx->tx_max - 3 * usb_maxpacket(dev->udev, dev->out), 473 CDC_NCM_MIN_TX_PKT, ctx->tx_max); 474 } 475 476 /* helpers for NCM and MBIM differences */ 477 static u8 cdc_ncm_flags(struct usbnet *dev) 478 { 479 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 480 481 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting) && ctx->mbim_desc) 482 return ctx->mbim_desc->bmNetworkCapabilities; 483 if (ctx->func_desc) 484 return ctx->func_desc->bmNetworkCapabilities; 485 return 0; 486 } 487 488 static int cdc_ncm_eth_hlen(struct usbnet *dev) 489 { 490 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting)) 491 return 0; 492 return ETH_HLEN; 493 } 494 495 static u32 cdc_ncm_min_dgram_size(struct usbnet *dev) 496 { 497 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting)) 498 return CDC_MBIM_MIN_DATAGRAM_SIZE; 499 return CDC_NCM_MIN_DATAGRAM_SIZE; 500 } 501 502 static u32 cdc_ncm_max_dgram_size(struct usbnet *dev) 503 { 504 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 505 506 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting) && ctx->mbim_desc) 507 return le16_to_cpu(ctx->mbim_desc->wMaxSegmentSize); 508 if (ctx->ether_desc) 509 return le16_to_cpu(ctx->ether_desc->wMaxSegmentSize); 510 return CDC_NCM_MAX_DATAGRAM_SIZE; 511 } 512 513 /* initial one-time device setup. MUST be called with the data interface 514 * in altsetting 0 515 */ 516 static int cdc_ncm_init(struct usbnet *dev) 517 { 518 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 519 u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; 520 int err; 521 522 err = usbnet_read_cmd(dev, USB_CDC_GET_NTB_PARAMETERS, 523 USB_TYPE_CLASS | USB_DIR_IN 524 |USB_RECIP_INTERFACE, 525 0, iface_no, &ctx->ncm_parm, 526 sizeof(ctx->ncm_parm)); 527 if (err < 0) { 528 dev_err(&dev->intf->dev, "failed GET_NTB_PARAMETERS\n"); 529 return err; /* GET_NTB_PARAMETERS is required */ 530 } 531 532 /* set CRC Mode */ 533 if (cdc_ncm_flags(dev) & USB_CDC_NCM_NCAP_CRC_MODE) { 534 dev_dbg(&dev->intf->dev, "Setting CRC mode off\n"); 535 err = usbnet_write_cmd(dev, USB_CDC_SET_CRC_MODE, 536 USB_TYPE_CLASS | USB_DIR_OUT 537 | USB_RECIP_INTERFACE, 538 USB_CDC_NCM_CRC_NOT_APPENDED, 539 iface_no, NULL, 0); 540 if (err < 0) 541 dev_err(&dev->intf->dev, "SET_CRC_MODE failed\n"); 542 } 543 544 /* use ndp16 by default */ 545 ctx->is_ndp16 = 1; 546 547 /* set NTB format, if both formats are supported. 548 * 549 * "The host shall only send this command while the NCM Data 550 * Interface is in alternate setting 0." 551 */ 552 if (le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported) & 553 USB_CDC_NCM_NTB32_SUPPORTED) { 554 if (ctx->drvflags & CDC_NCM_FLAG_PREFER_NTB32) { 555 ctx->is_ndp16 = 0; 556 dev_dbg(&dev->intf->dev, "Setting NTB format to 32-bit\n"); 557 err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT, 558 USB_TYPE_CLASS | USB_DIR_OUT 559 | USB_RECIP_INTERFACE, 560 USB_CDC_NCM_NTB32_FORMAT, 561 iface_no, NULL, 0); 562 } else { 563 ctx->is_ndp16 = 1; 564 dev_dbg(&dev->intf->dev, "Setting NTB format to 16-bit\n"); 565 err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT, 566 USB_TYPE_CLASS | USB_DIR_OUT 567 | USB_RECIP_INTERFACE, 568 USB_CDC_NCM_NTB16_FORMAT, 569 iface_no, NULL, 0); 570 } 571 if (err < 0) { 572 ctx->is_ndp16 = 1; 573 dev_err(&dev->intf->dev, "SET_NTB_FORMAT failed\n"); 574 } 575 } 576 577 /* set initial device values */ 578 ctx->rx_max = le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize); 579 ctx->tx_max = le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize); 580 ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder); 581 ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor); 582 ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment); 583 /* devices prior to NCM Errata shall set this field to zero */ 584 ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams); 585 586 dev_dbg(&dev->intf->dev, 587 "dwNtbInMaxSize=%u dwNtbOutMaxSize=%u wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n", 588 ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus, 589 ctx->tx_ndp_modulus, ctx->tx_max_datagrams, cdc_ncm_flags(dev)); 590 591 /* max count of tx datagrams */ 592 if ((ctx->tx_max_datagrams == 0) || 593 (ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX)) 594 ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX; 595 596 /* set up maximum NDP size */ 597 if (ctx->is_ndp16) 598 ctx->max_ndp_size = sizeof(struct usb_cdc_ncm_ndp16) + (ctx->tx_max_datagrams + 1) * sizeof(struct usb_cdc_ncm_dpe16); 599 else 600 ctx->max_ndp_size = sizeof(struct usb_cdc_ncm_ndp32) + (ctx->tx_max_datagrams + 1) * sizeof(struct usb_cdc_ncm_dpe32); 601 602 /* initial coalescing timer interval */ 603 ctx->timer_interval = CDC_NCM_TIMER_INTERVAL_USEC * NSEC_PER_USEC; 604 605 return 0; 606 } 607 608 /* set a new max datagram size */ 609 static void cdc_ncm_set_dgram_size(struct usbnet *dev, int new_size) 610 { 611 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 612 u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; 613 __le16 max_datagram_size; 614 u16 mbim_mtu; 615 int err; 616 617 /* set default based on descriptors */ 618 ctx->max_datagram_size = clamp_t(u32, new_size, 619 cdc_ncm_min_dgram_size(dev), 620 CDC_NCM_MAX_DATAGRAM_SIZE); 621 622 /* inform the device about the selected Max Datagram Size? */ 623 if (!(cdc_ncm_flags(dev) & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE)) 624 goto out; 625 626 /* read current mtu value from device */ 627 err = usbnet_read_cmd(dev, USB_CDC_GET_MAX_DATAGRAM_SIZE, 628 USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE, 629 0, iface_no, &max_datagram_size, sizeof(max_datagram_size)); 630 if (err != sizeof(max_datagram_size)) { 631 dev_dbg(&dev->intf->dev, "GET_MAX_DATAGRAM_SIZE failed\n"); 632 goto out; 633 } 634 635 if (le16_to_cpu(max_datagram_size) == ctx->max_datagram_size) 636 goto out; 637 638 max_datagram_size = cpu_to_le16(ctx->max_datagram_size); 639 err = usbnet_write_cmd(dev, USB_CDC_SET_MAX_DATAGRAM_SIZE, 640 USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE, 641 0, iface_no, &max_datagram_size, sizeof(max_datagram_size)); 642 if (err < 0) 643 dev_dbg(&dev->intf->dev, "SET_MAX_DATAGRAM_SIZE failed\n"); 644 645 out: 646 /* set MTU to max supported by the device if necessary */ 647 dev->net->mtu = min_t(int, dev->net->mtu, ctx->max_datagram_size - cdc_ncm_eth_hlen(dev)); 648 649 /* do not exceed operator preferred MTU */ 650 if (ctx->mbim_extended_desc) { 651 mbim_mtu = le16_to_cpu(ctx->mbim_extended_desc->wMTU); 652 if (mbim_mtu != 0 && mbim_mtu < dev->net->mtu) 653 dev->net->mtu = mbim_mtu; 654 } 655 } 656 657 static void cdc_ncm_fix_modulus(struct usbnet *dev) 658 { 659 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 660 u32 val; 661 662 /* 663 * verify that the structure alignment is: 664 * - power of two 665 * - not greater than the maximum transmit length 666 * - not less than four bytes 667 */ 668 val = ctx->tx_ndp_modulus; 669 670 if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) || 671 (val != ((-val) & val)) || (val >= ctx->tx_max)) { 672 dev_dbg(&dev->intf->dev, "Using default alignment: 4 bytes\n"); 673 ctx->tx_ndp_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE; 674 } 675 676 /* 677 * verify that the payload alignment is: 678 * - power of two 679 * - not greater than the maximum transmit length 680 * - not less than four bytes 681 */ 682 val = ctx->tx_modulus; 683 684 if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) || 685 (val != ((-val) & val)) || (val >= ctx->tx_max)) { 686 dev_dbg(&dev->intf->dev, "Using default transmit modulus: 4 bytes\n"); 687 ctx->tx_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE; 688 } 689 690 /* verify the payload remainder */ 691 if (ctx->tx_remainder >= ctx->tx_modulus) { 692 dev_dbg(&dev->intf->dev, "Using default transmit remainder: 0 bytes\n"); 693 ctx->tx_remainder = 0; 694 } 695 696 /* adjust TX-remainder according to NCM specification. */ 697 ctx->tx_remainder = ((ctx->tx_remainder - cdc_ncm_eth_hlen(dev)) & 698 (ctx->tx_modulus - 1)); 699 } 700 701 static int cdc_ncm_setup(struct usbnet *dev) 702 { 703 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 704 u32 def_rx, def_tx; 705 706 /* be conservative when selecting initial buffer size to 707 * increase the number of hosts this will work for 708 */ 709 def_rx = min_t(u32, CDC_NCM_NTB_DEF_SIZE_RX, 710 le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)); 711 def_tx = min_t(u32, CDC_NCM_NTB_DEF_SIZE_TX, 712 le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize)); 713 714 /* clamp rx_max and tx_max and inform device */ 715 cdc_ncm_update_rxtx_max(dev, def_rx, def_tx); 716 717 /* sanitize the modulus and remainder values */ 718 cdc_ncm_fix_modulus(dev); 719 720 /* set max datagram size */ 721 cdc_ncm_set_dgram_size(dev, cdc_ncm_max_dgram_size(dev)); 722 return 0; 723 } 724 725 static void 726 cdc_ncm_find_endpoints(struct usbnet *dev, struct usb_interface *intf) 727 { 728 struct usb_host_endpoint *e, *in = NULL, *out = NULL; 729 u8 ep; 730 731 for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) { 732 e = intf->cur_altsetting->endpoint + ep; 733 734 /* ignore endpoints which cannot transfer data */ 735 if (!usb_endpoint_maxp(&e->desc)) 736 continue; 737 738 switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { 739 case USB_ENDPOINT_XFER_INT: 740 if (usb_endpoint_dir_in(&e->desc)) { 741 if (!dev->status) 742 dev->status = e; 743 } 744 break; 745 746 case USB_ENDPOINT_XFER_BULK: 747 if (usb_endpoint_dir_in(&e->desc)) { 748 if (!in) 749 in = e; 750 } else { 751 if (!out) 752 out = e; 753 } 754 break; 755 756 default: 757 break; 758 } 759 } 760 if (in && !dev->in) 761 dev->in = usb_rcvbulkpipe(dev->udev, 762 in->desc.bEndpointAddress & 763 USB_ENDPOINT_NUMBER_MASK); 764 if (out && !dev->out) 765 dev->out = usb_sndbulkpipe(dev->udev, 766 out->desc.bEndpointAddress & 767 USB_ENDPOINT_NUMBER_MASK); 768 } 769 770 static void cdc_ncm_free(struct cdc_ncm_ctx *ctx) 771 { 772 if (ctx == NULL) 773 return; 774 775 if (ctx->tx_rem_skb != NULL) { 776 dev_kfree_skb_any(ctx->tx_rem_skb); 777 ctx->tx_rem_skb = NULL; 778 } 779 780 if (ctx->tx_curr_skb != NULL) { 781 dev_kfree_skb_any(ctx->tx_curr_skb); 782 ctx->tx_curr_skb = NULL; 783 } 784 785 if (ctx->is_ndp16) 786 kfree(ctx->delayed_ndp16); 787 else 788 kfree(ctx->delayed_ndp32); 789 790 kfree(ctx); 791 } 792 793 /* we need to override the usbnet change_mtu ndo for two reasons: 794 * - respect the negotiated maximum datagram size 795 * - avoid unwanted changes to rx and tx buffers 796 */ 797 int cdc_ncm_change_mtu(struct net_device *net, int new_mtu) 798 { 799 struct usbnet *dev = netdev_priv(net); 800 801 WRITE_ONCE(net->mtu, new_mtu); 802 cdc_ncm_set_dgram_size(dev, new_mtu + cdc_ncm_eth_hlen(dev)); 803 804 return 0; 805 } 806 EXPORT_SYMBOL_GPL(cdc_ncm_change_mtu); 807 808 static const struct net_device_ops cdc_ncm_netdev_ops = { 809 .ndo_open = usbnet_open, 810 .ndo_stop = usbnet_stop, 811 .ndo_start_xmit = usbnet_start_xmit, 812 .ndo_tx_timeout = usbnet_tx_timeout, 813 .ndo_set_rx_mode = usbnet_set_rx_mode, 814 .ndo_get_stats64 = dev_get_tstats64, 815 .ndo_change_mtu = cdc_ncm_change_mtu, 816 .ndo_set_mac_address = eth_mac_addr, 817 .ndo_validate_addr = eth_validate_addr, 818 }; 819 820 int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting, int drvflags) 821 { 822 struct cdc_ncm_ctx *ctx; 823 struct usb_driver *driver; 824 u8 *buf; 825 int len; 826 int temp; 827 u8 iface_no; 828 struct usb_cdc_parsed_header hdr; 829 830 ctx = kzalloc_obj(*ctx); 831 if (!ctx) 832 return -ENOMEM; 833 834 ctx->dev = dev; 835 836 hrtimer_setup(&ctx->tx_timer, &cdc_ncm_tx_timer_cb, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 837 tasklet_setup(&ctx->bh, cdc_ncm_txpath_bh); 838 atomic_set(&ctx->stop, 0); 839 spin_lock_init(&ctx->mtx); 840 841 /* store ctx pointer in device data field */ 842 dev->data[0] = (unsigned long)ctx; 843 844 /* only the control interface can be successfully probed */ 845 ctx->control = intf; 846 847 /* get some pointers */ 848 driver = driver_of(intf); 849 buf = intf->cur_altsetting->extra; 850 len = intf->cur_altsetting->extralen; 851 852 /* parse through descriptors associated with control interface */ 853 cdc_parse_cdc_header(&hdr, intf, buf, len); 854 855 if (hdr.usb_cdc_union_desc) 856 ctx->data = usb_ifnum_to_if(dev->udev, 857 hdr.usb_cdc_union_desc->bSlaveInterface0); 858 ctx->ether_desc = hdr.usb_cdc_ether_desc; 859 ctx->func_desc = hdr.usb_cdc_ncm_desc; 860 ctx->mbim_desc = hdr.usb_cdc_mbim_desc; 861 ctx->mbim_extended_desc = hdr.usb_cdc_mbim_extended_desc; 862 863 /* some buggy devices have an IAD but no CDC Union */ 864 if (!hdr.usb_cdc_union_desc && intf->intf_assoc && intf->intf_assoc->bInterfaceCount == 2) { 865 ctx->data = usb_ifnum_to_if(dev->udev, intf->cur_altsetting->desc.bInterfaceNumber + 1); 866 dev_dbg(&intf->dev, "CDC Union missing - got slave from IAD\n"); 867 } 868 869 /* check if we got everything */ 870 if (!ctx->data) { 871 dev_err(&intf->dev, "CDC Union missing and no IAD found\n"); 872 goto error; 873 } 874 if (cdc_ncm_comm_intf_is_mbim(intf->cur_altsetting)) { 875 if (!ctx->mbim_desc) { 876 dev_err(&intf->dev, "MBIM functional descriptor missing\n"); 877 goto error; 878 } 879 } else { 880 if (!ctx->ether_desc || !ctx->func_desc) { 881 dev_err(&intf->dev, "NCM or ECM functional descriptors missing\n"); 882 goto error; 883 } 884 } 885 886 /* claim data interface, if different from control */ 887 if (ctx->data != ctx->control) { 888 temp = usb_driver_claim_interface(driver, ctx->data, dev); 889 if (temp) { 890 dev_err(&intf->dev, "failed to claim data intf\n"); 891 goto error; 892 } 893 } 894 895 if (ctx->func_desc) 896 ctx->filtering_supported = !!(ctx->func_desc->bmNetworkCapabilities 897 & USB_CDC_NCM_NCAP_ETH_FILTER); 898 899 iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber; 900 901 /* Device-specific flags */ 902 ctx->drvflags = drvflags; 903 904 /* Reset data interface. Some devices will not reset properly 905 * unless they are configured first. Toggle the altsetting to 906 * force a reset. 907 * Some other devices do not work properly with this procedure 908 * that can be avoided using quirk CDC_MBIM_FLAG_AVOID_ALTSETTING_TOGGLE 909 */ 910 if (!(ctx->drvflags & CDC_MBIM_FLAG_AVOID_ALTSETTING_TOGGLE)) 911 usb_set_interface(dev->udev, iface_no, data_altsetting); 912 913 temp = usb_set_interface(dev->udev, iface_no, 0); 914 if (temp) { 915 dev_dbg(&intf->dev, "set interface failed\n"); 916 goto error2; 917 } 918 919 /* initialize basic device settings */ 920 if (cdc_ncm_init(dev)) 921 goto error2; 922 923 /* Some firmwares need a pause here or they will silently fail 924 * to set up the interface properly. This value was decided 925 * empirically on a Sierra Wireless MC7455 running 02.08.02.00 926 * firmware. 927 */ 928 usleep_range(10000, 20000); 929 930 /* configure data interface */ 931 temp = usb_set_interface(dev->udev, iface_no, data_altsetting); 932 if (temp) { 933 dev_dbg(&intf->dev, "set interface failed\n"); 934 goto error2; 935 } 936 937 cdc_ncm_find_endpoints(dev, ctx->data); 938 cdc_ncm_find_endpoints(dev, ctx->control); 939 if (!dev->in || !dev->out || 940 (!dev->status && dev->driver_info->flags & FLAG_LINK_INTR)) { 941 dev_dbg(&intf->dev, "failed to collect endpoints\n"); 942 goto error2; 943 } 944 945 usb_set_intfdata(ctx->control, dev); 946 947 if (ctx->ether_desc) { 948 temp = usbnet_get_ethernet_addr(dev, ctx->ether_desc->iMACAddress); 949 if (temp) { 950 dev_err(&intf->dev, "failed to get mac address\n"); 951 goto error2; 952 } 953 dev_info(&intf->dev, "MAC-Address: %pM\n", dev->net->dev_addr); 954 } 955 956 /* finish setting up the device specific data */ 957 cdc_ncm_setup(dev); 958 959 /* Allocate the delayed NDP if needed. */ 960 if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) { 961 if (ctx->is_ndp16) { 962 ctx->delayed_ndp16 = kzalloc(ctx->max_ndp_size, GFP_KERNEL); 963 if (!ctx->delayed_ndp16) 964 goto error2; 965 } else { 966 ctx->delayed_ndp32 = kzalloc(ctx->max_ndp_size, GFP_KERNEL); 967 if (!ctx->delayed_ndp32) 968 goto error2; 969 } 970 dev_info(&intf->dev, "NDP will be placed at end of frame for this device."); 971 } 972 973 /* override ethtool_ops */ 974 dev->net->ethtool_ops = &cdc_ncm_ethtool_ops; 975 976 /* add our sysfs attrs */ 977 dev->net->sysfs_groups[0] = &cdc_ncm_sysfs_attr_group; 978 979 /* must handle MTU changes */ 980 dev->net->netdev_ops = &cdc_ncm_netdev_ops; 981 dev->net->max_mtu = cdc_ncm_max_dgram_size(dev) - cdc_ncm_eth_hlen(dev); 982 983 return 0; 984 985 error2: 986 usb_set_intfdata(ctx->control, NULL); 987 usb_set_intfdata(ctx->data, NULL); 988 if (ctx->data != ctx->control) 989 usb_driver_release_interface(driver, ctx->data); 990 error: 991 cdc_ncm_free((struct cdc_ncm_ctx *)dev->data[0]); 992 dev->data[0] = 0; 993 dev_info(&intf->dev, "bind() failure\n"); 994 return -ENODEV; 995 } 996 EXPORT_SYMBOL_GPL(cdc_ncm_bind_common); 997 998 void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf) 999 { 1000 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1001 struct usb_driver *driver = driver_of(intf); 1002 1003 if (ctx == NULL) 1004 return; /* no setup */ 1005 1006 atomic_set(&ctx->stop, 1); 1007 1008 hrtimer_cancel(&ctx->tx_timer); 1009 1010 tasklet_kill(&ctx->bh); 1011 1012 /* handle devices with combined control and data interface */ 1013 if (ctx->control == ctx->data) 1014 ctx->data = NULL; 1015 1016 /* disconnect master --> disconnect slave */ 1017 if (intf == ctx->control && ctx->data) { 1018 usb_set_intfdata(ctx->data, NULL); 1019 usb_driver_release_interface(driver, ctx->data); 1020 ctx->data = NULL; 1021 1022 } else if (intf == ctx->data && ctx->control) { 1023 usb_set_intfdata(ctx->control, NULL); 1024 usb_driver_release_interface(driver, ctx->control); 1025 ctx->control = NULL; 1026 } 1027 1028 usb_set_intfdata(intf, NULL); 1029 cdc_ncm_free(ctx); 1030 } 1031 EXPORT_SYMBOL_GPL(cdc_ncm_unbind); 1032 1033 /* Return the number of the MBIM control interface altsetting iff it 1034 * is preferred and available, 1035 */ 1036 u8 cdc_ncm_select_altsetting(struct usb_interface *intf) 1037 { 1038 struct usb_host_interface *alt; 1039 1040 /* The MBIM spec defines a NCM compatible default altsetting, 1041 * which we may have matched: 1042 * 1043 * "Functions that implement both NCM 1.0 and MBIM (an 1044 * “NCM/MBIM function”) according to this recommendation 1045 * shall provide two alternate settings for the 1046 * Communication Interface. Alternate setting 0, and the 1047 * associated class and endpoint descriptors, shall be 1048 * constructed according to the rules given for the 1049 * Communication Interface in section 5 of [USBNCM10]. 1050 * Alternate setting 1, and the associated class and 1051 * endpoint descriptors, shall be constructed according to 1052 * the rules given in section 6 (USB Device Model) of this 1053 * specification." 1054 */ 1055 if (intf->num_altsetting < 2) 1056 return intf->cur_altsetting->desc.bAlternateSetting; 1057 1058 if (prefer_mbim) { 1059 alt = usb_altnum_to_altsetting(intf, CDC_NCM_COMM_ALTSETTING_MBIM); 1060 if (alt && cdc_ncm_comm_intf_is_mbim(alt)) 1061 return CDC_NCM_COMM_ALTSETTING_MBIM; 1062 } 1063 return CDC_NCM_COMM_ALTSETTING_NCM; 1064 } 1065 EXPORT_SYMBOL_GPL(cdc_ncm_select_altsetting); 1066 1067 static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf) 1068 { 1069 /* MBIM backwards compatible function? */ 1070 if (cdc_ncm_select_altsetting(intf) != CDC_NCM_COMM_ALTSETTING_NCM) 1071 return -ENODEV; 1072 1073 /* The NCM data altsetting is fixed, so we hard-coded it. 1074 * Additionally, generic NCM devices are assumed to accept arbitrarily 1075 * placed NDP. 1076 */ 1077 return cdc_ncm_bind_common(dev, intf, CDC_NCM_DATA_ALTSETTING_NCM, 0); 1078 } 1079 1080 static void cdc_ncm_align_tail(struct sk_buff *skb, size_t modulus, size_t remainder, size_t max) 1081 { 1082 size_t align = ALIGN(skb->len, modulus) - skb->len + remainder; 1083 1084 if (skb->len + align > max) 1085 align = max - skb->len; 1086 if (align && skb_tailroom(skb) >= align) 1087 skb_put_zero(skb, align); 1088 } 1089 1090 /* return a pointer to a valid struct usb_cdc_ncm_ndp16 of type sign, possibly 1091 * allocating a new one within skb 1092 */ 1093 static struct usb_cdc_ncm_ndp16 *cdc_ncm_ndp16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign, size_t reserve) 1094 { 1095 struct usb_cdc_ncm_ndp16 *ndp16 = NULL; 1096 struct usb_cdc_ncm_nth16 *nth16 = (void *)skb->data; 1097 size_t ndpoffset = le16_to_cpu(nth16->wNdpIndex); 1098 1099 /* If NDP should be moved to the end of the NCM package, we can't follow the 1100 * NTH16 header as we would normally do. NDP isn't written to the SKB yet, and 1101 * the wNdpIndex field in the header is actually not consistent with reality. It will be later. 1102 */ 1103 if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) { 1104 if (ctx->delayed_ndp16->dwSignature == sign) 1105 return ctx->delayed_ndp16; 1106 1107 /* We can only push a single NDP to the end. Return 1108 * NULL to send what we've already got and queue this 1109 * skb for later. 1110 */ 1111 else if (ctx->delayed_ndp16->dwSignature) 1112 return NULL; 1113 } 1114 1115 /* follow the chain of NDPs, looking for a match */ 1116 while (ndpoffset) { 1117 ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb->data + ndpoffset); 1118 if (ndp16->dwSignature == sign) 1119 return ndp16; 1120 ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex); 1121 } 1122 1123 /* align new NDP */ 1124 if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END)) 1125 cdc_ncm_align_tail(skb, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size); 1126 1127 /* verify that there is room for the NDP and the datagram (reserve) */ 1128 if ((ctx->tx_curr_size - skb->len - reserve) < ctx->max_ndp_size) 1129 return NULL; 1130 1131 /* link to it */ 1132 if (ndp16) 1133 ndp16->wNextNdpIndex = cpu_to_le16(skb->len); 1134 else 1135 nth16->wNdpIndex = cpu_to_le16(skb->len); 1136 1137 /* push a new empty NDP */ 1138 if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END)) 1139 ndp16 = skb_put_zero(skb, ctx->max_ndp_size); 1140 else 1141 ndp16 = ctx->delayed_ndp16; 1142 1143 ndp16->dwSignature = sign; 1144 ndp16->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp16) + sizeof(struct usb_cdc_ncm_dpe16)); 1145 return ndp16; 1146 } 1147 1148 static struct usb_cdc_ncm_ndp32 *cdc_ncm_ndp32(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign, size_t reserve) 1149 { 1150 struct usb_cdc_ncm_ndp32 *ndp32 = NULL; 1151 struct usb_cdc_ncm_nth32 *nth32 = (void *)skb->data; 1152 size_t ndpoffset = le32_to_cpu(nth32->dwNdpIndex); 1153 1154 /* If NDP should be moved to the end of the NCM package, we can't follow the 1155 * NTH32 header as we would normally do. NDP isn't written to the SKB yet, and 1156 * the wNdpIndex field in the header is actually not consistent with reality. It will be later. 1157 */ 1158 if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) { 1159 if (ctx->delayed_ndp32->dwSignature == sign) 1160 return ctx->delayed_ndp32; 1161 1162 /* We can only push a single NDP to the end. Return 1163 * NULL to send what we've already got and queue this 1164 * skb for later. 1165 */ 1166 else if (ctx->delayed_ndp32->dwSignature) 1167 return NULL; 1168 } 1169 1170 /* follow the chain of NDPs, looking for a match */ 1171 while (ndpoffset) { 1172 ndp32 = (struct usb_cdc_ncm_ndp32 *)(skb->data + ndpoffset); 1173 if (ndp32->dwSignature == sign) 1174 return ndp32; 1175 ndpoffset = le32_to_cpu(ndp32->dwNextNdpIndex); 1176 } 1177 1178 /* align new NDP */ 1179 if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END)) 1180 cdc_ncm_align_tail(skb, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size); 1181 1182 /* verify that there is room for the NDP and the datagram (reserve) */ 1183 if ((ctx->tx_curr_size - skb->len - reserve) < ctx->max_ndp_size) 1184 return NULL; 1185 1186 /* link to it */ 1187 if (ndp32) 1188 ndp32->dwNextNdpIndex = cpu_to_le32(skb->len); 1189 else 1190 nth32->dwNdpIndex = cpu_to_le32(skb->len); 1191 1192 /* push a new empty NDP */ 1193 if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END)) 1194 ndp32 = skb_put_zero(skb, ctx->max_ndp_size); 1195 else 1196 ndp32 = ctx->delayed_ndp32; 1197 1198 ndp32->dwSignature = sign; 1199 ndp32->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp32) + sizeof(struct usb_cdc_ncm_dpe32)); 1200 return ndp32; 1201 } 1202 1203 struct sk_buff * 1204 cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign) 1205 { 1206 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1207 union { 1208 struct usb_cdc_ncm_nth16 *nth16; 1209 struct usb_cdc_ncm_nth32 *nth32; 1210 } nth; 1211 union { 1212 struct usb_cdc_ncm_ndp16 *ndp16; 1213 struct usb_cdc_ncm_ndp32 *ndp32; 1214 } ndp; 1215 struct sk_buff *skb_out; 1216 u16 n = 0, index, ndplen; 1217 u8 ready2send = 0; 1218 u32 delayed_ndp_size; 1219 size_t padding_count; 1220 1221 /* When our NDP gets written in cdc_ncm_ndp(), then skb_out->len gets updated 1222 * accordingly. Otherwise, we should check here. 1223 */ 1224 if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) 1225 delayed_ndp_size = ctx->max_ndp_size + 1226 max_t(u32, 1227 ctx->tx_ndp_modulus, 1228 ctx->tx_modulus + ctx->tx_remainder) - 1; 1229 else 1230 delayed_ndp_size = 0; 1231 1232 /* if there is a remaining skb, it gets priority */ 1233 if (skb != NULL) { 1234 swap(skb, ctx->tx_rem_skb); 1235 swap(sign, ctx->tx_rem_sign); 1236 } else { 1237 ready2send = 1; 1238 } 1239 1240 /* check if we are resuming an OUT skb */ 1241 skb_out = ctx->tx_curr_skb; 1242 1243 /* allocate a new OUT skb */ 1244 if (!skb_out) { 1245 if (ctx->tx_low_mem_val == 0) { 1246 ctx->tx_curr_size = ctx->tx_max; 1247 skb_out = alloc_skb(ctx->tx_curr_size, GFP_ATOMIC); 1248 /* If the memory allocation fails we will wait longer 1249 * each time before attempting another full size 1250 * allocation again to not overload the system 1251 * further. 1252 */ 1253 if (skb_out == NULL) { 1254 /* If even the smallest allocation fails, abort. */ 1255 if (ctx->tx_curr_size == USB_CDC_NCM_NTB_MIN_OUT_SIZE) 1256 goto alloc_failed; 1257 ctx->tx_low_mem_max_cnt = min(ctx->tx_low_mem_max_cnt + 1, 1258 (unsigned)CDC_NCM_LOW_MEM_MAX_CNT); 1259 ctx->tx_low_mem_val = ctx->tx_low_mem_max_cnt; 1260 } 1261 } 1262 if (skb_out == NULL) { 1263 /* See if a very small allocation is possible. 1264 * We will send this packet immediately and hope 1265 * that there is more memory available later. 1266 */ 1267 if (skb) 1268 ctx->tx_curr_size = max(skb->len, 1269 (u32)USB_CDC_NCM_NTB_MIN_OUT_SIZE); 1270 else 1271 ctx->tx_curr_size = USB_CDC_NCM_NTB_MIN_OUT_SIZE; 1272 skb_out = alloc_skb(ctx->tx_curr_size, GFP_ATOMIC); 1273 1274 /* No allocation possible so we will abort */ 1275 if (!skb_out) 1276 goto alloc_failed; 1277 ctx->tx_low_mem_val--; 1278 } 1279 if (ctx->is_ndp16) { 1280 /* fill out the initial 16-bit NTB header */ 1281 nth.nth16 = skb_put_zero(skb_out, sizeof(struct usb_cdc_ncm_nth16)); 1282 nth.nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN); 1283 nth.nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16)); 1284 nth.nth16->wSequence = cpu_to_le16(ctx->tx_seq++); 1285 } else { 1286 /* fill out the initial 32-bit NTB header */ 1287 nth.nth32 = skb_put_zero(skb_out, sizeof(struct usb_cdc_ncm_nth32)); 1288 nth.nth32->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH32_SIGN); 1289 nth.nth32->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth32)); 1290 nth.nth32->wSequence = cpu_to_le16(ctx->tx_seq++); 1291 } 1292 1293 /* count total number of frames in this NTB */ 1294 ctx->tx_curr_frame_num = 0; 1295 1296 /* recent payload counter for this skb_out */ 1297 ctx->tx_curr_frame_payload = 0; 1298 } 1299 1300 for (n = ctx->tx_curr_frame_num; n < ctx->tx_max_datagrams; n++) { 1301 /* send any remaining skb first */ 1302 if (skb == NULL) { 1303 skb = ctx->tx_rem_skb; 1304 sign = ctx->tx_rem_sign; 1305 ctx->tx_rem_skb = NULL; 1306 1307 /* check for end of skb */ 1308 if (skb == NULL) 1309 break; 1310 } 1311 1312 /* get the appropriate NDP for this skb */ 1313 if (ctx->is_ndp16) 1314 ndp.ndp16 = cdc_ncm_ndp16(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder); 1315 else 1316 ndp.ndp32 = cdc_ncm_ndp32(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder); 1317 1318 /* align beginning of next frame */ 1319 cdc_ncm_align_tail(skb_out, ctx->tx_modulus, ctx->tx_remainder, ctx->tx_curr_size); 1320 1321 /* check if we had enough room left for both NDP and frame */ 1322 if ((ctx->is_ndp16 && !ndp.ndp16) || (!ctx->is_ndp16 && !ndp.ndp32) || 1323 skb_out->len + skb->len + delayed_ndp_size > ctx->tx_curr_size) { 1324 if (n == 0) { 1325 /* won't fit, MTU problem? */ 1326 dev_kfree_skb_any(skb); 1327 skb = NULL; 1328 dev->net->stats.tx_dropped++; 1329 } else { 1330 /* no room for skb - store for later */ 1331 if (ctx->tx_rem_skb != NULL) { 1332 dev_kfree_skb_any(ctx->tx_rem_skb); 1333 dev->net->stats.tx_dropped++; 1334 } 1335 ctx->tx_rem_skb = skb; 1336 ctx->tx_rem_sign = sign; 1337 skb = NULL; 1338 ready2send = 1; 1339 ctx->tx_reason_ntb_full++; /* count reason for transmitting */ 1340 } 1341 break; 1342 } 1343 1344 /* calculate frame number within this NDP */ 1345 if (ctx->is_ndp16) { 1346 ndplen = le16_to_cpu(ndp.ndp16->wLength); 1347 index = (ndplen - sizeof(struct usb_cdc_ncm_ndp16)) / sizeof(struct usb_cdc_ncm_dpe16) - 1; 1348 1349 /* OK, add this skb */ 1350 ndp.ndp16->dpe16[index].wDatagramLength = cpu_to_le16(skb->len); 1351 ndp.ndp16->dpe16[index].wDatagramIndex = cpu_to_le16(skb_out->len); 1352 ndp.ndp16->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe16)); 1353 } else { 1354 ndplen = le16_to_cpu(ndp.ndp32->wLength); 1355 index = (ndplen - sizeof(struct usb_cdc_ncm_ndp32)) / sizeof(struct usb_cdc_ncm_dpe32) - 1; 1356 1357 ndp.ndp32->dpe32[index].dwDatagramLength = cpu_to_le32(skb->len); 1358 ndp.ndp32->dpe32[index].dwDatagramIndex = cpu_to_le32(skb_out->len); 1359 ndp.ndp32->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe32)); 1360 } 1361 skb_put_data(skb_out, skb->data, skb->len); 1362 ctx->tx_curr_frame_payload += skb->len; /* count real tx payload data */ 1363 dev_kfree_skb_any(skb); 1364 skb = NULL; 1365 1366 /* send now if this NDP is full */ 1367 if (index >= CDC_NCM_DPT_DATAGRAMS_MAX) { 1368 ready2send = 1; 1369 ctx->tx_reason_ndp_full++; /* count reason for transmitting */ 1370 break; 1371 } 1372 } 1373 1374 /* free up any dangling skb */ 1375 if (skb != NULL) { 1376 dev_kfree_skb_any(skb); 1377 skb = NULL; 1378 dev->net->stats.tx_dropped++; 1379 } 1380 1381 ctx->tx_curr_frame_num = n; 1382 1383 if (n == 0) { 1384 /* wait for more frames */ 1385 /* push variables */ 1386 ctx->tx_curr_skb = skb_out; 1387 goto exit_no_skb; 1388 1389 } else if ((n < ctx->tx_max_datagrams) && (ready2send == 0) && (ctx->timer_interval > 0)) { 1390 /* wait for more frames */ 1391 /* push variables */ 1392 ctx->tx_curr_skb = skb_out; 1393 /* set the pending count */ 1394 if (n < CDC_NCM_RESTART_TIMER_DATAGRAM_CNT) 1395 ctx->tx_timer_pending = CDC_NCM_TIMER_PENDING_CNT; 1396 goto exit_no_skb; 1397 1398 } else { 1399 if (n == ctx->tx_max_datagrams) 1400 ctx->tx_reason_max_datagram++; /* count reason for transmitting */ 1401 /* frame goes out */ 1402 /* variables will be reset at next call */ 1403 } 1404 1405 /* If requested, put NDP at end of frame. */ 1406 if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) { 1407 if (ctx->is_ndp16) { 1408 nth.nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data; 1409 cdc_ncm_align_tail(skb_out, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size - ctx->max_ndp_size); 1410 nth.nth16->wNdpIndex = cpu_to_le16(skb_out->len); 1411 skb_put_data(skb_out, ctx->delayed_ndp16, ctx->max_ndp_size); 1412 1413 /* Zero out delayed NDP - signature checking will naturally fail. */ 1414 ndp.ndp16 = memset(ctx->delayed_ndp16, 0, ctx->max_ndp_size); 1415 } else { 1416 nth.nth32 = (struct usb_cdc_ncm_nth32 *)skb_out->data; 1417 cdc_ncm_align_tail(skb_out, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size - ctx->max_ndp_size); 1418 nth.nth32->dwNdpIndex = cpu_to_le32(skb_out->len); 1419 skb_put_data(skb_out, ctx->delayed_ndp32, ctx->max_ndp_size); 1420 1421 ndp.ndp32 = memset(ctx->delayed_ndp32, 0, ctx->max_ndp_size); 1422 } 1423 } 1424 1425 /* If collected data size is less or equal ctx->min_tx_pkt 1426 * bytes, we send buffers as it is. If we get more data, it 1427 * would be more efficient for USB HS mobile device with DMA 1428 * engine to receive a full size NTB, than canceling DMA 1429 * transfer and receiving a short packet. 1430 * 1431 * This optimization support is pointless if we end up sending 1432 * a ZLP after full sized NTBs. 1433 */ 1434 if (!(dev->driver_info->flags & FLAG_SEND_ZLP) && 1435 skb_out->len > ctx->min_tx_pkt) { 1436 padding_count = ctx->tx_curr_size - skb_out->len; 1437 if (!WARN_ON(padding_count > ctx->tx_curr_size)) 1438 skb_put_zero(skb_out, padding_count); 1439 } else if (skb_out->len < ctx->tx_curr_size && 1440 (skb_out->len % dev->maxpacket) == 0) { 1441 skb_put_u8(skb_out, 0); /* force short packet */ 1442 } 1443 1444 /* set final frame length */ 1445 if (ctx->is_ndp16) { 1446 nth.nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data; 1447 nth.nth16->wBlockLength = cpu_to_le16(skb_out->len); 1448 } else { 1449 nth.nth32 = (struct usb_cdc_ncm_nth32 *)skb_out->data; 1450 nth.nth32->dwBlockLength = cpu_to_le32(skb_out->len); 1451 } 1452 1453 /* return skb */ 1454 ctx->tx_curr_skb = NULL; 1455 1456 /* keep private stats: framing overhead and number of NTBs */ 1457 ctx->tx_overhead += skb_out->len - ctx->tx_curr_frame_payload; 1458 ctx->tx_ntbs++; 1459 1460 /* usbnet will count all the framing overhead by default. 1461 * Adjust the stats so that the tx_bytes counter show real 1462 * payload data instead. 1463 */ 1464 usbnet_set_skb_tx_stats(skb_out, n, 1465 (long)ctx->tx_curr_frame_payload - skb_out->len); 1466 1467 return skb_out; 1468 1469 alloc_failed: 1470 if (skb) { 1471 dev_kfree_skb_any(skb); 1472 dev->net->stats.tx_dropped++; 1473 } 1474 exit_no_skb: 1475 /* Start timer, if there is a remaining non-empty skb */ 1476 if (ctx->tx_curr_skb != NULL && n > 0) 1477 cdc_ncm_tx_timeout_start(ctx); 1478 return NULL; 1479 } 1480 EXPORT_SYMBOL_GPL(cdc_ncm_fill_tx_frame); 1481 1482 static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx) 1483 { 1484 /* start timer, if not already started */ 1485 if (!(hrtimer_active(&ctx->tx_timer) || atomic_read(&ctx->stop))) 1486 hrtimer_start(&ctx->tx_timer, 1487 ctx->timer_interval, 1488 HRTIMER_MODE_REL); 1489 } 1490 1491 static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *timer) 1492 { 1493 struct cdc_ncm_ctx *ctx = 1494 container_of(timer, struct cdc_ncm_ctx, tx_timer); 1495 1496 if (!atomic_read(&ctx->stop)) 1497 tasklet_schedule(&ctx->bh); 1498 return HRTIMER_NORESTART; 1499 } 1500 1501 static void cdc_ncm_txpath_bh(struct tasklet_struct *t) 1502 { 1503 struct cdc_ncm_ctx *ctx = from_tasklet(ctx, t, bh); 1504 struct usbnet *dev = ctx->dev; 1505 1506 spin_lock(&ctx->mtx); 1507 if (ctx->tx_timer_pending != 0) { 1508 ctx->tx_timer_pending--; 1509 cdc_ncm_tx_timeout_start(ctx); 1510 spin_unlock(&ctx->mtx); 1511 } else if (dev->net != NULL) { 1512 ctx->tx_reason_timeout++; /* count reason for transmitting */ 1513 spin_unlock(&ctx->mtx); 1514 netif_tx_lock_bh(dev->net); 1515 usbnet_start_xmit(NULL, dev->net); 1516 netif_tx_unlock_bh(dev->net); 1517 } else { 1518 spin_unlock(&ctx->mtx); 1519 } 1520 } 1521 1522 struct sk_buff * 1523 cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags) 1524 { 1525 struct sk_buff *skb_out; 1526 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1527 1528 /* 1529 * The Ethernet API we are using does not support transmitting 1530 * multiple Ethernet frames in a single call. This driver will 1531 * accumulate multiple Ethernet frames and send out a larger 1532 * USB frame when the USB buffer is full or when a single jiffies 1533 * timeout happens. 1534 */ 1535 if (ctx == NULL) 1536 goto error; 1537 1538 spin_lock_bh(&ctx->mtx); 1539 1540 if (ctx->is_ndp16) 1541 skb_out = cdc_ncm_fill_tx_frame(dev, skb, cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN)); 1542 else 1543 skb_out = cdc_ncm_fill_tx_frame(dev, skb, cpu_to_le32(USB_CDC_NCM_NDP32_NOCRC_SIGN)); 1544 1545 spin_unlock_bh(&ctx->mtx); 1546 return skb_out; 1547 1548 error: 1549 if (skb != NULL) 1550 dev_kfree_skb_any(skb); 1551 1552 return NULL; 1553 } 1554 EXPORT_SYMBOL_GPL(cdc_ncm_tx_fixup); 1555 1556 /* verify NTB header and return offset of first NDP, or negative error */ 1557 int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in) 1558 { 1559 struct usbnet *dev = netdev_priv(skb_in->dev); 1560 struct usb_cdc_ncm_nth16 *nth16; 1561 int len; 1562 int ret = -EINVAL; 1563 1564 if (ctx == NULL) 1565 goto error; 1566 1567 if (skb_in->len < (sizeof(struct usb_cdc_ncm_nth16) + 1568 sizeof(struct usb_cdc_ncm_ndp16))) { 1569 netif_dbg(dev, rx_err, dev->net, "frame too short\n"); 1570 goto error; 1571 } 1572 1573 nth16 = (struct usb_cdc_ncm_nth16 *)skb_in->data; 1574 1575 if (nth16->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH16_SIGN)) { 1576 netif_dbg(dev, rx_err, dev->net, 1577 "invalid NTH16 signature <%#010x>\n", 1578 le32_to_cpu(nth16->dwSignature)); 1579 goto error; 1580 } 1581 1582 len = le16_to_cpu(nth16->wBlockLength); 1583 if (len > ctx->rx_max) { 1584 netif_dbg(dev, rx_err, dev->net, 1585 "unsupported NTB block length %u/%u\n", len, 1586 ctx->rx_max); 1587 goto error; 1588 } 1589 1590 if ((ctx->rx_seq + 1) != le16_to_cpu(nth16->wSequence) && 1591 (ctx->rx_seq || le16_to_cpu(nth16->wSequence)) && 1592 !((ctx->rx_seq == 0xffff) && !le16_to_cpu(nth16->wSequence))) { 1593 netif_dbg(dev, rx_err, dev->net, 1594 "sequence number glitch prev=%d curr=%d\n", 1595 ctx->rx_seq, le16_to_cpu(nth16->wSequence)); 1596 } 1597 ctx->rx_seq = le16_to_cpu(nth16->wSequence); 1598 1599 ret = le16_to_cpu(nth16->wNdpIndex); 1600 error: 1601 return ret; 1602 } 1603 EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_nth16); 1604 1605 int cdc_ncm_rx_verify_nth32(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in) 1606 { 1607 struct usbnet *dev = netdev_priv(skb_in->dev); 1608 struct usb_cdc_ncm_nth32 *nth32; 1609 int len; 1610 int ret = -EINVAL; 1611 1612 if (ctx == NULL) 1613 goto error; 1614 1615 if (skb_in->len < (sizeof(struct usb_cdc_ncm_nth32) + 1616 sizeof(struct usb_cdc_ncm_ndp32))) { 1617 netif_dbg(dev, rx_err, dev->net, "frame too short\n"); 1618 goto error; 1619 } 1620 1621 nth32 = (struct usb_cdc_ncm_nth32 *)skb_in->data; 1622 1623 if (nth32->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH32_SIGN)) { 1624 netif_dbg(dev, rx_err, dev->net, 1625 "invalid NTH32 signature <%#010x>\n", 1626 le32_to_cpu(nth32->dwSignature)); 1627 goto error; 1628 } 1629 1630 len = le32_to_cpu(nth32->dwBlockLength); 1631 if (len > ctx->rx_max) { 1632 netif_dbg(dev, rx_err, dev->net, 1633 "unsupported NTB block length %u/%u\n", len, 1634 ctx->rx_max); 1635 goto error; 1636 } 1637 1638 if ((ctx->rx_seq + 1) != le16_to_cpu(nth32->wSequence) && 1639 (ctx->rx_seq || le16_to_cpu(nth32->wSequence)) && 1640 !((ctx->rx_seq == 0xffff) && !le16_to_cpu(nth32->wSequence))) { 1641 netif_dbg(dev, rx_err, dev->net, 1642 "sequence number glitch prev=%d curr=%d\n", 1643 ctx->rx_seq, le16_to_cpu(nth32->wSequence)); 1644 } 1645 ctx->rx_seq = le16_to_cpu(nth32->wSequence); 1646 1647 ret = le32_to_cpu(nth32->dwNdpIndex); 1648 error: 1649 return ret; 1650 } 1651 EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_nth32); 1652 1653 /* verify NDP header and return number of datagrams, or negative error */ 1654 int cdc_ncm_rx_verify_ndp16(struct sk_buff *skb_in, int ndpoffset) 1655 { 1656 struct usbnet *dev = netdev_priv(skb_in->dev); 1657 struct usb_cdc_ncm_ndp16 *ndp16; 1658 int ret = -EINVAL; 1659 size_t ndp_len; 1660 1661 if ((ndpoffset + sizeof(struct usb_cdc_ncm_ndp16)) > skb_in->len) { 1662 netif_dbg(dev, rx_err, dev->net, "invalid NDP offset <%u>\n", 1663 ndpoffset); 1664 goto error; 1665 } 1666 ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset); 1667 1668 if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) { 1669 netif_dbg(dev, rx_err, dev->net, "invalid DPT16 length <%u>\n", 1670 le16_to_cpu(ndp16->wLength)); 1671 goto error; 1672 } 1673 1674 ret = ((le16_to_cpu(ndp16->wLength) - 1675 sizeof(struct usb_cdc_ncm_ndp16)) / 1676 sizeof(struct usb_cdc_ncm_dpe16)); 1677 ret--; /* we process NDP entries except for the last one */ 1678 1679 ndp_len = struct_size_t(struct usb_cdc_ncm_ndp16, dpe16, ret); 1680 if (ndpoffset + ndp_len > skb_in->len) { 1681 netif_dbg(dev, rx_err, dev->net, "Invalid nframes = %d\n", ret); 1682 ret = -EINVAL; 1683 } 1684 1685 error: 1686 return ret; 1687 } 1688 EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp16); 1689 1690 /* verify NDP header and return number of datagrams, or negative error */ 1691 int cdc_ncm_rx_verify_ndp32(struct sk_buff *skb_in, int ndpoffset) 1692 { 1693 struct usbnet *dev = netdev_priv(skb_in->dev); 1694 struct usb_cdc_ncm_ndp32 *ndp32; 1695 int ret = -EINVAL; 1696 size_t ndp_len; 1697 1698 if ((ndpoffset + sizeof(struct usb_cdc_ncm_ndp32)) > skb_in->len) { 1699 netif_dbg(dev, rx_err, dev->net, "invalid NDP offset <%u>\n", 1700 ndpoffset); 1701 goto error; 1702 } 1703 ndp32 = (struct usb_cdc_ncm_ndp32 *)(skb_in->data + ndpoffset); 1704 1705 if (le16_to_cpu(ndp32->wLength) < USB_CDC_NCM_NDP32_LENGTH_MIN) { 1706 netif_dbg(dev, rx_err, dev->net, "invalid DPT32 length <%u>\n", 1707 le16_to_cpu(ndp32->wLength)); 1708 goto error; 1709 } 1710 1711 ret = ((le16_to_cpu(ndp32->wLength) - 1712 sizeof(struct usb_cdc_ncm_ndp32)) / 1713 sizeof(struct usb_cdc_ncm_dpe32)); 1714 ret--; /* we process NDP entries except for the last one */ 1715 1716 ndp_len = struct_size_t(struct usb_cdc_ncm_ndp32, dpe32, ret); 1717 if (ndpoffset + ndp_len > skb_in->len) { 1718 netif_dbg(dev, rx_err, dev->net, "Invalid nframes = %d\n", ret); 1719 ret = -EINVAL; 1720 } 1721 1722 error: 1723 return ret; 1724 } 1725 EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp32); 1726 1727 int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in) 1728 { 1729 struct sk_buff *skb; 1730 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1731 unsigned int len; 1732 int nframes; 1733 int x; 1734 unsigned int offset; 1735 union { 1736 struct usb_cdc_ncm_ndp16 *ndp16; 1737 struct usb_cdc_ncm_ndp32 *ndp32; 1738 } ndp; 1739 union { 1740 struct usb_cdc_ncm_dpe16 *dpe16; 1741 struct usb_cdc_ncm_dpe32 *dpe32; 1742 } dpe; 1743 1744 int ndpoffset; 1745 int loopcount = 50; /* arbitrary max preventing infinite loop */ 1746 u32 payload = 0; 1747 1748 if (ctx->is_ndp16) 1749 ndpoffset = cdc_ncm_rx_verify_nth16(ctx, skb_in); 1750 else 1751 ndpoffset = cdc_ncm_rx_verify_nth32(ctx, skb_in); 1752 1753 if (ndpoffset < 0) 1754 goto error; 1755 1756 next_ndp: 1757 if (ctx->is_ndp16) { 1758 nframes = cdc_ncm_rx_verify_ndp16(skb_in, ndpoffset); 1759 if (nframes < 0) 1760 goto error; 1761 1762 ndp.ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset); 1763 1764 if (ndp.ndp16->dwSignature != cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN)) { 1765 netif_dbg(dev, rx_err, dev->net, 1766 "invalid DPT16 signature <%#010x>\n", 1767 le32_to_cpu(ndp.ndp16->dwSignature)); 1768 goto err_ndp; 1769 } 1770 dpe.dpe16 = ndp.ndp16->dpe16; 1771 } else { 1772 nframes = cdc_ncm_rx_verify_ndp32(skb_in, ndpoffset); 1773 if (nframes < 0) 1774 goto error; 1775 1776 ndp.ndp32 = (struct usb_cdc_ncm_ndp32 *)(skb_in->data + ndpoffset); 1777 1778 if (ndp.ndp32->dwSignature != cpu_to_le32(USB_CDC_NCM_NDP32_NOCRC_SIGN)) { 1779 netif_dbg(dev, rx_err, dev->net, 1780 "invalid DPT32 signature <%#010x>\n", 1781 le32_to_cpu(ndp.ndp32->dwSignature)); 1782 goto err_ndp; 1783 } 1784 dpe.dpe32 = ndp.ndp32->dpe32; 1785 } 1786 1787 for (x = 0; x < nframes; x++) { 1788 if (ctx->is_ndp16) { 1789 offset = le16_to_cpu(dpe.dpe16->wDatagramIndex); 1790 len = le16_to_cpu(dpe.dpe16->wDatagramLength); 1791 } else { 1792 offset = le32_to_cpu(dpe.dpe32->dwDatagramIndex); 1793 len = le32_to_cpu(dpe.dpe32->dwDatagramLength); 1794 } 1795 1796 /* 1797 * CDC NCM ch. 3.7 1798 * All entries after first NULL entry are to be ignored 1799 */ 1800 if ((offset == 0) || (len == 0)) { 1801 if (!x) 1802 goto err_ndp; /* empty NTB */ 1803 break; 1804 } 1805 1806 /* sanity checking - watch out for integer wrap*/ 1807 if ((offset > skb_in->len) || (len > skb_in->len - offset) || 1808 (len > ctx->rx_max) || (len < ETH_HLEN)) { 1809 netif_dbg(dev, rx_err, dev->net, 1810 "invalid frame detected (ignored) offset[%u]=%u, length=%u, skb=%p\n", 1811 x, offset, len, skb_in); 1812 if (!x) 1813 goto err_ndp; 1814 break; 1815 1816 } else { 1817 /* create a fresh copy to reduce truesize */ 1818 skb = netdev_alloc_skb_ip_align(dev->net, len); 1819 if (!skb) 1820 goto error; 1821 skb_put_data(skb, skb_in->data + offset, len); 1822 usbnet_skb_return(dev, skb); 1823 payload += len; /* count payload bytes in this NTB */ 1824 } 1825 1826 if (ctx->is_ndp16) 1827 dpe.dpe16++; 1828 else 1829 dpe.dpe32++; 1830 } 1831 err_ndp: 1832 /* are there more NDPs to process? */ 1833 if (ctx->is_ndp16) 1834 ndpoffset = le16_to_cpu(ndp.ndp16->wNextNdpIndex); 1835 else 1836 ndpoffset = le32_to_cpu(ndp.ndp32->dwNextNdpIndex); 1837 1838 if (ndpoffset && loopcount--) 1839 goto next_ndp; 1840 1841 /* update stats */ 1842 ctx->rx_overhead += skb_in->len - payload; 1843 ctx->rx_ntbs++; 1844 1845 return 1; 1846 error: 1847 return 0; 1848 } 1849 EXPORT_SYMBOL_GPL(cdc_ncm_rx_fixup); 1850 1851 static void 1852 cdc_ncm_speed_change(struct usbnet *dev, 1853 struct usb_cdc_speed_change *data) 1854 { 1855 /* RTL8156 shipped before 2021 sends notification about every 32ms. */ 1856 dev->rx_speed = le32_to_cpu(data->DLBitRRate); 1857 dev->tx_speed = le32_to_cpu(data->ULBitRate); 1858 } 1859 1860 static void cdc_ncm_status(struct usbnet *dev, struct urb *urb) 1861 { 1862 struct usb_cdc_notification *event; 1863 1864 if (urb->actual_length < sizeof(*event)) 1865 return; 1866 1867 /* test for split data in 8-byte chunks */ 1868 if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) { 1869 cdc_ncm_speed_change(dev, 1870 (struct usb_cdc_speed_change *)urb->transfer_buffer); 1871 return; 1872 } 1873 1874 event = urb->transfer_buffer; 1875 1876 switch (event->bNotificationType) { 1877 case USB_CDC_NOTIFY_NETWORK_CONNECTION: 1878 /* 1879 * According to the CDC NCM specification ch.7.1 1880 * USB_CDC_NOTIFY_NETWORK_CONNECTION notification shall be 1881 * sent by device after USB_CDC_NOTIFY_SPEED_CHANGE. 1882 */ 1883 /* RTL8156 shipped before 2021 sends notification about 1884 * every 32ms. Don't forward notification if state is same. 1885 */ 1886 if (netif_carrier_ok(dev->net) != !!event->wValue) 1887 usbnet_link_change(dev, !!event->wValue, 0); 1888 break; 1889 1890 case USB_CDC_NOTIFY_SPEED_CHANGE: 1891 if (urb->actual_length < (sizeof(*event) + 1892 sizeof(struct usb_cdc_speed_change))) 1893 set_bit(EVENT_STS_SPLIT, &dev->flags); 1894 else 1895 cdc_ncm_speed_change(dev, 1896 (struct usb_cdc_speed_change *)&event[1]); 1897 break; 1898 1899 default: 1900 dev_dbg(&dev->udev->dev, 1901 "NCM: unexpected notification 0x%02x!\n", 1902 event->bNotificationType); 1903 break; 1904 } 1905 } 1906 1907 static void cdc_ncm_update_filter(struct usbnet *dev) 1908 { 1909 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1910 1911 if (ctx->filtering_supported) 1912 usbnet_cdc_update_filter(dev); 1913 } 1914 1915 static const struct driver_info cdc_ncm_info = { 1916 .description = "CDC NCM (NO ZLP)", 1917 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1918 | FLAG_LINK_INTR | FLAG_ETHER, 1919 .bind = cdc_ncm_bind, 1920 .unbind = cdc_ncm_unbind, 1921 .manage_power = usbnet_manage_power, 1922 .status = cdc_ncm_status, 1923 .rx_fixup = cdc_ncm_rx_fixup, 1924 .tx_fixup = cdc_ncm_tx_fixup, 1925 .set_rx_mode = cdc_ncm_update_filter, 1926 }; 1927 1928 /* Same as cdc_ncm_info, but with FLAG_SEND_ZLP */ 1929 static const struct driver_info cdc_ncm_zlp_info = { 1930 .description = "CDC NCM (SEND ZLP)", 1931 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1932 | FLAG_LINK_INTR | FLAG_ETHER | FLAG_SEND_ZLP, 1933 .bind = cdc_ncm_bind, 1934 .unbind = cdc_ncm_unbind, 1935 .manage_power = usbnet_manage_power, 1936 .status = cdc_ncm_status, 1937 .rx_fixup = cdc_ncm_rx_fixup, 1938 .tx_fixup = cdc_ncm_tx_fixup, 1939 .set_rx_mode = cdc_ncm_update_filter, 1940 }; 1941 1942 /* Same as cdc_ncm_info, but with FLAG_SEND_ZLP */ 1943 static const struct driver_info apple_tethering_interface_info = { 1944 .description = "CDC NCM (Apple Tethering)", 1945 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1946 | FLAG_LINK_INTR | FLAG_ETHER | FLAG_SEND_ZLP, 1947 .bind = cdc_ncm_bind, 1948 .unbind = cdc_ncm_unbind, 1949 .manage_power = usbnet_manage_power, 1950 .status = cdc_ncm_status, 1951 .rx_fixup = cdc_ncm_rx_fixup, 1952 .tx_fixup = cdc_ncm_tx_fixup, 1953 .set_rx_mode = usbnet_cdc_update_filter, 1954 }; 1955 1956 /* Same as apple_tethering_interface_info, but without FLAG_LINK_INTR */ 1957 static const struct driver_info apple_private_interface_info = { 1958 .description = "CDC NCM (Apple Private)", 1959 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1960 | FLAG_ETHER | FLAG_SEND_ZLP, 1961 .bind = cdc_ncm_bind, 1962 .unbind = cdc_ncm_unbind, 1963 .manage_power = usbnet_manage_power, 1964 .status = cdc_ncm_status, 1965 .rx_fixup = cdc_ncm_rx_fixup, 1966 .tx_fixup = cdc_ncm_tx_fixup, 1967 .set_rx_mode = usbnet_cdc_update_filter, 1968 }; 1969 1970 /* Same as cdc_ncm_info, but with FLAG_WWAN */ 1971 static const struct driver_info wwan_info = { 1972 .description = "Mobile Broadband Network Device", 1973 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1974 | FLAG_LINK_INTR | FLAG_WWAN, 1975 .bind = cdc_ncm_bind, 1976 .unbind = cdc_ncm_unbind, 1977 .manage_power = usbnet_manage_power, 1978 .status = cdc_ncm_status, 1979 .rx_fixup = cdc_ncm_rx_fixup, 1980 .tx_fixup = cdc_ncm_tx_fixup, 1981 .set_rx_mode = cdc_ncm_update_filter, 1982 }; 1983 1984 /* Same as wwan_info, but with FLAG_NOARP */ 1985 static const struct driver_info wwan_noarp_info = { 1986 .description = "Mobile Broadband Network Device (NO ARP)", 1987 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1988 | FLAG_LINK_INTR | FLAG_WWAN | FLAG_NOARP, 1989 .bind = cdc_ncm_bind, 1990 .unbind = cdc_ncm_unbind, 1991 .manage_power = usbnet_manage_power, 1992 .status = cdc_ncm_status, 1993 .rx_fixup = cdc_ncm_rx_fixup, 1994 .tx_fixup = cdc_ncm_tx_fixup, 1995 .set_rx_mode = cdc_ncm_update_filter, 1996 }; 1997 1998 static const struct usb_device_id cdc_devs[] = { 1999 /* iPhone */ 2000 { USB_DEVICE_INTERFACE_NUMBER(0x05ac, 0x12a8, 2), 2001 .driver_info = (unsigned long)&apple_tethering_interface_info, 2002 }, 2003 { USB_DEVICE_INTERFACE_NUMBER(0x05ac, 0x12a8, 4), 2004 .driver_info = (unsigned long)&apple_private_interface_info, 2005 }, 2006 2007 /* iPad */ 2008 { USB_DEVICE_INTERFACE_NUMBER(0x05ac, 0x12ab, 2), 2009 .driver_info = (unsigned long)&apple_tethering_interface_info, 2010 }, 2011 { USB_DEVICE_INTERFACE_NUMBER(0x05ac, 0x12ab, 4), 2012 .driver_info = (unsigned long)&apple_private_interface_info, 2013 }, 2014 2015 /* Ericsson MBM devices like F5521gw */ 2016 { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 2017 | USB_DEVICE_ID_MATCH_VENDOR, 2018 .idVendor = 0x0bdb, 2019 .bInterfaceClass = USB_CLASS_COMM, 2020 .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM, 2021 .bInterfaceProtocol = USB_CDC_PROTO_NONE, 2022 .driver_info = (unsigned long) &wwan_info, 2023 }, 2024 2025 /* Telit LE910 V2 */ 2026 { USB_DEVICE_AND_INTERFACE_INFO(0x1bc7, 0x0036, 2027 USB_CLASS_COMM, 2028 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 2029 .driver_info = (unsigned long)&wwan_noarp_info, 2030 }, 2031 2032 /* DW5812 LTE Verizon Mobile Broadband Card 2033 * Unlike DW5550 this device requires FLAG_NOARP 2034 */ 2035 { USB_DEVICE_AND_INTERFACE_INFO(0x413c, 0x81bb, 2036 USB_CLASS_COMM, 2037 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 2038 .driver_info = (unsigned long)&wwan_noarp_info, 2039 }, 2040 2041 /* DW5813 LTE AT&T Mobile Broadband Card 2042 * Unlike DW5550 this device requires FLAG_NOARP 2043 */ 2044 { USB_DEVICE_AND_INTERFACE_INFO(0x413c, 0x81bc, 2045 USB_CLASS_COMM, 2046 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 2047 .driver_info = (unsigned long)&wwan_noarp_info, 2048 }, 2049 2050 /* Dell branded MBM devices like DW5550 */ 2051 { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 2052 | USB_DEVICE_ID_MATCH_VENDOR, 2053 .idVendor = 0x413c, 2054 .bInterfaceClass = USB_CLASS_COMM, 2055 .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM, 2056 .bInterfaceProtocol = USB_CDC_PROTO_NONE, 2057 .driver_info = (unsigned long) &wwan_info, 2058 }, 2059 2060 /* Toshiba branded MBM devices */ 2061 { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 2062 | USB_DEVICE_ID_MATCH_VENDOR, 2063 .idVendor = 0x0930, 2064 .bInterfaceClass = USB_CLASS_COMM, 2065 .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM, 2066 .bInterfaceProtocol = USB_CDC_PROTO_NONE, 2067 .driver_info = (unsigned long) &wwan_info, 2068 }, 2069 2070 /* tag Huawei devices as wwan */ 2071 { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 2072 USB_CLASS_COMM, 2073 USB_CDC_SUBCLASS_NCM, 2074 USB_CDC_PROTO_NONE), 2075 .driver_info = (unsigned long)&wwan_info, 2076 }, 2077 2078 /* Infineon(now Intel) HSPA Modem platform */ 2079 { USB_DEVICE_AND_INTERFACE_INFO(0x1519, 0x0443, 2080 USB_CLASS_COMM, 2081 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 2082 .driver_info = (unsigned long)&wwan_noarp_info, 2083 }, 2084 2085 /* u-blox TOBY-L4 */ 2086 { USB_DEVICE_AND_INTERFACE_INFO(0x1546, 0x1010, 2087 USB_CLASS_COMM, 2088 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 2089 .driver_info = (unsigned long)&wwan_info, 2090 }, 2091 2092 /* Intel modem (label from OEM reads Fibocom L850-GL) */ 2093 { USB_DEVICE_AND_INTERFACE_INFO(0x8087, 0x095a, 2094 USB_CLASS_COMM, 2095 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 2096 .driver_info = (unsigned long)&wwan_info, 2097 }, 2098 2099 /* DisplayLink docking stations */ 2100 { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 2101 | USB_DEVICE_ID_MATCH_VENDOR, 2102 .idVendor = 0x17e9, 2103 .bInterfaceClass = USB_CLASS_COMM, 2104 .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM, 2105 .bInterfaceProtocol = USB_CDC_PROTO_NONE, 2106 .driver_info = (unsigned long)&cdc_ncm_zlp_info, 2107 }, 2108 2109 /* Generic CDC-NCM devices */ 2110 { USB_INTERFACE_INFO(USB_CLASS_COMM, 2111 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 2112 .driver_info = (unsigned long)&cdc_ncm_info, 2113 }, 2114 { 2115 }, 2116 }; 2117 MODULE_DEVICE_TABLE(usb, cdc_devs); 2118 2119 static struct usb_driver cdc_ncm_driver = { 2120 .name = "cdc_ncm", 2121 .id_table = cdc_devs, 2122 .probe = usbnet_probe, 2123 .disconnect = usbnet_disconnect, 2124 .suspend = usbnet_suspend, 2125 .resume = usbnet_resume, 2126 .reset_resume = usbnet_resume, 2127 .supports_autosuspend = 1, 2128 .disable_hub_initiated_lpm = 1, 2129 }; 2130 2131 module_usb_driver(cdc_ncm_driver); 2132 2133 MODULE_AUTHOR("Hans Petter Selasky"); 2134 MODULE_DESCRIPTION("USB CDC NCM host driver"); 2135 MODULE_LICENSE("Dual BSD/GPL"); 2136