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