1900d495aSAlexey Orishko /*
2900d495aSAlexey Orishko * cdc_ncm.c
3900d495aSAlexey Orishko *
4c84ff1d6SAlexey Orishko * Copyright (C) ST-Ericsson 2010-2012
5900d495aSAlexey Orishko * Contact: Alexey Orishko <alexey.orishko@stericsson.com>
6900d495aSAlexey Orishko * Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com>
7900d495aSAlexey Orishko *
8900d495aSAlexey Orishko * USB Host Driver for Network Control Model (NCM)
922401ff1SEnrico Mioso * http://www.usb.org/developers/docs/devclass_docs/NCM10_012011.zip
10900d495aSAlexey Orishko *
11900d495aSAlexey Orishko * The NCM encoding, decoding and initialization logic
12900d495aSAlexey Orishko * derives from FreeBSD 8.x. if_cdce.c and if_cdcereg.h
13900d495aSAlexey Orishko *
14900d495aSAlexey Orishko * This software is available to you under a choice of one of two
15900d495aSAlexey Orishko * licenses. You may choose this file to be licensed under the terms
16900d495aSAlexey Orishko * of the GNU General Public License (GPL) Version 2 or the 2-clause
17900d495aSAlexey Orishko * BSD license listed below:
18900d495aSAlexey Orishko *
19900d495aSAlexey Orishko * Redistribution and use in source and binary forms, with or without
20900d495aSAlexey Orishko * modification, are permitted provided that the following conditions
21900d495aSAlexey Orishko * are met:
22900d495aSAlexey Orishko * 1. Redistributions of source code must retain the above copyright
23900d495aSAlexey Orishko * notice, this list of conditions and the following disclaimer.
24900d495aSAlexey Orishko * 2. Redistributions in binary form must reproduce the above copyright
25900d495aSAlexey Orishko * notice, this list of conditions and the following disclaimer in the
26900d495aSAlexey Orishko * documentation and/or other materials provided with the distribution.
27900d495aSAlexey Orishko *
28900d495aSAlexey Orishko * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
29900d495aSAlexey Orishko * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30900d495aSAlexey Orishko * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31900d495aSAlexey Orishko * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
32900d495aSAlexey Orishko * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33900d495aSAlexey Orishko * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34900d495aSAlexey Orishko * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35900d495aSAlexey Orishko * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36900d495aSAlexey Orishko * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37900d495aSAlexey Orishko * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38900d495aSAlexey Orishko * SUCH DAMAGE.
39900d495aSAlexey Orishko */
40900d495aSAlexey Orishko
41900d495aSAlexey Orishko #include <linux/module.h>
42900d495aSAlexey Orishko #include <linux/netdevice.h>
43900d495aSAlexey Orishko #include <linux/ctype.h>
441dfddff5SBjørn Mork #include <linux/etherdevice.h>
45900d495aSAlexey Orishko #include <linux/ethtool.h>
46c2cce3a6SChristophe JAILLET #include <linux/kstrtox.h>
47900d495aSAlexey Orishko #include <linux/workqueue.h>
48900d495aSAlexey Orishko #include <linux/mii.h>
49900d495aSAlexey Orishko #include <linux/crc32.h>
50900d495aSAlexey Orishko #include <linux/usb.h>
51c84ff1d6SAlexey Orishko #include <linux/hrtimer.h>
52900d495aSAlexey Orishko #include <linux/atomic.h>
53900d495aSAlexey Orishko #include <linux/usb/usbnet.h>
54900d495aSAlexey Orishko #include <linux/usb/cdc.h>
55c91ce3b6SBjørn Mork #include <linux/usb/cdc_ncm.h>
56900d495aSAlexey Orishko
571e8bbe6cSBjørn Mork #if IS_ENABLED(CONFIG_USB_NET_CDC_MBIM)
581e8bbe6cSBjørn Mork static bool prefer_mbim = true;
591e8bbe6cSBjørn Mork #else
601e8bbe6cSBjørn Mork static bool prefer_mbim;
611e8bbe6cSBjørn Mork #endif
62d61e4038SJoe Perches module_param(prefer_mbim, bool, 0644);
631e8bbe6cSBjørn Mork MODULE_PARM_DESC(prefer_mbim, "Prefer MBIM setting on dual NCM/MBIM functions");
641e8bbe6cSBjørn Mork
654f4e5436SEmil Renner Berthing static void cdc_ncm_txpath_bh(struct tasklet_struct *t);
66c84ff1d6SAlexey Orishko static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx);
67c84ff1d6SAlexey Orishko static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *hr_timer);
68900d495aSAlexey Orishko static struct usb_driver cdc_ncm_driver;
69900d495aSAlexey Orishko
70beeecd42SBjørn Mork struct cdc_ncm_stats {
71beeecd42SBjørn Mork char stat_string[ETH_GSTRING_LEN];
72beeecd42SBjørn Mork int sizeof_stat;
73beeecd42SBjørn Mork int stat_offset;
74beeecd42SBjørn Mork };
75beeecd42SBjørn Mork
76beeecd42SBjørn Mork #define CDC_NCM_STAT(str, m) { \
77beeecd42SBjørn Mork .stat_string = str, \
78beeecd42SBjørn Mork .sizeof_stat = sizeof(((struct cdc_ncm_ctx *)0)->m), \
79beeecd42SBjørn Mork .stat_offset = offsetof(struct cdc_ncm_ctx, m) }
80beeecd42SBjørn Mork #define CDC_NCM_SIMPLE_STAT(m) CDC_NCM_STAT(__stringify(m), m)
81beeecd42SBjørn Mork
82beeecd42SBjørn Mork static const struct cdc_ncm_stats cdc_ncm_gstrings_stats[] = {
83beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(tx_reason_ntb_full),
84beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(tx_reason_ndp_full),
85beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(tx_reason_timeout),
86beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(tx_reason_max_datagram),
87beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(tx_overhead),
88beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(tx_ntbs),
89beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(rx_overhead),
90beeecd42SBjørn Mork CDC_NCM_SIMPLE_STAT(rx_ntbs),
91beeecd42SBjørn Mork };
92beeecd42SBjørn Mork
93e1069bbfSJim Baxter #define CDC_NCM_LOW_MEM_MAX_CNT 10
94e1069bbfSJim Baxter
cdc_ncm_get_sset_count(struct net_device __always_unused * netdev,int sset)95beeecd42SBjørn Mork static int cdc_ncm_get_sset_count(struct net_device __always_unused *netdev, int sset)
96beeecd42SBjørn Mork {
97beeecd42SBjørn Mork switch (sset) {
98beeecd42SBjørn Mork case ETH_SS_STATS:
99beeecd42SBjørn Mork return ARRAY_SIZE(cdc_ncm_gstrings_stats);
100beeecd42SBjørn Mork default:
101beeecd42SBjørn Mork return -EOPNOTSUPP;
102beeecd42SBjørn Mork }
103beeecd42SBjørn Mork }
104beeecd42SBjørn Mork
cdc_ncm_get_ethtool_stats(struct net_device * netdev,struct ethtool_stats __always_unused * stats,u64 * data)105beeecd42SBjørn Mork static void cdc_ncm_get_ethtool_stats(struct net_device *netdev,
106beeecd42SBjørn Mork struct ethtool_stats __always_unused *stats,
107beeecd42SBjørn Mork u64 *data)
108beeecd42SBjørn Mork {
109beeecd42SBjørn Mork struct usbnet *dev = netdev_priv(netdev);
110beeecd42SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
111beeecd42SBjørn Mork int i;
112beeecd42SBjørn Mork char *p = NULL;
113beeecd42SBjørn Mork
114beeecd42SBjørn Mork for (i = 0; i < ARRAY_SIZE(cdc_ncm_gstrings_stats); i++) {
115beeecd42SBjørn Mork p = (char *)ctx + cdc_ncm_gstrings_stats[i].stat_offset;
116beeecd42SBjørn Mork data[i] = (cdc_ncm_gstrings_stats[i].sizeof_stat == sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
117beeecd42SBjørn Mork }
118beeecd42SBjørn Mork }
119beeecd42SBjørn Mork
cdc_ncm_get_strings(struct net_device __always_unused * netdev,u32 stringset,u8 * data)120beeecd42SBjørn Mork static void cdc_ncm_get_strings(struct net_device __always_unused *netdev, u32 stringset, u8 *data)
121beeecd42SBjørn Mork {
122beeecd42SBjørn Mork u8 *p = data;
123beeecd42SBjørn Mork int i;
124beeecd42SBjørn Mork
125beeecd42SBjørn Mork switch (stringset) {
126beeecd42SBjørn Mork case ETH_SS_STATS:
127beeecd42SBjørn Mork for (i = 0; i < ARRAY_SIZE(cdc_ncm_gstrings_stats); i++) {
128beeecd42SBjørn Mork memcpy(p, cdc_ncm_gstrings_stats[i].stat_string, ETH_GSTRING_LEN);
129beeecd42SBjørn Mork p += ETH_GSTRING_LEN;
130beeecd42SBjørn Mork }
131beeecd42SBjørn Mork }
132beeecd42SBjørn Mork }
133beeecd42SBjørn Mork
1346c4e548fSBjørn Mork static void cdc_ncm_update_rxtx_max(struct usbnet *dev, u32 new_rx, u32 new_tx);
1356c4e548fSBjørn Mork
1366c4e548fSBjørn Mork static const struct ethtool_ops cdc_ncm_ethtool_ops = {
1376c4e548fSBjørn Mork .get_link = usbnet_get_link,
1386c4e548fSBjørn Mork .nway_reset = usbnet_nway_reset,
1396c4e548fSBjørn Mork .get_drvinfo = usbnet_get_drvinfo,
1406c4e548fSBjørn Mork .get_msglevel = usbnet_get_msglevel,
1416c4e548fSBjørn Mork .set_msglevel = usbnet_set_msglevel,
1426c4e548fSBjørn Mork .get_ts_info = ethtool_op_get_ts_info,
143beeecd42SBjørn Mork .get_sset_count = cdc_ncm_get_sset_count,
144beeecd42SBjørn Mork .get_strings = cdc_ncm_get_strings,
145beeecd42SBjørn Mork .get_ethtool_stats = cdc_ncm_get_ethtool_stats,
146eb47c274SOliver Neukum .get_link_ksettings = usbnet_get_link_ksettings_internal,
147eb47c274SOliver Neukum .set_link_ksettings = NULL,
1486c4e548fSBjørn Mork };
1496c4e548fSBjørn Mork
cdc_ncm_check_rx_max(struct usbnet * dev,u32 new_rx)150289507d3SBjørn Mork static u32 cdc_ncm_check_rx_max(struct usbnet *dev, u32 new_rx)
1515aa73d5dSBjørn Mork {
1525aa73d5dSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
1535aa73d5dSBjørn Mork u32 val, max, min;
1545aa73d5dSBjørn Mork
1555aa73d5dSBjørn Mork /* clamp new_rx to sane values */
1565aa73d5dSBjørn Mork min = USB_CDC_NCM_NTB_MIN_IN_SIZE;
1575aa73d5dSBjørn Mork max = min_t(u32, CDC_NCM_NTB_MAX_SIZE_RX, le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize));
1585aa73d5dSBjørn Mork
1595aa73d5dSBjørn Mork /* dwNtbInMaxSize spec violation? Use MIN size for both limits */
1605aa73d5dSBjørn Mork if (max < min) {
1615aa73d5dSBjørn Mork dev_warn(&dev->intf->dev, "dwNtbInMaxSize=%u is too small. Using %u\n",
1625aa73d5dSBjørn Mork le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize), min);
1635aa73d5dSBjørn Mork max = min;
1645aa73d5dSBjørn Mork }
1655aa73d5dSBjørn Mork
1665aa73d5dSBjørn Mork val = clamp_t(u32, new_rx, min, max);
167289507d3SBjørn Mork if (val != new_rx)
168289507d3SBjørn Mork dev_dbg(&dev->intf->dev, "rx_max must be in the [%u, %u] range\n", min, max);
169289507d3SBjørn Mork
170289507d3SBjørn Mork return val;
1715aa73d5dSBjørn Mork }
1725aa73d5dSBjørn Mork
cdc_ncm_check_tx_max(struct usbnet * dev,u32 new_tx)173289507d3SBjørn Mork static u32 cdc_ncm_check_tx_max(struct usbnet *dev, u32 new_tx)
174289507d3SBjørn Mork {
175289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
176289507d3SBjørn Mork u32 val, max, min;
177289507d3SBjørn Mork
178289507d3SBjørn Mork /* clamp new_tx to sane values */
1790fa81b30SAlexander Bersenev if (ctx->is_ndp16)
180289507d3SBjørn Mork min = ctx->max_datagram_size + ctx->max_ndp_size + sizeof(struct usb_cdc_ncm_nth16);
1810fa81b30SAlexander Bersenev else
1820fa81b30SAlexander Bersenev min = ctx->max_datagram_size + ctx->max_ndp_size + sizeof(struct usb_cdc_ncm_nth32);
1830fa81b30SAlexander Bersenev
184*7e01c7f7STudor Ambarus if (le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize) == 0)
1852be6d4d1SLee Jones max = CDC_NCM_NTB_MAX_SIZE_TX; /* dwNtbOutMaxSize not set */
186*7e01c7f7STudor Ambarus else
187*7e01c7f7STudor Ambarus max = clamp_t(u32, le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize),
188*7e01c7f7STudor Ambarus USB_CDC_NCM_NTB_MIN_OUT_SIZE,
189*7e01c7f7STudor Ambarus CDC_NCM_NTB_MAX_SIZE_TX);
190289507d3SBjørn Mork
191289507d3SBjørn Mork /* some devices set dwNtbOutMaxSize too low for the above default */
192289507d3SBjørn Mork min = min(min, max);
193289507d3SBjørn Mork
194289507d3SBjørn Mork val = clamp_t(u32, new_tx, min, max);
195289507d3SBjørn Mork if (val != new_tx)
196289507d3SBjørn Mork dev_dbg(&dev->intf->dev, "tx_max must be in the [%u, %u] range\n", min, max);
197289507d3SBjørn Mork
198289507d3SBjørn Mork return val;
199289507d3SBjørn Mork }
200289507d3SBjørn Mork
min_tx_pkt_show(struct device * d,struct device_attribute * attr,char * buf)20186fe2f8aSYueHaibing static ssize_t min_tx_pkt_show(struct device *d,
20286fe2f8aSYueHaibing struct device_attribute *attr, char *buf)
20339eb7e0eSBjørn Mork {
20439eb7e0eSBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
20539eb7e0eSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
20639eb7e0eSBjørn Mork
20739eb7e0eSBjørn Mork return sprintf(buf, "%u\n", ctx->min_tx_pkt);
20839eb7e0eSBjørn Mork }
20939eb7e0eSBjørn Mork
rx_max_show(struct device * d,struct device_attribute * attr,char * buf)21086fe2f8aSYueHaibing static ssize_t rx_max_show(struct device *d,
21186fe2f8aSYueHaibing struct device_attribute *attr, char *buf)
212289507d3SBjørn Mork {
213289507d3SBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
214289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
215289507d3SBjørn Mork
216289507d3SBjørn Mork return sprintf(buf, "%u\n", ctx->rx_max);
217289507d3SBjørn Mork }
218289507d3SBjørn Mork
tx_max_show(struct device * d,struct device_attribute * attr,char * buf)21986fe2f8aSYueHaibing static ssize_t tx_max_show(struct device *d,
22086fe2f8aSYueHaibing struct device_attribute *attr, char *buf)
221289507d3SBjørn Mork {
222289507d3SBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
223289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
224289507d3SBjørn Mork
225289507d3SBjørn Mork return sprintf(buf, "%u\n", ctx->tx_max);
226289507d3SBjørn Mork }
227289507d3SBjørn Mork
tx_timer_usecs_show(struct device * d,struct device_attribute * attr,char * buf)22886fe2f8aSYueHaibing static ssize_t tx_timer_usecs_show(struct device *d,
22986fe2f8aSYueHaibing struct device_attribute *attr, char *buf)
230289507d3SBjørn Mork {
231289507d3SBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
232289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
233289507d3SBjørn Mork
234289507d3SBjørn Mork return sprintf(buf, "%u\n", ctx->timer_interval / (u32)NSEC_PER_USEC);
235289507d3SBjørn Mork }
236289507d3SBjørn Mork
min_tx_pkt_store(struct device * d,struct device_attribute * attr,const char * buf,size_t len)23786fe2f8aSYueHaibing static ssize_t min_tx_pkt_store(struct device *d,
23886fe2f8aSYueHaibing struct device_attribute *attr,
23986fe2f8aSYueHaibing const char *buf, size_t len)
24039eb7e0eSBjørn Mork {
24139eb7e0eSBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
24239eb7e0eSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
24339eb7e0eSBjørn Mork unsigned long val;
24439eb7e0eSBjørn Mork
24539eb7e0eSBjørn Mork /* no need to restrict values - anything from 0 to infinity is OK */
24639eb7e0eSBjørn Mork if (kstrtoul(buf, 0, &val))
24739eb7e0eSBjørn Mork return -EINVAL;
24839eb7e0eSBjørn Mork
24939eb7e0eSBjørn Mork ctx->min_tx_pkt = val;
25039eb7e0eSBjørn Mork return len;
25139eb7e0eSBjørn Mork }
25239eb7e0eSBjørn Mork
rx_max_store(struct device * d,struct device_attribute * attr,const char * buf,size_t len)25386fe2f8aSYueHaibing static ssize_t rx_max_store(struct device *d,
25486fe2f8aSYueHaibing struct device_attribute *attr,
25586fe2f8aSYueHaibing const char *buf, size_t len)
256289507d3SBjørn Mork {
257289507d3SBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
258289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
259289507d3SBjørn Mork unsigned long val;
260289507d3SBjørn Mork
261289507d3SBjørn Mork if (kstrtoul(buf, 0, &val) || cdc_ncm_check_rx_max(dev, val) != val)
262289507d3SBjørn Mork return -EINVAL;
263289507d3SBjørn Mork
264289507d3SBjørn Mork cdc_ncm_update_rxtx_max(dev, val, ctx->tx_max);
265289507d3SBjørn Mork return len;
266289507d3SBjørn Mork }
267289507d3SBjørn Mork
tx_max_store(struct device * d,struct device_attribute * attr,const char * buf,size_t len)26886fe2f8aSYueHaibing static ssize_t tx_max_store(struct device *d,
26986fe2f8aSYueHaibing struct device_attribute *attr,
27086fe2f8aSYueHaibing const char *buf, size_t len)
271289507d3SBjørn Mork {
272289507d3SBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
273289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
274289507d3SBjørn Mork unsigned long val;
275289507d3SBjørn Mork
276289507d3SBjørn Mork if (kstrtoul(buf, 0, &val) || cdc_ncm_check_tx_max(dev, val) != val)
277289507d3SBjørn Mork return -EINVAL;
278289507d3SBjørn Mork
279289507d3SBjørn Mork cdc_ncm_update_rxtx_max(dev, ctx->rx_max, val);
280289507d3SBjørn Mork return len;
281289507d3SBjørn Mork }
282289507d3SBjørn Mork
tx_timer_usecs_store(struct device * d,struct device_attribute * attr,const char * buf,size_t len)28386fe2f8aSYueHaibing static ssize_t tx_timer_usecs_store(struct device *d,
28486fe2f8aSYueHaibing struct device_attribute *attr,
28586fe2f8aSYueHaibing const char *buf, size_t len)
286289507d3SBjørn Mork {
287289507d3SBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
288289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
289289507d3SBjørn Mork ssize_t ret;
290289507d3SBjørn Mork unsigned long val;
291289507d3SBjørn Mork
292289507d3SBjørn Mork ret = kstrtoul(buf, 0, &val);
293289507d3SBjørn Mork if (ret)
294289507d3SBjørn Mork return ret;
295289507d3SBjørn Mork if (val && (val < CDC_NCM_TIMER_INTERVAL_MIN || val > CDC_NCM_TIMER_INTERVAL_MAX))
296289507d3SBjørn Mork return -EINVAL;
297289507d3SBjørn Mork
298289507d3SBjørn Mork spin_lock_bh(&ctx->mtx);
299289507d3SBjørn Mork ctx->timer_interval = val * NSEC_PER_USEC;
300289507d3SBjørn Mork if (!ctx->timer_interval)
301289507d3SBjørn Mork ctx->tx_timer_pending = 0;
302289507d3SBjørn Mork spin_unlock_bh(&ctx->mtx);
303289507d3SBjørn Mork return len;
304289507d3SBjørn Mork }
305289507d3SBjørn Mork
30686fe2f8aSYueHaibing static DEVICE_ATTR_RW(min_tx_pkt);
30786fe2f8aSYueHaibing static DEVICE_ATTR_RW(rx_max);
30886fe2f8aSYueHaibing static DEVICE_ATTR_RW(tx_max);
30986fe2f8aSYueHaibing static DEVICE_ATTR_RW(tx_timer_usecs);
310289507d3SBjørn Mork
ndp_to_end_show(struct device * d,struct device_attribute * attr,char * buf)311404814afSBjørn Mork static ssize_t ndp_to_end_show(struct device *d, struct device_attribute *attr, char *buf)
312404814afSBjørn Mork {
313404814afSBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
314404814afSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
315404814afSBjørn Mork
316404814afSBjørn Mork return sprintf(buf, "%c\n", ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END ? 'Y' : 'N');
317404814afSBjørn Mork }
318404814afSBjørn Mork
ndp_to_end_store(struct device * d,struct device_attribute * attr,const char * buf,size_t len)319404814afSBjørn Mork static ssize_t ndp_to_end_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len)
320404814afSBjørn Mork {
321404814afSBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d));
322404814afSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
323404814afSBjørn Mork bool enable;
324404814afSBjørn Mork
325c2cce3a6SChristophe JAILLET if (kstrtobool(buf, &enable))
326404814afSBjørn Mork return -EINVAL;
327404814afSBjørn Mork
328404814afSBjørn Mork /* no change? */
329404814afSBjørn Mork if (enable == (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END))
330404814afSBjørn Mork return len;
331404814afSBjørn Mork
3320fa81b30SAlexander Bersenev if (enable) {
3330fa81b30SAlexander Bersenev if (ctx->is_ndp16 && !ctx->delayed_ndp16) {
334404814afSBjørn Mork ctx->delayed_ndp16 = kzalloc(ctx->max_ndp_size, GFP_KERNEL);
335404814afSBjørn Mork if (!ctx->delayed_ndp16)
336404814afSBjørn Mork return -ENOMEM;
337404814afSBjørn Mork }
3380fa81b30SAlexander Bersenev if (!ctx->is_ndp16 && !ctx->delayed_ndp32) {
3390fa81b30SAlexander Bersenev ctx->delayed_ndp32 = kzalloc(ctx->max_ndp_size, GFP_KERNEL);
3400fa81b30SAlexander Bersenev if (!ctx->delayed_ndp32)
3410fa81b30SAlexander Bersenev return -ENOMEM;
3420fa81b30SAlexander Bersenev }
3430fa81b30SAlexander Bersenev }
344404814afSBjørn Mork
345404814afSBjørn Mork /* flush pending data before changing flag */
346404814afSBjørn Mork netif_tx_lock_bh(dev->net);
347404814afSBjørn Mork usbnet_start_xmit(NULL, dev->net);
348404814afSBjørn Mork spin_lock_bh(&ctx->mtx);
349404814afSBjørn Mork if (enable)
350404814afSBjørn Mork ctx->drvflags |= CDC_NCM_FLAG_NDP_TO_END;
351404814afSBjørn Mork else
352404814afSBjørn Mork ctx->drvflags &= ~CDC_NCM_FLAG_NDP_TO_END;
353404814afSBjørn Mork spin_unlock_bh(&ctx->mtx);
354404814afSBjørn Mork netif_tx_unlock_bh(dev->net);
355404814afSBjørn Mork
356404814afSBjørn Mork return len;
357404814afSBjørn Mork }
358404814afSBjørn Mork static DEVICE_ATTR_RW(ndp_to_end);
359404814afSBjørn Mork
360871578c9SBjørn Mork #define NCM_PARM_ATTR(name, format, tocpu) \
361871578c9SBjørn Mork static ssize_t cdc_ncm_show_##name(struct device *d, struct device_attribute *attr, char *buf) \
362871578c9SBjørn Mork { \
363871578c9SBjørn Mork struct usbnet *dev = netdev_priv(to_net_dev(d)); \
364871578c9SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; \
365871578c9SBjørn Mork return sprintf(buf, format "\n", tocpu(ctx->ncm_parm.name)); \
366871578c9SBjørn Mork } \
367d61e4038SJoe Perches static DEVICE_ATTR(name, 0444, cdc_ncm_show_##name, NULL)
368871578c9SBjørn Mork
369871578c9SBjørn Mork NCM_PARM_ATTR(bmNtbFormatsSupported, "0x%04x", le16_to_cpu);
370871578c9SBjørn Mork NCM_PARM_ATTR(dwNtbInMaxSize, "%u", le32_to_cpu);
371871578c9SBjørn Mork NCM_PARM_ATTR(wNdpInDivisor, "%u", le16_to_cpu);
372871578c9SBjørn Mork NCM_PARM_ATTR(wNdpInPayloadRemainder, "%u", le16_to_cpu);
373871578c9SBjørn Mork NCM_PARM_ATTR(wNdpInAlignment, "%u", le16_to_cpu);
374871578c9SBjørn Mork NCM_PARM_ATTR(dwNtbOutMaxSize, "%u", le32_to_cpu);
375871578c9SBjørn Mork NCM_PARM_ATTR(wNdpOutDivisor, "%u", le16_to_cpu);
376871578c9SBjørn Mork NCM_PARM_ATTR(wNdpOutPayloadRemainder, "%u", le16_to_cpu);
377871578c9SBjørn Mork NCM_PARM_ATTR(wNdpOutAlignment, "%u", le16_to_cpu);
378871578c9SBjørn Mork NCM_PARM_ATTR(wNtbOutMaxDatagrams, "%u", le16_to_cpu);
379871578c9SBjørn Mork
380289507d3SBjørn Mork static struct attribute *cdc_ncm_sysfs_attrs[] = {
38139eb7e0eSBjørn Mork &dev_attr_min_tx_pkt.attr,
382404814afSBjørn Mork &dev_attr_ndp_to_end.attr,
383289507d3SBjørn Mork &dev_attr_rx_max.attr,
384289507d3SBjørn Mork &dev_attr_tx_max.attr,
385289507d3SBjørn Mork &dev_attr_tx_timer_usecs.attr,
386871578c9SBjørn Mork &dev_attr_bmNtbFormatsSupported.attr,
387871578c9SBjørn Mork &dev_attr_dwNtbInMaxSize.attr,
388871578c9SBjørn Mork &dev_attr_wNdpInDivisor.attr,
389871578c9SBjørn Mork &dev_attr_wNdpInPayloadRemainder.attr,
390871578c9SBjørn Mork &dev_attr_wNdpInAlignment.attr,
391871578c9SBjørn Mork &dev_attr_dwNtbOutMaxSize.attr,
392871578c9SBjørn Mork &dev_attr_wNdpOutDivisor.attr,
393871578c9SBjørn Mork &dev_attr_wNdpOutPayloadRemainder.attr,
394871578c9SBjørn Mork &dev_attr_wNdpOutAlignment.attr,
395871578c9SBjørn Mork &dev_attr_wNtbOutMaxDatagrams.attr,
396289507d3SBjørn Mork NULL,
397289507d3SBjørn Mork };
398289507d3SBjørn Mork
39943f51ef1SArvind Yadav static const struct attribute_group cdc_ncm_sysfs_attr_group = {
400289507d3SBjørn Mork .name = "cdc_ncm",
401289507d3SBjørn Mork .attrs = cdc_ncm_sysfs_attrs,
402289507d3SBjørn Mork };
403289507d3SBjørn Mork
404289507d3SBjørn Mork /* handle rx_max and tx_max changes */
cdc_ncm_update_rxtx_max(struct usbnet * dev,u32 new_rx,u32 new_tx)405289507d3SBjørn Mork static void cdc_ncm_update_rxtx_max(struct usbnet *dev, u32 new_rx, u32 new_tx)
406289507d3SBjørn Mork {
407289507d3SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
408289507d3SBjørn Mork u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
409289507d3SBjørn Mork u32 val;
410289507d3SBjørn Mork
411289507d3SBjørn Mork val = cdc_ncm_check_rx_max(dev, new_rx);
412289507d3SBjørn Mork
4135aa73d5dSBjørn Mork /* inform device about NTB input size changes */
4145aa73d5dSBjørn Mork if (val != ctx->rx_max) {
4155aa73d5dSBjørn Mork __le32 dwNtbInMaxSize = cpu_to_le32(val);
4165aa73d5dSBjørn Mork
4175aa73d5dSBjørn Mork dev_info(&dev->intf->dev, "setting rx_max = %u\n", val);
41868864abfSBjørn Mork
41968864abfSBjørn Mork /* tell device to use new size */
4205aa73d5dSBjørn Mork if (usbnet_write_cmd(dev, USB_CDC_SET_NTB_INPUT_SIZE,
4215aa73d5dSBjørn Mork USB_TYPE_CLASS | USB_DIR_OUT
4225aa73d5dSBjørn Mork | USB_RECIP_INTERFACE,
4235aa73d5dSBjørn Mork 0, iface_no, &dwNtbInMaxSize, 4) < 0)
4245aa73d5dSBjørn Mork dev_dbg(&dev->intf->dev, "Setting NTB Input Size failed\n");
4255aa73d5dSBjørn Mork else
4265aa73d5dSBjørn Mork ctx->rx_max = val;
4275aa73d5dSBjørn Mork }
4285aa73d5dSBjørn Mork
429f42763dbSBjørn Mork /* usbnet use these values for sizing rx queues */
430f42763dbSBjørn Mork if (dev->rx_urb_size != ctx->rx_max) {
431f42763dbSBjørn Mork dev->rx_urb_size = ctx->rx_max;
432f42763dbSBjørn Mork if (netif_running(dev->net))
433f42763dbSBjørn Mork usbnet_unlink_rx_urbs(dev);
434f42763dbSBjørn Mork }
435f42763dbSBjørn Mork
436289507d3SBjørn Mork val = cdc_ncm_check_tx_max(dev, new_tx);
4375aa73d5dSBjørn Mork if (val != ctx->tx_max)
4385aa73d5dSBjørn Mork dev_info(&dev->intf->dev, "setting tx_max = %u\n", val);
43908c74fc9SBjørn Mork
44008c74fc9SBjørn Mork /* Adding a pad byte here if necessary simplifies the handling
44108c74fc9SBjørn Mork * in cdc_ncm_fill_tx_frame, making tx_max always represent
44208c74fc9SBjørn Mork * the real skb max size.
44308c74fc9SBjørn Mork *
44408c74fc9SBjørn Mork * We cannot use dev->maxpacket here because this is called from
44508c74fc9SBjørn Mork * .bind which is called before usbnet sets up dev->maxpacket
44608c74fc9SBjørn Mork */
44768864abfSBjørn Mork if (val != le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize) &&
448e13adbfaSVincent Mailhol val % usb_maxpacket(dev->udev, dev->out) == 0)
44968864abfSBjørn Mork val++;
45008c74fc9SBjørn Mork
45168864abfSBjørn Mork /* we might need to flush any pending tx buffers if running */
45268864abfSBjørn Mork if (netif_running(dev->net) && val > ctx->tx_max) {
45368864abfSBjørn Mork netif_tx_lock_bh(dev->net);
45468864abfSBjørn Mork usbnet_start_xmit(NULL, dev->net);
4551ba5d0ffSBjørn Mork /* make sure tx_curr_skb is reallocated if it was empty */
4561ba5d0ffSBjørn Mork if (ctx->tx_curr_skb) {
4571ba5d0ffSBjørn Mork dev_kfree_skb_any(ctx->tx_curr_skb);
4581ba5d0ffSBjørn Mork ctx->tx_curr_skb = NULL;
4591ba5d0ffSBjørn Mork }
46068864abfSBjørn Mork ctx->tx_max = val;
46168864abfSBjørn Mork netif_tx_unlock_bh(dev->net);
46268864abfSBjørn Mork } else {
46368864abfSBjørn Mork ctx->tx_max = val;
46468864abfSBjørn Mork }
46568864abfSBjørn Mork
46608c74fc9SBjørn Mork dev->hard_mtu = ctx->tx_max;
46768864abfSBjørn Mork
46868864abfSBjørn Mork /* max qlen depend on hard_mtu and rx_urb_size */
46968864abfSBjørn Mork usbnet_update_max_qlen(dev);
47043e4c6dfSBjørn Mork
47143e4c6dfSBjørn Mork /* never pad more than 3 full USB packets per transfer */
472e13adbfaSVincent Mailhol ctx->min_tx_pkt = clamp_t(u16, ctx->tx_max - 3 * usb_maxpacket(dev->udev, dev->out),
47343e4c6dfSBjørn Mork CDC_NCM_MIN_TX_PKT, ctx->tx_max);
4745aa73d5dSBjørn Mork }
4755aa73d5dSBjørn Mork
476f8afb73dSBjørn Mork /* helpers for NCM and MBIM differences */
cdc_ncm_flags(struct usbnet * dev)477f8afb73dSBjørn Mork static u8 cdc_ncm_flags(struct usbnet *dev)
478900d495aSAlexey Orishko {
479bed6f762SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
480900d495aSAlexey Orishko
481f8afb73dSBjørn Mork if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting) && ctx->mbim_desc)
482f8afb73dSBjørn Mork return ctx->mbim_desc->bmNetworkCapabilities;
483f8afb73dSBjørn Mork if (ctx->func_desc)
484f8afb73dSBjørn Mork return ctx->func_desc->bmNetworkCapabilities;
485f8afb73dSBjørn Mork return 0;
486f8afb73dSBjørn Mork }
487f8afb73dSBjørn Mork
cdc_ncm_eth_hlen(struct usbnet * dev)488f8afb73dSBjørn Mork static int cdc_ncm_eth_hlen(struct usbnet *dev)
489f8afb73dSBjørn Mork {
490f8afb73dSBjørn Mork if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting))
491f8afb73dSBjørn Mork return 0;
492f8afb73dSBjørn Mork return ETH_HLEN;
493f8afb73dSBjørn Mork }
494f8afb73dSBjørn Mork
cdc_ncm_min_dgram_size(struct usbnet * dev)495f8afb73dSBjørn Mork static u32 cdc_ncm_min_dgram_size(struct usbnet *dev)
496f8afb73dSBjørn Mork {
497f8afb73dSBjørn Mork if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting))
498f8afb73dSBjørn Mork return CDC_MBIM_MIN_DATAGRAM_SIZE;
499f8afb73dSBjørn Mork return CDC_NCM_MIN_DATAGRAM_SIZE;
500f8afb73dSBjørn Mork }
501f8afb73dSBjørn Mork
cdc_ncm_max_dgram_size(struct usbnet * dev)502f8afb73dSBjørn Mork static u32 cdc_ncm_max_dgram_size(struct usbnet *dev)
503f8afb73dSBjørn Mork {
504f8afb73dSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
505f8afb73dSBjørn Mork
506f8afb73dSBjørn Mork if (cdc_ncm_comm_intf_is_mbim(dev->intf->cur_altsetting) && ctx->mbim_desc)
507f8afb73dSBjørn Mork return le16_to_cpu(ctx->mbim_desc->wMaxSegmentSize);
508f8afb73dSBjørn Mork if (ctx->ether_desc)
509f8afb73dSBjørn Mork return le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
510f8afb73dSBjørn Mork return CDC_NCM_MAX_DATAGRAM_SIZE;
511f8afb73dSBjørn Mork }
512f8afb73dSBjørn Mork
513f8afb73dSBjørn Mork /* initial one-time device setup. MUST be called with the data interface
514f8afb73dSBjørn Mork * in altsetting 0
515f8afb73dSBjørn Mork */
cdc_ncm_init(struct usbnet * dev)516f8afb73dSBjørn Mork static int cdc_ncm_init(struct usbnet *dev)
517f8afb73dSBjørn Mork {
518f8afb73dSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
519f8afb73dSBjørn Mork u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
520f8afb73dSBjørn Mork int err;
521900d495aSAlexey Orishko
52290b8b037SMing Lei err = usbnet_read_cmd(dev, USB_CDC_GET_NTB_PARAMETERS,
52336c35416SGiuseppe Scrivano USB_TYPE_CLASS | USB_DIR_IN
52436c35416SGiuseppe Scrivano |USB_RECIP_INTERFACE,
525ff0992e9SBjørn Mork 0, iface_no, &ctx->ncm_parm,
526ff0992e9SBjørn Mork sizeof(ctx->ncm_parm));
52736c35416SGiuseppe Scrivano if (err < 0) {
52859ede316SBjørn Mork dev_err(&dev->intf->dev, "failed GET_NTB_PARAMETERS\n");
52959ede316SBjørn Mork return err; /* GET_NTB_PARAMETERS is required */
530900d495aSAlexey Orishko }
531900d495aSAlexey Orishko
532f8afb73dSBjørn Mork /* set CRC Mode */
533f8afb73dSBjørn Mork if (cdc_ncm_flags(dev) & USB_CDC_NCM_NCAP_CRC_MODE) {
534f8afb73dSBjørn Mork dev_dbg(&dev->intf->dev, "Setting CRC mode off\n");
535f8afb73dSBjørn Mork err = usbnet_write_cmd(dev, USB_CDC_SET_CRC_MODE,
536f8afb73dSBjørn Mork USB_TYPE_CLASS | USB_DIR_OUT
537f8afb73dSBjørn Mork | USB_RECIP_INTERFACE,
538f8afb73dSBjørn Mork USB_CDC_NCM_CRC_NOT_APPENDED,
539f8afb73dSBjørn Mork iface_no, NULL, 0);
540f8afb73dSBjørn Mork if (err < 0)
541f8afb73dSBjørn Mork dev_err(&dev->intf->dev, "SET_CRC_MODE failed\n");
542f8afb73dSBjørn Mork }
543f8afb73dSBjørn Mork
5440fa81b30SAlexander Bersenev /* use ndp16 by default */
5450fa81b30SAlexander Bersenev ctx->is_ndp16 = 1;
5460fa81b30SAlexander Bersenev
547f8afb73dSBjørn Mork /* set NTB format, if both formats are supported.
548f8afb73dSBjørn Mork *
549f8afb73dSBjørn Mork * "The host shall only send this command while the NCM Data
550f8afb73dSBjørn Mork * Interface is in alternate setting 0."
551f8afb73dSBjørn Mork */
552d22adbfbSDan Carpenter if (le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported) &
553d22adbfbSDan Carpenter USB_CDC_NCM_NTB32_SUPPORTED) {
5540fa81b30SAlexander Bersenev if (ctx->drvflags & CDC_NCM_FLAG_PREFER_NTB32) {
5550fa81b30SAlexander Bersenev ctx->is_ndp16 = 0;
5560fa81b30SAlexander Bersenev dev_dbg(&dev->intf->dev, "Setting NTB format to 32-bit\n");
5570fa81b30SAlexander Bersenev err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT,
5580fa81b30SAlexander Bersenev USB_TYPE_CLASS | USB_DIR_OUT
5590fa81b30SAlexander Bersenev | USB_RECIP_INTERFACE,
5600fa81b30SAlexander Bersenev USB_CDC_NCM_NTB32_FORMAT,
5610fa81b30SAlexander Bersenev iface_no, NULL, 0);
5620fa81b30SAlexander Bersenev } else {
5630fa81b30SAlexander Bersenev ctx->is_ndp16 = 1;
564f8afb73dSBjørn Mork dev_dbg(&dev->intf->dev, "Setting NTB format to 16-bit\n");
565f8afb73dSBjørn Mork err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT,
566f8afb73dSBjørn Mork USB_TYPE_CLASS | USB_DIR_OUT
567f8afb73dSBjørn Mork | USB_RECIP_INTERFACE,
568f8afb73dSBjørn Mork USB_CDC_NCM_NTB16_FORMAT,
569f8afb73dSBjørn Mork iface_no, NULL, 0);
5700fa81b30SAlexander Bersenev }
5710fa81b30SAlexander Bersenev if (err < 0) {
5720fa81b30SAlexander Bersenev ctx->is_ndp16 = 1;
573f8afb73dSBjørn Mork dev_err(&dev->intf->dev, "SET_NTB_FORMAT failed\n");
574f8afb73dSBjørn Mork }
5750fa81b30SAlexander Bersenev }
576f8afb73dSBjørn Mork
577f8afb73dSBjørn Mork /* set initial device values */
578ff0992e9SBjørn Mork ctx->rx_max = le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize);
579ff0992e9SBjørn Mork ctx->tx_max = le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize);
580ff0992e9SBjørn Mork ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder);
581ff0992e9SBjørn Mork ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor);
582ff0992e9SBjørn Mork ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment);
58384e77a8bSAlexey Orishko /* devices prior to NCM Errata shall set this field to zero */
584ff0992e9SBjørn Mork ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams);
58547175e5fSBjørn Mork
586ae223cd4SBjørn Mork dev_dbg(&dev->intf->dev,
587ae223cd4SBjørn Mork "dwNtbInMaxSize=%u dwNtbOutMaxSize=%u wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n",
588900d495aSAlexey Orishko ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus,
589f8afb73dSBjørn Mork ctx->tx_ndp_modulus, ctx->tx_max_datagrams, cdc_ncm_flags(dev));
590900d495aSAlexey Orishko
59184e77a8bSAlexey Orishko /* max count of tx datagrams */
59284e77a8bSAlexey Orishko if ((ctx->tx_max_datagrams == 0) ||
59384e77a8bSAlexey Orishko (ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX))
594900d495aSAlexey Orishko ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX;
595900d495aSAlexey Orishko
59670559b89SBjørn Mork /* set up maximum NDP size */
5970fa81b30SAlexander Bersenev if (ctx->is_ndp16)
59870559b89SBjørn Mork ctx->max_ndp_size = sizeof(struct usb_cdc_ncm_ndp16) + (ctx->tx_max_datagrams + 1) * sizeof(struct usb_cdc_ncm_dpe16);
5990fa81b30SAlexander Bersenev else
6000fa81b30SAlexander Bersenev ctx->max_ndp_size = sizeof(struct usb_cdc_ncm_ndp32) + (ctx->tx_max_datagrams + 1) * sizeof(struct usb_cdc_ncm_dpe32);
60170559b89SBjørn Mork
6026c4e548fSBjørn Mork /* initial coalescing timer interval */
6036c4e548fSBjørn Mork ctx->timer_interval = CDC_NCM_TIMER_INTERVAL_USEC * NSEC_PER_USEC;
6046c4e548fSBjørn Mork
605f8afb73dSBjørn Mork return 0;
606f8afb73dSBjørn Mork }
607f8afb73dSBjørn Mork
608f8afb73dSBjørn Mork /* set a new max datagram size */
cdc_ncm_set_dgram_size(struct usbnet * dev,int new_size)609f8afb73dSBjørn Mork static void cdc_ncm_set_dgram_size(struct usbnet *dev, int new_size)
610f8afb73dSBjørn Mork {
611f8afb73dSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
612f8afb73dSBjørn Mork u8 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
613f8afb73dSBjørn Mork __le16 max_datagram_size;
614f8afb73dSBjørn Mork u16 mbim_mtu;
615f8afb73dSBjørn Mork int err;
616f8afb73dSBjørn Mork
617f8afb73dSBjørn Mork /* set default based on descriptors */
618f8afb73dSBjørn Mork ctx->max_datagram_size = clamp_t(u32, new_size,
619f8afb73dSBjørn Mork cdc_ncm_min_dgram_size(dev),
620f8afb73dSBjørn Mork CDC_NCM_MAX_DATAGRAM_SIZE);
621f8afb73dSBjørn Mork
622f8afb73dSBjørn Mork /* inform the device about the selected Max Datagram Size? */
623f8afb73dSBjørn Mork if (!(cdc_ncm_flags(dev) & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE))
624f8afb73dSBjørn Mork goto out;
625f8afb73dSBjørn Mork
626f8afb73dSBjørn Mork /* read current mtu value from device */
627f8afb73dSBjørn Mork err = usbnet_read_cmd(dev, USB_CDC_GET_MAX_DATAGRAM_SIZE,
628f8afb73dSBjørn Mork USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE,
629332f989aSOliver Neukum 0, iface_no, &max_datagram_size, sizeof(max_datagram_size));
630a56dcc6bSDan Carpenter if (err != sizeof(max_datagram_size)) {
631f8afb73dSBjørn Mork dev_dbg(&dev->intf->dev, "GET_MAX_DATAGRAM_SIZE failed\n");
632f8afb73dSBjørn Mork goto out;
633f8afb73dSBjørn Mork }
634f8afb73dSBjørn Mork
635f8afb73dSBjørn Mork if (le16_to_cpu(max_datagram_size) == ctx->max_datagram_size)
636f8afb73dSBjørn Mork goto out;
637f8afb73dSBjørn Mork
638f8afb73dSBjørn Mork max_datagram_size = cpu_to_le16(ctx->max_datagram_size);
639f8afb73dSBjørn Mork err = usbnet_write_cmd(dev, USB_CDC_SET_MAX_DATAGRAM_SIZE,
640f8afb73dSBjørn Mork USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE,
641332f989aSOliver Neukum 0, iface_no, &max_datagram_size, sizeof(max_datagram_size));
642f8afb73dSBjørn Mork if (err < 0)
643f8afb73dSBjørn Mork dev_dbg(&dev->intf->dev, "SET_MAX_DATAGRAM_SIZE failed\n");
644f8afb73dSBjørn Mork
645f8afb73dSBjørn Mork out:
646f8afb73dSBjørn Mork /* set MTU to max supported by the device if necessary */
647f8afb73dSBjørn Mork dev->net->mtu = min_t(int, dev->net->mtu, ctx->max_datagram_size - cdc_ncm_eth_hlen(dev));
648f8afb73dSBjørn Mork
649f62c4f38SZheng Yongjun /* do not exceed operator preferred MTU */
650f8afb73dSBjørn Mork if (ctx->mbim_extended_desc) {
651f8afb73dSBjørn Mork mbim_mtu = le16_to_cpu(ctx->mbim_extended_desc->wMTU);
652f8afb73dSBjørn Mork if (mbim_mtu != 0 && mbim_mtu < dev->net->mtu)
653f8afb73dSBjørn Mork dev->net->mtu = mbim_mtu;
654f8afb73dSBjørn Mork }
655f8afb73dSBjørn Mork }
656f8afb73dSBjørn Mork
cdc_ncm_fix_modulus(struct usbnet * dev)657f8afb73dSBjørn Mork static void cdc_ncm_fix_modulus(struct usbnet *dev)
658f8afb73dSBjørn Mork {
659f8afb73dSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
660f8afb73dSBjørn Mork u32 val;
661900d495aSAlexey Orishko
662900d495aSAlexey Orishko /*
663900d495aSAlexey Orishko * verify that the structure alignment is:
664900d495aSAlexey Orishko * - power of two
665900d495aSAlexey Orishko * - not greater than the maximum transmit length
666900d495aSAlexey Orishko * - not less than four bytes
667900d495aSAlexey Orishko */
668900d495aSAlexey Orishko val = ctx->tx_ndp_modulus;
669900d495aSAlexey Orishko
670900d495aSAlexey Orishko if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) ||
671900d495aSAlexey Orishko (val != ((-val) & val)) || (val >= ctx->tx_max)) {
672ae223cd4SBjørn Mork dev_dbg(&dev->intf->dev, "Using default alignment: 4 bytes\n");
673900d495aSAlexey Orishko ctx->tx_ndp_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE;
674900d495aSAlexey Orishko }
675900d495aSAlexey Orishko
676900d495aSAlexey Orishko /*
677900d495aSAlexey Orishko * verify that the payload alignment is:
678900d495aSAlexey Orishko * - power of two
679900d495aSAlexey Orishko * - not greater than the maximum transmit length
680900d495aSAlexey Orishko * - not less than four bytes
681900d495aSAlexey Orishko */
682900d495aSAlexey Orishko val = ctx->tx_modulus;
683900d495aSAlexey Orishko
684900d495aSAlexey Orishko if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) ||
685900d495aSAlexey Orishko (val != ((-val) & val)) || (val >= ctx->tx_max)) {
686ae223cd4SBjørn Mork dev_dbg(&dev->intf->dev, "Using default transmit modulus: 4 bytes\n");
687900d495aSAlexey Orishko ctx->tx_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE;
688900d495aSAlexey Orishko }
689900d495aSAlexey Orishko
690900d495aSAlexey Orishko /* verify the payload remainder */
691900d495aSAlexey Orishko if (ctx->tx_remainder >= ctx->tx_modulus) {
692ae223cd4SBjørn Mork dev_dbg(&dev->intf->dev, "Using default transmit remainder: 0 bytes\n");
693900d495aSAlexey Orishko ctx->tx_remainder = 0;
694900d495aSAlexey Orishko }
695900d495aSAlexey Orishko
696900d495aSAlexey Orishko /* adjust TX-remainder according to NCM specification. */
697f8afb73dSBjørn Mork ctx->tx_remainder = ((ctx->tx_remainder - cdc_ncm_eth_hlen(dev)) &
698900d495aSAlexey Orishko (ctx->tx_modulus - 1));
69984e77a8bSAlexey Orishko }
700900d495aSAlexey Orishko
cdc_ncm_setup(struct usbnet * dev)701f8afb73dSBjørn Mork static int cdc_ncm_setup(struct usbnet *dev)
702f8afb73dSBjørn Mork {
703f8afb73dSBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
70450f1cb1cSBjørn Mork u32 def_rx, def_tx;
70550f1cb1cSBjørn Mork
706f62c4f38SZheng Yongjun /* be conservative when selecting initial buffer size to
70750f1cb1cSBjørn Mork * increase the number of hosts this will work for
70850f1cb1cSBjørn Mork */
70950f1cb1cSBjørn Mork def_rx = min_t(u32, CDC_NCM_NTB_DEF_SIZE_RX,
71050f1cb1cSBjørn Mork le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize));
71150f1cb1cSBjørn Mork def_tx = min_t(u32, CDC_NCM_NTB_DEF_SIZE_TX,
71250f1cb1cSBjørn Mork le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize));
71384e77a8bSAlexey Orishko
714f8afb73dSBjørn Mork /* clamp rx_max and tx_max and inform device */
71550f1cb1cSBjørn Mork cdc_ncm_update_rxtx_max(dev, def_rx, def_tx);
7163f658cdeSAlexey Orishko
717f8afb73dSBjørn Mork /* sanitize the modulus and remainder values */
718f8afb73dSBjørn Mork cdc_ncm_fix_modulus(dev);
719900d495aSAlexey Orishko
720f8afb73dSBjørn Mork /* set max datagram size */
721f8afb73dSBjørn Mork cdc_ncm_set_dgram_size(dev, cdc_ncm_max_dgram_size(dev));
722900d495aSAlexey Orishko return 0;
723900d495aSAlexey Orishko }
724900d495aSAlexey Orishko
725900d495aSAlexey Orishko static void
cdc_ncm_find_endpoints(struct usbnet * dev,struct usb_interface * intf)726ff1632aaSBjørn Mork cdc_ncm_find_endpoints(struct usbnet *dev, struct usb_interface *intf)
727900d495aSAlexey Orishko {
728ff1632aaSBjørn Mork struct usb_host_endpoint *e, *in = NULL, *out = NULL;
729900d495aSAlexey Orishko u8 ep;
730900d495aSAlexey Orishko
731900d495aSAlexey Orishko for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) {
732900d495aSAlexey Orishko e = intf->cur_altsetting->endpoint + ep;
7333fe4b335SBjørn Mork
7343fe4b335SBjørn Mork /* ignore endpoints which cannot transfer data */
7353fe4b335SBjørn Mork if (!usb_endpoint_maxp(&e->desc))
7363fe4b335SBjørn Mork continue;
7373fe4b335SBjørn Mork
738900d495aSAlexey Orishko switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
739900d495aSAlexey Orishko case USB_ENDPOINT_XFER_INT:
740900d495aSAlexey Orishko if (usb_endpoint_dir_in(&e->desc)) {
741ff1632aaSBjørn Mork if (!dev->status)
742ff1632aaSBjørn Mork dev->status = e;
743900d495aSAlexey Orishko }
744900d495aSAlexey Orishko break;
745900d495aSAlexey Orishko
746900d495aSAlexey Orishko case USB_ENDPOINT_XFER_BULK:
747900d495aSAlexey Orishko if (usb_endpoint_dir_in(&e->desc)) {
748ff1632aaSBjørn Mork if (!in)
749ff1632aaSBjørn Mork in = e;
750900d495aSAlexey Orishko } else {
751ff1632aaSBjørn Mork if (!out)
752ff1632aaSBjørn Mork out = e;
753900d495aSAlexey Orishko }
754900d495aSAlexey Orishko break;
755900d495aSAlexey Orishko
756900d495aSAlexey Orishko default:
757900d495aSAlexey Orishko break;
758900d495aSAlexey Orishko }
759900d495aSAlexey Orishko }
760ff1632aaSBjørn Mork if (in && !dev->in)
761ff1632aaSBjørn Mork dev->in = usb_rcvbulkpipe(dev->udev,
762ff1632aaSBjørn Mork in->desc.bEndpointAddress &
763ff1632aaSBjørn Mork USB_ENDPOINT_NUMBER_MASK);
764ff1632aaSBjørn Mork if (out && !dev->out)
765ff1632aaSBjørn Mork dev->out = usb_sndbulkpipe(dev->udev,
766ff1632aaSBjørn Mork out->desc.bEndpointAddress &
767ff1632aaSBjørn Mork USB_ENDPOINT_NUMBER_MASK);
768900d495aSAlexey Orishko }
769900d495aSAlexey Orishko
cdc_ncm_free(struct cdc_ncm_ctx * ctx)770900d495aSAlexey Orishko static void cdc_ncm_free(struct cdc_ncm_ctx *ctx)
771900d495aSAlexey Orishko {
772900d495aSAlexey Orishko if (ctx == NULL)
773900d495aSAlexey Orishko return;
774900d495aSAlexey Orishko
775900d495aSAlexey Orishko if (ctx->tx_rem_skb != NULL) {
776900d495aSAlexey Orishko dev_kfree_skb_any(ctx->tx_rem_skb);
777900d495aSAlexey Orishko ctx->tx_rem_skb = NULL;
778900d495aSAlexey Orishko }
779900d495aSAlexey Orishko
780900d495aSAlexey Orishko if (ctx->tx_curr_skb != NULL) {
781900d495aSAlexey Orishko dev_kfree_skb_any(ctx->tx_curr_skb);
782900d495aSAlexey Orishko ctx->tx_curr_skb = NULL;
783900d495aSAlexey Orishko }
784900d495aSAlexey Orishko
7850fa81b30SAlexander Bersenev if (ctx->is_ndp16)
7864a0e3e98SEnrico Mioso kfree(ctx->delayed_ndp16);
7870fa81b30SAlexander Bersenev else
7880fa81b30SAlexander Bersenev kfree(ctx->delayed_ndp32);
7894a0e3e98SEnrico Mioso
790900d495aSAlexey Orishko kfree(ctx);
791900d495aSAlexey Orishko }
792900d495aSAlexey Orishko
7931dfddff5SBjørn Mork /* we need to override the usbnet change_mtu ndo for two reasons:
7941dfddff5SBjørn Mork * - respect the negotiated maximum datagram size
7951dfddff5SBjørn Mork * - avoid unwanted changes to rx and tx buffers
7961dfddff5SBjørn Mork */
cdc_ncm_change_mtu(struct net_device * net,int new_mtu)7971dfddff5SBjørn Mork int cdc_ncm_change_mtu(struct net_device *net, int new_mtu)
7981dfddff5SBjørn Mork {
7991dfddff5SBjørn Mork struct usbnet *dev = netdev_priv(net);
80005a56487SRafal Redzimski
8011dfddff5SBjørn Mork net->mtu = new_mtu;
80205a56487SRafal Redzimski cdc_ncm_set_dgram_size(dev, new_mtu + cdc_ncm_eth_hlen(dev));
80305a56487SRafal Redzimski
8041dfddff5SBjørn Mork return 0;
8051dfddff5SBjørn Mork }
8061dfddff5SBjørn Mork EXPORT_SYMBOL_GPL(cdc_ncm_change_mtu);
8071dfddff5SBjørn Mork
8081dfddff5SBjørn Mork static const struct net_device_ops cdc_ncm_netdev_ops = {
8091dfddff5SBjørn Mork .ndo_open = usbnet_open,
8101dfddff5SBjørn Mork .ndo_stop = usbnet_stop,
8111dfddff5SBjørn Mork .ndo_start_xmit = usbnet_start_xmit,
8121dfddff5SBjørn Mork .ndo_tx_timeout = usbnet_tx_timeout,
81337a2ebddSMiguel Rodríguez Pérez .ndo_set_rx_mode = usbnet_set_rx_mode,
814323955a0SHeiner Kallweit .ndo_get_stats64 = dev_get_tstats64,
8151dfddff5SBjørn Mork .ndo_change_mtu = cdc_ncm_change_mtu,
8161dfddff5SBjørn Mork .ndo_set_mac_address = eth_mac_addr,
8171dfddff5SBjørn Mork .ndo_validate_addr = eth_validate_addr,
8181dfddff5SBjørn Mork };
8191dfddff5SBjørn Mork
cdc_ncm_bind_common(struct usbnet * dev,struct usb_interface * intf,u8 data_altsetting,int drvflags)8204a0e3e98SEnrico Mioso int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting, int drvflags)
821900d495aSAlexey Orishko {
822900d495aSAlexey Orishko struct cdc_ncm_ctx *ctx;
823900d495aSAlexey Orishko struct usb_driver *driver;
824900d495aSAlexey Orishko u8 *buf;
825900d495aSAlexey Orishko int len;
826900d495aSAlexey Orishko int temp;
827900d495aSAlexey Orishko u8 iface_no;
82877b0a099SOliver Neukum struct usb_cdc_parsed_header hdr;
829900d495aSAlexey Orishko
830c796984fSThomas Meyer ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
8318f0923c1SDevendra Naga if (!ctx)
8328f0923c1SDevendra Naga return -ENOMEM;
833900d495aSAlexey Orishko
8344f4e5436SEmil Renner Berthing ctx->dev = dev;
8354f4e5436SEmil Renner Berthing
836c84ff1d6SAlexey Orishko hrtimer_init(&ctx->tx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
837c84ff1d6SAlexey Orishko ctx->tx_timer.function = &cdc_ncm_tx_timer_cb;
8384f4e5436SEmil Renner Berthing tasklet_setup(&ctx->bh, cdc_ncm_txpath_bh);
839c84ff1d6SAlexey Orishko atomic_set(&ctx->stop, 0);
840900d495aSAlexey Orishko spin_lock_init(&ctx->mtx);
841900d495aSAlexey Orishko
842900d495aSAlexey Orishko /* store ctx pointer in device data field */
843900d495aSAlexey Orishko dev->data[0] = (unsigned long)ctx;
844900d495aSAlexey Orishko
8459fe0234cSBjørn Mork /* only the control interface can be successfully probed */
8469fe0234cSBjørn Mork ctx->control = intf;
8479fe0234cSBjørn Mork
848900d495aSAlexey Orishko /* get some pointers */
849900d495aSAlexey Orishko driver = driver_of(intf);
850900d495aSAlexey Orishko buf = intf->cur_altsetting->extra;
851900d495aSAlexey Orishko len = intf->cur_altsetting->extralen;
852900d495aSAlexey Orishko
853900d495aSAlexey Orishko /* parse through descriptors associated with control interface */
85477b0a099SOliver Neukum cdc_parse_cdc_header(&hdr, intf, buf, len);
855900d495aSAlexey Orishko
8566527f833SBjørn Mork if (hdr.usb_cdc_union_desc)
857900d495aSAlexey Orishko ctx->data = usb_ifnum_to_if(dev->udev,
85877b0a099SOliver Neukum hdr.usb_cdc_union_desc->bSlaveInterface0);
85977b0a099SOliver Neukum ctx->ether_desc = hdr.usb_cdc_ether_desc;
86077b0a099SOliver Neukum ctx->func_desc = hdr.usb_cdc_ncm_desc;
86177b0a099SOliver Neukum ctx->mbim_desc = hdr.usb_cdc_mbim_desc;
86277b0a099SOliver Neukum ctx->mbim_extended_desc = hdr.usb_cdc_mbim_extended_desc;
863900d495aSAlexey Orishko
8649992c2e2SBjørn Mork /* some buggy devices have an IAD but no CDC Union */
8656527f833SBjørn Mork if (!hdr.usb_cdc_union_desc && intf->intf_assoc && intf->intf_assoc->bInterfaceCount == 2) {
86656a666dcSBjørn Mork ctx->data = usb_ifnum_to_if(dev->udev, intf->cur_altsetting->desc.bInterfaceNumber + 1);
86756a666dcSBjørn Mork dev_dbg(&intf->dev, "CDC Union missing - got slave from IAD\n");
8689992c2e2SBjørn Mork }
8699992c2e2SBjørn Mork
870900d495aSAlexey Orishko /* check if we got everything */
871f8afb73dSBjørn Mork if (!ctx->data) {
872492bbe7fSGrant Grundler dev_err(&intf->dev, "CDC Union missing and no IAD found\n");
873900d495aSAlexey Orishko goto error;
874296e81f8SBjørn Mork }
875f8afb73dSBjørn Mork if (cdc_ncm_comm_intf_is_mbim(intf->cur_altsetting)) {
876f8afb73dSBjørn Mork if (!ctx->mbim_desc) {
877492bbe7fSGrant Grundler dev_err(&intf->dev, "MBIM functional descriptor missing\n");
878f8afb73dSBjørn Mork goto error;
879f8afb73dSBjørn Mork }
880f8afb73dSBjørn Mork } else {
881f8afb73dSBjørn Mork if (!ctx->ether_desc || !ctx->func_desc) {
882492bbe7fSGrant Grundler dev_err(&intf->dev, "NCM or ECM functional descriptors missing\n");
883f8afb73dSBjørn Mork goto error;
884f8afb73dSBjørn Mork }
885f8afb73dSBjørn Mork }
886900d495aSAlexey Orishko
887bbc8d922SBjørn Mork /* claim data interface, if different from control */
888bbc8d922SBjørn Mork if (ctx->data != ctx->control) {
889900d495aSAlexey Orishko temp = usb_driver_claim_interface(driver, ctx->data, dev);
890296e81f8SBjørn Mork if (temp) {
891492bbe7fSGrant Grundler dev_err(&intf->dev, "failed to claim data intf\n");
892900d495aSAlexey Orishko goto error;
893bbc8d922SBjørn Mork }
894296e81f8SBjørn Mork }
895900d495aSAlexey Orishko
896900d495aSAlexey Orishko iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber;
897900d495aSAlexey Orishko
8987b8076ceSDaniele Palmas /* Device-specific flags */
8997b8076ceSDaniele Palmas ctx->drvflags = drvflags;
9007b8076ceSDaniele Palmas
90148906f62SBjørn Mork /* Reset data interface. Some devices will not reset properly
90248906f62SBjørn Mork * unless they are configured first. Toggle the altsetting to
9037b8076ceSDaniele Palmas * force a reset.
9047b8076ceSDaniele Palmas * Some other devices do not work properly with this procedure
9057b8076ceSDaniele Palmas * that can be avoided using quirk CDC_MBIM_FLAG_AVOID_ALTSETTING_TOGGLE
90648906f62SBjørn Mork */
9077b8076ceSDaniele Palmas if (!(ctx->drvflags & CDC_MBIM_FLAG_AVOID_ALTSETTING_TOGGLE))
90848906f62SBjørn Mork usb_set_interface(dev->udev, iface_no, data_altsetting);
9097b8076ceSDaniele Palmas
910900d495aSAlexey Orishko temp = usb_set_interface(dev->udev, iface_no, 0);
911296e81f8SBjørn Mork if (temp) {
912296e81f8SBjørn Mork dev_dbg(&intf->dev, "set interface failed\n");
91319694ac8SAlexey Orishko goto error2;
914296e81f8SBjørn Mork }
915900d495aSAlexey Orishko
91608c74fc9SBjørn Mork /* initialize basic device settings */
91708c74fc9SBjørn Mork if (cdc_ncm_init(dev))
918ff0992e9SBjørn Mork goto error2;
919ff0992e9SBjørn Mork
920c086e709SBjørn Mork /* Some firmwares need a pause here or they will silently fail
921c086e709SBjørn Mork * to set up the interface properly. This value was decided
922c086e709SBjørn Mork * empirically on a Sierra Wireless MC7455 running 02.08.02.00
923c086e709SBjørn Mork * firmware.
924c086e709SBjørn Mork */
925c086e709SBjørn Mork usleep_range(10000, 20000);
926c086e709SBjørn Mork
927900d495aSAlexey Orishko /* configure data interface */
92838396e4cSGreg Suarez temp = usb_set_interface(dev->udev, iface_no, data_altsetting);
929296e81f8SBjørn Mork if (temp) {
930296e81f8SBjørn Mork dev_dbg(&intf->dev, "set interface failed\n");
93119694ac8SAlexey Orishko goto error2;
932296e81f8SBjørn Mork }
933900d495aSAlexey Orishko
934ff1632aaSBjørn Mork cdc_ncm_find_endpoints(dev, ctx->data);
935ff1632aaSBjørn Mork cdc_ncm_find_endpoints(dev, ctx->control);
936296e81f8SBjørn Mork if (!dev->in || !dev->out || !dev->status) {
937296e81f8SBjørn Mork dev_dbg(&intf->dev, "failed to collect endpoints\n");
93819694ac8SAlexey Orishko goto error2;
939296e81f8SBjørn Mork }
940900d495aSAlexey Orishko
941900d495aSAlexey Orishko usb_set_intfdata(ctx->control, dev);
942900d495aSAlexey Orishko
94338396e4cSGreg Suarez if (ctx->ether_desc) {
944900d495aSAlexey Orishko temp = usbnet_get_ethernet_addr(dev, ctx->ether_desc->iMACAddress);
945296e81f8SBjørn Mork if (temp) {
946492bbe7fSGrant Grundler dev_err(&intf->dev, "failed to get mac address\n");
94719694ac8SAlexey Orishko goto error2;
948296e81f8SBjørn Mork }
949296e81f8SBjørn Mork dev_info(&intf->dev, "MAC-Address: %pM\n", dev->net->dev_addr);
95038396e4cSGreg Suarez }
95138396e4cSGreg Suarez
95208c74fc9SBjørn Mork /* finish setting up the device specific data */
95308c74fc9SBjørn Mork cdc_ncm_setup(dev);
954ff0992e9SBjørn Mork
9554a0e3e98SEnrico Mioso /* Allocate the delayed NDP if needed. */
9564a0e3e98SEnrico Mioso if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) {
9570fa81b30SAlexander Bersenev if (ctx->is_ndp16) {
9584a0e3e98SEnrico Mioso ctx->delayed_ndp16 = kzalloc(ctx->max_ndp_size, GFP_KERNEL);
9594a0e3e98SEnrico Mioso if (!ctx->delayed_ndp16)
9604a0e3e98SEnrico Mioso goto error2;
9610fa81b30SAlexander Bersenev } else {
9620fa81b30SAlexander Bersenev ctx->delayed_ndp32 = kzalloc(ctx->max_ndp_size, GFP_KERNEL);
9630fa81b30SAlexander Bersenev if (!ctx->delayed_ndp32)
9640fa81b30SAlexander Bersenev goto error2;
9650fa81b30SAlexander Bersenev }
9664a0e3e98SEnrico Mioso dev_info(&intf->dev, "NDP will be placed at end of frame for this device.");
9674a0e3e98SEnrico Mioso }
9684a0e3e98SEnrico Mioso
9696c4e548fSBjørn Mork /* override ethtool_ops */
9706c4e548fSBjørn Mork dev->net->ethtool_ops = &cdc_ncm_ethtool_ops;
9716c4e548fSBjørn Mork
972289507d3SBjørn Mork /* add our sysfs attrs */
973289507d3SBjørn Mork dev->net->sysfs_groups[0] = &cdc_ncm_sysfs_attr_group;
974289507d3SBjørn Mork
9751dfddff5SBjørn Mork /* must handle MTU changes */
9761dfddff5SBjørn Mork dev->net->netdev_ops = &cdc_ncm_netdev_ops;
977f77f0aeeSJarod Wilson dev->net->max_mtu = cdc_ncm_max_dgram_size(dev) - cdc_ncm_eth_hlen(dev);
9781dfddff5SBjørn Mork
979900d495aSAlexey Orishko return 0;
980900d495aSAlexey Orishko
98119694ac8SAlexey Orishko error2:
98219694ac8SAlexey Orishko usb_set_intfdata(ctx->control, NULL);
98319694ac8SAlexey Orishko usb_set_intfdata(ctx->data, NULL);
9846b4ef602SBjørn Mork if (ctx->data != ctx->control)
98519694ac8SAlexey Orishko usb_driver_release_interface(driver, ctx->data);
986900d495aSAlexey Orishko error:
987900d495aSAlexey Orishko cdc_ncm_free((struct cdc_ncm_ctx *)dev->data[0]);
988900d495aSAlexey Orishko dev->data[0] = 0;
989296e81f8SBjørn Mork dev_info(&intf->dev, "bind() failure\n");
990900d495aSAlexey Orishko return -ENODEV;
991900d495aSAlexey Orishko }
992c91ce3b6SBjørn Mork EXPORT_SYMBOL_GPL(cdc_ncm_bind_common);
993900d495aSAlexey Orishko
cdc_ncm_unbind(struct usbnet * dev,struct usb_interface * intf)994c91ce3b6SBjørn Mork void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf)
995900d495aSAlexey Orishko {
996900d495aSAlexey Orishko struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
99719694ac8SAlexey Orishko struct usb_driver *driver = driver_of(intf);
998900d495aSAlexey Orishko
999900d495aSAlexey Orishko if (ctx == NULL)
1000900d495aSAlexey Orishko return; /* no setup */
1001900d495aSAlexey Orishko
1002c84ff1d6SAlexey Orishko atomic_set(&ctx->stop, 1);
1003c84ff1d6SAlexey Orishko
1004c84ff1d6SAlexey Orishko hrtimer_cancel(&ctx->tx_timer);
1005c84ff1d6SAlexey Orishko
1006c84ff1d6SAlexey Orishko tasklet_kill(&ctx->bh);
1007c84ff1d6SAlexey Orishko
1008bbc8d922SBjørn Mork /* handle devices with combined control and data interface */
1009bbc8d922SBjørn Mork if (ctx->control == ctx->data)
1010bbc8d922SBjørn Mork ctx->data = NULL;
1011bbc8d922SBjørn Mork
101219694ac8SAlexey Orishko /* disconnect master --> disconnect slave */
101319694ac8SAlexey Orishko if (intf == ctx->control && ctx->data) {
1014900d495aSAlexey Orishko usb_set_intfdata(ctx->data, NULL);
1015900d495aSAlexey Orishko usb_driver_release_interface(driver, ctx->data);
101619694ac8SAlexey Orishko ctx->data = NULL;
1017900d495aSAlexey Orishko
101819694ac8SAlexey Orishko } else if (intf == ctx->data && ctx->control) {
101919694ac8SAlexey Orishko usb_set_intfdata(ctx->control, NULL);
1020900d495aSAlexey Orishko usb_driver_release_interface(driver, ctx->control);
102119694ac8SAlexey Orishko ctx->control = NULL;
1022900d495aSAlexey Orishko }
1023900d495aSAlexey Orishko
10243e515665SBjørn Mork usb_set_intfdata(intf, NULL);
1025900d495aSAlexey Orishko cdc_ncm_free(ctx);
1026900d495aSAlexey Orishko }
1027c91ce3b6SBjørn Mork EXPORT_SYMBOL_GPL(cdc_ncm_unbind);
1028900d495aSAlexey Orishko
102950a0ffafSBjørn Mork /* Return the number of the MBIM control interface altsetting iff it
103050a0ffafSBjørn Mork * is preferred and available,
10311e8bbe6cSBjørn Mork */
cdc_ncm_select_altsetting(struct usb_interface * intf)103250a0ffafSBjørn Mork u8 cdc_ncm_select_altsetting(struct usb_interface *intf)
103338396e4cSGreg Suarez {
10341e8bbe6cSBjørn Mork struct usb_host_interface *alt;
103538396e4cSGreg Suarez
1036bd329e12SBjørn Mork /* The MBIM spec defines a NCM compatible default altsetting,
1037bd329e12SBjørn Mork * which we may have matched:
1038bd329e12SBjørn Mork *
1039bd329e12SBjørn Mork * "Functions that implement both NCM 1.0 and MBIM (an
1040bd329e12SBjørn Mork * “NCM/MBIM function”) according to this recommendation
1041bd329e12SBjørn Mork * shall provide two alternate settings for the
1042bd329e12SBjørn Mork * Communication Interface. Alternate setting 0, and the
1043bd329e12SBjørn Mork * associated class and endpoint descriptors, shall be
1044bd329e12SBjørn Mork * constructed according to the rules given for the
1045bd329e12SBjørn Mork * Communication Interface in section 5 of [USBNCM10].
1046bd329e12SBjørn Mork * Alternate setting 1, and the associated class and
1047bd329e12SBjørn Mork * endpoint descriptors, shall be constructed according to
1048bd329e12SBjørn Mork * the rules given in section 6 (USB Device Model) of this
1049bd329e12SBjørn Mork * specification."
1050bd329e12SBjørn Mork */
105150a0ffafSBjørn Mork if (intf->num_altsetting < 2)
105250a0ffafSBjørn Mork return intf->cur_altsetting->desc.bAlternateSetting;
105350a0ffafSBjørn Mork
105450a0ffafSBjørn Mork if (prefer_mbim) {
10551e8bbe6cSBjørn Mork alt = usb_altnum_to_altsetting(intf, CDC_NCM_COMM_ALTSETTING_MBIM);
105650a0ffafSBjørn Mork if (alt && cdc_ncm_comm_intf_is_mbim(alt))
105750a0ffafSBjørn Mork return CDC_NCM_COMM_ALTSETTING_MBIM;
10581e8bbe6cSBjørn Mork }
105950a0ffafSBjørn Mork return CDC_NCM_COMM_ALTSETTING_NCM;
10601e8bbe6cSBjørn Mork }
10611e8bbe6cSBjørn Mork EXPORT_SYMBOL_GPL(cdc_ncm_select_altsetting);
10621e8bbe6cSBjørn Mork
cdc_ncm_bind(struct usbnet * dev,struct usb_interface * intf)10631e8bbe6cSBjørn Mork static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf)
10641e8bbe6cSBjørn Mork {
10651e8bbe6cSBjørn Mork /* MBIM backwards compatible function? */
106650a0ffafSBjørn Mork if (cdc_ncm_select_altsetting(intf) != CDC_NCM_COMM_ALTSETTING_NCM)
1067bd329e12SBjørn Mork return -ENODEV;
1068bd329e12SBjørn Mork
10694a0e3e98SEnrico Mioso /* The NCM data altsetting is fixed, so we hard-coded it.
10704a0e3e98SEnrico Mioso * Additionally, generic NCM devices are assumed to accept arbitrarily
10714a0e3e98SEnrico Mioso * placed NDP.
10724a0e3e98SEnrico Mioso */
10734d06dd53SBjørn Mork return cdc_ncm_bind_common(dev, intf, CDC_NCM_DATA_ALTSETTING_NCM, 0);
107438396e4cSGreg Suarez }
107538396e4cSGreg Suarez
cdc_ncm_align_tail(struct sk_buff * skb,size_t modulus,size_t remainder,size_t max)1076c78b7c58SBjørn Mork static void cdc_ncm_align_tail(struct sk_buff *skb, size_t modulus, size_t remainder, size_t max)
1077900d495aSAlexey Orishko {
1078c78b7c58SBjørn Mork size_t align = ALIGN(skb->len, modulus) - skb->len + remainder;
1079c78b7c58SBjørn Mork
1080c78b7c58SBjørn Mork if (skb->len + align > max)
1081c78b7c58SBjørn Mork align = max - skb->len;
1082c78b7c58SBjørn Mork if (align && skb_tailroom(skb) >= align)
1083b080db58SJohannes Berg skb_put_zero(skb, align);
1084c78b7c58SBjørn Mork }
1085c78b7c58SBjørn Mork
1086c78b7c58SBjørn Mork /* return a pointer to a valid struct usb_cdc_ncm_ndp16 of type sign, possibly
1087c78b7c58SBjørn Mork * allocating a new one within skb
1088c78b7c58SBjørn Mork */
cdc_ncm_ndp16(struct cdc_ncm_ctx * ctx,struct sk_buff * skb,__le32 sign,size_t reserve)10890fa81b30SAlexander Bersenev static struct usb_cdc_ncm_ndp16 *cdc_ncm_ndp16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign, size_t reserve)
1090c78b7c58SBjørn Mork {
1091c78b7c58SBjørn Mork struct usb_cdc_ncm_ndp16 *ndp16 = NULL;
1092c78b7c58SBjørn Mork struct usb_cdc_ncm_nth16 *nth16 = (void *)skb->data;
1093c78b7c58SBjørn Mork size_t ndpoffset = le16_to_cpu(nth16->wNdpIndex);
1094c78b7c58SBjørn Mork
10954a0e3e98SEnrico Mioso /* If NDP should be moved to the end of the NCM package, we can't follow the
10964a0e3e98SEnrico Mioso * NTH16 header as we would normally do. NDP isn't written to the SKB yet, and
10974a0e3e98SEnrico Mioso * the wNdpIndex field in the header is actually not consistent with reality. It will be later.
10984a0e3e98SEnrico Mioso */
1099f8c0cfa5SBjørn Mork if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) {
11004a0e3e98SEnrico Mioso if (ctx->delayed_ndp16->dwSignature == sign)
11014a0e3e98SEnrico Mioso return ctx->delayed_ndp16;
11024a0e3e98SEnrico Mioso
1103f8c0cfa5SBjørn Mork /* We can only push a single NDP to the end. Return
1104f8c0cfa5SBjørn Mork * NULL to send what we've already got and queue this
1105f8c0cfa5SBjørn Mork * skb for later.
1106f8c0cfa5SBjørn Mork */
1107f8c0cfa5SBjørn Mork else if (ctx->delayed_ndp16->dwSignature)
1108f8c0cfa5SBjørn Mork return NULL;
1109f8c0cfa5SBjørn Mork }
1110f8c0cfa5SBjørn Mork
1111c78b7c58SBjørn Mork /* follow the chain of NDPs, looking for a match */
1112c78b7c58SBjørn Mork while (ndpoffset) {
1113c78b7c58SBjørn Mork ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb->data + ndpoffset);
1114c78b7c58SBjørn Mork if (ndp16->dwSignature == sign)
1115c78b7c58SBjørn Mork return ndp16;
1116c78b7c58SBjørn Mork ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex);
1117c78b7c58SBjørn Mork }
1118c78b7c58SBjørn Mork
1119c78b7c58SBjørn Mork /* align new NDP */
11204a0e3e98SEnrico Mioso if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END))
1121e1069bbfSJim Baxter cdc_ncm_align_tail(skb, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size);
1122c78b7c58SBjørn Mork
1123c78b7c58SBjørn Mork /* verify that there is room for the NDP and the datagram (reserve) */
1124e1069bbfSJim Baxter if ((ctx->tx_curr_size - skb->len - reserve) < ctx->max_ndp_size)
1125c78b7c58SBjørn Mork return NULL;
1126c78b7c58SBjørn Mork
1127c78b7c58SBjørn Mork /* link to it */
1128c78b7c58SBjørn Mork if (ndp16)
1129c78b7c58SBjørn Mork ndp16->wNextNdpIndex = cpu_to_le16(skb->len);
1130c78b7c58SBjørn Mork else
1131c78b7c58SBjørn Mork nth16->wNdpIndex = cpu_to_le16(skb->len);
1132c78b7c58SBjørn Mork
1133c78b7c58SBjørn Mork /* push a new empty NDP */
11344a0e3e98SEnrico Mioso if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END))
1135ad941e69Syuan linyu ndp16 = skb_put_zero(skb, ctx->max_ndp_size);
11364a0e3e98SEnrico Mioso else
11374a0e3e98SEnrico Mioso ndp16 = ctx->delayed_ndp16;
11384a0e3e98SEnrico Mioso
1139c78b7c58SBjørn Mork ndp16->dwSignature = sign;
1140c78b7c58SBjørn Mork ndp16->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp16) + sizeof(struct usb_cdc_ncm_dpe16));
1141c78b7c58SBjørn Mork return ndp16;
1142900d495aSAlexey Orishko }
1143900d495aSAlexey Orishko
cdc_ncm_ndp32(struct cdc_ncm_ctx * ctx,struct sk_buff * skb,__le32 sign,size_t reserve)11440fa81b30SAlexander Bersenev static struct usb_cdc_ncm_ndp32 *cdc_ncm_ndp32(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign, size_t reserve)
11450fa81b30SAlexander Bersenev {
11460fa81b30SAlexander Bersenev struct usb_cdc_ncm_ndp32 *ndp32 = NULL;
11470fa81b30SAlexander Bersenev struct usb_cdc_ncm_nth32 *nth32 = (void *)skb->data;
11480fa81b30SAlexander Bersenev size_t ndpoffset = le32_to_cpu(nth32->dwNdpIndex);
11490fa81b30SAlexander Bersenev
11500fa81b30SAlexander Bersenev /* If NDP should be moved to the end of the NCM package, we can't follow the
11510fa81b30SAlexander Bersenev * NTH32 header as we would normally do. NDP isn't written to the SKB yet, and
11520fa81b30SAlexander Bersenev * the wNdpIndex field in the header is actually not consistent with reality. It will be later.
11530fa81b30SAlexander Bersenev */
11540fa81b30SAlexander Bersenev if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) {
11550fa81b30SAlexander Bersenev if (ctx->delayed_ndp32->dwSignature == sign)
11560fa81b30SAlexander Bersenev return ctx->delayed_ndp32;
11570fa81b30SAlexander Bersenev
11580fa81b30SAlexander Bersenev /* We can only push a single NDP to the end. Return
11590fa81b30SAlexander Bersenev * NULL to send what we've already got and queue this
11600fa81b30SAlexander Bersenev * skb for later.
11610fa81b30SAlexander Bersenev */
11620fa81b30SAlexander Bersenev else if (ctx->delayed_ndp32->dwSignature)
11630fa81b30SAlexander Bersenev return NULL;
11640fa81b30SAlexander Bersenev }
11650fa81b30SAlexander Bersenev
11660fa81b30SAlexander Bersenev /* follow the chain of NDPs, looking for a match */
11670fa81b30SAlexander Bersenev while (ndpoffset) {
11680fa81b30SAlexander Bersenev ndp32 = (struct usb_cdc_ncm_ndp32 *)(skb->data + ndpoffset);
11690fa81b30SAlexander Bersenev if (ndp32->dwSignature == sign)
11700fa81b30SAlexander Bersenev return ndp32;
11710fa81b30SAlexander Bersenev ndpoffset = le32_to_cpu(ndp32->dwNextNdpIndex);
11720fa81b30SAlexander Bersenev }
11730fa81b30SAlexander Bersenev
11740fa81b30SAlexander Bersenev /* align new NDP */
11750fa81b30SAlexander Bersenev if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END))
11760fa81b30SAlexander Bersenev cdc_ncm_align_tail(skb, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size);
11770fa81b30SAlexander Bersenev
11780fa81b30SAlexander Bersenev /* verify that there is room for the NDP and the datagram (reserve) */
11790fa81b30SAlexander Bersenev if ((ctx->tx_curr_size - skb->len - reserve) < ctx->max_ndp_size)
11800fa81b30SAlexander Bersenev return NULL;
11810fa81b30SAlexander Bersenev
11820fa81b30SAlexander Bersenev /* link to it */
11830fa81b30SAlexander Bersenev if (ndp32)
11840fa81b30SAlexander Bersenev ndp32->dwNextNdpIndex = cpu_to_le32(skb->len);
11850fa81b30SAlexander Bersenev else
11860fa81b30SAlexander Bersenev nth32->dwNdpIndex = cpu_to_le32(skb->len);
11870fa81b30SAlexander Bersenev
11880fa81b30SAlexander Bersenev /* push a new empty NDP */
11890fa81b30SAlexander Bersenev if (!(ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END))
11900fa81b30SAlexander Bersenev ndp32 = skb_put_zero(skb, ctx->max_ndp_size);
11910fa81b30SAlexander Bersenev else
11920fa81b30SAlexander Bersenev ndp32 = ctx->delayed_ndp32;
11930fa81b30SAlexander Bersenev
11940fa81b30SAlexander Bersenev ndp32->dwSignature = sign;
11955d0ab06bSAlexander Bersenev ndp32->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp32) + sizeof(struct usb_cdc_ncm_dpe32));
11960fa81b30SAlexander Bersenev return ndp32;
11970fa81b30SAlexander Bersenev }
11980fa81b30SAlexander Bersenev
1199c91ce3b6SBjørn Mork struct sk_buff *
cdc_ncm_fill_tx_frame(struct usbnet * dev,struct sk_buff * skb,__le32 sign)1200bed6f762SBjørn Mork cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign)
1201900d495aSAlexey Orishko {
1202bed6f762SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
12030fa81b30SAlexander Bersenev union {
1204c78b7c58SBjørn Mork struct usb_cdc_ncm_nth16 *nth16;
12050fa81b30SAlexander Bersenev struct usb_cdc_ncm_nth32 *nth32;
12060fa81b30SAlexander Bersenev } nth;
12070fa81b30SAlexander Bersenev union {
1208c78b7c58SBjørn Mork struct usb_cdc_ncm_ndp16 *ndp16;
12090fa81b30SAlexander Bersenev struct usb_cdc_ncm_ndp32 *ndp32;
12100fa81b30SAlexander Bersenev } ndp;
1211900d495aSAlexey Orishko struct sk_buff *skb_out;
1212c78b7c58SBjørn Mork u16 n = 0, index, ndplen;
121384e77a8bSAlexey Orishko u8 ready2send = 0;
12144a0e3e98SEnrico Mioso u32 delayed_ndp_size;
1215aeca3a77SJim Baxter size_t padding_count;
12164a0e3e98SEnrico Mioso
12174a0e3e98SEnrico Mioso /* When our NDP gets written in cdc_ncm_ndp(), then skb_out->len gets updated
12184a0e3e98SEnrico Mioso * accordingly. Otherwise, we should check here.
12194a0e3e98SEnrico Mioso */
12204a0e3e98SEnrico Mioso if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END)
12217a68d725SJouni K. Seppänen delayed_ndp_size = ctx->max_ndp_size +
12227a68d725SJouni K. Seppänen max_t(u32,
12237a68d725SJouni K. Seppänen ctx->tx_ndp_modulus,
12247a68d725SJouni K. Seppänen ctx->tx_modulus + ctx->tx_remainder) - 1;
12254a0e3e98SEnrico Mioso else
12264a0e3e98SEnrico Mioso delayed_ndp_size = 0;
1227900d495aSAlexey Orishko
1228900d495aSAlexey Orishko /* if there is a remaining skb, it gets priority */
1229c78b7c58SBjørn Mork if (skb != NULL) {
1230900d495aSAlexey Orishko swap(skb, ctx->tx_rem_skb);
1231c78b7c58SBjørn Mork swap(sign, ctx->tx_rem_sign);
1232c78b7c58SBjørn Mork } else {
123384e77a8bSAlexey Orishko ready2send = 1;
1234c78b7c58SBjørn Mork }
1235900d495aSAlexey Orishko
1236900d495aSAlexey Orishko /* check if we are resuming an OUT skb */
1237900d495aSAlexey Orishko skb_out = ctx->tx_curr_skb;
1238900d495aSAlexey Orishko
1239c78b7c58SBjørn Mork /* allocate a new OUT skb */
1240c78b7c58SBjørn Mork if (!skb_out) {
1241e1069bbfSJim Baxter if (ctx->tx_low_mem_val == 0) {
1242e1069bbfSJim Baxter ctx->tx_curr_size = ctx->tx_max;
1243e1069bbfSJim Baxter skb_out = alloc_skb(ctx->tx_curr_size, GFP_ATOMIC);
1244e1069bbfSJim Baxter /* If the memory allocation fails we will wait longer
1245e1069bbfSJim Baxter * each time before attempting another full size
1246e1069bbfSJim Baxter * allocation again to not overload the system
1247e1069bbfSJim Baxter * further.
1248e1069bbfSJim Baxter */
1249e1069bbfSJim Baxter if (skb_out == NULL) {
1250*7e01c7f7STudor Ambarus /* If even the smallest allocation fails, abort. */
1251*7e01c7f7STudor Ambarus if (ctx->tx_curr_size == USB_CDC_NCM_NTB_MIN_OUT_SIZE)
1252*7e01c7f7STudor Ambarus goto alloc_failed;
1253e1069bbfSJim Baxter ctx->tx_low_mem_max_cnt = min(ctx->tx_low_mem_max_cnt + 1,
1254e1069bbfSJim Baxter (unsigned)CDC_NCM_LOW_MEM_MAX_CNT);
1255e1069bbfSJim Baxter ctx->tx_low_mem_val = ctx->tx_low_mem_max_cnt;
1256e1069bbfSJim Baxter }
1257e1069bbfSJim Baxter }
1258e1069bbfSJim Baxter if (skb_out == NULL) {
1259e1069bbfSJim Baxter /* See if a very small allocation is possible.
1260e1069bbfSJim Baxter * We will send this packet immediately and hope
1261e1069bbfSJim Baxter * that there is more memory available later.
1262e1069bbfSJim Baxter */
1263e1069bbfSJim Baxter if (skb)
1264e1069bbfSJim Baxter ctx->tx_curr_size = max(skb->len,
1265e1069bbfSJim Baxter (u32)USB_CDC_NCM_NTB_MIN_OUT_SIZE);
1266e1069bbfSJim Baxter else
1267e1069bbfSJim Baxter ctx->tx_curr_size = USB_CDC_NCM_NTB_MIN_OUT_SIZE;
1268e1069bbfSJim Baxter skb_out = alloc_skb(ctx->tx_curr_size, GFP_ATOMIC);
1269e1069bbfSJim Baxter
1270e1069bbfSJim Baxter /* No allocation possible so we will abort */
1271*7e01c7f7STudor Ambarus if (!skb_out)
1272*7e01c7f7STudor Ambarus goto alloc_failed;
1273e1069bbfSJim Baxter ctx->tx_low_mem_val--;
1274e1069bbfSJim Baxter }
12750fa81b30SAlexander Bersenev if (ctx->is_ndp16) {
1276c78b7c58SBjørn Mork /* fill out the initial 16-bit NTB header */
12770fa81b30SAlexander Bersenev nth.nth16 = skb_put_zero(skb_out, sizeof(struct usb_cdc_ncm_nth16));
12780fa81b30SAlexander Bersenev nth.nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN);
12790fa81b30SAlexander Bersenev nth.nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16));
12800fa81b30SAlexander Bersenev nth.nth16->wSequence = cpu_to_le16(ctx->tx_seq++);
12810fa81b30SAlexander Bersenev } else {
12820fa81b30SAlexander Bersenev /* fill out the initial 32-bit NTB header */
12830fa81b30SAlexander Bersenev nth.nth32 = skb_put_zero(skb_out, sizeof(struct usb_cdc_ncm_nth32));
12840fa81b30SAlexander Bersenev nth.nth32->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH32_SIGN);
12850fa81b30SAlexander Bersenev nth.nth32->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth32));
12860fa81b30SAlexander Bersenev nth.nth32->wSequence = cpu_to_le16(ctx->tx_seq++);
12870fa81b30SAlexander Bersenev }
1288900d495aSAlexey Orishko
1289c78b7c58SBjørn Mork /* count total number of frames in this NTB */
1290900d495aSAlexey Orishko ctx->tx_curr_frame_num = 0;
1291beeecd42SBjørn Mork
1292beeecd42SBjørn Mork /* recent payload counter for this skb_out */
1293beeecd42SBjørn Mork ctx->tx_curr_frame_payload = 0;
1294900d495aSAlexey Orishko }
1295900d495aSAlexey Orishko
1296c78b7c58SBjørn Mork for (n = ctx->tx_curr_frame_num; n < ctx->tx_max_datagrams; n++) {
1297c78b7c58SBjørn Mork /* send any remaining skb first */
1298900d495aSAlexey Orishko if (skb == NULL) {
1299900d495aSAlexey Orishko skb = ctx->tx_rem_skb;
1300c78b7c58SBjørn Mork sign = ctx->tx_rem_sign;
1301900d495aSAlexey Orishko ctx->tx_rem_skb = NULL;
1302900d495aSAlexey Orishko
1303900d495aSAlexey Orishko /* check for end of skb */
1304900d495aSAlexey Orishko if (skb == NULL)
1305900d495aSAlexey Orishko break;
1306900d495aSAlexey Orishko }
1307900d495aSAlexey Orishko
1308c78b7c58SBjørn Mork /* get the appropriate NDP for this skb */
13090fa81b30SAlexander Bersenev if (ctx->is_ndp16)
13100fa81b30SAlexander Bersenev ndp.ndp16 = cdc_ncm_ndp16(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder);
13110fa81b30SAlexander Bersenev else
13120fa81b30SAlexander Bersenev ndp.ndp32 = cdc_ncm_ndp32(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder);
1313c78b7c58SBjørn Mork
1314c78b7c58SBjørn Mork /* align beginning of next frame */
1315e1069bbfSJim Baxter cdc_ncm_align_tail(skb_out, ctx->tx_modulus, ctx->tx_remainder, ctx->tx_curr_size);
1316c78b7c58SBjørn Mork
1317c78b7c58SBjørn Mork /* check if we had enough room left for both NDP and frame */
13180fa81b30SAlexander Bersenev if ((ctx->is_ndp16 && !ndp.ndp16) || (!ctx->is_ndp16 && !ndp.ndp32) ||
13190fa81b30SAlexander Bersenev skb_out->len + skb->len + delayed_ndp_size > ctx->tx_curr_size) {
1320900d495aSAlexey Orishko if (n == 0) {
1321900d495aSAlexey Orishko /* won't fit, MTU problem? */
1322900d495aSAlexey Orishko dev_kfree_skb_any(skb);
1323900d495aSAlexey Orishko skb = NULL;
1324bed6f762SBjørn Mork dev->net->stats.tx_dropped++;
1325900d495aSAlexey Orishko } else {
1326900d495aSAlexey Orishko /* no room for skb - store for later */
1327900d495aSAlexey Orishko if (ctx->tx_rem_skb != NULL) {
1328900d495aSAlexey Orishko dev_kfree_skb_any(ctx->tx_rem_skb);
1329bed6f762SBjørn Mork dev->net->stats.tx_dropped++;
1330900d495aSAlexey Orishko }
1331900d495aSAlexey Orishko ctx->tx_rem_skb = skb;
1332c78b7c58SBjørn Mork ctx->tx_rem_sign = sign;
1333900d495aSAlexey Orishko skb = NULL;
133484e77a8bSAlexey Orishko ready2send = 1;
1335beeecd42SBjørn Mork ctx->tx_reason_ntb_full++; /* count reason for transmitting */
1336900d495aSAlexey Orishko }
1337900d495aSAlexey Orishko break;
1338900d495aSAlexey Orishko }
1339900d495aSAlexey Orishko
1340ef9ac209SWang Qing /* calculate frame number within this NDP */
13410fa81b30SAlexander Bersenev if (ctx->is_ndp16) {
13420fa81b30SAlexander Bersenev ndplen = le16_to_cpu(ndp.ndp16->wLength);
1343c78b7c58SBjørn Mork index = (ndplen - sizeof(struct usb_cdc_ncm_ndp16)) / sizeof(struct usb_cdc_ncm_dpe16) - 1;
1344900d495aSAlexey Orishko
1345c78b7c58SBjørn Mork /* OK, add this skb */
13460fa81b30SAlexander Bersenev ndp.ndp16->dpe16[index].wDatagramLength = cpu_to_le16(skb->len);
13470fa81b30SAlexander Bersenev ndp.ndp16->dpe16[index].wDatagramIndex = cpu_to_le16(skb_out->len);
13480fa81b30SAlexander Bersenev ndp.ndp16->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe16));
13490fa81b30SAlexander Bersenev } else {
13500fa81b30SAlexander Bersenev ndplen = le16_to_cpu(ndp.ndp32->wLength);
13510fa81b30SAlexander Bersenev index = (ndplen - sizeof(struct usb_cdc_ncm_ndp32)) / sizeof(struct usb_cdc_ncm_dpe32) - 1;
13520fa81b30SAlexander Bersenev
13530fa81b30SAlexander Bersenev ndp.ndp32->dpe32[index].dwDatagramLength = cpu_to_le32(skb->len);
13540fa81b30SAlexander Bersenev ndp.ndp32->dpe32[index].dwDatagramIndex = cpu_to_le32(skb_out->len);
13550fa81b30SAlexander Bersenev ndp.ndp32->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe32));
13560fa81b30SAlexander Bersenev }
135759ae1d12SJohannes Berg skb_put_data(skb_out, skb->data, skb->len);
1358beeecd42SBjørn Mork ctx->tx_curr_frame_payload += skb->len; /* count real tx payload data */
1359900d495aSAlexey Orishko dev_kfree_skb_any(skb);
1360900d495aSAlexey Orishko skb = NULL;
1361c78b7c58SBjørn Mork
1362c78b7c58SBjørn Mork /* send now if this NDP is full */
1363c78b7c58SBjørn Mork if (index >= CDC_NCM_DPT_DATAGRAMS_MAX) {
1364c78b7c58SBjørn Mork ready2send = 1;
1365beeecd42SBjørn Mork ctx->tx_reason_ndp_full++; /* count reason for transmitting */
1366c78b7c58SBjørn Mork break;
1367c78b7c58SBjørn Mork }
1368900d495aSAlexey Orishko }
1369900d495aSAlexey Orishko
1370900d495aSAlexey Orishko /* free up any dangling skb */
1371900d495aSAlexey Orishko if (skb != NULL) {
1372900d495aSAlexey Orishko dev_kfree_skb_any(skb);
1373900d495aSAlexey Orishko skb = NULL;
1374bed6f762SBjørn Mork dev->net->stats.tx_dropped++;
1375900d495aSAlexey Orishko }
1376900d495aSAlexey Orishko
1377900d495aSAlexey Orishko ctx->tx_curr_frame_num = n;
1378900d495aSAlexey Orishko
1379900d495aSAlexey Orishko if (n == 0) {
1380900d495aSAlexey Orishko /* wait for more frames */
1381900d495aSAlexey Orishko /* push variables */
1382900d495aSAlexey Orishko ctx->tx_curr_skb = skb_out;
1383900d495aSAlexey Orishko goto exit_no_skb;
1384900d495aSAlexey Orishko
13856c4e548fSBjørn Mork } else if ((n < ctx->tx_max_datagrams) && (ready2send == 0) && (ctx->timer_interval > 0)) {
1386900d495aSAlexey Orishko /* wait for more frames */
1387900d495aSAlexey Orishko /* push variables */
1388900d495aSAlexey Orishko ctx->tx_curr_skb = skb_out;
1389900d495aSAlexey Orishko /* set the pending count */
1390900d495aSAlexey Orishko if (n < CDC_NCM_RESTART_TIMER_DATAGRAM_CNT)
1391c84ff1d6SAlexey Orishko ctx->tx_timer_pending = CDC_NCM_TIMER_PENDING_CNT;
1392900d495aSAlexey Orishko goto exit_no_skb;
1393900d495aSAlexey Orishko
1394900d495aSAlexey Orishko } else {
1395beeecd42SBjørn Mork if (n == ctx->tx_max_datagrams)
1396beeecd42SBjørn Mork ctx->tx_reason_max_datagram++; /* count reason for transmitting */
1397900d495aSAlexey Orishko /* frame goes out */
1398900d495aSAlexey Orishko /* variables will be reset at next call */
1399900d495aSAlexey Orishko }
1400900d495aSAlexey Orishko
14014a0e3e98SEnrico Mioso /* If requested, put NDP at end of frame. */
14024a0e3e98SEnrico Mioso if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) {
14030fa81b30SAlexander Bersenev if (ctx->is_ndp16) {
14040fa81b30SAlexander Bersenev nth.nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data;
140549c2c3f2SBjørn Mork cdc_ncm_align_tail(skb_out, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size - ctx->max_ndp_size);
14060fa81b30SAlexander Bersenev nth.nth16->wNdpIndex = cpu_to_le16(skb_out->len);
140759ae1d12SJohannes Berg skb_put_data(skb_out, ctx->delayed_ndp16, ctx->max_ndp_size);
14084a0e3e98SEnrico Mioso
14094a0e3e98SEnrico Mioso /* Zero out delayed NDP - signature checking will naturally fail. */
14100fa81b30SAlexander Bersenev ndp.ndp16 = memset(ctx->delayed_ndp16, 0, ctx->max_ndp_size);
14110fa81b30SAlexander Bersenev } else {
14120fa81b30SAlexander Bersenev nth.nth32 = (struct usb_cdc_ncm_nth32 *)skb_out->data;
14130fa81b30SAlexander Bersenev cdc_ncm_align_tail(skb_out, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size - ctx->max_ndp_size);
14140fa81b30SAlexander Bersenev nth.nth32->dwNdpIndex = cpu_to_le32(skb_out->len);
14150fa81b30SAlexander Bersenev skb_put_data(skb_out, ctx->delayed_ndp32, ctx->max_ndp_size);
14160fa81b30SAlexander Bersenev
14170fa81b30SAlexander Bersenev ndp.ndp32 = memset(ctx->delayed_ndp32, 0, ctx->max_ndp_size);
14180fa81b30SAlexander Bersenev }
14194a0e3e98SEnrico Mioso }
14204a0e3e98SEnrico Mioso
142143e4c6dfSBjørn Mork /* If collected data size is less or equal ctx->min_tx_pkt
142220572226SBjørn Mork * bytes, we send buffers as it is. If we get more data, it
142320572226SBjørn Mork * would be more efficient for USB HS mobile device with DMA
142420572226SBjørn Mork * engine to receive a full size NTB, than canceling DMA
142520572226SBjørn Mork * transfer and receiving a short packet.
14264d619f62SBjørn Mork *
14274d619f62SBjørn Mork * This optimization support is pointless if we end up sending
14284d619f62SBjørn Mork * a ZLP after full sized NTBs.
1429900d495aSAlexey Orishko */
14304d619f62SBjørn Mork if (!(dev->driver_info->flags & FLAG_SEND_ZLP) &&
1431aeca3a77SJim Baxter skb_out->len > ctx->min_tx_pkt) {
1432e1069bbfSJim Baxter padding_count = ctx->tx_curr_size - skb_out->len;
14337a68d725SJouni K. Seppänen if (!WARN_ON(padding_count > ctx->tx_curr_size))
1434b080db58SJohannes Berg skb_put_zero(skb_out, padding_count);
1435e1069bbfSJim Baxter } else if (skb_out->len < ctx->tx_curr_size &&
1436aeca3a77SJim Baxter (skb_out->len % dev->maxpacket) == 0) {
1437634fef61SJohannes Berg skb_put_u8(skb_out, 0); /* force short packet */
1438aeca3a77SJim Baxter }
1439900d495aSAlexey Orishko
1440c78b7c58SBjørn Mork /* set final frame length */
14410fa81b30SAlexander Bersenev if (ctx->is_ndp16) {
14420fa81b30SAlexander Bersenev nth.nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data;
14430fa81b30SAlexander Bersenev nth.nth16->wBlockLength = cpu_to_le16(skb_out->len);
14440fa81b30SAlexander Bersenev } else {
14450fa81b30SAlexander Bersenev nth.nth32 = (struct usb_cdc_ncm_nth32 *)skb_out->data;
14460fa81b30SAlexander Bersenev nth.nth32->dwBlockLength = cpu_to_le32(skb_out->len);
14470fa81b30SAlexander Bersenev }
1448900d495aSAlexey Orishko
1449900d495aSAlexey Orishko /* return skb */
1450900d495aSAlexey Orishko ctx->tx_curr_skb = NULL;
1451beeecd42SBjørn Mork
1452beeecd42SBjørn Mork /* keep private stats: framing overhead and number of NTBs */
1453beeecd42SBjørn Mork ctx->tx_overhead += skb_out->len - ctx->tx_curr_frame_payload;
1454beeecd42SBjørn Mork ctx->tx_ntbs++;
1455beeecd42SBjørn Mork
14567a1e890eSBen Hutchings /* usbnet will count all the framing overhead by default.
1457beeecd42SBjørn Mork * Adjust the stats so that the tx_bytes counter show real
1458beeecd42SBjørn Mork * payload data instead.
1459beeecd42SBjørn Mork */
14607a1e890eSBen Hutchings usbnet_set_skb_tx_stats(skb_out, n,
146144f6731dSBjørn Mork (long)ctx->tx_curr_frame_payload - skb_out->len);
14621e9e39f4SBen Hutchings
1463900d495aSAlexey Orishko return skb_out;
1464900d495aSAlexey Orishko
1465*7e01c7f7STudor Ambarus alloc_failed:
1466*7e01c7f7STudor Ambarus if (skb) {
1467*7e01c7f7STudor Ambarus dev_kfree_skb_any(skb);
1468*7e01c7f7STudor Ambarus dev->net->stats.tx_dropped++;
1469*7e01c7f7STudor Ambarus }
1470900d495aSAlexey Orishko exit_no_skb:
1471046c6594SBjørn Mork /* Start timer, if there is a remaining non-empty skb */
1472046c6594SBjørn Mork if (ctx->tx_curr_skb != NULL && n > 0)
1473c84ff1d6SAlexey Orishko cdc_ncm_tx_timeout_start(ctx);
1474900d495aSAlexey Orishko return NULL;
1475900d495aSAlexey Orishko }
1476c91ce3b6SBjørn Mork EXPORT_SYMBOL_GPL(cdc_ncm_fill_tx_frame);
1477900d495aSAlexey Orishko
cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx * ctx)1478900d495aSAlexey Orishko static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx)
1479900d495aSAlexey Orishko {
1480900d495aSAlexey Orishko /* start timer, if not already started */
1481c84ff1d6SAlexey Orishko if (!(hrtimer_active(&ctx->tx_timer) || atomic_read(&ctx->stop)))
1482c84ff1d6SAlexey Orishko hrtimer_start(&ctx->tx_timer,
14838b0e1953SThomas Gleixner ctx->timer_interval,
1484c84ff1d6SAlexey Orishko HRTIMER_MODE_REL);
1485900d495aSAlexey Orishko }
1486900d495aSAlexey Orishko
cdc_ncm_tx_timer_cb(struct hrtimer * timer)1487c84ff1d6SAlexey Orishko static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *timer)
1488900d495aSAlexey Orishko {
1489c84ff1d6SAlexey Orishko struct cdc_ncm_ctx *ctx =
1490c84ff1d6SAlexey Orishko container_of(timer, struct cdc_ncm_ctx, tx_timer);
1491900d495aSAlexey Orishko
1492c84ff1d6SAlexey Orishko if (!atomic_read(&ctx->stop))
1493c84ff1d6SAlexey Orishko tasklet_schedule(&ctx->bh);
1494c84ff1d6SAlexey Orishko return HRTIMER_NORESTART;
1495c84ff1d6SAlexey Orishko }
1496c84ff1d6SAlexey Orishko
cdc_ncm_txpath_bh(struct tasklet_struct * t)14974f4e5436SEmil Renner Berthing static void cdc_ncm_txpath_bh(struct tasklet_struct *t)
1498c84ff1d6SAlexey Orishko {
14994f4e5436SEmil Renner Berthing struct cdc_ncm_ctx *ctx = from_tasklet(ctx, t, bh);
15004f4e5436SEmil Renner Berthing struct usbnet *dev = ctx->dev;
1501c84ff1d6SAlexey Orishko
1502f1ed409fSYunbo Yu spin_lock(&ctx->mtx);
1503900d495aSAlexey Orishko if (ctx->tx_timer_pending != 0) {
1504900d495aSAlexey Orishko ctx->tx_timer_pending--;
1505900d495aSAlexey Orishko cdc_ncm_tx_timeout_start(ctx);
1506f1ed409fSYunbo Yu spin_unlock(&ctx->mtx);
1507bed6f762SBjørn Mork } else if (dev->net != NULL) {
1508beeecd42SBjørn Mork ctx->tx_reason_timeout++; /* count reason for transmitting */
1509f1ed409fSYunbo Yu spin_unlock(&ctx->mtx);
1510bed6f762SBjørn Mork netif_tx_lock_bh(dev->net);
1511bed6f762SBjørn Mork usbnet_start_xmit(NULL, dev->net);
1512bed6f762SBjørn Mork netif_tx_unlock_bh(dev->net);
15137b1e0cbaSBjørn Mork } else {
1514f1ed409fSYunbo Yu spin_unlock(&ctx->mtx);
1515900d495aSAlexey Orishko }
1516f742aa8aSAlexey Orishko }
1517900d495aSAlexey Orishko
15182f69702cSEnrico Mioso struct sk_buff *
cdc_ncm_tx_fixup(struct usbnet * dev,struct sk_buff * skb,gfp_t flags)1519900d495aSAlexey Orishko cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
1520900d495aSAlexey Orishko {
1521900d495aSAlexey Orishko struct sk_buff *skb_out;
1522900d495aSAlexey Orishko struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
1523900d495aSAlexey Orishko
1524900d495aSAlexey Orishko /*
1525900d495aSAlexey Orishko * The Ethernet API we are using does not support transmitting
1526900d495aSAlexey Orishko * multiple Ethernet frames in a single call. This driver will
1527900d495aSAlexey Orishko * accumulate multiple Ethernet frames and send out a larger
1528900d495aSAlexey Orishko * USB frame when the USB buffer is full or when a single jiffies
1529900d495aSAlexey Orishko * timeout happens.
1530900d495aSAlexey Orishko */
1531900d495aSAlexey Orishko if (ctx == NULL)
1532900d495aSAlexey Orishko goto error;
1533900d495aSAlexey Orishko
1534c84ff1d6SAlexey Orishko spin_lock_bh(&ctx->mtx);
15350fa81b30SAlexander Bersenev
15360fa81b30SAlexander Bersenev if (ctx->is_ndp16)
1537bed6f762SBjørn Mork skb_out = cdc_ncm_fill_tx_frame(dev, skb, cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN));
15380fa81b30SAlexander Bersenev else
15390fa81b30SAlexander Bersenev skb_out = cdc_ncm_fill_tx_frame(dev, skb, cpu_to_le32(USB_CDC_NCM_NDP32_NOCRC_SIGN));
15400fa81b30SAlexander Bersenev
1541c84ff1d6SAlexey Orishko spin_unlock_bh(&ctx->mtx);
1542900d495aSAlexey Orishko return skb_out;
1543900d495aSAlexey Orishko
1544900d495aSAlexey Orishko error:
1545900d495aSAlexey Orishko if (skb != NULL)
1546900d495aSAlexey Orishko dev_kfree_skb_any(skb);
1547900d495aSAlexey Orishko
1548900d495aSAlexey Orishko return NULL;
1549900d495aSAlexey Orishko }
15502f69702cSEnrico Mioso EXPORT_SYMBOL_GPL(cdc_ncm_tx_fixup);
1551900d495aSAlexey Orishko
1552ff06ab13SBjørn Mork /* verify NTB header and return offset of first NDP, or negative error */
cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx * ctx,struct sk_buff * skb_in)1553c91ce3b6SBjørn Mork int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in)
1554900d495aSAlexey Orishko {
1555ae223cd4SBjørn Mork struct usbnet *dev = netdev_priv(skb_in->dev);
1556d5ddb4a5SAlexey Orishko struct usb_cdc_ncm_nth16 *nth16;
1557ff06ab13SBjørn Mork int len;
1558ff06ab13SBjørn Mork int ret = -EINVAL;
1559900d495aSAlexey Orishko
1560900d495aSAlexey Orishko if (ctx == NULL)
1561900d495aSAlexey Orishko goto error;
1562900d495aSAlexey Orishko
1563d5ddb4a5SAlexey Orishko if (skb_in->len < (sizeof(struct usb_cdc_ncm_nth16) +
1564d5ddb4a5SAlexey Orishko sizeof(struct usb_cdc_ncm_ndp16))) {
1565ae223cd4SBjørn Mork netif_dbg(dev, rx_err, dev->net, "frame too short\n");
1566900d495aSAlexey Orishko goto error;
1567900d495aSAlexey Orishko }
1568900d495aSAlexey Orishko
1569d5ddb4a5SAlexey Orishko nth16 = (struct usb_cdc_ncm_nth16 *)skb_in->data;
1570900d495aSAlexey Orishko
1571986e10d6SBjørn Mork if (nth16->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH16_SIGN)) {
15725448d75fSBjørn Mork netif_dbg(dev, rx_err, dev->net,
15735448d75fSBjørn Mork "invalid NTH16 signature <%#010x>\n",
1574d5ddb4a5SAlexey Orishko le32_to_cpu(nth16->dwSignature));
1575900d495aSAlexey Orishko goto error;
1576900d495aSAlexey Orishko }
1577900d495aSAlexey Orishko
1578d5ddb4a5SAlexey Orishko len = le16_to_cpu(nth16->wBlockLength);
1579d5ddb4a5SAlexey Orishko if (len > ctx->rx_max) {
1580ae223cd4SBjørn Mork netif_dbg(dev, rx_err, dev->net,
1581ae223cd4SBjørn Mork "unsupported NTB block length %u/%u\n", len,
1582d5ddb4a5SAlexey Orishko ctx->rx_max);
1583900d495aSAlexey Orishko goto error;
1584900d495aSAlexey Orishko }
1585900d495aSAlexey Orishko
1586d5ddb4a5SAlexey Orishko if ((ctx->rx_seq + 1) != le16_to_cpu(nth16->wSequence) &&
1587d5ddb4a5SAlexey Orishko (ctx->rx_seq || le16_to_cpu(nth16->wSequence)) &&
1588d5ddb4a5SAlexey Orishko !((ctx->rx_seq == 0xffff) && !le16_to_cpu(nth16->wSequence))) {
1589ae223cd4SBjørn Mork netif_dbg(dev, rx_err, dev->net,
1590ae223cd4SBjørn Mork "sequence number glitch prev=%d curr=%d\n",
1591d5ddb4a5SAlexey Orishko ctx->rx_seq, le16_to_cpu(nth16->wSequence));
1592d5ddb4a5SAlexey Orishko }
1593d5ddb4a5SAlexey Orishko ctx->rx_seq = le16_to_cpu(nth16->wSequence);
1594d5ddb4a5SAlexey Orishko
1595ff06ab13SBjørn Mork ret = le16_to_cpu(nth16->wNdpIndex);
1596ff06ab13SBjørn Mork error:
1597ff06ab13SBjørn Mork return ret;
1598ff06ab13SBjørn Mork }
1599c91ce3b6SBjørn Mork EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_nth16);
1600ff06ab13SBjørn Mork
cdc_ncm_rx_verify_nth32(struct cdc_ncm_ctx * ctx,struct sk_buff * skb_in)16010fa81b30SAlexander Bersenev int cdc_ncm_rx_verify_nth32(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in)
16020fa81b30SAlexander Bersenev {
16030fa81b30SAlexander Bersenev struct usbnet *dev = netdev_priv(skb_in->dev);
16040fa81b30SAlexander Bersenev struct usb_cdc_ncm_nth32 *nth32;
16050fa81b30SAlexander Bersenev int len;
16060fa81b30SAlexander Bersenev int ret = -EINVAL;
16070fa81b30SAlexander Bersenev
16080fa81b30SAlexander Bersenev if (ctx == NULL)
16090fa81b30SAlexander Bersenev goto error;
16100fa81b30SAlexander Bersenev
16110fa81b30SAlexander Bersenev if (skb_in->len < (sizeof(struct usb_cdc_ncm_nth32) +
16120fa81b30SAlexander Bersenev sizeof(struct usb_cdc_ncm_ndp32))) {
16130fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net, "frame too short\n");
16140fa81b30SAlexander Bersenev goto error;
16150fa81b30SAlexander Bersenev }
16160fa81b30SAlexander Bersenev
16170fa81b30SAlexander Bersenev nth32 = (struct usb_cdc_ncm_nth32 *)skb_in->data;
16180fa81b30SAlexander Bersenev
16190fa81b30SAlexander Bersenev if (nth32->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH32_SIGN)) {
16200fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net,
16210fa81b30SAlexander Bersenev "invalid NTH32 signature <%#010x>\n",
16220fa81b30SAlexander Bersenev le32_to_cpu(nth32->dwSignature));
16230fa81b30SAlexander Bersenev goto error;
16240fa81b30SAlexander Bersenev }
16250fa81b30SAlexander Bersenev
16260fa81b30SAlexander Bersenev len = le32_to_cpu(nth32->dwBlockLength);
16270fa81b30SAlexander Bersenev if (len > ctx->rx_max) {
16280fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net,
16290fa81b30SAlexander Bersenev "unsupported NTB block length %u/%u\n", len,
16300fa81b30SAlexander Bersenev ctx->rx_max);
16310fa81b30SAlexander Bersenev goto error;
16320fa81b30SAlexander Bersenev }
16330fa81b30SAlexander Bersenev
16340fa81b30SAlexander Bersenev if ((ctx->rx_seq + 1) != le16_to_cpu(nth32->wSequence) &&
16350fa81b30SAlexander Bersenev (ctx->rx_seq || le16_to_cpu(nth32->wSequence)) &&
16360fa81b30SAlexander Bersenev !((ctx->rx_seq == 0xffff) && !le16_to_cpu(nth32->wSequence))) {
16370fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net,
16380fa81b30SAlexander Bersenev "sequence number glitch prev=%d curr=%d\n",
16390fa81b30SAlexander Bersenev ctx->rx_seq, le16_to_cpu(nth32->wSequence));
16400fa81b30SAlexander Bersenev }
16410fa81b30SAlexander Bersenev ctx->rx_seq = le16_to_cpu(nth32->wSequence);
16420fa81b30SAlexander Bersenev
16430fa81b30SAlexander Bersenev ret = le32_to_cpu(nth32->dwNdpIndex);
16440fa81b30SAlexander Bersenev error:
16450fa81b30SAlexander Bersenev return ret;
16460fa81b30SAlexander Bersenev }
16470fa81b30SAlexander Bersenev EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_nth32);
16480fa81b30SAlexander Bersenev
1649ff06ab13SBjørn Mork /* verify NDP header and return number of datagrams, or negative error */
cdc_ncm_rx_verify_ndp16(struct sk_buff * skb_in,int ndpoffset)1650c91ce3b6SBjørn Mork int cdc_ncm_rx_verify_ndp16(struct sk_buff *skb_in, int ndpoffset)
1651ff06ab13SBjørn Mork {
1652ae223cd4SBjørn Mork struct usbnet *dev = netdev_priv(skb_in->dev);
1653ff06ab13SBjørn Mork struct usb_cdc_ncm_ndp16 *ndp16;
1654ff06ab13SBjørn Mork int ret = -EINVAL;
1655ff06ab13SBjørn Mork
165675d67d35SBjørn Mork if ((ndpoffset + sizeof(struct usb_cdc_ncm_ndp16)) > skb_in->len) {
1657ae223cd4SBjørn Mork netif_dbg(dev, rx_err, dev->net, "invalid NDP offset <%u>\n",
1658ae223cd4SBjørn Mork ndpoffset);
1659900d495aSAlexey Orishko goto error;
1660900d495aSAlexey Orishko }
166175d67d35SBjørn Mork ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset);
1662900d495aSAlexey Orishko
1663ff06ab13SBjørn Mork if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) {
1664ae223cd4SBjørn Mork netif_dbg(dev, rx_err, dev->net, "invalid DPT16 length <%u>\n",
1665a26fd05dSBjørn Mork le16_to_cpu(ndp16->wLength));
1666ff06ab13SBjørn Mork goto error;
1667ff06ab13SBjørn Mork }
1668ff06ab13SBjørn Mork
1669ff06ab13SBjørn Mork ret = ((le16_to_cpu(ndp16->wLength) -
1670ff06ab13SBjørn Mork sizeof(struct usb_cdc_ncm_ndp16)) /
1671ff06ab13SBjørn Mork sizeof(struct usb_cdc_ncm_dpe16));
1672ff06ab13SBjørn Mork ret--; /* we process NDP entries except for the last one */
1673ff06ab13SBjørn Mork
1674ae223cd4SBjørn Mork if ((sizeof(struct usb_cdc_ncm_ndp16) +
1675ae223cd4SBjørn Mork ret * (sizeof(struct usb_cdc_ncm_dpe16))) > skb_in->len) {
1676ae223cd4SBjørn Mork netif_dbg(dev, rx_err, dev->net, "Invalid nframes = %d\n", ret);
1677ff06ab13SBjørn Mork ret = -EINVAL;
1678ff06ab13SBjørn Mork }
1679ff06ab13SBjørn Mork
1680ff06ab13SBjørn Mork error:
1681ff06ab13SBjørn Mork return ret;
1682ff06ab13SBjørn Mork }
1683c91ce3b6SBjørn Mork EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp16);
1684ff06ab13SBjørn Mork
16850fa81b30SAlexander Bersenev /* verify NDP header and return number of datagrams, or negative error */
cdc_ncm_rx_verify_ndp32(struct sk_buff * skb_in,int ndpoffset)16860fa81b30SAlexander Bersenev int cdc_ncm_rx_verify_ndp32(struct sk_buff *skb_in, int ndpoffset)
16870fa81b30SAlexander Bersenev {
16880fa81b30SAlexander Bersenev struct usbnet *dev = netdev_priv(skb_in->dev);
16890fa81b30SAlexander Bersenev struct usb_cdc_ncm_ndp32 *ndp32;
16900fa81b30SAlexander Bersenev int ret = -EINVAL;
16910fa81b30SAlexander Bersenev
16920fa81b30SAlexander Bersenev if ((ndpoffset + sizeof(struct usb_cdc_ncm_ndp32)) > skb_in->len) {
16930fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net, "invalid NDP offset <%u>\n",
16940fa81b30SAlexander Bersenev ndpoffset);
16950fa81b30SAlexander Bersenev goto error;
16960fa81b30SAlexander Bersenev }
16970fa81b30SAlexander Bersenev ndp32 = (struct usb_cdc_ncm_ndp32 *)(skb_in->data + ndpoffset);
16980fa81b30SAlexander Bersenev
16990fa81b30SAlexander Bersenev if (le16_to_cpu(ndp32->wLength) < USB_CDC_NCM_NDP32_LENGTH_MIN) {
17000fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net, "invalid DPT32 length <%u>\n",
17010fa81b30SAlexander Bersenev le16_to_cpu(ndp32->wLength));
17020fa81b30SAlexander Bersenev goto error;
17030fa81b30SAlexander Bersenev }
17040fa81b30SAlexander Bersenev
17050fa81b30SAlexander Bersenev ret = ((le16_to_cpu(ndp32->wLength) -
17060fa81b30SAlexander Bersenev sizeof(struct usb_cdc_ncm_ndp32)) /
17070fa81b30SAlexander Bersenev sizeof(struct usb_cdc_ncm_dpe32));
17080fa81b30SAlexander Bersenev ret--; /* we process NDP entries except for the last one */
17090fa81b30SAlexander Bersenev
17100fa81b30SAlexander Bersenev if ((sizeof(struct usb_cdc_ncm_ndp32) +
17110fa81b30SAlexander Bersenev ret * (sizeof(struct usb_cdc_ncm_dpe32))) > skb_in->len) {
17120fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net, "Invalid nframes = %d\n", ret);
17130fa81b30SAlexander Bersenev ret = -EINVAL;
17140fa81b30SAlexander Bersenev }
17150fa81b30SAlexander Bersenev
17160fa81b30SAlexander Bersenev error:
17170fa81b30SAlexander Bersenev return ret;
17180fa81b30SAlexander Bersenev }
17190fa81b30SAlexander Bersenev EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp32);
17200fa81b30SAlexander Bersenev
cdc_ncm_rx_fixup(struct usbnet * dev,struct sk_buff * skb_in)17212f69702cSEnrico Mioso int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
1722ff06ab13SBjørn Mork {
1723ff06ab13SBjørn Mork struct sk_buff *skb;
1724ff06ab13SBjørn Mork struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
17258d2b1a1eSOliver Neukum unsigned int len;
1726ff06ab13SBjørn Mork int nframes;
1727ff06ab13SBjørn Mork int x;
17288d2b1a1eSOliver Neukum unsigned int offset;
17290fa81b30SAlexander Bersenev union {
1730ff06ab13SBjørn Mork struct usb_cdc_ncm_ndp16 *ndp16;
17310fa81b30SAlexander Bersenev struct usb_cdc_ncm_ndp32 *ndp32;
17320fa81b30SAlexander Bersenev } ndp;
17330fa81b30SAlexander Bersenev union {
1734ff06ab13SBjørn Mork struct usb_cdc_ncm_dpe16 *dpe16;
17350fa81b30SAlexander Bersenev struct usb_cdc_ncm_dpe32 *dpe32;
17360fa81b30SAlexander Bersenev } dpe;
17370fa81b30SAlexander Bersenev
1738ff06ab13SBjørn Mork int ndpoffset;
1739ff06ab13SBjørn Mork int loopcount = 50; /* arbitrary max preventing infinite loop */
1740beeecd42SBjørn Mork u32 payload = 0;
1741ff06ab13SBjørn Mork
17420fa81b30SAlexander Bersenev if (ctx->is_ndp16)
1743ff06ab13SBjørn Mork ndpoffset = cdc_ncm_rx_verify_nth16(ctx, skb_in);
17440fa81b30SAlexander Bersenev else
17450fa81b30SAlexander Bersenev ndpoffset = cdc_ncm_rx_verify_nth32(ctx, skb_in);
17460fa81b30SAlexander Bersenev
1747ff06ab13SBjørn Mork if (ndpoffset < 0)
1748ff06ab13SBjørn Mork goto error;
1749ff06ab13SBjørn Mork
1750ff06ab13SBjørn Mork next_ndp:
17510fa81b30SAlexander Bersenev if (ctx->is_ndp16) {
1752ff06ab13SBjørn Mork nframes = cdc_ncm_rx_verify_ndp16(skb_in, ndpoffset);
1753ff06ab13SBjørn Mork if (nframes < 0)
1754ff06ab13SBjørn Mork goto error;
1755ff06ab13SBjørn Mork
17560fa81b30SAlexander Bersenev ndp.ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset);
1757ff06ab13SBjørn Mork
17580fa81b30SAlexander Bersenev if (ndp.ndp16->dwSignature != cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN)) {
17595448d75fSBjørn Mork netif_dbg(dev, rx_err, dev->net,
17605448d75fSBjørn Mork "invalid DPT16 signature <%#010x>\n",
17610fa81b30SAlexander Bersenev le32_to_cpu(ndp.ndp16->dwSignature));
176275d67d35SBjørn Mork goto err_ndp;
1763900d495aSAlexey Orishko }
17640fa81b30SAlexander Bersenev dpe.dpe16 = ndp.ndp16->dpe16;
17650fa81b30SAlexander Bersenev } else {
17660fa81b30SAlexander Bersenev nframes = cdc_ncm_rx_verify_ndp32(skb_in, ndpoffset);
17670fa81b30SAlexander Bersenev if (nframes < 0)
17680fa81b30SAlexander Bersenev goto error;
1769900d495aSAlexey Orishko
17700fa81b30SAlexander Bersenev ndp.ndp32 = (struct usb_cdc_ncm_ndp32 *)(skb_in->data + ndpoffset);
17710fa81b30SAlexander Bersenev
17720fa81b30SAlexander Bersenev if (ndp.ndp32->dwSignature != cpu_to_le32(USB_CDC_NCM_NDP32_NOCRC_SIGN)) {
17730fa81b30SAlexander Bersenev netif_dbg(dev, rx_err, dev->net,
17740fa81b30SAlexander Bersenev "invalid DPT32 signature <%#010x>\n",
17750fa81b30SAlexander Bersenev le32_to_cpu(ndp.ndp32->dwSignature));
17760fa81b30SAlexander Bersenev goto err_ndp;
17770fa81b30SAlexander Bersenev }
17780fa81b30SAlexander Bersenev dpe.dpe32 = ndp.ndp32->dpe32;
17790fa81b30SAlexander Bersenev }
17800fa81b30SAlexander Bersenev
17810fa81b30SAlexander Bersenev for (x = 0; x < nframes; x++) {
17820fa81b30SAlexander Bersenev if (ctx->is_ndp16) {
17830fa81b30SAlexander Bersenev offset = le16_to_cpu(dpe.dpe16->wDatagramIndex);
17840fa81b30SAlexander Bersenev len = le16_to_cpu(dpe.dpe16->wDatagramLength);
17850fa81b30SAlexander Bersenev } else {
17860fa81b30SAlexander Bersenev offset = le32_to_cpu(dpe.dpe32->dwDatagramIndex);
17870fa81b30SAlexander Bersenev len = le32_to_cpu(dpe.dpe32->dwDatagramLength);
17880fa81b30SAlexander Bersenev }
1789900d495aSAlexey Orishko
1790900d495aSAlexey Orishko /*
1791900d495aSAlexey Orishko * CDC NCM ch. 3.7
1792900d495aSAlexey Orishko * All entries after first NULL entry are to be ignored
1793900d495aSAlexey Orishko */
1794d5ddb4a5SAlexey Orishko if ((offset == 0) || (len == 0)) {
1795900d495aSAlexey Orishko if (!x)
179675d67d35SBjørn Mork goto err_ndp; /* empty NTB */
1797900d495aSAlexey Orishko break;
1798900d495aSAlexey Orishko }
1799900d495aSAlexey Orishko
18008d2b1a1eSOliver Neukum /* sanity checking - watch out for integer wrap*/
18018d2b1a1eSOliver Neukum if ((offset > skb_in->len) || (len > skb_in->len - offset) ||
1802d5ddb4a5SAlexey Orishko (len > ctx->rx_max) || (len < ETH_HLEN)) {
1803ae223cd4SBjørn Mork netif_dbg(dev, rx_err, dev->net,
1804ae223cd4SBjørn Mork "invalid frame detected (ignored) offset[%u]=%u, length=%u, skb=%p\n",
1805d5ddb4a5SAlexey Orishko x, offset, len, skb_in);
1806900d495aSAlexey Orishko if (!x)
180775d67d35SBjørn Mork goto err_ndp;
1808900d495aSAlexey Orishko break;
1809900d495aSAlexey Orishko
1810900d495aSAlexey Orishko } else {
18111e2c6117SBjørn Mork /* create a fresh copy to reduce truesize */
18121e2c6117SBjørn Mork skb = netdev_alloc_skb_ip_align(dev->net, len);
18139e56790aSJesper Juhl if (!skb)
18149e56790aSJesper Juhl goto error;
181559ae1d12SJohannes Berg skb_put_data(skb, skb_in->data + offset, len);
1816900d495aSAlexey Orishko usbnet_skb_return(dev, skb);
1817beeecd42SBjørn Mork payload += len; /* count payload bytes in this NTB */
1818900d495aSAlexey Orishko }
18190fa81b30SAlexander Bersenev
18200fa81b30SAlexander Bersenev if (ctx->is_ndp16)
18210fa81b30SAlexander Bersenev dpe.dpe16++;
18220fa81b30SAlexander Bersenev else
18230fa81b30SAlexander Bersenev dpe.dpe32++;
1824900d495aSAlexey Orishko }
182575d67d35SBjørn Mork err_ndp:
182675d67d35SBjørn Mork /* are there more NDPs to process? */
18270fa81b30SAlexander Bersenev if (ctx->is_ndp16)
18280fa81b30SAlexander Bersenev ndpoffset = le16_to_cpu(ndp.ndp16->wNextNdpIndex);
18290fa81b30SAlexander Bersenev else
18300fa81b30SAlexander Bersenev ndpoffset = le32_to_cpu(ndp.ndp32->dwNextNdpIndex);
18310fa81b30SAlexander Bersenev
183275d67d35SBjørn Mork if (ndpoffset && loopcount--)
183375d67d35SBjørn Mork goto next_ndp;
183475d67d35SBjørn Mork
1835beeecd42SBjørn Mork /* update stats */
1836beeecd42SBjørn Mork ctx->rx_overhead += skb_in->len - payload;
1837beeecd42SBjørn Mork ctx->rx_ntbs++;
1838beeecd42SBjørn Mork
1839900d495aSAlexey Orishko return 1;
1840900d495aSAlexey Orishko error:
1841900d495aSAlexey Orishko return 0;
1842900d495aSAlexey Orishko }
18432f69702cSEnrico Mioso EXPORT_SYMBOL_GPL(cdc_ncm_rx_fixup);
1844900d495aSAlexey Orishko
1845900d495aSAlexey Orishko static void
cdc_ncm_speed_change(struct usbnet * dev,struct usb_cdc_speed_change * data)1846bed6f762SBjørn Mork cdc_ncm_speed_change(struct usbnet *dev,
184784e77a8bSAlexey Orishko struct usb_cdc_speed_change *data)
1848900d495aSAlexey Orishko {
1849eb47c274SOliver Neukum /* RTL8156 shipped before 2021 sends notification about every 32ms. */
1850eb47c274SOliver Neukum dev->rx_speed = le32_to_cpu(data->DLBitRRate);
1851eb47c274SOliver Neukum dev->tx_speed = le32_to_cpu(data->ULBitRate);
1852900d495aSAlexey Orishko }
1853900d495aSAlexey Orishko
cdc_ncm_status(struct usbnet * dev,struct urb * urb)1854900d495aSAlexey Orishko static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
1855900d495aSAlexey Orishko {
1856900d495aSAlexey Orishko struct usb_cdc_notification *event;
1857900d495aSAlexey Orishko
1858900d495aSAlexey Orishko if (urb->actual_length < sizeof(*event))
1859900d495aSAlexey Orishko return;
1860900d495aSAlexey Orishko
1861900d495aSAlexey Orishko /* test for split data in 8-byte chunks */
1862900d495aSAlexey Orishko if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
1863bed6f762SBjørn Mork cdc_ncm_speed_change(dev,
186484e77a8bSAlexey Orishko (struct usb_cdc_speed_change *)urb->transfer_buffer);
1865900d495aSAlexey Orishko return;
1866900d495aSAlexey Orishko }
1867900d495aSAlexey Orishko
1868900d495aSAlexey Orishko event = urb->transfer_buffer;
1869900d495aSAlexey Orishko
1870900d495aSAlexey Orishko switch (event->bNotificationType) {
1871900d495aSAlexey Orishko case USB_CDC_NOTIFY_NETWORK_CONNECTION:
1872900d495aSAlexey Orishko /*
1873900d495aSAlexey Orishko * According to the CDC NCM specification ch.7.1
1874900d495aSAlexey Orishko * USB_CDC_NOTIFY_NETWORK_CONNECTION notification shall be
1875900d495aSAlexey Orishko * sent by device after USB_CDC_NOTIFY_SPEED_CHANGE.
1876900d495aSAlexey Orishko */
1877eb47c274SOliver Neukum /* RTL8156 shipped before 2021 sends notification about
1878eb47c274SOliver Neukum * every 32ms. Don't forward notification if state is same.
1879eb47c274SOliver Neukum */
1880de658a19SGrant Grundler if (netif_carrier_ok(dev->net) != !!event->wValue)
1881fa83dbeeSBjørn Mork usbnet_link_change(dev, !!event->wValue, 0);
1882900d495aSAlexey Orishko break;
1883900d495aSAlexey Orishko
1884900d495aSAlexey Orishko case USB_CDC_NOTIFY_SPEED_CHANGE:
188584e77a8bSAlexey Orishko if (urb->actual_length < (sizeof(*event) +
188684e77a8bSAlexey Orishko sizeof(struct usb_cdc_speed_change)))
1887900d495aSAlexey Orishko set_bit(EVENT_STS_SPLIT, &dev->flags);
1888900d495aSAlexey Orishko else
1889bed6f762SBjørn Mork cdc_ncm_speed_change(dev,
189084e77a8bSAlexey Orishko (struct usb_cdc_speed_change *)&event[1]);
1891900d495aSAlexey Orishko break;
1892900d495aSAlexey Orishko
1893900d495aSAlexey Orishko default:
189467a36606SBjørn Mork dev_dbg(&dev->udev->dev,
189567a36606SBjørn Mork "NCM: unexpected notification 0x%02x!\n",
189667a36606SBjørn Mork event->bNotificationType);
1897900d495aSAlexey Orishko break;
1898900d495aSAlexey Orishko }
1899900d495aSAlexey Orishko }
1900900d495aSAlexey Orishko
1901900d495aSAlexey Orishko static const struct driver_info cdc_ncm_info = {
1902266c0190SDominik Czerwik .description = "CDC NCM (NO ZLP)",
19034d06dd53SBjørn Mork .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
1904c1a3d406SMaciej Żenczykowski | FLAG_LINK_INTR | FLAG_ETHER,
1905900d495aSAlexey Orishko .bind = cdc_ncm_bind,
1906900d495aSAlexey Orishko .unbind = cdc_ncm_unbind,
1907a5e40708SOliver Neukum .manage_power = usbnet_manage_power,
1908900d495aSAlexey Orishko .status = cdc_ncm_status,
1909900d495aSAlexey Orishko .rx_fixup = cdc_ncm_rx_fixup,
1910900d495aSAlexey Orishko .tx_fixup = cdc_ncm_tx_fixup,
1911e10dcb1bSMiguel Rodríguez Pérez .set_rx_mode = usbnet_cdc_update_filter,
1912900d495aSAlexey Orishko };
1913900d495aSAlexey Orishko
1914266c0190SDominik Czerwik /* Same as cdc_ncm_info, but with FLAG_SEND_ZLP */
1915266c0190SDominik Czerwik static const struct driver_info cdc_ncm_zlp_info = {
1916266c0190SDominik Czerwik .description = "CDC NCM (SEND ZLP)",
1917266c0190SDominik Czerwik .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
1918266c0190SDominik Czerwik | FLAG_LINK_INTR | FLAG_ETHER | FLAG_SEND_ZLP,
1919266c0190SDominik Czerwik .bind = cdc_ncm_bind,
1920266c0190SDominik Czerwik .unbind = cdc_ncm_unbind,
1921266c0190SDominik Czerwik .manage_power = usbnet_manage_power,
1922266c0190SDominik Czerwik .status = cdc_ncm_status,
1923266c0190SDominik Czerwik .rx_fixup = cdc_ncm_rx_fixup,
1924266c0190SDominik Czerwik .tx_fixup = cdc_ncm_tx_fixup,
1925748064b5SSantiago Ruano Rincón .set_rx_mode = usbnet_cdc_update_filter,
1926266c0190SDominik Czerwik };
1927266c0190SDominik Czerwik
1928f94898eaSDan Williams /* Same as cdc_ncm_info, but with FLAG_WWAN */
1929f94898eaSDan Williams static const struct driver_info wwan_info = {
1930f94898eaSDan Williams .description = "Mobile Broadband Network Device",
1931f94898eaSDan Williams .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
19324d06dd53SBjørn Mork | FLAG_LINK_INTR | FLAG_WWAN,
1933f94898eaSDan Williams .bind = cdc_ncm_bind,
1934f94898eaSDan Williams .unbind = cdc_ncm_unbind,
1935a5e40708SOliver Neukum .manage_power = usbnet_manage_power,
1936f94898eaSDan Williams .status = cdc_ncm_status,
1937f94898eaSDan Williams .rx_fixup = cdc_ncm_rx_fixup,
1938f94898eaSDan Williams .tx_fixup = cdc_ncm_tx_fixup,
1939e10dcb1bSMiguel Rodríguez Pérez .set_rx_mode = usbnet_cdc_update_filter,
1940f94898eaSDan Williams };
1941f94898eaSDan Williams
19422f62d5aaSWei Shuai /* Same as wwan_info, but with FLAG_NOARP */
19432f62d5aaSWei Shuai static const struct driver_info wwan_noarp_info = {
19442f62d5aaSWei Shuai .description = "Mobile Broadband Network Device (NO ARP)",
19452f62d5aaSWei Shuai .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
19464d06dd53SBjørn Mork | FLAG_LINK_INTR | FLAG_WWAN | FLAG_NOARP,
19472f62d5aaSWei Shuai .bind = cdc_ncm_bind,
19482f62d5aaSWei Shuai .unbind = cdc_ncm_unbind,
19492f62d5aaSWei Shuai .manage_power = usbnet_manage_power,
19502f62d5aaSWei Shuai .status = cdc_ncm_status,
19512f62d5aaSWei Shuai .rx_fixup = cdc_ncm_rx_fixup,
19522f62d5aaSWei Shuai .tx_fixup = cdc_ncm_tx_fixup,
1953e10dcb1bSMiguel Rodríguez Pérez .set_rx_mode = usbnet_cdc_update_filter,
19542f62d5aaSWei Shuai };
19552f62d5aaSWei Shuai
1956f94898eaSDan Williams static const struct usb_device_id cdc_devs[] = {
1957f94898eaSDan Williams /* Ericsson MBM devices like F5521gw */
1958f94898eaSDan Williams { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
1959f94898eaSDan Williams | USB_DEVICE_ID_MATCH_VENDOR,
1960f94898eaSDan Williams .idVendor = 0x0bdb,
1961f94898eaSDan Williams .bInterfaceClass = USB_CLASS_COMM,
1962f94898eaSDan Williams .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
1963f94898eaSDan Williams .bInterfaceProtocol = USB_CDC_PROTO_NONE,
1964f94898eaSDan Williams .driver_info = (unsigned long) &wwan_info,
1965f94898eaSDan Williams },
1966f94898eaSDan Williams
196779f42232SDaniele Palmas /* Telit LE910 V2 */
196879f42232SDaniele Palmas { USB_DEVICE_AND_INTERFACE_INFO(0x1bc7, 0x0036,
196979f42232SDaniele Palmas USB_CLASS_COMM,
197079f42232SDaniele Palmas USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
197179f42232SDaniele Palmas .driver_info = (unsigned long)&wwan_noarp_info,
197279f42232SDaniele Palmas },
197379f42232SDaniele Palmas
1974670c0d62SDaniele Palmas /* DW5812 LTE Verizon Mobile Broadband Card
1975670c0d62SDaniele Palmas * Unlike DW5550 this device requires FLAG_NOARP
1976670c0d62SDaniele Palmas */
1977670c0d62SDaniele Palmas { USB_DEVICE_AND_INTERFACE_INFO(0x413c, 0x81bb,
1978670c0d62SDaniele Palmas USB_CLASS_COMM,
1979670c0d62SDaniele Palmas USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
1980670c0d62SDaniele Palmas .driver_info = (unsigned long)&wwan_noarp_info,
1981670c0d62SDaniele Palmas },
1982670c0d62SDaniele Palmas
1983fb83d5f2SDaniele Palmas /* DW5813 LTE AT&T Mobile Broadband Card
1984fb83d5f2SDaniele Palmas * Unlike DW5550 this device requires FLAG_NOARP
1985fb83d5f2SDaniele Palmas */
1986fb83d5f2SDaniele Palmas { USB_DEVICE_AND_INTERFACE_INFO(0x413c, 0x81bc,
1987fb83d5f2SDaniele Palmas USB_CLASS_COMM,
1988fb83d5f2SDaniele Palmas USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
1989fb83d5f2SDaniele Palmas .driver_info = (unsigned long)&wwan_noarp_info,
1990fb83d5f2SDaniele Palmas },
1991fb83d5f2SDaniele Palmas
1992f3a1ef9cSPeter Meiser /* Dell branded MBM devices like DW5550 */
1993f3a1ef9cSPeter Meiser { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
1994f3a1ef9cSPeter Meiser | USB_DEVICE_ID_MATCH_VENDOR,
1995f3a1ef9cSPeter Meiser .idVendor = 0x413c,
1996f3a1ef9cSPeter Meiser .bInterfaceClass = USB_CLASS_COMM,
1997f3a1ef9cSPeter Meiser .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
1998f3a1ef9cSPeter Meiser .bInterfaceProtocol = USB_CDC_PROTO_NONE,
1999f3a1ef9cSPeter Meiser .driver_info = (unsigned long) &wwan_info,
2000f3a1ef9cSPeter Meiser },
2001f3a1ef9cSPeter Meiser
2002f3a1ef9cSPeter Meiser /* Toshiba branded MBM devices */
2003f3a1ef9cSPeter Meiser { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
2004f3a1ef9cSPeter Meiser | USB_DEVICE_ID_MATCH_VENDOR,
2005f3a1ef9cSPeter Meiser .idVendor = 0x0930,
2006f3a1ef9cSPeter Meiser .bInterfaceClass = USB_CLASS_COMM,
2007f3a1ef9cSPeter Meiser .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
2008f3a1ef9cSPeter Meiser .bInterfaceProtocol = USB_CDC_PROTO_NONE,
2009f3a1ef9cSPeter Meiser .driver_info = (unsigned long) &wwan_info,
2010f3a1ef9cSPeter Meiser },
2011f3a1ef9cSPeter Meiser
20121f84eab4SBjørn Mork /* tag Huawei devices as wwan */
20131f84eab4SBjørn Mork { USB_VENDOR_AND_INTERFACE_INFO(0x12d1,
20141f84eab4SBjørn Mork USB_CLASS_COMM,
20151f84eab4SBjørn Mork USB_CDC_SUBCLASS_NCM,
20161f84eab4SBjørn Mork USB_CDC_PROTO_NONE),
20171f84eab4SBjørn Mork .driver_info = (unsigned long)&wwan_info,
20181f84eab4SBjørn Mork },
20191f84eab4SBjørn Mork
20202f62d5aaSWei Shuai /* Infineon(now Intel) HSPA Modem platform */
20212f62d5aaSWei Shuai { USB_DEVICE_AND_INTERFACE_INFO(0x1519, 0x0443,
20222f62d5aaSWei Shuai USB_CLASS_COMM,
20232f62d5aaSWei Shuai USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
20242f62d5aaSWei Shuai .driver_info = (unsigned long)&wwan_noarp_info,
20252f62d5aaSWei Shuai },
20262f62d5aaSWei Shuai
20273b638f0fSAleksander Morgado /* u-blox TOBY-L4 */
20283b638f0fSAleksander Morgado { USB_DEVICE_AND_INTERFACE_INFO(0x1546, 0x1010,
20293b638f0fSAleksander Morgado USB_CLASS_COMM,
20303b638f0fSAleksander Morgado USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
20313b638f0fSAleksander Morgado .driver_info = (unsigned long)&wwan_info,
20323b638f0fSAleksander Morgado },
20333b638f0fSAleksander Morgado
2034266c0190SDominik Czerwik /* DisplayLink docking stations */
2035266c0190SDominik Czerwik { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
2036266c0190SDominik Czerwik | USB_DEVICE_ID_MATCH_VENDOR,
2037266c0190SDominik Czerwik .idVendor = 0x17e9,
2038266c0190SDominik Czerwik .bInterfaceClass = USB_CLASS_COMM,
2039266c0190SDominik Czerwik .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
2040266c0190SDominik Czerwik .bInterfaceProtocol = USB_CDC_PROTO_NONE,
2041266c0190SDominik Czerwik .driver_info = (unsigned long)&cdc_ncm_zlp_info,
2042266c0190SDominik Czerwik },
2043266c0190SDominik Czerwik
2044f94898eaSDan Williams /* Generic CDC-NCM devices */
2045f94898eaSDan Williams { USB_INTERFACE_INFO(USB_CLASS_COMM,
2046f94898eaSDan Williams USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
2047f94898eaSDan Williams .driver_info = (unsigned long)&cdc_ncm_info,
2048f94898eaSDan Williams },
2049f94898eaSDan Williams {
2050f94898eaSDan Williams },
2051f94898eaSDan Williams };
2052f94898eaSDan Williams MODULE_DEVICE_TABLE(usb, cdc_devs);
2053f94898eaSDan Williams
2054900d495aSAlexey Orishko static struct usb_driver cdc_ncm_driver = {
2055900d495aSAlexey Orishko .name = "cdc_ncm",
2056900d495aSAlexey Orishko .id_table = cdc_devs,
2057085e50e1SBjørn Mork .probe = usbnet_probe,
2058085e50e1SBjørn Mork .disconnect = usbnet_disconnect,
2059900d495aSAlexey Orishko .suspend = usbnet_suspend,
2060900d495aSAlexey Orishko .resume = usbnet_resume,
206185e3c65fSStefan Metzmacher .reset_resume = usbnet_resume,
2062900d495aSAlexey Orishko .supports_autosuspend = 1,
2063e1f12eb6SSarah Sharp .disable_hub_initiated_lpm = 1,
2064900d495aSAlexey Orishko };
2065900d495aSAlexey Orishko
2066d632eb1bSGreg Kroah-Hartman module_usb_driver(cdc_ncm_driver);
2067900d495aSAlexey Orishko
2068900d495aSAlexey Orishko MODULE_AUTHOR("Hans Petter Selasky");
2069900d495aSAlexey Orishko MODULE_DESCRIPTION("USB CDC NCM host driver");
2070900d495aSAlexey Orishko MODULE_LICENSE("Dual BSD/GPL");
2071