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