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