• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/devclass_docs/NCM10.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/init.h>
43 #include <linux/netdevice.h>
44 #include <linux/ctype.h>
45 #include <linux/ethtool.h>
46 #include <linux/workqueue.h>
47 #include <linux/mii.h>
48 #include <linux/crc32.h>
49 #include <linux/usb.h>
50 #include <linux/hrtimer.h>
51 #include <linux/atomic.h>
52 #include <linux/usb/usbnet.h>
53 #include <linux/usb/cdc.h>
54 #include <linux/usb/cdc_ncm.h>
55 
56 #define	DRIVER_VERSION				"14-Mar-2012"
57 
58 #if IS_ENABLED(CONFIG_USB_NET_CDC_MBIM)
59 static bool prefer_mbim = true;
60 #else
61 static bool prefer_mbim;
62 #endif
63 module_param(prefer_mbim, bool, S_IRUGO | S_IWUSR);
64 MODULE_PARM_DESC(prefer_mbim, "Prefer MBIM setting on dual NCM/MBIM functions");
65 
66 static void cdc_ncm_txpath_bh(unsigned long param);
67 static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx);
68 static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *hr_timer);
69 static struct usb_driver cdc_ncm_driver;
70 
71 static void
cdc_ncm_get_drvinfo(struct net_device * net,struct ethtool_drvinfo * info)72 cdc_ncm_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
73 {
74 	struct usbnet *dev = netdev_priv(net);
75 
76 	strlcpy(info->driver, dev->driver_name, sizeof(info->driver));
77 	strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
78 	strlcpy(info->fw_version, dev->driver_info->description,
79 		sizeof(info->fw_version));
80 	usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
81 }
82 
cdc_ncm_setup(struct cdc_ncm_ctx * ctx)83 static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
84 {
85 	u32 val;
86 	u8 flags;
87 	u8 iface_no;
88 	int err;
89 	int eth_hlen;
90 	u16 ntb_fmt_supported;
91 	u32 min_dgram_size;
92 	u32 min_hdr_size;
93 	struct usbnet *dev = netdev_priv(ctx->netdev);
94 
95 	iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
96 
97 	err = usbnet_read_cmd(dev, USB_CDC_GET_NTB_PARAMETERS,
98 			      USB_TYPE_CLASS | USB_DIR_IN
99 			      |USB_RECIP_INTERFACE,
100 			      0, iface_no, &ctx->ncm_parm,
101 			      sizeof(ctx->ncm_parm));
102 	if (err < 0) {
103 		pr_debug("failed GET_NTB_PARAMETERS\n");
104 		return 1;
105 	}
106 
107 	/* read correct set of parameters according to device mode */
108 	ctx->rx_max = le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize);
109 	ctx->tx_max = le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize);
110 	ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder);
111 	ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor);
112 	ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment);
113 	/* devices prior to NCM Errata shall set this field to zero */
114 	ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams);
115 	ntb_fmt_supported = le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported);
116 
117 	eth_hlen = ETH_HLEN;
118 	min_dgram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
119 	min_hdr_size = CDC_NCM_MIN_HDR_SIZE;
120 	if (ctx->mbim_desc != NULL) {
121 		flags = ctx->mbim_desc->bmNetworkCapabilities;
122 		eth_hlen = 0;
123 		min_dgram_size = CDC_MBIM_MIN_DATAGRAM_SIZE;
124 		min_hdr_size = 0;
125 	} else if (ctx->func_desc != NULL) {
126 		flags = ctx->func_desc->bmNetworkCapabilities;
127 	} else {
128 		flags = 0;
129 	}
130 
131 	pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u "
132 		 "wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u "
133 		 "wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n",
134 		 ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus,
135 		 ctx->tx_ndp_modulus, ctx->tx_max_datagrams, flags);
136 
137 	/* max count of tx datagrams */
138 	if ((ctx->tx_max_datagrams == 0) ||
139 			(ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX))
140 		ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX;
141 
142 	/* verify maximum size of received NTB in bytes */
143 	if (ctx->rx_max < USB_CDC_NCM_NTB_MIN_IN_SIZE) {
144 		pr_debug("Using min receive length=%d\n",
145 						USB_CDC_NCM_NTB_MIN_IN_SIZE);
146 		ctx->rx_max = USB_CDC_NCM_NTB_MIN_IN_SIZE;
147 	}
148 
149 	if (ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX) {
150 		pr_debug("Using default maximum receive length=%d\n",
151 						CDC_NCM_NTB_MAX_SIZE_RX);
152 		ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX;
153 	}
154 
155 	/* inform device about NTB input size changes */
156 	if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) {
157 		__le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
158 
159 		err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_INPUT_SIZE,
160 				       USB_TYPE_CLASS | USB_DIR_OUT
161 				       | USB_RECIP_INTERFACE,
162 				       0, iface_no, &dwNtbInMaxSize, 4);
163 		if (err < 0)
164 			pr_debug("Setting NTB Input Size failed\n");
165 	}
166 
167 	/* verify maximum size of transmitted NTB in bytes */
168 	if ((ctx->tx_max <
169 	    (min_hdr_size + min_dgram_size)) ||
170 	    (ctx->tx_max > CDC_NCM_NTB_MAX_SIZE_TX)) {
171 		pr_debug("Using default maximum transmit length=%d\n",
172 						CDC_NCM_NTB_MAX_SIZE_TX);
173 		ctx->tx_max = CDC_NCM_NTB_MAX_SIZE_TX;
174 	}
175 
176 	/*
177 	 * verify that the structure alignment is:
178 	 * - power of two
179 	 * - not greater than the maximum transmit length
180 	 * - not less than four bytes
181 	 */
182 	val = ctx->tx_ndp_modulus;
183 
184 	if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) ||
185 	    (val != ((-val) & val)) || (val >= ctx->tx_max)) {
186 		pr_debug("Using default alignment: 4 bytes\n");
187 		ctx->tx_ndp_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE;
188 	}
189 
190 	/*
191 	 * verify that the payload alignment is:
192 	 * - power of two
193 	 * - not greater than the maximum transmit length
194 	 * - not less than four bytes
195 	 */
196 	val = ctx->tx_modulus;
197 
198 	if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) ||
199 	    (val != ((-val) & val)) || (val >= ctx->tx_max)) {
200 		pr_debug("Using default transmit modulus: 4 bytes\n");
201 		ctx->tx_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE;
202 	}
203 
204 	/* verify the payload remainder */
205 	if (ctx->tx_remainder >= ctx->tx_modulus) {
206 		pr_debug("Using default transmit remainder: 0 bytes\n");
207 		ctx->tx_remainder = 0;
208 	}
209 
210 	/* adjust TX-remainder according to NCM specification. */
211 	ctx->tx_remainder = ((ctx->tx_remainder - eth_hlen) &
212 			     (ctx->tx_modulus - 1));
213 
214 	/* additional configuration */
215 
216 	/* set CRC Mode */
217 	if (flags & USB_CDC_NCM_NCAP_CRC_MODE) {
218 		err = usbnet_write_cmd(dev, USB_CDC_SET_CRC_MODE,
219 				       USB_TYPE_CLASS | USB_DIR_OUT
220 				       | USB_RECIP_INTERFACE,
221 				       USB_CDC_NCM_CRC_NOT_APPENDED,
222 				       iface_no, NULL, 0);
223 		if (err < 0)
224 			pr_debug("Setting CRC mode off failed\n");
225 	}
226 
227 	/* set NTB format, if both formats are supported */
228 	if (ntb_fmt_supported & USB_CDC_NCM_NTH32_SIGN) {
229 		err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT,
230 				       USB_TYPE_CLASS | USB_DIR_OUT
231 				       | USB_RECIP_INTERFACE,
232 				       USB_CDC_NCM_NTB16_FORMAT,
233 				       iface_no, NULL, 0);
234 		if (err < 0)
235 			pr_debug("Setting NTB format to 16-bit failed\n");
236 	}
237 
238 	ctx->max_datagram_size = min_dgram_size;
239 
240 	/* set Max Datagram Size (MTU) */
241 	if (flags & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE) {
242 		__le16 max_datagram_size;
243 		u16 eth_max_sz;
244 		if (ctx->ether_desc != NULL)
245 			eth_max_sz = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
246 		else if (ctx->mbim_desc != NULL)
247 			eth_max_sz = le16_to_cpu(ctx->mbim_desc->wMaxSegmentSize);
248 		else
249 			goto max_dgram_err;
250 
251 		err = usbnet_read_cmd(dev, USB_CDC_GET_MAX_DATAGRAM_SIZE,
252 				      USB_TYPE_CLASS | USB_DIR_IN
253 				      | USB_RECIP_INTERFACE,
254 				      0, iface_no, &max_datagram_size, 2);
255 		if (err < 0) {
256 			pr_debug("GET_MAX_DATAGRAM_SIZE failed, use size=%u\n",
257 				 min_dgram_size);
258 		} else {
259 			ctx->max_datagram_size =
260 				le16_to_cpu(max_datagram_size);
261 			/* Check Eth descriptor value */
262 			if (ctx->max_datagram_size > eth_max_sz)
263 					ctx->max_datagram_size = eth_max_sz;
264 
265 			if (ctx->max_datagram_size > CDC_NCM_MAX_DATAGRAM_SIZE)
266 				ctx->max_datagram_size = CDC_NCM_MAX_DATAGRAM_SIZE;
267 
268 			if (ctx->max_datagram_size < min_dgram_size)
269 				ctx->max_datagram_size = min_dgram_size;
270 
271 			/* if value changed, update device */
272 			if (ctx->max_datagram_size !=
273 					le16_to_cpu(max_datagram_size)) {
274 				err = usbnet_write_cmd(dev,
275 						USB_CDC_SET_MAX_DATAGRAM_SIZE,
276 						USB_TYPE_CLASS | USB_DIR_OUT
277 						 | USB_RECIP_INTERFACE,
278 						0,
279 						iface_no, &max_datagram_size,
280 						2);
281 				if (err < 0)
282 					pr_debug("SET_MAX_DGRAM_SIZE failed\n");
283 			}
284 		}
285 	}
286 
287 max_dgram_err:
288 	if (ctx->netdev->mtu != (ctx->max_datagram_size - eth_hlen))
289 		ctx->netdev->mtu = ctx->max_datagram_size - eth_hlen;
290 
291 	return 0;
292 }
293 
294 static void
cdc_ncm_find_endpoints(struct cdc_ncm_ctx * ctx,struct usb_interface * intf)295 cdc_ncm_find_endpoints(struct cdc_ncm_ctx *ctx, struct usb_interface *intf)
296 {
297 	struct usb_host_endpoint *e;
298 	u8 ep;
299 
300 	for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) {
301 
302 		e = intf->cur_altsetting->endpoint + ep;
303 		switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
304 		case USB_ENDPOINT_XFER_INT:
305 			if (usb_endpoint_dir_in(&e->desc)) {
306 				if (ctx->status_ep == NULL)
307 					ctx->status_ep = e;
308 			}
309 			break;
310 
311 		case USB_ENDPOINT_XFER_BULK:
312 			if (usb_endpoint_dir_in(&e->desc)) {
313 				if (ctx->in_ep == NULL)
314 					ctx->in_ep = e;
315 			} else {
316 				if (ctx->out_ep == NULL)
317 					ctx->out_ep = e;
318 			}
319 			break;
320 
321 		default:
322 			break;
323 		}
324 	}
325 }
326 
cdc_ncm_free(struct cdc_ncm_ctx * ctx)327 static void cdc_ncm_free(struct cdc_ncm_ctx *ctx)
328 {
329 	if (ctx == NULL)
330 		return;
331 
332 	if (ctx->tx_rem_skb != NULL) {
333 		dev_kfree_skb_any(ctx->tx_rem_skb);
334 		ctx->tx_rem_skb = NULL;
335 	}
336 
337 	if (ctx->tx_curr_skb != NULL) {
338 		dev_kfree_skb_any(ctx->tx_curr_skb);
339 		ctx->tx_curr_skb = NULL;
340 	}
341 
342 	kfree(ctx);
343 }
344 
345 static const struct ethtool_ops cdc_ncm_ethtool_ops = {
346 	.get_drvinfo = cdc_ncm_get_drvinfo,
347 	.get_link = usbnet_get_link,
348 	.get_msglevel = usbnet_get_msglevel,
349 	.set_msglevel = usbnet_set_msglevel,
350 	.get_settings = usbnet_get_settings,
351 	.set_settings = usbnet_set_settings,
352 	.nway_reset = usbnet_nway_reset,
353 };
354 
cdc_ncm_bind_common(struct usbnet * dev,struct usb_interface * intf,u8 data_altsetting)355 int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting)
356 {
357 	struct cdc_ncm_ctx *ctx;
358 	struct usb_driver *driver;
359 	u8 *buf;
360 	int len;
361 	int temp;
362 	u8 iface_no;
363 
364 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
365 	if (!ctx)
366 		return -ENOMEM;
367 
368 	hrtimer_init(&ctx->tx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
369 	ctx->tx_timer.function = &cdc_ncm_tx_timer_cb;
370 	ctx->bh.data = (unsigned long)ctx;
371 	ctx->bh.func = cdc_ncm_txpath_bh;
372 	atomic_set(&ctx->stop, 0);
373 	spin_lock_init(&ctx->mtx);
374 	ctx->netdev = dev->net;
375 
376 	/* store ctx pointer in device data field */
377 	dev->data[0] = (unsigned long)ctx;
378 
379 	/* get some pointers */
380 	driver = driver_of(intf);
381 	buf = intf->cur_altsetting->extra;
382 	len = intf->cur_altsetting->extralen;
383 
384 	ctx->udev = dev->udev;
385 	ctx->intf = intf;
386 
387 	/* parse through descriptors associated with control interface */
388 	while ((len > 0) && (buf[0] > 2) && (buf[0] <= len)) {
389 
390 		if (buf[1] != USB_DT_CS_INTERFACE)
391 			goto advance;
392 
393 		switch (buf[2]) {
394 		case USB_CDC_UNION_TYPE:
395 			if (buf[0] < sizeof(*(ctx->union_desc)))
396 				break;
397 
398 			ctx->union_desc =
399 					(const struct usb_cdc_union_desc *)buf;
400 
401 			ctx->control = usb_ifnum_to_if(dev->udev,
402 					ctx->union_desc->bMasterInterface0);
403 			ctx->data = usb_ifnum_to_if(dev->udev,
404 					ctx->union_desc->bSlaveInterface0);
405 			break;
406 
407 		case USB_CDC_ETHERNET_TYPE:
408 			if (buf[0] < sizeof(*(ctx->ether_desc)))
409 				break;
410 
411 			ctx->ether_desc =
412 					(const struct usb_cdc_ether_desc *)buf;
413 			dev->hard_mtu =
414 				le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
415 
416 			if (dev->hard_mtu < CDC_NCM_MIN_DATAGRAM_SIZE)
417 				dev->hard_mtu =	CDC_NCM_MIN_DATAGRAM_SIZE;
418 			else if (dev->hard_mtu > CDC_NCM_MAX_DATAGRAM_SIZE)
419 				dev->hard_mtu =	CDC_NCM_MAX_DATAGRAM_SIZE;
420 			break;
421 
422 		case USB_CDC_NCM_TYPE:
423 			if (buf[0] < sizeof(*(ctx->func_desc)))
424 				break;
425 
426 			ctx->func_desc = (const struct usb_cdc_ncm_desc *)buf;
427 			break;
428 
429 		case USB_CDC_MBIM_TYPE:
430 			if (buf[0] < sizeof(*(ctx->mbim_desc)))
431 				break;
432 
433 			ctx->mbim_desc = (const struct usb_cdc_mbim_desc *)buf;
434 			break;
435 
436 		default:
437 			break;
438 		}
439 advance:
440 		/* advance to next descriptor */
441 		temp = buf[0];
442 		buf += temp;
443 		len -= temp;
444 	}
445 
446 	/* some buggy devices have an IAD but no CDC Union */
447 	if (!ctx->union_desc && intf->intf_assoc && intf->intf_assoc->bInterfaceCount == 2) {
448 		ctx->control = intf;
449 		ctx->data = usb_ifnum_to_if(dev->udev, intf->cur_altsetting->desc.bInterfaceNumber + 1);
450 		dev_dbg(&intf->dev, "CDC Union missing - got slave from IAD\n");
451 	}
452 
453 	/* check if we got everything */
454 	if ((ctx->control == NULL) || (ctx->data == NULL) ||
455 	    ((!ctx->mbim_desc) && ((ctx->ether_desc == NULL) || (ctx->control != intf))))
456 		goto error;
457 
458 	/* claim data interface, if different from control */
459 	if (ctx->data != ctx->control) {
460 		temp = usb_driver_claim_interface(driver, ctx->data, dev);
461 		if (temp)
462 			goto error;
463 	}
464 
465 	iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber;
466 
467 	/* reset data interface */
468 	temp = usb_set_interface(dev->udev, iface_no, 0);
469 	if (temp)
470 		goto error2;
471 
472 	/* initialize data interface */
473 	if (cdc_ncm_setup(ctx))
474 		goto error2;
475 
476 	/* configure data interface */
477 	temp = usb_set_interface(dev->udev, iface_no, data_altsetting);
478 	if (temp)
479 		goto error2;
480 
481 	cdc_ncm_find_endpoints(ctx, ctx->data);
482 	cdc_ncm_find_endpoints(ctx, ctx->control);
483 
484 	if ((ctx->in_ep == NULL) || (ctx->out_ep == NULL) ||
485 	    (ctx->status_ep == NULL))
486 		goto error2;
487 
488 	dev->net->ethtool_ops = &cdc_ncm_ethtool_ops;
489 
490 	usb_set_intfdata(ctx->data, dev);
491 	usb_set_intfdata(ctx->control, dev);
492 	usb_set_intfdata(ctx->intf, dev);
493 
494 	if (ctx->ether_desc) {
495 		temp = usbnet_get_ethernet_addr(dev, ctx->ether_desc->iMACAddress);
496 		if (temp)
497 			goto error2;
498 		dev_info(&dev->udev->dev, "MAC-Address: %pM\n", dev->net->dev_addr);
499 	}
500 
501 
502 	dev->in = usb_rcvbulkpipe(dev->udev,
503 		ctx->in_ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
504 	dev->out = usb_sndbulkpipe(dev->udev,
505 		ctx->out_ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
506 	dev->status = ctx->status_ep;
507 	dev->rx_urb_size = ctx->rx_max;
508 
509 	ctx->tx_speed = ctx->rx_speed = 0;
510 	return 0;
511 
512 error2:
513 	usb_set_intfdata(ctx->control, NULL);
514 	usb_set_intfdata(ctx->data, NULL);
515 	if (ctx->data != ctx->control)
516 		usb_driver_release_interface(driver, ctx->data);
517 error:
518 	cdc_ncm_free((struct cdc_ncm_ctx *)dev->data[0]);
519 	dev->data[0] = 0;
520 	dev_info(&dev->udev->dev, "bind() failure\n");
521 	return -ENODEV;
522 }
523 EXPORT_SYMBOL_GPL(cdc_ncm_bind_common);
524 
cdc_ncm_unbind(struct usbnet * dev,struct usb_interface * intf)525 void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf)
526 {
527 	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
528 	struct usb_driver *driver = driver_of(intf);
529 
530 	if (ctx == NULL)
531 		return;		/* no setup */
532 
533 	atomic_set(&ctx->stop, 1);
534 
535 	if (hrtimer_active(&ctx->tx_timer))
536 		hrtimer_cancel(&ctx->tx_timer);
537 
538 	tasklet_kill(&ctx->bh);
539 
540 	/* handle devices with combined control and data interface */
541 	if (ctx->control == ctx->data)
542 		ctx->data = NULL;
543 
544 	/* disconnect master --> disconnect slave */
545 	if (intf == ctx->control && ctx->data) {
546 		usb_set_intfdata(ctx->data, NULL);
547 		usb_driver_release_interface(driver, ctx->data);
548 		ctx->data = NULL;
549 
550 	} else if (intf == ctx->data && ctx->control) {
551 		usb_set_intfdata(ctx->control, NULL);
552 		usb_driver_release_interface(driver, ctx->control);
553 		ctx->control = NULL;
554 	}
555 
556 	usb_set_intfdata(ctx->intf, NULL);
557 	cdc_ncm_free(ctx);
558 }
559 EXPORT_SYMBOL_GPL(cdc_ncm_unbind);
560 
561 /* Select the MBIM altsetting iff it is preferred and available,
562  * returning the number of the corresponding data interface altsetting
563  */
cdc_ncm_select_altsetting(struct usbnet * dev,struct usb_interface * intf)564 u8 cdc_ncm_select_altsetting(struct usbnet *dev, struct usb_interface *intf)
565 {
566 	struct usb_host_interface *alt;
567 
568 	/* The MBIM spec defines a NCM compatible default altsetting,
569 	 * which we may have matched:
570 	 *
571 	 *  "Functions that implement both NCM 1.0 and MBIM (an
572 	 *   “NCM/MBIM function”) according to this recommendation
573 	 *   shall provide two alternate settings for the
574 	 *   Communication Interface.  Alternate setting 0, and the
575 	 *   associated class and endpoint descriptors, shall be
576 	 *   constructed according to the rules given for the
577 	 *   Communication Interface in section 5 of [USBNCM10].
578 	 *   Alternate setting 1, and the associated class and
579 	 *   endpoint descriptors, shall be constructed according to
580 	 *   the rules given in section 6 (USB Device Model) of this
581 	 *   specification."
582 	 */
583 	if (prefer_mbim && intf->num_altsetting == 2) {
584 		alt = usb_altnum_to_altsetting(intf, CDC_NCM_COMM_ALTSETTING_MBIM);
585 		if (alt && cdc_ncm_comm_intf_is_mbim(alt) &&
586 		    !usb_set_interface(dev->udev,
587 				       intf->cur_altsetting->desc.bInterfaceNumber,
588 				       CDC_NCM_COMM_ALTSETTING_MBIM))
589 			return CDC_NCM_DATA_ALTSETTING_MBIM;
590 	}
591 	return CDC_NCM_DATA_ALTSETTING_NCM;
592 }
593 EXPORT_SYMBOL_GPL(cdc_ncm_select_altsetting);
594 
cdc_ncm_bind(struct usbnet * dev,struct usb_interface * intf)595 static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf)
596 {
597 	/* MBIM backwards compatible function? */
598 	cdc_ncm_select_altsetting(dev, intf);
599 	if (cdc_ncm_comm_intf_is_mbim(intf->cur_altsetting))
600 		return -ENODEV;
601 
602 	/* NCM data altsetting is always 1 */
603 	return cdc_ncm_bind_common(dev, intf, 1);
604 }
605 
cdc_ncm_align_tail(struct sk_buff * skb,size_t modulus,size_t remainder,size_t max)606 static void cdc_ncm_align_tail(struct sk_buff *skb, size_t modulus, size_t remainder, size_t max)
607 {
608 	size_t align = ALIGN(skb->len, modulus) - skb->len + remainder;
609 
610 	if (skb->len + align > max)
611 		align = max - skb->len;
612 	if (align && skb_tailroom(skb) >= align)
613 		memset(skb_put(skb, align), 0, align);
614 }
615 
616 /* return a pointer to a valid struct usb_cdc_ncm_ndp16 of type sign, possibly
617  * allocating a new one within skb
618  */
cdc_ncm_ndp(struct cdc_ncm_ctx * ctx,struct sk_buff * skb,__le32 sign,size_t reserve)619 static struct usb_cdc_ncm_ndp16 *cdc_ncm_ndp(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign, size_t reserve)
620 {
621 	struct usb_cdc_ncm_ndp16 *ndp16 = NULL;
622 	struct usb_cdc_ncm_nth16 *nth16 = (void *)skb->data;
623 	size_t ndpoffset = le16_to_cpu(nth16->wNdpIndex);
624 
625 	/* follow the chain of NDPs, looking for a match */
626 	while (ndpoffset) {
627 		ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb->data + ndpoffset);
628 		if  (ndp16->dwSignature == sign)
629 			return ndp16;
630 		ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex);
631 	}
632 
633 	/* align new NDP */
634 	cdc_ncm_align_tail(skb, ctx->tx_ndp_modulus, 0, ctx->tx_max);
635 
636 	/* verify that there is room for the NDP and the datagram (reserve) */
637 	if ((ctx->tx_max - skb->len - reserve) < CDC_NCM_NDP_SIZE)
638 		return NULL;
639 
640 	/* link to it */
641 	if (ndp16)
642 		ndp16->wNextNdpIndex = cpu_to_le16(skb->len);
643 	else
644 		nth16->wNdpIndex = cpu_to_le16(skb->len);
645 
646 	/* push a new empty NDP */
647 	ndp16 = (struct usb_cdc_ncm_ndp16 *)memset(skb_put(skb, CDC_NCM_NDP_SIZE), 0, CDC_NCM_NDP_SIZE);
648 	ndp16->dwSignature = sign;
649 	ndp16->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp16) + sizeof(struct usb_cdc_ncm_dpe16));
650 	return ndp16;
651 }
652 
653 struct sk_buff *
cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx * ctx,struct sk_buff * skb,__le32 sign)654 cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign)
655 {
656 	struct usb_cdc_ncm_nth16 *nth16;
657 	struct usb_cdc_ncm_ndp16 *ndp16;
658 	struct sk_buff *skb_out;
659 	u16 n = 0, index, ndplen;
660 	u8 ready2send = 0;
661 
662 	/* if there is a remaining skb, it gets priority */
663 	if (skb != NULL) {
664 		swap(skb, ctx->tx_rem_skb);
665 		swap(sign, ctx->tx_rem_sign);
666 	} else {
667 		ready2send = 1;
668 	}
669 
670 	/* check if we are resuming an OUT skb */
671 	skb_out = ctx->tx_curr_skb;
672 
673 	/* allocate a new OUT skb */
674 	if (!skb_out) {
675 		skb_out = alloc_skb((ctx->tx_max + 1), GFP_ATOMIC);
676 		if (skb_out == NULL) {
677 			if (skb != NULL) {
678 				dev_kfree_skb_any(skb);
679 				ctx->netdev->stats.tx_dropped++;
680 			}
681 			goto exit_no_skb;
682 		}
683 		/* fill out the initial 16-bit NTB header */
684 		nth16 = (struct usb_cdc_ncm_nth16 *)memset(skb_put(skb_out, sizeof(struct usb_cdc_ncm_nth16)), 0, sizeof(struct usb_cdc_ncm_nth16));
685 		nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN);
686 		nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16));
687 		nth16->wSequence = cpu_to_le16(ctx->tx_seq++);
688 
689 		/* count total number of frames in this NTB */
690 		ctx->tx_curr_frame_num = 0;
691 	}
692 
693 	for (n = ctx->tx_curr_frame_num; n < ctx->tx_max_datagrams; n++) {
694 		/* send any remaining skb first */
695 		if (skb == NULL) {
696 			skb = ctx->tx_rem_skb;
697 			sign = ctx->tx_rem_sign;
698 			ctx->tx_rem_skb = NULL;
699 
700 			/* check for end of skb */
701 			if (skb == NULL)
702 				break;
703 		}
704 
705 		/* get the appropriate NDP for this skb */
706 		ndp16 = cdc_ncm_ndp(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder);
707 
708 		/* align beginning of next frame */
709 		cdc_ncm_align_tail(skb_out,  ctx->tx_modulus, ctx->tx_remainder, ctx->tx_max);
710 
711 		/* check if we had enough room left for both NDP and frame */
712 		if (!ndp16 || skb_out->len + skb->len > ctx->tx_max) {
713 			if (n == 0) {
714 				/* won't fit, MTU problem? */
715 				dev_kfree_skb_any(skb);
716 				skb = NULL;
717 				ctx->netdev->stats.tx_dropped++;
718 			} else {
719 				/* no room for skb - store for later */
720 				if (ctx->tx_rem_skb != NULL) {
721 					dev_kfree_skb_any(ctx->tx_rem_skb);
722 					ctx->netdev->stats.tx_dropped++;
723 				}
724 				ctx->tx_rem_skb = skb;
725 				ctx->tx_rem_sign = sign;
726 				skb = NULL;
727 				ready2send = 1;
728 			}
729 			break;
730 		}
731 
732 		/* calculate frame number withing this NDP */
733 		ndplen = le16_to_cpu(ndp16->wLength);
734 		index = (ndplen - sizeof(struct usb_cdc_ncm_ndp16)) / sizeof(struct usb_cdc_ncm_dpe16) - 1;
735 
736 		/* OK, add this skb */
737 		ndp16->dpe16[index].wDatagramLength = cpu_to_le16(skb->len);
738 		ndp16->dpe16[index].wDatagramIndex = cpu_to_le16(skb_out->len);
739 		ndp16->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe16));
740 		memcpy(skb_put(skb_out, skb->len), skb->data, skb->len);
741 		dev_kfree_skb_any(skb);
742 		skb = NULL;
743 
744 		/* send now if this NDP is full */
745 		if (index >= CDC_NCM_DPT_DATAGRAMS_MAX) {
746 			ready2send = 1;
747 			break;
748 		}
749 	}
750 
751 	/* free up any dangling skb */
752 	if (skb != NULL) {
753 		dev_kfree_skb_any(skb);
754 		skb = NULL;
755 		ctx->netdev->stats.tx_dropped++;
756 	}
757 
758 	ctx->tx_curr_frame_num = n;
759 
760 	if (n == 0) {
761 		/* wait for more frames */
762 		/* push variables */
763 		ctx->tx_curr_skb = skb_out;
764 		goto exit_no_skb;
765 
766 	} else if ((n < ctx->tx_max_datagrams) && (ready2send == 0)) {
767 		/* wait for more frames */
768 		/* push variables */
769 		ctx->tx_curr_skb = skb_out;
770 		/* set the pending count */
771 		if (n < CDC_NCM_RESTART_TIMER_DATAGRAM_CNT)
772 			ctx->tx_timer_pending = CDC_NCM_TIMER_PENDING_CNT;
773 		goto exit_no_skb;
774 
775 	} else {
776 		/* frame goes out */
777 		/* variables will be reset at next call */
778 	}
779 
780 	/*
781 	 * If collected data size is less or equal CDC_NCM_MIN_TX_PKT bytes,
782 	 * we send buffers as it is. If we get more data, it would be more
783 	 * efficient for USB HS mobile device with DMA engine to receive a full
784 	 * size NTB, than canceling DMA transfer and receiving a short packet.
785 	 */
786 	if (skb_out->len > CDC_NCM_MIN_TX_PKT)
787 		/* final zero padding */
788 		memset(skb_put(skb_out, ctx->tx_max - skb_out->len), 0, ctx->tx_max - skb_out->len);
789 
790 	/* do we need to prevent a ZLP? */
791 	if (((skb_out->len % le16_to_cpu(ctx->out_ep->desc.wMaxPacketSize)) == 0) &&
792 	    (skb_out->len < le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize)) && skb_tailroom(skb_out))
793 		*skb_put(skb_out, 1) = 0;	/* force short packet */
794 
795 	/* set final frame length */
796 	nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data;
797 	nth16->wBlockLength = cpu_to_le16(skb_out->len);
798 
799 	/* return skb */
800 	ctx->tx_curr_skb = NULL;
801 	ctx->netdev->stats.tx_packets += ctx->tx_curr_frame_num;
802 	return skb_out;
803 
804 exit_no_skb:
805 	/* Start timer, if there is a remaining skb */
806 	if (ctx->tx_curr_skb != NULL)
807 		cdc_ncm_tx_timeout_start(ctx);
808 	return NULL;
809 }
810 EXPORT_SYMBOL_GPL(cdc_ncm_fill_tx_frame);
811 
cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx * ctx)812 static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx)
813 {
814 	/* start timer, if not already started */
815 	if (!(hrtimer_active(&ctx->tx_timer) || atomic_read(&ctx->stop)))
816 		hrtimer_start(&ctx->tx_timer,
817 				ktime_set(0, CDC_NCM_TIMER_INTERVAL),
818 				HRTIMER_MODE_REL);
819 }
820 
cdc_ncm_tx_timer_cb(struct hrtimer * timer)821 static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *timer)
822 {
823 	struct cdc_ncm_ctx *ctx =
824 			container_of(timer, struct cdc_ncm_ctx, tx_timer);
825 
826 	if (!atomic_read(&ctx->stop))
827 		tasklet_schedule(&ctx->bh);
828 	return HRTIMER_NORESTART;
829 }
830 
cdc_ncm_txpath_bh(unsigned long param)831 static void cdc_ncm_txpath_bh(unsigned long param)
832 {
833 	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)param;
834 
835 	spin_lock_bh(&ctx->mtx);
836 	if (ctx->tx_timer_pending != 0) {
837 		ctx->tx_timer_pending--;
838 		cdc_ncm_tx_timeout_start(ctx);
839 		spin_unlock_bh(&ctx->mtx);
840 	} else if (ctx->netdev != NULL) {
841 		spin_unlock_bh(&ctx->mtx);
842 		netif_tx_lock_bh(ctx->netdev);
843 		usbnet_start_xmit(NULL, ctx->netdev);
844 		netif_tx_unlock_bh(ctx->netdev);
845 	} else {
846 		spin_unlock_bh(&ctx->mtx);
847 	}
848 }
849 
850 static struct sk_buff *
cdc_ncm_tx_fixup(struct usbnet * dev,struct sk_buff * skb,gfp_t flags)851 cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
852 {
853 	struct sk_buff *skb_out;
854 	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
855 
856 	/*
857 	 * The Ethernet API we are using does not support transmitting
858 	 * multiple Ethernet frames in a single call. This driver will
859 	 * accumulate multiple Ethernet frames and send out a larger
860 	 * USB frame when the USB buffer is full or when a single jiffies
861 	 * timeout happens.
862 	 */
863 	if (ctx == NULL)
864 		goto error;
865 
866 	spin_lock_bh(&ctx->mtx);
867 	skb_out = cdc_ncm_fill_tx_frame(ctx, skb, cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN));
868 	spin_unlock_bh(&ctx->mtx);
869 	return skb_out;
870 
871 error:
872 	if (skb != NULL)
873 		dev_kfree_skb_any(skb);
874 
875 	return NULL;
876 }
877 
878 /* 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)879 int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in)
880 {
881 	struct usb_cdc_ncm_nth16 *nth16;
882 	int len;
883 	int ret = -EINVAL;
884 
885 	if (ctx == NULL)
886 		goto error;
887 
888 	if (skb_in->len < (sizeof(struct usb_cdc_ncm_nth16) +
889 					sizeof(struct usb_cdc_ncm_ndp16))) {
890 		pr_debug("frame too short\n");
891 		goto error;
892 	}
893 
894 	nth16 = (struct usb_cdc_ncm_nth16 *)skb_in->data;
895 
896 	if (le32_to_cpu(nth16->dwSignature) != USB_CDC_NCM_NTH16_SIGN) {
897 		pr_debug("invalid NTH16 signature <%u>\n",
898 					le32_to_cpu(nth16->dwSignature));
899 		goto error;
900 	}
901 
902 	len = le16_to_cpu(nth16->wBlockLength);
903 	if (len > ctx->rx_max) {
904 		pr_debug("unsupported NTB block length %u/%u\n", len,
905 								ctx->rx_max);
906 		goto error;
907 	}
908 
909 	if ((ctx->rx_seq + 1) != le16_to_cpu(nth16->wSequence) &&
910 		(ctx->rx_seq || le16_to_cpu(nth16->wSequence)) &&
911 		!((ctx->rx_seq == 0xffff) && !le16_to_cpu(nth16->wSequence))) {
912 		pr_debug("sequence number glitch prev=%d curr=%d\n",
913 				ctx->rx_seq, le16_to_cpu(nth16->wSequence));
914 	}
915 	ctx->rx_seq = le16_to_cpu(nth16->wSequence);
916 
917 	ret = le16_to_cpu(nth16->wNdpIndex);
918 error:
919 	return ret;
920 }
921 EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_nth16);
922 
923 /* verify NDP header and return number of datagrams, or negative error */
cdc_ncm_rx_verify_ndp16(struct sk_buff * skb_in,int ndpoffset)924 int cdc_ncm_rx_verify_ndp16(struct sk_buff *skb_in, int ndpoffset)
925 {
926 	struct usb_cdc_ncm_ndp16 *ndp16;
927 	int ret = -EINVAL;
928 
929 	if ((ndpoffset + sizeof(struct usb_cdc_ncm_ndp16)) > skb_in->len) {
930 		pr_debug("invalid NDP offset  <%u>\n", ndpoffset);
931 		goto error;
932 	}
933 	ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset);
934 
935 	if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) {
936 		pr_debug("invalid DPT16 length <%u>\n",
937 					le32_to_cpu(ndp16->dwSignature));
938 		goto error;
939 	}
940 
941 	ret = ((le16_to_cpu(ndp16->wLength) -
942 					sizeof(struct usb_cdc_ncm_ndp16)) /
943 					sizeof(struct usb_cdc_ncm_dpe16));
944 	ret--; /* we process NDP entries except for the last one */
945 
946 	if ((sizeof(struct usb_cdc_ncm_ndp16) + ret * (sizeof(struct usb_cdc_ncm_dpe16))) >
947 								skb_in->len) {
948 		pr_debug("Invalid nframes = %d\n", ret);
949 		ret = -EINVAL;
950 	}
951 
952 error:
953 	return ret;
954 }
955 EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp16);
956 
cdc_ncm_rx_fixup(struct usbnet * dev,struct sk_buff * skb_in)957 static int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
958 {
959 	struct sk_buff *skb;
960 	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
961 	int len;
962 	int nframes;
963 	int x;
964 	int offset;
965 	struct usb_cdc_ncm_ndp16 *ndp16;
966 	struct usb_cdc_ncm_dpe16 *dpe16;
967 	int ndpoffset;
968 	int loopcount = 50; /* arbitrary max preventing infinite loop */
969 
970 	ndpoffset = cdc_ncm_rx_verify_nth16(ctx, skb_in);
971 	if (ndpoffset < 0)
972 		goto error;
973 
974 next_ndp:
975 	nframes = cdc_ncm_rx_verify_ndp16(skb_in, ndpoffset);
976 	if (nframes < 0)
977 		goto error;
978 
979 	ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset);
980 
981 	if (le32_to_cpu(ndp16->dwSignature) != USB_CDC_NCM_NDP16_NOCRC_SIGN) {
982 		pr_debug("invalid DPT16 signature <%u>\n",
983 			 le32_to_cpu(ndp16->dwSignature));
984 		goto err_ndp;
985 	}
986 	dpe16 = ndp16->dpe16;
987 
988 	for (x = 0; x < nframes; x++, dpe16++) {
989 		offset = le16_to_cpu(dpe16->wDatagramIndex);
990 		len = le16_to_cpu(dpe16->wDatagramLength);
991 
992 		/*
993 		 * CDC NCM ch. 3.7
994 		 * All entries after first NULL entry are to be ignored
995 		 */
996 		if ((offset == 0) || (len == 0)) {
997 			if (!x)
998 				goto err_ndp; /* empty NTB */
999 			break;
1000 		}
1001 
1002 		/* sanity checking */
1003 		if (((offset + len) > skb_in->len) ||
1004 				(len > ctx->rx_max) || (len < ETH_HLEN)) {
1005 			pr_debug("invalid frame detected (ignored)"
1006 					"offset[%u]=%u, length=%u, skb=%p\n",
1007 					x, offset, len, skb_in);
1008 			if (!x)
1009 				goto err_ndp;
1010 			break;
1011 
1012 		} else {
1013 			skb = skb_clone(skb_in, GFP_ATOMIC);
1014 			if (!skb)
1015 				goto error;
1016 			skb->len = len;
1017 			skb->data = ((u8 *)skb_in->data) + offset;
1018 			skb_set_tail_pointer(skb, len);
1019 			usbnet_skb_return(dev, skb);
1020 		}
1021 	}
1022 err_ndp:
1023 	/* are there more NDPs to process? */
1024 	ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex);
1025 	if (ndpoffset && loopcount--)
1026 		goto next_ndp;
1027 
1028 	return 1;
1029 error:
1030 	return 0;
1031 }
1032 
1033 static void
cdc_ncm_speed_change(struct cdc_ncm_ctx * ctx,struct usb_cdc_speed_change * data)1034 cdc_ncm_speed_change(struct cdc_ncm_ctx *ctx,
1035 		     struct usb_cdc_speed_change *data)
1036 {
1037 	uint32_t rx_speed = le32_to_cpu(data->DLBitRRate);
1038 	uint32_t tx_speed = le32_to_cpu(data->ULBitRate);
1039 
1040 	/*
1041 	 * Currently the USB-NET API does not support reporting the actual
1042 	 * device speed. Do print it instead.
1043 	 */
1044 	if ((tx_speed != ctx->tx_speed) || (rx_speed != ctx->rx_speed)) {
1045 		ctx->tx_speed = tx_speed;
1046 		ctx->rx_speed = rx_speed;
1047 
1048 		if ((tx_speed > 1000000) && (rx_speed > 1000000)) {
1049 			printk(KERN_INFO KBUILD_MODNAME
1050 				": %s: %u mbit/s downlink "
1051 				"%u mbit/s uplink\n",
1052 				ctx->netdev->name,
1053 				(unsigned int)(rx_speed / 1000000U),
1054 				(unsigned int)(tx_speed / 1000000U));
1055 		} else {
1056 			printk(KERN_INFO KBUILD_MODNAME
1057 				": %s: %u kbit/s downlink "
1058 				"%u kbit/s uplink\n",
1059 				ctx->netdev->name,
1060 				(unsigned int)(rx_speed / 1000U),
1061 				(unsigned int)(tx_speed / 1000U));
1062 		}
1063 	}
1064 }
1065 
cdc_ncm_status(struct usbnet * dev,struct urb * urb)1066 static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
1067 {
1068 	struct cdc_ncm_ctx *ctx;
1069 	struct usb_cdc_notification *event;
1070 
1071 	ctx = (struct cdc_ncm_ctx *)dev->data[0];
1072 
1073 	if (urb->actual_length < sizeof(*event))
1074 		return;
1075 
1076 	/* test for split data in 8-byte chunks */
1077 	if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
1078 		cdc_ncm_speed_change(ctx,
1079 		      (struct usb_cdc_speed_change *)urb->transfer_buffer);
1080 		return;
1081 	}
1082 
1083 	event = urb->transfer_buffer;
1084 
1085 	switch (event->bNotificationType) {
1086 	case USB_CDC_NOTIFY_NETWORK_CONNECTION:
1087 		/*
1088 		 * According to the CDC NCM specification ch.7.1
1089 		 * USB_CDC_NOTIFY_NETWORK_CONNECTION notification shall be
1090 		 * sent by device after USB_CDC_NOTIFY_SPEED_CHANGE.
1091 		 */
1092 		ctx->connected = le16_to_cpu(event->wValue);
1093 
1094 		printk(KERN_INFO KBUILD_MODNAME ": %s: network connection:"
1095 			" %sconnected\n",
1096 			ctx->netdev->name, ctx->connected ? "" : "dis");
1097 
1098 		usbnet_link_change(dev, ctx->connected, 0);
1099 		if (!ctx->connected)
1100 			ctx->tx_speed = ctx->rx_speed = 0;
1101 		break;
1102 
1103 	case USB_CDC_NOTIFY_SPEED_CHANGE:
1104 		if (urb->actual_length < (sizeof(*event) +
1105 					sizeof(struct usb_cdc_speed_change)))
1106 			set_bit(EVENT_STS_SPLIT, &dev->flags);
1107 		else
1108 			cdc_ncm_speed_change(ctx,
1109 				(struct usb_cdc_speed_change *) &event[1]);
1110 		break;
1111 
1112 	default:
1113 		dev_dbg(&dev->udev->dev,
1114 			"NCM: unexpected notification 0x%02x!\n",
1115 			event->bNotificationType);
1116 		break;
1117 	}
1118 }
1119 
cdc_ncm_check_connect(struct usbnet * dev)1120 static int cdc_ncm_check_connect(struct usbnet *dev)
1121 {
1122 	struct cdc_ncm_ctx *ctx;
1123 
1124 	ctx = (struct cdc_ncm_ctx *)dev->data[0];
1125 	if (ctx == NULL)
1126 		return 1;	/* disconnected */
1127 
1128 	return !ctx->connected;
1129 }
1130 
1131 static int
cdc_ncm_probe(struct usb_interface * udev,const struct usb_device_id * prod)1132 cdc_ncm_probe(struct usb_interface *udev, const struct usb_device_id *prod)
1133 {
1134 	return usbnet_probe(udev, prod);
1135 }
1136 
cdc_ncm_disconnect(struct usb_interface * intf)1137 static void cdc_ncm_disconnect(struct usb_interface *intf)
1138 {
1139 	struct usbnet *dev = usb_get_intfdata(intf);
1140 
1141 	if (dev == NULL)
1142 		return;		/* already disconnected */
1143 
1144 	usbnet_disconnect(intf);
1145 }
1146 
1147 static const struct driver_info cdc_ncm_info = {
1148 	.description = "CDC NCM",
1149 	.flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
1150 			| FLAG_LINK_INTR,
1151 	.bind = cdc_ncm_bind,
1152 	.unbind = cdc_ncm_unbind,
1153 	.check_connect = cdc_ncm_check_connect,
1154 	.manage_power = usbnet_manage_power,
1155 	.status = cdc_ncm_status,
1156 	.rx_fixup = cdc_ncm_rx_fixup,
1157 	.tx_fixup = cdc_ncm_tx_fixup,
1158 };
1159 
1160 /* Same as cdc_ncm_info, but with FLAG_WWAN */
1161 static const struct driver_info wwan_info = {
1162 	.description = "Mobile Broadband Network Device",
1163 	.flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
1164 			| FLAG_LINK_INTR | FLAG_WWAN,
1165 	.bind = cdc_ncm_bind,
1166 	.unbind = cdc_ncm_unbind,
1167 	.check_connect = cdc_ncm_check_connect,
1168 	.manage_power = usbnet_manage_power,
1169 	.status = cdc_ncm_status,
1170 	.rx_fixup = cdc_ncm_rx_fixup,
1171 	.tx_fixup = cdc_ncm_tx_fixup,
1172 };
1173 
1174 /* Same as wwan_info, but with FLAG_NOARP  */
1175 static const struct driver_info wwan_noarp_info = {
1176 	.description = "Mobile Broadband Network Device (NO ARP)",
1177 	.flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
1178 			| FLAG_LINK_INTR | FLAG_WWAN | FLAG_NOARP,
1179 	.bind = cdc_ncm_bind,
1180 	.unbind = cdc_ncm_unbind,
1181 	.check_connect = cdc_ncm_check_connect,
1182 	.manage_power = usbnet_manage_power,
1183 	.status = cdc_ncm_status,
1184 	.rx_fixup = cdc_ncm_rx_fixup,
1185 	.tx_fixup = cdc_ncm_tx_fixup,
1186 };
1187 
1188 static const struct usb_device_id cdc_devs[] = {
1189 	/* Ericsson MBM devices like F5521gw */
1190 	{ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
1191 		| USB_DEVICE_ID_MATCH_VENDOR,
1192 	  .idVendor = 0x0bdb,
1193 	  .bInterfaceClass = USB_CLASS_COMM,
1194 	  .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
1195 	  .bInterfaceProtocol = USB_CDC_PROTO_NONE,
1196 	  .driver_info = (unsigned long) &wwan_info,
1197 	},
1198 
1199 	/* Dell branded MBM devices like DW5550 */
1200 	{ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
1201 		| USB_DEVICE_ID_MATCH_VENDOR,
1202 	  .idVendor = 0x413c,
1203 	  .bInterfaceClass = USB_CLASS_COMM,
1204 	  .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
1205 	  .bInterfaceProtocol = USB_CDC_PROTO_NONE,
1206 	  .driver_info = (unsigned long) &wwan_info,
1207 	},
1208 
1209 	/* Toshiba branded MBM devices */
1210 	{ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
1211 		| USB_DEVICE_ID_MATCH_VENDOR,
1212 	  .idVendor = 0x0930,
1213 	  .bInterfaceClass = USB_CLASS_COMM,
1214 	  .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
1215 	  .bInterfaceProtocol = USB_CDC_PROTO_NONE,
1216 	  .driver_info = (unsigned long) &wwan_info,
1217 	},
1218 
1219 	/* tag Huawei devices as wwan */
1220 	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1,
1221 					USB_CLASS_COMM,
1222 					USB_CDC_SUBCLASS_NCM,
1223 					USB_CDC_PROTO_NONE),
1224 	  .driver_info = (unsigned long)&wwan_info,
1225 	},
1226 
1227 	/* Huawei NCM devices disguised as vendor specific */
1228 	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
1229 	  .driver_info = (unsigned long)&wwan_info,
1230 	},
1231 	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
1232 	  .driver_info = (unsigned long)&wwan_info,
1233 	},
1234 	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x76),
1235 	  .driver_info = (unsigned long)&wwan_info,
1236 	},
1237 
1238 	/* Infineon(now Intel) HSPA Modem platform */
1239 	{ USB_DEVICE_AND_INTERFACE_INFO(0x1519, 0x0443,
1240 		USB_CLASS_COMM,
1241 		USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
1242 	  .driver_info = (unsigned long)&wwan_noarp_info,
1243 	},
1244 
1245 	/* Generic CDC-NCM devices */
1246 	{ USB_INTERFACE_INFO(USB_CLASS_COMM,
1247 		USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
1248 		.driver_info = (unsigned long)&cdc_ncm_info,
1249 	},
1250 	{
1251 	},
1252 };
1253 MODULE_DEVICE_TABLE(usb, cdc_devs);
1254 
1255 static struct usb_driver cdc_ncm_driver = {
1256 	.name = "cdc_ncm",
1257 	.id_table = cdc_devs,
1258 	.probe = cdc_ncm_probe,
1259 	.disconnect = cdc_ncm_disconnect,
1260 	.suspend = usbnet_suspend,
1261 	.resume = usbnet_resume,
1262 	.reset_resume =	usbnet_resume,
1263 	.supports_autosuspend = 1,
1264 	.disable_hub_initiated_lpm = 1,
1265 };
1266 
1267 module_usb_driver(cdc_ncm_driver);
1268 
1269 MODULE_AUTHOR("Hans Petter Selasky");
1270 MODULE_DESCRIPTION("USB CDC NCM host driver");
1271 MODULE_LICENSE("Dual BSD/GPL");
1272