cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

cdc_ncm.c (61944B)


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