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