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/devclass_docs/NCM10.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/workqueue.h> 47#include <linux/mii.h> 48#include <linux/crc32.h> 49#include <linux/usb.h> 50#include <linux/hrtimer.h> 51#include <linux/atomic.h> 52#include <linux/usb/usbnet.h> 53#include <linux/usb/cdc.h> 54#include <linux/usb/cdc_ncm.h> 55 56#if IS_ENABLED(CONFIG_USB_NET_CDC_MBIM) 57static bool prefer_mbim = true; 58#else 59static bool prefer_mbim; 60#endif 61module_param(prefer_mbim, bool, S_IRUGO | S_IWUSR); 62MODULE_PARM_DESC(prefer_mbim, "Prefer MBIM setting on dual NCM/MBIM functions"); 63 64static void cdc_ncm_txpath_bh(unsigned long param); 65static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx); 66static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *hr_timer); 67static struct usb_driver cdc_ncm_driver; 68 69struct cdc_ncm_stats { 70 char stat_string[ETH_GSTRING_LEN]; 71 int sizeof_stat; 72 int stat_offset; 73}; 74 75#define CDC_NCM_STAT(str, m) { \ 76 .stat_string = str, \ 77 .sizeof_stat = sizeof(((struct cdc_ncm_ctx *)0)->m), \ 78 .stat_offset = offsetof(struct cdc_ncm_ctx, m) } 79#define CDC_NCM_SIMPLE_STAT(m) CDC_NCM_STAT(__stringify(m), m) 80 81static const struct cdc_ncm_stats cdc_ncm_gstrings_stats[] = { 82 CDC_NCM_SIMPLE_STAT(tx_reason_ntb_full), 83 CDC_NCM_SIMPLE_STAT(tx_reason_ndp_full), 84 CDC_NCM_SIMPLE_STAT(tx_reason_timeout), 85 CDC_NCM_SIMPLE_STAT(tx_reason_max_datagram), 86 CDC_NCM_SIMPLE_STAT(tx_overhead), 87 CDC_NCM_SIMPLE_STAT(tx_ntbs), 88 CDC_NCM_SIMPLE_STAT(rx_overhead), 89 CDC_NCM_SIMPLE_STAT(rx_ntbs), 90}; 91 92static int cdc_ncm_get_sset_count(struct net_device __always_unused *netdev, int sset) 93{ 94 switch (sset) { 95 case ETH_SS_STATS: 96 return ARRAY_SIZE(cdc_ncm_gstrings_stats); 97 default: 98 return -EOPNOTSUPP; 99 } 100} 101 102static void cdc_ncm_get_ethtool_stats(struct net_device *netdev, 103 struct ethtool_stats __always_unused *stats, 104 u64 *data) 105{ 106 struct usbnet *dev = netdev_priv(netdev); 107 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 108 int i; 109 char *p = NULL; 110 111 for (i = 0; i < ARRAY_SIZE(cdc_ncm_gstrings_stats); i++) { 112 p = (char *)ctx + cdc_ncm_gstrings_stats[i].stat_offset; 113 data[i] = (cdc_ncm_gstrings_stats[i].sizeof_stat == sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 114 } 115} 116 117static void cdc_ncm_get_strings(struct net_device __always_unused *netdev, u32 stringset, u8 *data) 118{ 119 u8 *p = data; 120 int i; 121 122 switch (stringset) { 123 case ETH_SS_STATS: 124 for (i = 0; i < ARRAY_SIZE(cdc_ncm_gstrings_stats); i++) { 125 memcpy(p, cdc_ncm_gstrings_stats[i].stat_string, ETH_GSTRING_LEN); 126 p += ETH_GSTRING_LEN; 127 } 128 } 129} 130 131static void cdc_ncm_update_rxtx_max(struct usbnet *dev, u32 new_rx, u32 new_tx); 132 133static const struct ethtool_ops cdc_ncm_ethtool_ops = { 134 .get_settings = usbnet_get_settings, 135 .set_settings = usbnet_set_settings, 136 .get_link = usbnet_get_link, 137 .nway_reset = usbnet_nway_reset, 138 .get_drvinfo = usbnet_get_drvinfo, 139 .get_msglevel = usbnet_get_msglevel, 140 .set_msglevel = usbnet_set_msglevel, 141 .get_ts_info = ethtool_op_get_ts_info, 142 .get_sset_count = cdc_ncm_get_sset_count, 143 .get_strings = cdc_ncm_get_strings, 144 .get_ethtool_stats = cdc_ncm_get_ethtool_stats, 145}; 146 147static u32 cdc_ncm_check_rx_max(struct usbnet *dev, u32 new_rx) 148{ 149 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 150 u32 val, max, min; 151 152 /* clamp new_rx to sane values */ 153 min = USB_CDC_NCM_NTB_MIN_IN_SIZE; 154 max = min_t(u32, CDC_NCM_NTB_MAX_SIZE_RX, le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)); 155 156 /* dwNtbInMaxSize spec violation? Use MIN size for both limits */ 157 if (max < min) { 158 dev_warn(&dev->intf->dev, "dwNtbInMaxSize=%u is too small. Using %u\n", 159 le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize), min); 160 max = min; 161 } 162 163 val = clamp_t(u32, new_rx, min, max); 164 if (val != new_rx) 165 dev_dbg(&dev->intf->dev, "rx_max must be in the [%u, %u] range\n", min, max); 166 167 return val; 168} 169 170static u32 cdc_ncm_check_tx_max(struct usbnet *dev, u32 new_tx) 171{ 172 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 173 u32 val, max, min; 174 175 /* clamp new_tx to sane values */ 176 min = ctx->max_datagram_size + ctx->max_ndp_size + sizeof(struct usb_cdc_ncm_nth16); 177 max = min_t(u32, CDC_NCM_NTB_MAX_SIZE_TX, le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize)); 178 179 /* some devices set dwNtbOutMaxSize too low for the above default */ 180 min = min(min, max); 181 182 val = clamp_t(u32, new_tx, min, max); 183 if (val != new_tx) 184 dev_dbg(&dev->intf->dev, "tx_max must be in the [%u, %u] range\n", min, max); 185 186 return val; 187} 188 189static ssize_t cdc_ncm_show_min_tx_pkt(struct device *d, struct device_attribute *attr, char *buf) 190{ 191 struct usbnet *dev = netdev_priv(to_net_dev(d)); 192 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 193 194 return sprintf(buf, "%u\n", ctx->min_tx_pkt); 195} 196 197static ssize_t cdc_ncm_show_rx_max(struct device *d, struct device_attribute *attr, char *buf) 198{ 199 struct usbnet *dev = netdev_priv(to_net_dev(d)); 200 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 201 202 return sprintf(buf, "%u\n", ctx->rx_max); 203} 204 205static ssize_t cdc_ncm_show_tx_max(struct device *d, struct device_attribute *attr, char *buf) 206{ 207 struct usbnet *dev = netdev_priv(to_net_dev(d)); 208 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 209 210 return sprintf(buf, "%u\n", ctx->tx_max); 211} 212 213static ssize_t cdc_ncm_show_tx_timer_usecs(struct device *d, struct device_attribute *attr, char *buf) 214{ 215 struct usbnet *dev = netdev_priv(to_net_dev(d)); 216 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 217 218 return sprintf(buf, "%u\n", ctx->timer_interval / (u32)NSEC_PER_USEC); 219} 220 221static ssize_t cdc_ncm_store_min_tx_pkt(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 222{ 223 struct usbnet *dev = netdev_priv(to_net_dev(d)); 224 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 225 unsigned long val; 226 227 /* no need to restrict values - anything from 0 to infinity is OK */ 228 if (kstrtoul(buf, 0, &val)) 229 return -EINVAL; 230 231 ctx->min_tx_pkt = val; 232 return len; 233} 234 235static ssize_t cdc_ncm_store_rx_max(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 236{ 237 struct usbnet *dev = netdev_priv(to_net_dev(d)); 238 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 239 unsigned long val; 240 241 if (kstrtoul(buf, 0, &val) || cdc_ncm_check_rx_max(dev, val) != val) 242 return -EINVAL; 243 244 cdc_ncm_update_rxtx_max(dev, val, ctx->tx_max); 245 return len; 246} 247 248static ssize_t cdc_ncm_store_tx_max(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 249{ 250 struct usbnet *dev = netdev_priv(to_net_dev(d)); 251 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 252 unsigned long val; 253 254 if (kstrtoul(buf, 0, &val) || cdc_ncm_check_tx_max(dev, val) != val) 255 return -EINVAL; 256 257 cdc_ncm_update_rxtx_max(dev, ctx->rx_max, val); 258 return len; 259} 260 261static ssize_t cdc_ncm_store_tx_timer_usecs(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 262{ 263 struct usbnet *dev = netdev_priv(to_net_dev(d)); 264 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 265 ssize_t ret; 266 unsigned long val; 267 268 ret = kstrtoul(buf, 0, &val); 269 if (ret) 270 return ret; 271 if (val && (val < CDC_NCM_TIMER_INTERVAL_MIN || val > CDC_NCM_TIMER_INTERVAL_MAX)) 272 return -EINVAL; 273 274 spin_lock_bh(&ctx->mtx); 275 ctx->timer_interval = val * NSEC_PER_USEC; 276 if (!ctx->timer_interval) 277 ctx->tx_timer_pending = 0; 278 spin_unlock_bh(&ctx->mtx); 279 return len; 280} 281 282static DEVICE_ATTR(min_tx_pkt, S_IRUGO | S_IWUSR, cdc_ncm_show_min_tx_pkt, cdc_ncm_store_min_tx_pkt); 283static DEVICE_ATTR(rx_max, S_IRUGO | S_IWUSR, cdc_ncm_show_rx_max, cdc_ncm_store_rx_max); 284static DEVICE_ATTR(tx_max, S_IRUGO | S_IWUSR, cdc_ncm_show_tx_max, cdc_ncm_store_tx_max); 285static DEVICE_ATTR(tx_timer_usecs, S_IRUGO | S_IWUSR, cdc_ncm_show_tx_timer_usecs, cdc_ncm_store_tx_timer_usecs); 286 287#define NCM_PARM_ATTR(name, format, tocpu) \ 288static ssize_t cdc_ncm_show_##name(struct device *d, struct device_attribute *attr, char *buf) \ 289{ \ 290 struct usbnet *dev = netdev_priv(to_net_dev(d)); \ 291 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; \ 292 return sprintf(buf, format "\n", tocpu(ctx->ncm_parm.name)); \ 293} \ 294static DEVICE_ATTR(name, S_IRUGO, cdc_ncm_show_##name, NULL) 295 296NCM_PARM_ATTR(bmNtbFormatsSupported, "0x%04x", le16_to_cpu); 297NCM_PARM_ATTR(dwNtbInMaxSize, "%u", le32_to_cpu); 298NCM_PARM_ATTR(wNdpInDivisor, "%u", le16_to_cpu); 299NCM_PARM_ATTR(wNdpInPayloadRemainder, "%u", le16_to_cpu); 300NCM_PARM_ATTR(wNdpInAlignment, "%u", le16_to_cpu); 301NCM_PARM_ATTR(dwNtbOutMaxSize, "%u", le32_to_cpu); 302NCM_PARM_ATTR(wNdpOutDivisor, "%u", le16_to_cpu); 303NCM_PARM_ATTR(wNdpOutPayloadRemainder, "%u", le16_to_cpu); 304NCM_PARM_ATTR(wNdpOutAlignment, "%u", le16_to_cpu); 305NCM_PARM_ATTR(wNtbOutMaxDatagrams, "%u", le16_to_cpu); 306 307static struct attribute *cdc_ncm_sysfs_attrs[] = { 308 &dev_attr_min_tx_pkt.attr, 309 &dev_attr_rx_max.attr, 310 &dev_attr_tx_max.attr, 311 &dev_attr_tx_timer_usecs.attr, 312 &dev_attr_bmNtbFormatsSupported.attr, 313 &dev_attr_dwNtbInMaxSize.attr, 314 &dev_attr_wNdpInDivisor.attr, 315 &dev_attr_wNdpInPayloadRemainder.attr, 316 &dev_attr_wNdpInAlignment.attr, 317 &dev_attr_dwNtbOutMaxSize.attr, 318 &dev_attr_wNdpOutDivisor.attr, 319 &dev_attr_wNdpOutPayloadRemainder.attr, 320 &dev_attr_wNdpOutAlignment.attr, 321 &dev_attr_wNtbOutMaxDatagrams.attr, 322 NULL, 323}; 324 325static struct attribute_group cdc_ncm_sysfs_attr_group = { 326 .name = "cdc_ncm", 327 .attrs = cdc_ncm_sysfs_attrs, 328}; 329 330/* handle rx_max and tx_max changes */ 331static void cdc_ncm_update_rxtx_max(struct usbnet *dev, u32 new_rx, u32 new_tx) 332{ 333 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 334 u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; 335 u32 val; 336 337 val = cdc_ncm_check_rx_max(dev, new_rx); 338 339 /* inform device about NTB input size changes */ 340 if (val != ctx->rx_max) { 341 __le32 dwNtbInMaxSize = cpu_to_le32(val); 342 343 dev_info(&dev->intf->dev, "setting rx_max = %u\n", val); 344 345 /* tell device to use new size */ 346 if (usbnet_write_cmd(dev, USB_CDC_SET_NTB_INPUT_SIZE, 347 USB_TYPE_CLASS | USB_DIR_OUT 348 | USB_RECIP_INTERFACE, 349 0, iface_no, &dwNtbInMaxSize, 4) < 0) 350 dev_dbg(&dev->intf->dev, "Setting NTB Input Size failed\n"); 351 else 352 ctx->rx_max = val; 353 } 354 355 /* usbnet use these values for sizing rx queues */ 356 if (dev->rx_urb_size != ctx->rx_max) { 357 dev->rx_urb_size = ctx->rx_max; 358 if (netif_running(dev->net)) 359 usbnet_unlink_rx_urbs(dev); 360 } 361 362 val = cdc_ncm_check_tx_max(dev, new_tx); 363 if (val != ctx->tx_max) 364 dev_info(&dev->intf->dev, "setting tx_max = %u\n", val); 365 366 /* Adding a pad byte here if necessary simplifies the handling 367 * in cdc_ncm_fill_tx_frame, making tx_max always represent 368 * the real skb max size. 369 * 370 * We cannot use dev->maxpacket here because this is called from 371 * .bind which is called before usbnet sets up dev->maxpacket 372 */ 373 if (val != le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize) && 374 val % usb_maxpacket(dev->udev, dev->out, 1) == 0) 375 val++; 376 377 /* we might need to flush any pending tx buffers if running */ 378 if (netif_running(dev->net) && val > ctx->tx_max) { 379 netif_tx_lock_bh(dev->net); 380 usbnet_start_xmit(NULL, dev->net); 381 /* make sure tx_curr_skb is reallocated if it was empty */ 382 if (ctx->tx_curr_skb) { 383 dev_kfree_skb_any(ctx->tx_curr_skb); 384 ctx->tx_curr_skb = NULL; 385 } 386 ctx->tx_max = val; 387 netif_tx_unlock_bh(dev->net); 388 } else { 389 ctx->tx_max = val; 390 } 391 392 dev->hard_mtu = ctx->tx_max; 393 394 /* max qlen depend on hard_mtu and rx_urb_size */ 395 usbnet_update_max_qlen(dev); 396 397 /* never pad more than 3 full USB packets per transfer */ 398 ctx->min_tx_pkt = clamp_t(u16, ctx->tx_max - 3 * usb_maxpacket(dev->udev, dev->out, 1), 399 CDC_NCM_MIN_TX_PKT, ctx->tx_max); 400} 401 402/* helpers for NCM and MBIM differences */ 403static u8 cdc_ncm_flags(struct usbnet *dev) 404{ 405 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 406 407 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting) && ctx->mbim_desc) 408 return ctx->mbim_desc->bmNetworkCapabilities; 409 if (ctx->func_desc) 410 return ctx->func_desc->bmNetworkCapabilities; 411 return 0; 412} 413 414static int cdc_ncm_eth_hlen(struct usbnet *dev) 415{ 416 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting)) 417 return 0; 418 return ETH_HLEN; 419} 420 421static u32 cdc_ncm_min_dgram_size(struct usbnet *dev) 422{ 423 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting)) 424 return CDC_MBIM_MIN_DATAGRAM_SIZE; 425 return CDC_NCM_MIN_DATAGRAM_SIZE; 426} 427 428static u32 cdc_ncm_max_dgram_size(struct usbnet *dev) 429{ 430 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 431 432 if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting) && ctx->mbim_desc) 433 return le16_to_cpu(ctx->mbim_desc->wMaxSegmentSize); 434 if (ctx->ether_desc) 435 return le16_to_cpu(ctx->ether_desc->wMaxSegmentSize); 436 return CDC_NCM_MAX_DATAGRAM_SIZE; 437} 438 439/* initial one-time device setup. MUST be called with the data interface 440 * in altsetting 0 441 */ 442static int cdc_ncm_init(struct usbnet *dev) 443{ 444 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 445 u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; 446 int err; 447 448 err = usbnet_read_cmd(dev, USB_CDC_GET_NTB_PARAMETERS, 449 USB_TYPE_CLASS | USB_DIR_IN 450 |USB_RECIP_INTERFACE, 451 0, iface_no, &ctx->ncm_parm, 452 sizeof(ctx->ncm_parm)); 453 if (err < 0) { 454 dev_err(&dev->intf->dev, "failed GET_NTB_PARAMETERS\n"); 455 return err; /* GET_NTB_PARAMETERS is required */ 456 } 457 458 /* set CRC Mode */ 459 if (cdc_ncm_flags(dev) & USB_CDC_NCM_NCAP_CRC_MODE) { 460 dev_dbg(&dev->intf->dev, "Setting CRC mode off\n"); 461 err = usbnet_write_cmd(dev, USB_CDC_SET_CRC_MODE, 462 USB_TYPE_CLASS | USB_DIR_OUT 463 | USB_RECIP_INTERFACE, 464 USB_CDC_NCM_CRC_NOT_APPENDED, 465 iface_no, NULL, 0); 466 if (err < 0) 467 dev_err(&dev->intf->dev, "SET_CRC_MODE failed\n"); 468 } 469 470 /* set NTB format, if both formats are supported. 471 * 472 * "The host shall only send this command while the NCM Data 473 * Interface is in alternate setting 0." 474 */ 475 if (le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported) & 476 USB_CDC_NCM_NTB32_SUPPORTED) { 477 dev_dbg(&dev->intf->dev, "Setting NTB format to 16-bit\n"); 478 err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT, 479 USB_TYPE_CLASS | USB_DIR_OUT 480 | USB_RECIP_INTERFACE, 481 USB_CDC_NCM_NTB16_FORMAT, 482 iface_no, NULL, 0); 483 if (err < 0) 484 dev_err(&dev->intf->dev, "SET_NTB_FORMAT failed\n"); 485 } 486 487 /* set initial device values */ 488 ctx->rx_max = le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize); 489 ctx->tx_max = le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize); 490 ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder); 491 ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor); 492 ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment); 493 /* devices prior to NCM Errata shall set this field to zero */ 494 ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams); 495 496 dev_dbg(&dev->intf->dev, 497 "dwNtbInMaxSize=%u dwNtbOutMaxSize=%u wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n", 498 ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus, 499 ctx->tx_ndp_modulus, ctx->tx_max_datagrams, cdc_ncm_flags(dev)); 500 501 /* max count of tx datagrams */ 502 if ((ctx->tx_max_datagrams == 0) || 503 (ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX)) 504 ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX; 505 506 /* set up maximum NDP size */ 507 ctx->max_ndp_size = sizeof(struct usb_cdc_ncm_ndp16) + (ctx->tx_max_datagrams + 1) * sizeof(struct usb_cdc_ncm_dpe16); 508 509 /* initial coalescing timer interval */ 510 ctx->timer_interval = CDC_NCM_TIMER_INTERVAL_USEC * NSEC_PER_USEC; 511 512 return 0; 513} 514 515/* set a new max datagram size */ 516static void cdc_ncm_set_dgram_size(struct usbnet *dev, int new_size) 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 __le16 max_datagram_size; 521 u16 mbim_mtu; 522 int err; 523 524 /* set default based on descriptors */ 525 ctx->max_datagram_size = clamp_t(u32, new_size, 526 cdc_ncm_min_dgram_size(dev), 527 CDC_NCM_MAX_DATAGRAM_SIZE); 528 529 /* inform the device about the selected Max Datagram Size? */ 530 if (!(cdc_ncm_flags(dev) & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE)) 531 goto out; 532 533 /* read current mtu value from device */ 534 err = usbnet_read_cmd(dev, USB_CDC_GET_MAX_DATAGRAM_SIZE, 535 USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE, 536 0, iface_no, &max_datagram_size, 2); 537 if (err < 0) { 538 dev_dbg(&dev->intf->dev, "GET_MAX_DATAGRAM_SIZE failed\n"); 539 goto out; 540 } 541 542 if (le16_to_cpu(max_datagram_size) == ctx->max_datagram_size) 543 goto out; 544 545 max_datagram_size = cpu_to_le16(ctx->max_datagram_size); 546 err = usbnet_write_cmd(dev, USB_CDC_SET_MAX_DATAGRAM_SIZE, 547 USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE, 548 0, iface_no, &max_datagram_size, 2); 549 if (err < 0) 550 dev_dbg(&dev->intf->dev, "SET_MAX_DATAGRAM_SIZE failed\n"); 551 552out: 553 /* set MTU to max supported by the device if necessary */ 554 dev->net->mtu = min_t(int, dev->net->mtu, ctx->max_datagram_size - cdc_ncm_eth_hlen(dev)); 555 556 /* do not exceed operater preferred MTU */ 557 if (ctx->mbim_extended_desc) { 558 mbim_mtu = le16_to_cpu(ctx->mbim_extended_desc->wMTU); 559 if (mbim_mtu != 0 && mbim_mtu < dev->net->mtu) 560 dev->net->mtu = mbim_mtu; 561 } 562} 563 564static void cdc_ncm_fix_modulus(struct usbnet *dev) 565{ 566 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 567 u32 val; 568 569 /* 570 * verify that the structure alignment is: 571 * - power of two 572 * - not greater than the maximum transmit length 573 * - not less than four bytes 574 */ 575 val = ctx->tx_ndp_modulus; 576 577 if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) || 578 (val != ((-val) & val)) || (val >= ctx->tx_max)) { 579 dev_dbg(&dev->intf->dev, "Using default alignment: 4 bytes\n"); 580 ctx->tx_ndp_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE; 581 } 582 583 /* 584 * verify that the payload alignment is: 585 * - power of two 586 * - not greater than the maximum transmit length 587 * - not less than four bytes 588 */ 589 val = ctx->tx_modulus; 590 591 if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) || 592 (val != ((-val) & val)) || (val >= ctx->tx_max)) { 593 dev_dbg(&dev->intf->dev, "Using default transmit modulus: 4 bytes\n"); 594 ctx->tx_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE; 595 } 596 597 /* verify the payload remainder */ 598 if (ctx->tx_remainder >= ctx->tx_modulus) { 599 dev_dbg(&dev->intf->dev, "Using default transmit remainder: 0 bytes\n"); 600 ctx->tx_remainder = 0; 601 } 602 603 /* adjust TX-remainder according to NCM specification. */ 604 ctx->tx_remainder = ((ctx->tx_remainder - cdc_ncm_eth_hlen(dev)) & 605 (ctx->tx_modulus - 1)); 606} 607 608static int cdc_ncm_setup(struct usbnet *dev) 609{ 610 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 611 u32 def_rx, def_tx; 612 613 /* be conservative when selecting intial buffer size to 614 * increase the number of hosts this will work for 615 */ 616 def_rx = min_t(u32, CDC_NCM_NTB_DEF_SIZE_RX, 617 le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)); 618 def_tx = min_t(u32, CDC_NCM_NTB_DEF_SIZE_TX, 619 le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize)); 620 621 /* clamp rx_max and tx_max and inform device */ 622 cdc_ncm_update_rxtx_max(dev, def_rx, def_tx); 623 624 /* sanitize the modulus and remainder values */ 625 cdc_ncm_fix_modulus(dev); 626 627 /* set max datagram size */ 628 cdc_ncm_set_dgram_size(dev, cdc_ncm_max_dgram_size(dev)); 629 return 0; 630} 631 632static void 633cdc_ncm_find_endpoints(struct usbnet *dev, struct usb_interface *intf) 634{ 635 struct usb_host_endpoint *e, *in = NULL, *out = NULL; 636 u8 ep; 637 638 for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) { 639 640 e = intf->cur_altsetting->endpoint + ep; 641 switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { 642 case USB_ENDPOINT_XFER_INT: 643 if (usb_endpoint_dir_in(&e->desc)) { 644 if (!dev->status) 645 dev->status = e; 646 } 647 break; 648 649 case USB_ENDPOINT_XFER_BULK: 650 if (usb_endpoint_dir_in(&e->desc)) { 651 if (!in) 652 in = e; 653 } else { 654 if (!out) 655 out = e; 656 } 657 break; 658 659 default: 660 break; 661 } 662 } 663 if (in && !dev->in) 664 dev->in = usb_rcvbulkpipe(dev->udev, 665 in->desc.bEndpointAddress & 666 USB_ENDPOINT_NUMBER_MASK); 667 if (out && !dev->out) 668 dev->out = usb_sndbulkpipe(dev->udev, 669 out->desc.bEndpointAddress & 670 USB_ENDPOINT_NUMBER_MASK); 671} 672 673static void cdc_ncm_free(struct cdc_ncm_ctx *ctx) 674{ 675 if (ctx == NULL) 676 return; 677 678 if (ctx->tx_rem_skb != NULL) { 679 dev_kfree_skb_any(ctx->tx_rem_skb); 680 ctx->tx_rem_skb = NULL; 681 } 682 683 if (ctx->tx_curr_skb != NULL) { 684 dev_kfree_skb_any(ctx->tx_curr_skb); 685 ctx->tx_curr_skb = NULL; 686 } 687 688 kfree(ctx); 689} 690 691/* we need to override the usbnet change_mtu ndo for two reasons: 692 * - respect the negotiated maximum datagram size 693 * - avoid unwanted changes to rx and tx buffers 694 */ 695int cdc_ncm_change_mtu(struct net_device *net, int new_mtu) 696{ 697 struct usbnet *dev = netdev_priv(net); 698 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 699 int maxmtu = ctx->max_datagram_size - cdc_ncm_eth_hlen(dev); 700 701 if (new_mtu <= 0 || new_mtu > maxmtu) 702 return -EINVAL; 703 net->mtu = new_mtu; 704 return 0; 705} 706EXPORT_SYMBOL_GPL(cdc_ncm_change_mtu); 707 708static const struct net_device_ops cdc_ncm_netdev_ops = { 709 .ndo_open = usbnet_open, 710 .ndo_stop = usbnet_stop, 711 .ndo_start_xmit = usbnet_start_xmit, 712 .ndo_tx_timeout = usbnet_tx_timeout, 713 .ndo_change_mtu = cdc_ncm_change_mtu, 714 .ndo_set_mac_address = eth_mac_addr, 715 .ndo_validate_addr = eth_validate_addr, 716}; 717 718int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting) 719{ 720 const struct usb_cdc_union_desc *union_desc = NULL; 721 struct cdc_ncm_ctx *ctx; 722 struct usb_driver *driver; 723 u8 *buf; 724 int len; 725 int temp; 726 u8 iface_no; 727 728 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 729 if (!ctx) 730 return -ENOMEM; 731 732 hrtimer_init(&ctx->tx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 733 ctx->tx_timer.function = &cdc_ncm_tx_timer_cb; 734 ctx->bh.data = (unsigned long)dev; 735 ctx->bh.func = cdc_ncm_txpath_bh; 736 atomic_set(&ctx->stop, 0); 737 spin_lock_init(&ctx->mtx); 738 739 /* store ctx pointer in device data field */ 740 dev->data[0] = (unsigned long)ctx; 741 742 /* only the control interface can be successfully probed */ 743 ctx->control = intf; 744 745 /* get some pointers */ 746 driver = driver_of(intf); 747 buf = intf->cur_altsetting->extra; 748 len = intf->cur_altsetting->extralen; 749 750 /* parse through descriptors associated with control interface */ 751 while ((len > 0) && (buf[0] > 2) && (buf[0] <= len)) { 752 753 if (buf[1] != USB_DT_CS_INTERFACE) 754 goto advance; 755 756 switch (buf[2]) { 757 case USB_CDC_UNION_TYPE: 758 if (buf[0] < sizeof(*union_desc)) 759 break; 760 761 union_desc = (const struct usb_cdc_union_desc *)buf; 762 /* the master must be the interface we are probing */ 763 if (intf->cur_altsetting->desc.bInterfaceNumber != 764 union_desc->bMasterInterface0) { 765 dev_dbg(&intf->dev, "bogus CDC Union\n"); 766 goto error; 767 } 768 ctx->data = usb_ifnum_to_if(dev->udev, 769 union_desc->bSlaveInterface0); 770 break; 771 772 case USB_CDC_ETHERNET_TYPE: 773 if (buf[0] < sizeof(*(ctx->ether_desc))) 774 break; 775 776 ctx->ether_desc = 777 (const struct usb_cdc_ether_desc *)buf; 778 break; 779 780 case USB_CDC_NCM_TYPE: 781 if (buf[0] < sizeof(*(ctx->func_desc))) 782 break; 783 784 ctx->func_desc = (const struct usb_cdc_ncm_desc *)buf; 785 break; 786 787 case USB_CDC_MBIM_TYPE: 788 if (buf[0] < sizeof(*(ctx->mbim_desc))) 789 break; 790 791 ctx->mbim_desc = (const struct usb_cdc_mbim_desc *)buf; 792 break; 793 794 case USB_CDC_MBIM_EXTENDED_TYPE: 795 if (buf[0] < sizeof(*(ctx->mbim_extended_desc))) 796 break; 797 798 ctx->mbim_extended_desc = 799 (const struct usb_cdc_mbim_extended_desc *)buf; 800 break; 801 802 default: 803 break; 804 } 805advance: 806 /* advance to next descriptor */ 807 temp = buf[0]; 808 buf += temp; 809 len -= temp; 810 } 811 812 /* some buggy devices have an IAD but no CDC Union */ 813 if (!union_desc && intf->intf_assoc && intf->intf_assoc->bInterfaceCount == 2) { 814 ctx->data = usb_ifnum_to_if(dev->udev, intf->cur_altsetting->desc.bInterfaceNumber + 1); 815 dev_dbg(&intf->dev, "CDC Union missing - got slave from IAD\n"); 816 } 817 818 /* check if we got everything */ 819 if (!ctx->data) { 820 dev_dbg(&intf->dev, "CDC Union missing and no IAD found\n"); 821 goto error; 822 } 823 if (cdc_ncm_comm_intf_is_mbim(intf->cur_altsetting)) { 824 if (!ctx->mbim_desc) { 825 dev_dbg(&intf->dev, "MBIM functional descriptor missing\n"); 826 goto error; 827 } 828 } else { 829 if (!ctx->ether_desc || !ctx->func_desc) { 830 dev_dbg(&intf->dev, "NCM or ECM functional descriptors missing\n"); 831 goto error; 832 } 833 } 834 835 /* claim data interface, if different from control */ 836 if (ctx->data != ctx->control) { 837 temp = usb_driver_claim_interface(driver, ctx->data, dev); 838 if (temp) { 839 dev_dbg(&intf->dev, "failed to claim data intf\n"); 840 goto error; 841 } 842 } 843 844 iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber; 845 846 /* reset data interface */ 847 temp = usb_set_interface(dev->udev, iface_no, 0); 848 if (temp) { 849 dev_dbg(&intf->dev, "set interface failed\n"); 850 goto error2; 851 } 852 853 /* initialize basic device settings */ 854 if (cdc_ncm_init(dev)) 855 goto error2; 856 857 /* configure data interface */ 858 temp = usb_set_interface(dev->udev, iface_no, data_altsetting); 859 if (temp) { 860 dev_dbg(&intf->dev, "set interface failed\n"); 861 goto error2; 862 } 863 864 cdc_ncm_find_endpoints(dev, ctx->data); 865 cdc_ncm_find_endpoints(dev, ctx->control); 866 if (!dev->in || !dev->out || !dev->status) { 867 dev_dbg(&intf->dev, "failed to collect endpoints\n"); 868 goto error2; 869 } 870 871 usb_set_intfdata(ctx->data, dev); 872 usb_set_intfdata(ctx->control, dev); 873 874 if (ctx->ether_desc) { 875 temp = usbnet_get_ethernet_addr(dev, ctx->ether_desc->iMACAddress); 876 if (temp) { 877 dev_dbg(&intf->dev, "failed to get mac address\n"); 878 goto error2; 879 } 880 dev_info(&intf->dev, "MAC-Address: %pM\n", dev->net->dev_addr); 881 } 882 883 /* finish setting up the device specific data */ 884 cdc_ncm_setup(dev); 885 886 /* override ethtool_ops */ 887 dev->net->ethtool_ops = &cdc_ncm_ethtool_ops; 888 889 /* add our sysfs attrs */ 890 dev->net->sysfs_groups[0] = &cdc_ncm_sysfs_attr_group; 891 892 /* must handle MTU changes */ 893 dev->net->netdev_ops = &cdc_ncm_netdev_ops; 894 895 return 0; 896 897error2: 898 usb_set_intfdata(ctx->control, NULL); 899 usb_set_intfdata(ctx->data, NULL); 900 if (ctx->data != ctx->control) 901 usb_driver_release_interface(driver, ctx->data); 902error: 903 cdc_ncm_free((struct cdc_ncm_ctx *)dev->data[0]); 904 dev->data[0] = 0; 905 dev_info(&intf->dev, "bind() failure\n"); 906 return -ENODEV; 907} 908EXPORT_SYMBOL_GPL(cdc_ncm_bind_common); 909 910void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf) 911{ 912 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 913 struct usb_driver *driver = driver_of(intf); 914 915 if (ctx == NULL) 916 return; /* no setup */ 917 918 atomic_set(&ctx->stop, 1); 919 920 if (hrtimer_active(&ctx->tx_timer)) 921 hrtimer_cancel(&ctx->tx_timer); 922 923 tasklet_kill(&ctx->bh); 924 925 /* handle devices with combined control and data interface */ 926 if (ctx->control == ctx->data) 927 ctx->data = NULL; 928 929 /* disconnect master --> disconnect slave */ 930 if (intf == ctx->control && ctx->data) { 931 usb_set_intfdata(ctx->data, NULL); 932 usb_driver_release_interface(driver, ctx->data); 933 ctx->data = NULL; 934 935 } else if (intf == ctx->data && ctx->control) { 936 usb_set_intfdata(ctx->control, NULL); 937 usb_driver_release_interface(driver, ctx->control); 938 ctx->control = NULL; 939 } 940 941 usb_set_intfdata(intf, NULL); 942 cdc_ncm_free(ctx); 943} 944EXPORT_SYMBOL_GPL(cdc_ncm_unbind); 945 946/* Return the number of the MBIM control interface altsetting iff it 947 * is preferred and available, 948 */ 949u8 cdc_ncm_select_altsetting(struct usb_interface *intf) 950{ 951 struct usb_host_interface *alt; 952 953 /* The MBIM spec defines a NCM compatible default altsetting, 954 * which we may have matched: 955 * 956 * "Functions that implement both NCM 1.0 and MBIM (an 957 * “NCM/MBIM function”) according to this recommendation 958 * shall provide two alternate settings for the 959 * Communication Interface. Alternate setting 0, and the 960 * associated class and endpoint descriptors, shall be 961 * constructed according to the rules given for the 962 * Communication Interface in section 5 of [USBNCM10]. 963 * Alternate setting 1, and the associated class and 964 * endpoint descriptors, shall be constructed according to 965 * the rules given in section 6 (USB Device Model) of this 966 * specification." 967 */ 968 if (intf->num_altsetting < 2) 969 return intf->cur_altsetting->desc.bAlternateSetting; 970 971 if (prefer_mbim) { 972 alt = usb_altnum_to_altsetting(intf, CDC_NCM_COMM_ALTSETTING_MBIM); 973 if (alt && cdc_ncm_comm_intf_is_mbim(alt)) 974 return CDC_NCM_COMM_ALTSETTING_MBIM; 975 } 976 return CDC_NCM_COMM_ALTSETTING_NCM; 977} 978EXPORT_SYMBOL_GPL(cdc_ncm_select_altsetting); 979 980static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf) 981{ 982 int ret; 983 984 /* MBIM backwards compatible function? */ 985 if (cdc_ncm_select_altsetting(intf) != CDC_NCM_COMM_ALTSETTING_NCM) 986 return -ENODEV; 987 988 /* The NCM data altsetting is fixed */ 989 ret = cdc_ncm_bind_common(dev, intf, CDC_NCM_DATA_ALTSETTING_NCM); 990 991 /* 992 * We should get an event when network connection is "connected" or 993 * "disconnected". Set network connection in "disconnected" state 994 * (carrier is OFF) during attach, so the IP network stack does not 995 * start IPv6 negotiation and more. 996 */ 997 usbnet_link_change(dev, 0, 0); 998 return ret; 999} 1000 1001static void cdc_ncm_align_tail(struct sk_buff *skb, size_t modulus, size_t remainder, size_t max) 1002{ 1003 size_t align = ALIGN(skb->len, modulus) - skb->len + remainder; 1004 1005 if (skb->len + align > max) 1006 align = max - skb->len; 1007 if (align && skb_tailroom(skb) >= align) 1008 memset(skb_put(skb, align), 0, align); 1009} 1010 1011/* return a pointer to a valid struct usb_cdc_ncm_ndp16 of type sign, possibly 1012 * allocating a new one within skb 1013 */ 1014static struct usb_cdc_ncm_ndp16 *cdc_ncm_ndp(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign, size_t reserve) 1015{ 1016 struct usb_cdc_ncm_ndp16 *ndp16 = NULL; 1017 struct usb_cdc_ncm_nth16 *nth16 = (void *)skb->data; 1018 size_t ndpoffset = le16_to_cpu(nth16->wNdpIndex); 1019 1020 /* follow the chain of NDPs, looking for a match */ 1021 while (ndpoffset) { 1022 ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb->data + ndpoffset); 1023 if (ndp16->dwSignature == sign) 1024 return ndp16; 1025 ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex); 1026 } 1027 1028 /* align new NDP */ 1029 cdc_ncm_align_tail(skb, ctx->tx_ndp_modulus, 0, ctx->tx_max); 1030 1031 /* verify that there is room for the NDP and the datagram (reserve) */ 1032 if ((ctx->tx_max - skb->len - reserve) < ctx->max_ndp_size) 1033 return NULL; 1034 1035 /* link to it */ 1036 if (ndp16) 1037 ndp16->wNextNdpIndex = cpu_to_le16(skb->len); 1038 else 1039 nth16->wNdpIndex = cpu_to_le16(skb->len); 1040 1041 /* push a new empty NDP */ 1042 ndp16 = (struct usb_cdc_ncm_ndp16 *)memset(skb_put(skb, ctx->max_ndp_size), 0, ctx->max_ndp_size); 1043 ndp16->dwSignature = sign; 1044 ndp16->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp16) + sizeof(struct usb_cdc_ncm_dpe16)); 1045 return ndp16; 1046} 1047 1048struct sk_buff * 1049cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign) 1050{ 1051 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1052 struct usb_cdc_ncm_nth16 *nth16; 1053 struct usb_cdc_ncm_ndp16 *ndp16; 1054 struct sk_buff *skb_out; 1055 u16 n = 0, index, ndplen; 1056 u8 ready2send = 0; 1057 1058 /* if there is a remaining skb, it gets priority */ 1059 if (skb != NULL) { 1060 swap(skb, ctx->tx_rem_skb); 1061 swap(sign, ctx->tx_rem_sign); 1062 } else { 1063 ready2send = 1; 1064 } 1065 1066 /* check if we are resuming an OUT skb */ 1067 skb_out = ctx->tx_curr_skb; 1068 1069 /* allocate a new OUT skb */ 1070 if (!skb_out) { 1071 skb_out = alloc_skb(ctx->tx_max, GFP_ATOMIC); 1072 if (skb_out == NULL) { 1073 if (skb != NULL) { 1074 dev_kfree_skb_any(skb); 1075 dev->net->stats.tx_dropped++; 1076 } 1077 goto exit_no_skb; 1078 } 1079 /* fill out the initial 16-bit NTB header */ 1080 nth16 = (struct usb_cdc_ncm_nth16 *)memset(skb_put(skb_out, sizeof(struct usb_cdc_ncm_nth16)), 0, sizeof(struct usb_cdc_ncm_nth16)); 1081 nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN); 1082 nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16)); 1083 nth16->wSequence = cpu_to_le16(ctx->tx_seq++); 1084 1085 /* count total number of frames in this NTB */ 1086 ctx->tx_curr_frame_num = 0; 1087 1088 /* recent payload counter for this skb_out */ 1089 ctx->tx_curr_frame_payload = 0; 1090 } 1091 1092 for (n = ctx->tx_curr_frame_num; n < ctx->tx_max_datagrams; n++) { 1093 /* send any remaining skb first */ 1094 if (skb == NULL) { 1095 skb = ctx->tx_rem_skb; 1096 sign = ctx->tx_rem_sign; 1097 ctx->tx_rem_skb = NULL; 1098 1099 /* check for end of skb */ 1100 if (skb == NULL) 1101 break; 1102 } 1103 1104 /* get the appropriate NDP for this skb */ 1105 ndp16 = cdc_ncm_ndp(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder); 1106 1107 /* align beginning of next frame */ 1108 cdc_ncm_align_tail(skb_out, ctx->tx_modulus, ctx->tx_remainder, ctx->tx_max); 1109 1110 /* check if we had enough room left for both NDP and frame */ 1111 if (!ndp16 || skb_out->len + skb->len > ctx->tx_max) { 1112 if (n == 0) { 1113 /* won't fit, MTU problem? */ 1114 dev_kfree_skb_any(skb); 1115 skb = NULL; 1116 dev->net->stats.tx_dropped++; 1117 } else { 1118 /* no room for skb - store for later */ 1119 if (ctx->tx_rem_skb != NULL) { 1120 dev_kfree_skb_any(ctx->tx_rem_skb); 1121 dev->net->stats.tx_dropped++; 1122 } 1123 ctx->tx_rem_skb = skb; 1124 ctx->tx_rem_sign = sign; 1125 skb = NULL; 1126 ready2send = 1; 1127 ctx->tx_reason_ntb_full++; /* count reason for transmitting */ 1128 } 1129 break; 1130 } 1131 1132 /* calculate frame number withing this NDP */ 1133 ndplen = le16_to_cpu(ndp16->wLength); 1134 index = (ndplen - sizeof(struct usb_cdc_ncm_ndp16)) / sizeof(struct usb_cdc_ncm_dpe16) - 1; 1135 1136 /* OK, add this skb */ 1137 ndp16->dpe16[index].wDatagramLength = cpu_to_le16(skb->len); 1138 ndp16->dpe16[index].wDatagramIndex = cpu_to_le16(skb_out->len); 1139 ndp16->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe16)); 1140 memcpy(skb_put(skb_out, skb->len), skb->data, skb->len); 1141 ctx->tx_curr_frame_payload += skb->len; /* count real tx payload data */ 1142 dev_kfree_skb_any(skb); 1143 skb = NULL; 1144 1145 /* send now if this NDP is full */ 1146 if (index >= CDC_NCM_DPT_DATAGRAMS_MAX) { 1147 ready2send = 1; 1148 ctx->tx_reason_ndp_full++; /* count reason for transmitting */ 1149 break; 1150 } 1151 } 1152 1153 /* free up any dangling skb */ 1154 if (skb != NULL) { 1155 dev_kfree_skb_any(skb); 1156 skb = NULL; 1157 dev->net->stats.tx_dropped++; 1158 } 1159 1160 ctx->tx_curr_frame_num = n; 1161 1162 if (n == 0) { 1163 /* wait for more frames */ 1164 /* push variables */ 1165 ctx->tx_curr_skb = skb_out; 1166 goto exit_no_skb; 1167 1168 } else if ((n < ctx->tx_max_datagrams) && (ready2send == 0) && (ctx->timer_interval > 0)) { 1169 /* wait for more frames */ 1170 /* push variables */ 1171 ctx->tx_curr_skb = skb_out; 1172 /* set the pending count */ 1173 if (n < CDC_NCM_RESTART_TIMER_DATAGRAM_CNT) 1174 ctx->tx_timer_pending = CDC_NCM_TIMER_PENDING_CNT; 1175 goto exit_no_skb; 1176 1177 } else { 1178 if (n == ctx->tx_max_datagrams) 1179 ctx->tx_reason_max_datagram++; /* count reason for transmitting */ 1180 /* frame goes out */ 1181 /* variables will be reset at next call */ 1182 } 1183 1184 /* If collected data size is less or equal ctx->min_tx_pkt 1185 * bytes, we send buffers as it is. If we get more data, it 1186 * would be more efficient for USB HS mobile device with DMA 1187 * engine to receive a full size NTB, than canceling DMA 1188 * transfer and receiving a short packet. 1189 * 1190 * This optimization support is pointless if we end up sending 1191 * a ZLP after full sized NTBs. 1192 */ 1193 if (!(dev->driver_info->flags & FLAG_SEND_ZLP) && 1194 skb_out->len > ctx->min_tx_pkt) 1195 memset(skb_put(skb_out, ctx->tx_max - skb_out->len), 0, 1196 ctx->tx_max - skb_out->len); 1197 else if (skb_out->len < ctx->tx_max && (skb_out->len % dev->maxpacket) == 0) 1198 *skb_put(skb_out, 1) = 0; /* force short packet */ 1199 1200 /* set final frame length */ 1201 nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data; 1202 nth16->wBlockLength = cpu_to_le16(skb_out->len); 1203 1204 /* return skb */ 1205 ctx->tx_curr_skb = NULL; 1206 1207 /* keep private stats: framing overhead and number of NTBs */ 1208 ctx->tx_overhead += skb_out->len - ctx->tx_curr_frame_payload; 1209 ctx->tx_ntbs++; 1210 1211 /* usbnet will count all the framing overhead by default. 1212 * Adjust the stats so that the tx_bytes counter show real 1213 * payload data instead. 1214 */ 1215 usbnet_set_skb_tx_stats(skb_out, n, 1216 (long)ctx->tx_curr_frame_payload - skb_out->len); 1217 1218 return skb_out; 1219 1220exit_no_skb: 1221 /* Start timer, if there is a remaining non-empty skb */ 1222 if (ctx->tx_curr_skb != NULL && n > 0) 1223 cdc_ncm_tx_timeout_start(ctx); 1224 return NULL; 1225} 1226EXPORT_SYMBOL_GPL(cdc_ncm_fill_tx_frame); 1227 1228static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx) 1229{ 1230 /* start timer, if not already started */ 1231 if (!(hrtimer_active(&ctx->tx_timer) || atomic_read(&ctx->stop))) 1232 hrtimer_start(&ctx->tx_timer, 1233 ktime_set(0, ctx->timer_interval), 1234 HRTIMER_MODE_REL); 1235} 1236 1237static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *timer) 1238{ 1239 struct cdc_ncm_ctx *ctx = 1240 container_of(timer, struct cdc_ncm_ctx, tx_timer); 1241 1242 if (!atomic_read(&ctx->stop)) 1243 tasklet_schedule(&ctx->bh); 1244 return HRTIMER_NORESTART; 1245} 1246 1247static void cdc_ncm_txpath_bh(unsigned long param) 1248{ 1249 struct usbnet *dev = (struct usbnet *)param; 1250 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1251 1252 spin_lock_bh(&ctx->mtx); 1253 if (ctx->tx_timer_pending != 0) { 1254 ctx->tx_timer_pending--; 1255 cdc_ncm_tx_timeout_start(ctx); 1256 spin_unlock_bh(&ctx->mtx); 1257 } else if (dev->net != NULL) { 1258 ctx->tx_reason_timeout++; /* count reason for transmitting */ 1259 spin_unlock_bh(&ctx->mtx); 1260 netif_tx_lock_bh(dev->net); 1261 usbnet_start_xmit(NULL, dev->net); 1262 netif_tx_unlock_bh(dev->net); 1263 } else { 1264 spin_unlock_bh(&ctx->mtx); 1265 } 1266} 1267 1268struct sk_buff * 1269cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags) 1270{ 1271 struct sk_buff *skb_out; 1272 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1273 1274 /* 1275 * The Ethernet API we are using does not support transmitting 1276 * multiple Ethernet frames in a single call. This driver will 1277 * accumulate multiple Ethernet frames and send out a larger 1278 * USB frame when the USB buffer is full or when a single jiffies 1279 * timeout happens. 1280 */ 1281 if (ctx == NULL) 1282 goto error; 1283 1284 spin_lock_bh(&ctx->mtx); 1285 skb_out = cdc_ncm_fill_tx_frame(dev, skb, cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN)); 1286 spin_unlock_bh(&ctx->mtx); 1287 return skb_out; 1288 1289error: 1290 if (skb != NULL) 1291 dev_kfree_skb_any(skb); 1292 1293 return NULL; 1294} 1295EXPORT_SYMBOL_GPL(cdc_ncm_tx_fixup); 1296 1297/* verify NTB header and return offset of first NDP, or negative error */ 1298int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in) 1299{ 1300 struct usbnet *dev = netdev_priv(skb_in->dev); 1301 struct usb_cdc_ncm_nth16 *nth16; 1302 int len; 1303 int ret = -EINVAL; 1304 1305 if (ctx == NULL) 1306 goto error; 1307 1308 if (skb_in->len < (sizeof(struct usb_cdc_ncm_nth16) + 1309 sizeof(struct usb_cdc_ncm_ndp16))) { 1310 netif_dbg(dev, rx_err, dev->net, "frame too short\n"); 1311 goto error; 1312 } 1313 1314 nth16 = (struct usb_cdc_ncm_nth16 *)skb_in->data; 1315 1316 if (nth16->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH16_SIGN)) { 1317 netif_dbg(dev, rx_err, dev->net, 1318 "invalid NTH16 signature <%#010x>\n", 1319 le32_to_cpu(nth16->dwSignature)); 1320 goto error; 1321 } 1322 1323 len = le16_to_cpu(nth16->wBlockLength); 1324 if (len > ctx->rx_max) { 1325 netif_dbg(dev, rx_err, dev->net, 1326 "unsupported NTB block length %u/%u\n", len, 1327 ctx->rx_max); 1328 goto error; 1329 } 1330 1331 if ((ctx->rx_seq + 1) != le16_to_cpu(nth16->wSequence) && 1332 (ctx->rx_seq || le16_to_cpu(nth16->wSequence)) && 1333 !((ctx->rx_seq == 0xffff) && !le16_to_cpu(nth16->wSequence))) { 1334 netif_dbg(dev, rx_err, dev->net, 1335 "sequence number glitch prev=%d curr=%d\n", 1336 ctx->rx_seq, le16_to_cpu(nth16->wSequence)); 1337 } 1338 ctx->rx_seq = le16_to_cpu(nth16->wSequence); 1339 1340 ret = le16_to_cpu(nth16->wNdpIndex); 1341error: 1342 return ret; 1343} 1344EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_nth16); 1345 1346/* verify NDP header and return number of datagrams, or negative error */ 1347int cdc_ncm_rx_verify_ndp16(struct sk_buff *skb_in, int ndpoffset) 1348{ 1349 struct usbnet *dev = netdev_priv(skb_in->dev); 1350 struct usb_cdc_ncm_ndp16 *ndp16; 1351 int ret = -EINVAL; 1352 1353 if ((ndpoffset + sizeof(struct usb_cdc_ncm_ndp16)) > skb_in->len) { 1354 netif_dbg(dev, rx_err, dev->net, "invalid NDP offset <%u>\n", 1355 ndpoffset); 1356 goto error; 1357 } 1358 ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset); 1359 1360 if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) { 1361 netif_dbg(dev, rx_err, dev->net, "invalid DPT16 length <%u>\n", 1362 le16_to_cpu(ndp16->wLength)); 1363 goto error; 1364 } 1365 1366 ret = ((le16_to_cpu(ndp16->wLength) - 1367 sizeof(struct usb_cdc_ncm_ndp16)) / 1368 sizeof(struct usb_cdc_ncm_dpe16)); 1369 ret--; /* we process NDP entries except for the last one */ 1370 1371 if ((sizeof(struct usb_cdc_ncm_ndp16) + 1372 ret * (sizeof(struct usb_cdc_ncm_dpe16))) > skb_in->len) { 1373 netif_dbg(dev, rx_err, dev->net, "Invalid nframes = %d\n", ret); 1374 ret = -EINVAL; 1375 } 1376 1377error: 1378 return ret; 1379} 1380EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp16); 1381 1382int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in) 1383{ 1384 struct sk_buff *skb; 1385 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1386 int len; 1387 int nframes; 1388 int x; 1389 int offset; 1390 struct usb_cdc_ncm_ndp16 *ndp16; 1391 struct usb_cdc_ncm_dpe16 *dpe16; 1392 int ndpoffset; 1393 int loopcount = 50; /* arbitrary max preventing infinite loop */ 1394 u32 payload = 0; 1395 1396 ndpoffset = cdc_ncm_rx_verify_nth16(ctx, skb_in); 1397 if (ndpoffset < 0) 1398 goto error; 1399 1400next_ndp: 1401 nframes = cdc_ncm_rx_verify_ndp16(skb_in, ndpoffset); 1402 if (nframes < 0) 1403 goto error; 1404 1405 ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset); 1406 1407 if (ndp16->dwSignature != cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN)) { 1408 netif_dbg(dev, rx_err, dev->net, 1409 "invalid DPT16 signature <%#010x>\n", 1410 le32_to_cpu(ndp16->dwSignature)); 1411 goto err_ndp; 1412 } 1413 dpe16 = ndp16->dpe16; 1414 1415 for (x = 0; x < nframes; x++, dpe16++) { 1416 offset = le16_to_cpu(dpe16->wDatagramIndex); 1417 len = le16_to_cpu(dpe16->wDatagramLength); 1418 1419 /* 1420 * CDC NCM ch. 3.7 1421 * All entries after first NULL entry are to be ignored 1422 */ 1423 if ((offset == 0) || (len == 0)) { 1424 if (!x) 1425 goto err_ndp; /* empty NTB */ 1426 break; 1427 } 1428 1429 /* sanity checking */ 1430 if (((offset + len) > skb_in->len) || 1431 (len > ctx->rx_max) || (len < ETH_HLEN)) { 1432 netif_dbg(dev, rx_err, dev->net, 1433 "invalid frame detected (ignored) offset[%u]=%u, length=%u, skb=%p\n", 1434 x, offset, len, skb_in); 1435 if (!x) 1436 goto err_ndp; 1437 break; 1438 1439 } else { 1440 /* create a fresh copy to reduce truesize */ 1441 skb = netdev_alloc_skb_ip_align(dev->net, len); 1442 if (!skb) 1443 goto error; 1444 memcpy(skb_put(skb, len), skb_in->data + offset, len); 1445 usbnet_skb_return(dev, skb); 1446 payload += len; /* count payload bytes in this NTB */ 1447 } 1448 } 1449err_ndp: 1450 /* are there more NDPs to process? */ 1451 ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex); 1452 if (ndpoffset && loopcount--) 1453 goto next_ndp; 1454 1455 /* update stats */ 1456 ctx->rx_overhead += skb_in->len - payload; 1457 ctx->rx_ntbs++; 1458 1459 return 1; 1460error: 1461 return 0; 1462} 1463EXPORT_SYMBOL_GPL(cdc_ncm_rx_fixup); 1464 1465static void 1466cdc_ncm_speed_change(struct usbnet *dev, 1467 struct usb_cdc_speed_change *data) 1468{ 1469 uint32_t rx_speed = le32_to_cpu(data->DLBitRRate); 1470 uint32_t tx_speed = le32_to_cpu(data->ULBitRate); 1471 1472 /* 1473 * Currently the USB-NET API does not support reporting the actual 1474 * device speed. Do print it instead. 1475 */ 1476 if ((tx_speed > 1000000) && (rx_speed > 1000000)) { 1477 netif_info(dev, link, dev->net, 1478 "%u mbit/s downlink %u mbit/s uplink\n", 1479 (unsigned int)(rx_speed / 1000000U), 1480 (unsigned int)(tx_speed / 1000000U)); 1481 } else { 1482 netif_info(dev, link, dev->net, 1483 "%u kbit/s downlink %u kbit/s uplink\n", 1484 (unsigned int)(rx_speed / 1000U), 1485 (unsigned int)(tx_speed / 1000U)); 1486 } 1487} 1488 1489static void cdc_ncm_status(struct usbnet *dev, struct urb *urb) 1490{ 1491 struct cdc_ncm_ctx *ctx; 1492 struct usb_cdc_notification *event; 1493 1494 ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1495 1496 if (urb->actual_length < sizeof(*event)) 1497 return; 1498 1499 /* test for split data in 8-byte chunks */ 1500 if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) { 1501 cdc_ncm_speed_change(dev, 1502 (struct usb_cdc_speed_change *)urb->transfer_buffer); 1503 return; 1504 } 1505 1506 event = urb->transfer_buffer; 1507 1508 switch (event->bNotificationType) { 1509 case USB_CDC_NOTIFY_NETWORK_CONNECTION: 1510 /* 1511 * According to the CDC NCM specification ch.7.1 1512 * USB_CDC_NOTIFY_NETWORK_CONNECTION notification shall be 1513 * sent by device after USB_CDC_NOTIFY_SPEED_CHANGE. 1514 */ 1515 netif_info(dev, link, dev->net, 1516 "network connection: %sconnected\n", 1517 !!event->wValue ? "" : "dis"); 1518 usbnet_link_change(dev, !!event->wValue, 0); 1519 break; 1520 1521 case USB_CDC_NOTIFY_SPEED_CHANGE: 1522 if (urb->actual_length < (sizeof(*event) + 1523 sizeof(struct usb_cdc_speed_change))) 1524 set_bit(EVENT_STS_SPLIT, &dev->flags); 1525 else 1526 cdc_ncm_speed_change(dev, 1527 (struct usb_cdc_speed_change *)&event[1]); 1528 break; 1529 1530 default: 1531 dev_dbg(&dev->udev->dev, 1532 "NCM: unexpected notification 0x%02x!\n", 1533 event->bNotificationType); 1534 break; 1535 } 1536} 1537 1538static const struct driver_info cdc_ncm_info = { 1539 .description = "CDC NCM", 1540 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET, 1541 .bind = cdc_ncm_bind, 1542 .unbind = cdc_ncm_unbind, 1543 .manage_power = usbnet_manage_power, 1544 .status = cdc_ncm_status, 1545 .rx_fixup = cdc_ncm_rx_fixup, 1546 .tx_fixup = cdc_ncm_tx_fixup, 1547}; 1548 1549/* Same as cdc_ncm_info, but with FLAG_WWAN */ 1550static const struct driver_info wwan_info = { 1551 .description = "Mobile Broadband Network Device", 1552 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1553 | FLAG_WWAN, 1554 .bind = cdc_ncm_bind, 1555 .unbind = cdc_ncm_unbind, 1556 .manage_power = usbnet_manage_power, 1557 .status = cdc_ncm_status, 1558 .rx_fixup = cdc_ncm_rx_fixup, 1559 .tx_fixup = cdc_ncm_tx_fixup, 1560}; 1561 1562/* Same as wwan_info, but with FLAG_NOARP */ 1563static const struct driver_info wwan_noarp_info = { 1564 .description = "Mobile Broadband Network Device (NO ARP)", 1565 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET 1566 | FLAG_WWAN | FLAG_NOARP, 1567 .bind = cdc_ncm_bind, 1568 .unbind = cdc_ncm_unbind, 1569 .manage_power = usbnet_manage_power, 1570 .status = cdc_ncm_status, 1571 .rx_fixup = cdc_ncm_rx_fixup, 1572 .tx_fixup = cdc_ncm_tx_fixup, 1573}; 1574 1575static const struct usb_device_id cdc_devs[] = { 1576 /* Ericsson MBM devices like F5521gw */ 1577 { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 1578 | USB_DEVICE_ID_MATCH_VENDOR, 1579 .idVendor = 0x0bdb, 1580 .bInterfaceClass = USB_CLASS_COMM, 1581 .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM, 1582 .bInterfaceProtocol = USB_CDC_PROTO_NONE, 1583 .driver_info = (unsigned long) &wwan_info, 1584 }, 1585 1586 /* Dell branded MBM devices like DW5550 */ 1587 { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 1588 | USB_DEVICE_ID_MATCH_VENDOR, 1589 .idVendor = 0x413c, 1590 .bInterfaceClass = USB_CLASS_COMM, 1591 .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM, 1592 .bInterfaceProtocol = USB_CDC_PROTO_NONE, 1593 .driver_info = (unsigned long) &wwan_info, 1594 }, 1595 1596 /* Toshiba branded MBM devices */ 1597 { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 1598 | USB_DEVICE_ID_MATCH_VENDOR, 1599 .idVendor = 0x0930, 1600 .bInterfaceClass = USB_CLASS_COMM, 1601 .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM, 1602 .bInterfaceProtocol = USB_CDC_PROTO_NONE, 1603 .driver_info = (unsigned long) &wwan_info, 1604 }, 1605 1606 /* tag Huawei devices as wwan */ 1607 { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 1608 USB_CLASS_COMM, 1609 USB_CDC_SUBCLASS_NCM, 1610 USB_CDC_PROTO_NONE), 1611 .driver_info = (unsigned long)&wwan_info, 1612 }, 1613 1614 /* Infineon(now Intel) HSPA Modem platform */ 1615 { USB_DEVICE_AND_INTERFACE_INFO(0x1519, 0x0443, 1616 USB_CLASS_COMM, 1617 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 1618 .driver_info = (unsigned long)&wwan_noarp_info, 1619 }, 1620 1621 /* Generic CDC-NCM devices */ 1622 { USB_INTERFACE_INFO(USB_CLASS_COMM, 1623 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 1624 .driver_info = (unsigned long)&cdc_ncm_info, 1625 }, 1626 { 1627 }, 1628}; 1629MODULE_DEVICE_TABLE(usb, cdc_devs); 1630 1631static struct usb_driver cdc_ncm_driver = { 1632 .name = "cdc_ncm", 1633 .id_table = cdc_devs, 1634 .probe = usbnet_probe, 1635 .disconnect = usbnet_disconnect, 1636 .suspend = usbnet_suspend, 1637 .resume = usbnet_resume, 1638 .reset_resume = usbnet_resume, 1639 .supports_autosuspend = 1, 1640 .disable_hub_initiated_lpm = 1, 1641}; 1642 1643module_usb_driver(cdc_ncm_driver); 1644 1645MODULE_AUTHOR("Hans Petter Selasky"); 1646MODULE_DESCRIPTION("USB CDC NCM host driver"); 1647MODULE_LICENSE("Dual BSD/GPL"); 1648