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