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