cdc_ncm.c 35.0 KB
Newer Older
A
Alexey Orishko 已提交
1 2 3
/*
 * cdc_ncm.c
 *
4
 * Copyright (C) ST-Ericsson 2010-2012
A
Alexey Orishko 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
 * Contact: Alexey Orishko <alexey.orishko@stericsson.com>
 * Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com>
 *
 * USB Host Driver for Network Control Model (NCM)
 * http://www.usb.org/developers/devclass_docs/NCM10.zip
 *
 * The NCM encoding, decoding and initialization logic
 * derives from FreeBSD 8.x. if_cdce.c and if_cdcereg.h
 *
 * This software is available to you under a choice of one of two
 * licenses. You may choose this file to be licensed under the terms
 * of the GNU General Public License (GPL) Version 2 or the 2-clause
 * BSD license listed below:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/ctype.h>
#include <linux/ethtool.h>
#include <linux/workqueue.h>
#include <linux/mii.h>
#include <linux/crc32.h>
#include <linux/usb.h>
50
#include <linux/hrtimer.h>
A
Alexey Orishko 已提交
51 52 53
#include <linux/atomic.h>
#include <linux/usb/usbnet.h>
#include <linux/usb/cdc.h>
54
#include <linux/usb/cdc_ncm.h>
A
Alexey Orishko 已提交
55

56
#define	DRIVER_VERSION				"14-Mar-2012"
A
Alexey Orishko 已提交
57

58 59 60
static void cdc_ncm_txpath_bh(unsigned long param);
static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx);
static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *hr_timer);
A
Alexey Orishko 已提交
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
static struct usb_driver cdc_ncm_driver;

static void
cdc_ncm_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
{
	struct usbnet *dev = netdev_priv(net);

	strncpy(info->driver, dev->driver_name, sizeof(info->driver));
	strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
	strncpy(info->fw_version, dev->driver_info->description,
		sizeof(info->fw_version));
	usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
}

static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
{
	u32 val;
	u8 flags;
	u8 iface_no;
	int err;
81
	int eth_hlen;
82
	u16 ntb_fmt_supported;
83 84
	u32 min_dgram_size;
	u32 min_hdr_size;
85
	struct usbnet *dev = netdev_priv(ctx->netdev);
A
Alexey Orishko 已提交
86 87 88

	iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;

89 90 91 92 93
	err = usbnet_read_cmd(dev, USB_CDC_GET_NTB_PARAMETERS,
			      USB_TYPE_CLASS | USB_DIR_IN
			      |USB_RECIP_INTERFACE,
			      0, iface_no, &ctx->ncm_parm,
			      sizeof(ctx->ncm_parm));
94
	if (err < 0) {
A
Alexey Orishko 已提交
95 96 97 98 99 100 101 102 103 104
		pr_debug("failed GET_NTB_PARAMETERS\n");
		return 1;
	}

	/* read correct set of parameters according to device mode */
	ctx->rx_max = le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize);
	ctx->tx_max = le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize);
	ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder);
	ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor);
	ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment);
105 106 107
	/* devices prior to NCM Errata shall set this field to zero */
	ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams);
	ntb_fmt_supported = le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported);
A
Alexey Orishko 已提交
108

109 110 111 112 113 114 115 116 117
	eth_hlen = ETH_HLEN;
	min_dgram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
	min_hdr_size = CDC_NCM_MIN_HDR_SIZE;
	if (ctx->mbim_desc != NULL) {
		flags = ctx->mbim_desc->bmNetworkCapabilities;
		eth_hlen = 0;
		min_dgram_size = CDC_MBIM_MIN_DATAGRAM_SIZE;
		min_hdr_size = 0;
	} else if (ctx->func_desc != NULL) {
A
Alexey Orishko 已提交
118
		flags = ctx->func_desc->bmNetworkCapabilities;
119
	} else {
A
Alexey Orishko 已提交
120
		flags = 0;
121
	}
A
Alexey Orishko 已提交
122 123 124

	pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u "
		 "wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u "
125
		 "wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n",
A
Alexey Orishko 已提交
126
		 ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus,
127
		 ctx->tx_ndp_modulus, ctx->tx_max_datagrams, flags);
A
Alexey Orishko 已提交
128

129 130 131 132
	/* max count of tx datagrams */
	if ((ctx->tx_max_datagrams == 0) ||
			(ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX))
		ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX;
A
Alexey Orishko 已提交
133 134

	/* verify maximum size of received NTB in bytes */
135 136 137 138 139 140 141
	if (ctx->rx_max < USB_CDC_NCM_NTB_MIN_IN_SIZE) {
		pr_debug("Using min receive length=%d\n",
						USB_CDC_NCM_NTB_MIN_IN_SIZE);
		ctx->rx_max = USB_CDC_NCM_NTB_MIN_IN_SIZE;
	}

	if (ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX) {
A
Alexey Orishko 已提交
142 143 144 145 146
		pr_debug("Using default maximum receive length=%d\n",
						CDC_NCM_NTB_MAX_SIZE_RX);
		ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX;
	}

147 148
	/* inform device about NTB input size changes */
	if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) {
149
		__le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
150

151 152 153 154
		err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_INPUT_SIZE,
				       USB_TYPE_CLASS | USB_DIR_OUT
				       | USB_RECIP_INTERFACE,
				       0, iface_no, &dwNtbInMaxSize, 4);
155
		if (err < 0)
156 157 158
			pr_debug("Setting NTB Input Size failed\n");
	}

A
Alexey Orishko 已提交
159 160
	/* verify maximum size of transmitted NTB in bytes */
	if ((ctx->tx_max <
161
	    (min_hdr_size + min_dgram_size)) ||
A
Alexey Orishko 已提交
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
	    (ctx->tx_max > CDC_NCM_NTB_MAX_SIZE_TX)) {
		pr_debug("Using default maximum transmit length=%d\n",
						CDC_NCM_NTB_MAX_SIZE_TX);
		ctx->tx_max = CDC_NCM_NTB_MAX_SIZE_TX;
	}

	/*
	 * verify that the structure alignment is:
	 * - power of two
	 * - not greater than the maximum transmit length
	 * - not less than four bytes
	 */
	val = ctx->tx_ndp_modulus;

	if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) ||
	    (val != ((-val) & val)) || (val >= ctx->tx_max)) {
		pr_debug("Using default alignment: 4 bytes\n");
		ctx->tx_ndp_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE;
	}

	/*
	 * verify that the payload alignment is:
	 * - power of two
	 * - not greater than the maximum transmit length
	 * - not less than four bytes
	 */
	val = ctx->tx_modulus;

	if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) ||
	    (val != ((-val) & val)) || (val >= ctx->tx_max)) {
		pr_debug("Using default transmit modulus: 4 bytes\n");
		ctx->tx_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE;
	}

	/* verify the payload remainder */
	if (ctx->tx_remainder >= ctx->tx_modulus) {
		pr_debug("Using default transmit remainder: 0 bytes\n");
		ctx->tx_remainder = 0;
	}

	/* adjust TX-remainder according to NCM specification. */
203 204
	ctx->tx_remainder = ((ctx->tx_remainder - eth_hlen) &
			     (ctx->tx_modulus - 1));
A
Alexey Orishko 已提交
205 206 207 208

	/* additional configuration */

	/* set CRC Mode */
209
	if (flags & USB_CDC_NCM_NCAP_CRC_MODE) {
210 211 212 213 214
		err = usbnet_write_cmd(dev, USB_CDC_SET_CRC_MODE,
				       USB_TYPE_CLASS | USB_DIR_OUT
				       | USB_RECIP_INTERFACE,
				       USB_CDC_NCM_CRC_NOT_APPENDED,
				       iface_no, NULL, 0);
215
		if (err < 0)
216 217
			pr_debug("Setting CRC mode off failed\n");
	}
A
Alexey Orishko 已提交
218

219 220
	/* set NTB format, if both formats are supported */
	if (ntb_fmt_supported & USB_CDC_NCM_NTH32_SIGN) {
221 222 223 224 225
		err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT,
				       USB_TYPE_CLASS | USB_DIR_OUT
				       | USB_RECIP_INTERFACE,
				       USB_CDC_NCM_NTB16_FORMAT,
				       iface_no, NULL, 0);
226
		if (err < 0)
227 228
			pr_debug("Setting NTB format to 16-bit failed\n");
	}
A
Alexey Orishko 已提交
229

230
	ctx->max_datagram_size = min_dgram_size;
A
Alexey Orishko 已提交
231 232

	/* set Max Datagram Size (MTU) */
233
	if (flags & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE) {
234
		__le16 max_datagram_size;
235 236 237 238 239 240 241
		u16 eth_max_sz;
		if (ctx->ether_desc != NULL)
			eth_max_sz = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
		else if (ctx->mbim_desc != NULL)
			eth_max_sz = le16_to_cpu(ctx->mbim_desc->wMaxSegmentSize);
		else
			goto max_dgram_err;
242

243 244 245 246
		err = usbnet_read_cmd(dev, USB_CDC_GET_MAX_DATAGRAM_SIZE,
				      USB_TYPE_CLASS | USB_DIR_IN
				      | USB_RECIP_INTERFACE,
				      0, iface_no, &max_datagram_size, 2);
247
		if (err < 0) {
248
			pr_debug("GET_MAX_DATAGRAM_SIZE failed, use size=%u\n",
249
				 min_dgram_size);
250
		} else {
251
			ctx->max_datagram_size =
252
				le16_to_cpu(max_datagram_size);
253
			/* Check Eth descriptor value */
254
			if (ctx->max_datagram_size > eth_max_sz)
255
					ctx->max_datagram_size = eth_max_sz;
256 257

			if (ctx->max_datagram_size > CDC_NCM_MAX_DATAGRAM_SIZE)
258
				ctx->max_datagram_size = CDC_NCM_MAX_DATAGRAM_SIZE;
A
Alexey Orishko 已提交
259

260 261
			if (ctx->max_datagram_size < min_dgram_size)
				ctx->max_datagram_size = min_dgram_size;
262 263

			/* if value changed, update device */
264
			if (ctx->max_datagram_size !=
265 266
					le16_to_cpu(max_datagram_size)) {
				err = usbnet_write_cmd(dev,
267 268 269 270
						USB_CDC_SET_MAX_DATAGRAM_SIZE,
						USB_TYPE_CLASS | USB_DIR_OUT
						 | USB_RECIP_INTERFACE,
						0,
271 272
						iface_no, &max_datagram_size,
						2);
273 274 275
				if (err < 0)
					pr_debug("SET_MAX_DGRAM_SIZE failed\n");
			}
276
		}
A
Alexey Orishko 已提交
277 278
	}

279
max_dgram_err:
280 281
	if (ctx->netdev->mtu != (ctx->max_datagram_size - eth_hlen))
		ctx->netdev->mtu = ctx->max_datagram_size - eth_hlen;
A
Alexey Orishko 已提交
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336

	return 0;
}

static void
cdc_ncm_find_endpoints(struct cdc_ncm_ctx *ctx, struct usb_interface *intf)
{
	struct usb_host_endpoint *e;
	u8 ep;

	for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) {

		e = intf->cur_altsetting->endpoint + ep;
		switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
		case USB_ENDPOINT_XFER_INT:
			if (usb_endpoint_dir_in(&e->desc)) {
				if (ctx->status_ep == NULL)
					ctx->status_ep = e;
			}
			break;

		case USB_ENDPOINT_XFER_BULK:
			if (usb_endpoint_dir_in(&e->desc)) {
				if (ctx->in_ep == NULL)
					ctx->in_ep = e;
			} else {
				if (ctx->out_ep == NULL)
					ctx->out_ep = e;
			}
			break;

		default:
			break;
		}
	}
}

static void cdc_ncm_free(struct cdc_ncm_ctx *ctx)
{
	if (ctx == NULL)
		return;

	if (ctx->tx_rem_skb != NULL) {
		dev_kfree_skb_any(ctx->tx_rem_skb);
		ctx->tx_rem_skb = NULL;
	}

	if (ctx->tx_curr_skb != NULL) {
		dev_kfree_skb_any(ctx->tx_curr_skb);
		ctx->tx_curr_skb = NULL;
	}

	kfree(ctx);
}

337 338 339 340 341 342 343 344 345 346
static const struct ethtool_ops cdc_ncm_ethtool_ops = {
	.get_drvinfo = cdc_ncm_get_drvinfo,
	.get_link = usbnet_get_link,
	.get_msglevel = usbnet_get_msglevel,
	.set_msglevel = usbnet_set_msglevel,
	.get_settings = usbnet_get_settings,
	.set_settings = usbnet_set_settings,
	.nway_reset = usbnet_nway_reset,
};

347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
/* return first slave interface if an IAD matches the given master */
static struct usb_interface *get_iad_slave(struct usb_device *udev,
					   struct usb_interface *master) {
	int i;
	struct usb_interface_assoc_descriptor *iad;
	u8 mnum = master->cur_altsetting->desc.bInterfaceNumber;

	for (i = 0; i < USB_MAXIADS; i++) {
		iad = udev->actconfig->intf_assoc[i];
		if (!iad)
			break;
		if (iad->bFirstInterface == mnum && iad->bInterfaceCount == 2)
			return usb_ifnum_to_if(udev, mnum + 1);
	}
	return NULL;
}

364
int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting)
A
Alexey Orishko 已提交
365 366 367 368 369 370 371 372
{
	struct cdc_ncm_ctx *ctx;
	struct usb_driver *driver;
	u8 *buf;
	int len;
	int temp;
	u8 iface_no;

373
	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
A
Alexey Orishko 已提交
374
	if (ctx == NULL)
375
		return -ENODEV;
A
Alexey Orishko 已提交
376

377 378 379 380 381
	hrtimer_init(&ctx->tx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	ctx->tx_timer.function = &cdc_ncm_tx_timer_cb;
	ctx->bh.data = (unsigned long)ctx;
	ctx->bh.func = cdc_ncm_txpath_bh;
	atomic_set(&ctx->stop, 0);
A
Alexey Orishko 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
	spin_lock_init(&ctx->mtx);
	ctx->netdev = dev->net;

	/* store ctx pointer in device data field */
	dev->data[0] = (unsigned long)ctx;

	/* get some pointers */
	driver = driver_of(intf);
	buf = intf->cur_altsetting->extra;
	len = intf->cur_altsetting->extralen;

	ctx->udev = dev->udev;
	ctx->intf = intf;

	/* parse through descriptors associated with control interface */
	while ((len > 0) && (buf[0] > 2) && (buf[0] <= len)) {

		if (buf[1] != USB_DT_CS_INTERFACE)
			goto advance;

		switch (buf[2]) {
		case USB_CDC_UNION_TYPE:
			if (buf[0] < sizeof(*(ctx->union_desc)))
				break;

			ctx->union_desc =
					(const struct usb_cdc_union_desc *)buf;

			ctx->control = usb_ifnum_to_if(dev->udev,
					ctx->union_desc->bMasterInterface0);
			ctx->data = usb_ifnum_to_if(dev->udev,
					ctx->union_desc->bSlaveInterface0);
			break;

		case USB_CDC_ETHERNET_TYPE:
			if (buf[0] < sizeof(*(ctx->ether_desc)))
				break;

			ctx->ether_desc =
					(const struct usb_cdc_ether_desc *)buf;
			dev->hard_mtu =
				le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);

425 426 427 428
			if (dev->hard_mtu < CDC_NCM_MIN_DATAGRAM_SIZE)
				dev->hard_mtu =	CDC_NCM_MIN_DATAGRAM_SIZE;
			else if (dev->hard_mtu > CDC_NCM_MAX_DATAGRAM_SIZE)
				dev->hard_mtu =	CDC_NCM_MAX_DATAGRAM_SIZE;
A
Alexey Orishko 已提交
429 430 431 432 433 434 435 436 437
			break;

		case USB_CDC_NCM_TYPE:
			if (buf[0] < sizeof(*(ctx->func_desc)))
				break;

			ctx->func_desc = (const struct usb_cdc_ncm_desc *)buf;
			break;

438 439 440 441 442 443 444
		case USB_CDC_MBIM_TYPE:
			if (buf[0] < sizeof(*(ctx->mbim_desc)))
				break;

			ctx->mbim_desc = (const struct usb_cdc_mbim_desc *)buf;
			break;

A
Alexey Orishko 已提交
445 446 447 448 449 450 451 452 453 454
		default:
			break;
		}
advance:
		/* advance to next descriptor */
		temp = buf[0];
		buf += temp;
		len -= temp;
	}

455 456 457 458 459 460 461 462 463 464
	/* some buggy devices have an IAD but no CDC Union */
	if (!ctx->union_desc) {
		dev_dbg(&intf->dev, "missing CDC Union descriptor\n");
		ctx->data = get_iad_slave(dev->udev, intf);
		if (ctx->data) {
			ctx->control = intf;
			dev_dbg(&intf->dev, "got slave from IAD\n");
		}
	}

A
Alexey Orishko 已提交
465 466
	/* check if we got everything */
	if ((ctx->control == NULL) || (ctx->data == NULL) ||
467
	    ((!ctx->mbim_desc) && ((ctx->ether_desc == NULL) || (ctx->control != intf))))
A
Alexey Orishko 已提交
468 469
		goto error;

B
Bjørn Mork 已提交
470 471 472 473 474 475
	/* claim data interface, if different from control */
	if (ctx->data != ctx->control) {
		temp = usb_driver_claim_interface(driver, ctx->data, dev);
		if (temp)
			goto error;
	}
A
Alexey Orishko 已提交
476 477 478 479 480 481

	iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber;

	/* reset data interface */
	temp = usb_set_interface(dev->udev, iface_no, 0);
	if (temp)
482
		goto error2;
A
Alexey Orishko 已提交
483 484 485

	/* initialize data interface */
	if (cdc_ncm_setup(ctx))
486
		goto error2;
A
Alexey Orishko 已提交
487 488

	/* configure data interface */
489
	temp = usb_set_interface(dev->udev, iface_no, data_altsetting);
A
Alexey Orishko 已提交
490
	if (temp)
491
		goto error2;
A
Alexey Orishko 已提交
492 493 494 495 496 497

	cdc_ncm_find_endpoints(ctx, ctx->data);
	cdc_ncm_find_endpoints(ctx, ctx->control);

	if ((ctx->in_ep == NULL) || (ctx->out_ep == NULL) ||
	    (ctx->status_ep == NULL))
498
		goto error2;
A
Alexey Orishko 已提交
499 500 501 502 503 504 505

	dev->net->ethtool_ops = &cdc_ncm_ethtool_ops;

	usb_set_intfdata(ctx->data, dev);
	usb_set_intfdata(ctx->control, dev);
	usb_set_intfdata(ctx->intf, dev);

506 507 508 509 510 511
	if (ctx->ether_desc) {
		temp = usbnet_get_ethernet_addr(dev, ctx->ether_desc->iMACAddress);
		if (temp)
			goto error2;
		dev_info(&dev->udev->dev, "MAC-Address: %pM\n", dev->net->dev_addr);
	}
A
Alexey Orishko 已提交
512 513 514 515 516 517 518 519 520 521 522 523


	dev->in = usb_rcvbulkpipe(dev->udev,
		ctx->in_ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	dev->out = usb_sndbulkpipe(dev->udev,
		ctx->out_ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	dev->status = ctx->status_ep;
	dev->rx_urb_size = ctx->rx_max;

	ctx->tx_speed = ctx->rx_speed = 0;
	return 0;

524 525 526
error2:
	usb_set_intfdata(ctx->control, NULL);
	usb_set_intfdata(ctx->data, NULL);
527 528
	if (ctx->data != ctx->control)
		usb_driver_release_interface(driver, ctx->data);
A
Alexey Orishko 已提交
529 530 531
error:
	cdc_ncm_free((struct cdc_ncm_ctx *)dev->data[0]);
	dev->data[0] = 0;
532
	dev_info(&dev->udev->dev, "bind() failure\n");
A
Alexey Orishko 已提交
533 534
	return -ENODEV;
}
535
EXPORT_SYMBOL_GPL(cdc_ncm_bind_common);
A
Alexey Orishko 已提交
536

537
void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf)
A
Alexey Orishko 已提交
538 539
{
	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
540
	struct usb_driver *driver = driver_of(intf);
A
Alexey Orishko 已提交
541 542 543 544

	if (ctx == NULL)
		return;		/* no setup */

545 546 547 548 549 550 551
	atomic_set(&ctx->stop, 1);

	if (hrtimer_active(&ctx->tx_timer))
		hrtimer_cancel(&ctx->tx_timer);

	tasklet_kill(&ctx->bh);

B
Bjørn Mork 已提交
552 553 554 555
	/* handle devices with combined control and data interface */
	if (ctx->control == ctx->data)
		ctx->data = NULL;

556 557 558
	/* disconnect master --> disconnect slave */
	if (intf == ctx->control && ctx->data) {
		usb_set_intfdata(ctx->data, NULL);
A
Alexey Orishko 已提交
559
		usb_driver_release_interface(driver, ctx->data);
560
		ctx->data = NULL;
A
Alexey Orishko 已提交
561

562 563
	} else if (intf == ctx->data && ctx->control) {
		usb_set_intfdata(ctx->control, NULL);
A
Alexey Orishko 已提交
564
		usb_driver_release_interface(driver, ctx->control);
565
		ctx->control = NULL;
A
Alexey Orishko 已提交
566 567
	}

568
	usb_set_intfdata(ctx->intf, NULL);
A
Alexey Orishko 已提交
569 570
	cdc_ncm_free(ctx);
}
571
EXPORT_SYMBOL_GPL(cdc_ncm_unbind);
A
Alexey Orishko 已提交
572

573 574 575 576
static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf)
{
	int ret;

577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
	/* The MBIM spec defines a NCM compatible default altsetting,
	 * which we may have matched:
	 *
	 *  "Functions that implement both NCM 1.0 and MBIM (an
	 *   “NCM/MBIM function”) according to this recommendation
	 *   shall provide two alternate settings for the
	 *   Communication Interface.  Alternate setting 0, and the
	 *   associated class and endpoint descriptors, shall be
	 *   constructed according to the rules given for the
	 *   Communication Interface in section 5 of [USBNCM10].
	 *   Alternate setting 1, and the associated class and
	 *   endpoint descriptors, shall be constructed according to
	 *   the rules given in section 6 (USB Device Model) of this
	 *   specification."
	 *
	 * Do not bind to such interfaces, allowing cdc_mbim to handle
	 * them
	 */
#if IS_ENABLED(CONFIG_USB_NET_CDC_MBIM)
	if ((intf->num_altsetting == 2) &&
	    !usb_set_interface(dev->udev,
			       intf->cur_altsetting->desc.bInterfaceNumber,
			       CDC_NCM_COMM_ALTSETTING_MBIM) &&
	    cdc_ncm_comm_intf_is_mbim(intf->cur_altsetting))
		return -ENODEV;
#endif

604 605 606 607 608 609 610 611 612 613 614 615 616
	/* NCM data altsetting is always 1 */
	ret = cdc_ncm_bind_common(dev, intf, 1);

	/*
	 * We should get an event when network connection is "connected" or
	 * "disconnected". Set network connection in "disconnected" state
	 * (carrier is OFF) during attach, so the IP network stack does not
	 * start IPv6 negotiation and more.
	 */
	netif_carrier_off(dev->net);
	return ret;
}

617
static void cdc_ncm_align_tail(struct sk_buff *skb, size_t modulus, size_t remainder, size_t max)
A
Alexey Orishko 已提交
618
{
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
	size_t align = ALIGN(skb->len, modulus) - skb->len + remainder;

	if (skb->len + align > max)
		align = max - skb->len;
	if (align && skb_tailroom(skb) >= align)
		memset(skb_put(skb, align), 0, align);
}

/* return a pointer to a valid struct usb_cdc_ncm_ndp16 of type sign, possibly
 * allocating a new one within skb
 */
static struct usb_cdc_ncm_ndp16 *cdc_ncm_ndp(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign, size_t reserve)
{
	struct usb_cdc_ncm_ndp16 *ndp16 = NULL;
	struct usb_cdc_ncm_nth16 *nth16 = (void *)skb->data;
	size_t ndpoffset = le16_to_cpu(nth16->wNdpIndex);

	/* follow the chain of NDPs, looking for a match */
	while (ndpoffset) {
		ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb->data + ndpoffset);
		if  (ndp16->dwSignature == sign)
			return ndp16;
		ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex);
	}

	/* align new NDP */
	cdc_ncm_align_tail(skb, ctx->tx_ndp_modulus, 0, ctx->tx_max);

	/* verify that there is room for the NDP and the datagram (reserve) */
	if ((ctx->tx_max - skb->len - reserve) < CDC_NCM_NDP_SIZE)
		return NULL;

	/* link to it */
	if (ndp16)
		ndp16->wNextNdpIndex = cpu_to_le16(skb->len);
	else
		nth16->wNdpIndex = cpu_to_le16(skb->len);

	/* push a new empty NDP */
	ndp16 = (struct usb_cdc_ncm_ndp16 *)memset(skb_put(skb, CDC_NCM_NDP_SIZE), 0, CDC_NCM_NDP_SIZE);
	ndp16->dwSignature = sign;
	ndp16->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp16) + sizeof(struct usb_cdc_ncm_dpe16));
	return ndp16;
A
Alexey Orishko 已提交
662 663
}

664
struct sk_buff *
665
cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb, __le32 sign)
A
Alexey Orishko 已提交
666
{
667 668
	struct usb_cdc_ncm_nth16 *nth16;
	struct usb_cdc_ncm_ndp16 *ndp16;
A
Alexey Orishko 已提交
669
	struct sk_buff *skb_out;
670
	u16 n = 0, index, ndplen;
671
	u8 ready2send = 0;
A
Alexey Orishko 已提交
672 673

	/* if there is a remaining skb, it gets priority */
674
	if (skb != NULL) {
A
Alexey Orishko 已提交
675
		swap(skb, ctx->tx_rem_skb);
676 677
		swap(sign, ctx->tx_rem_sign);
	} else {
678
		ready2send = 1;
679
	}
A
Alexey Orishko 已提交
680 681

	/* check if we are resuming an OUT skb */
682
	skb_out = ctx->tx_curr_skb;
A
Alexey Orishko 已提交
683

684 685
	/* allocate a new OUT skb */
	if (!skb_out) {
686
		skb_out = alloc_skb((ctx->tx_max + 1), GFP_ATOMIC);
A
Alexey Orishko 已提交
687 688 689 690 691 692 693
		if (skb_out == NULL) {
			if (skb != NULL) {
				dev_kfree_skb_any(skb);
				ctx->netdev->stats.tx_dropped++;
			}
			goto exit_no_skb;
		}
694 695 696 697 698
		/* fill out the initial 16-bit NTB header */
		nth16 = (struct usb_cdc_ncm_nth16 *)memset(skb_put(skb_out, sizeof(struct usb_cdc_ncm_nth16)), 0, sizeof(struct usb_cdc_ncm_nth16));
		nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN);
		nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16));
		nth16->wSequence = cpu_to_le16(ctx->tx_seq++);
A
Alexey Orishko 已提交
699

700
		/* count total number of frames in this NTB */
A
Alexey Orishko 已提交
701 702 703
		ctx->tx_curr_frame_num = 0;
	}

704 705
	for (n = ctx->tx_curr_frame_num; n < ctx->tx_max_datagrams; n++) {
		/* send any remaining skb first */
A
Alexey Orishko 已提交
706 707
		if (skb == NULL) {
			skb = ctx->tx_rem_skb;
708
			sign = ctx->tx_rem_sign;
A
Alexey Orishko 已提交
709 710 711 712 713 714 715
			ctx->tx_rem_skb = NULL;

			/* check for end of skb */
			if (skb == NULL)
				break;
		}

716 717 718 719 720 721 722 723
		/* get the appropriate NDP for this skb */
		ndp16 = cdc_ncm_ndp(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder);

		/* align beginning of next frame */
		cdc_ncm_align_tail(skb_out,  ctx->tx_modulus, ctx->tx_remainder, ctx->tx_max);

		/* check if we had enough room left for both NDP and frame */
		if (!ndp16 || skb_out->len + skb->len > ctx->tx_max) {
A
Alexey Orishko 已提交
724 725 726 727 728 729 730 731 732 733 734 735
			if (n == 0) {
				/* won't fit, MTU problem? */
				dev_kfree_skb_any(skb);
				skb = NULL;
				ctx->netdev->stats.tx_dropped++;
			} else {
				/* no room for skb - store for later */
				if (ctx->tx_rem_skb != NULL) {
					dev_kfree_skb_any(ctx->tx_rem_skb);
					ctx->netdev->stats.tx_dropped++;
				}
				ctx->tx_rem_skb = skb;
736
				ctx->tx_rem_sign = sign;
A
Alexey Orishko 已提交
737
				skb = NULL;
738
				ready2send = 1;
A
Alexey Orishko 已提交
739 740 741 742
			}
			break;
		}

743 744 745
		/* calculate frame number withing this NDP */
		ndplen = le16_to_cpu(ndp16->wLength);
		index = (ndplen - sizeof(struct usb_cdc_ncm_ndp16)) / sizeof(struct usb_cdc_ncm_dpe16) - 1;
A
Alexey Orishko 已提交
746

747 748 749 750 751
		/* OK, add this skb */
		ndp16->dpe16[index].wDatagramLength = cpu_to_le16(skb->len);
		ndp16->dpe16[index].wDatagramIndex = cpu_to_le16(skb_out->len);
		ndp16->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe16));
		memcpy(skb_put(skb_out, skb->len), skb->data, skb->len);
A
Alexey Orishko 已提交
752 753
		dev_kfree_skb_any(skb);
		skb = NULL;
754 755 756 757 758 759

		/* send now if this NDP is full */
		if (index >= CDC_NCM_DPT_DATAGRAMS_MAX) {
			ready2send = 1;
			break;
		}
A
Alexey Orishko 已提交
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
	}

	/* free up any dangling skb */
	if (skb != NULL) {
		dev_kfree_skb_any(skb);
		skb = NULL;
		ctx->netdev->stats.tx_dropped++;
	}

	ctx->tx_curr_frame_num = n;

	if (n == 0) {
		/* wait for more frames */
		/* push variables */
		ctx->tx_curr_skb = skb_out;
		goto exit_no_skb;

777
	} else if ((n < ctx->tx_max_datagrams) && (ready2send == 0)) {
A
Alexey Orishko 已提交
778 779 780 781 782
		/* wait for more frames */
		/* push variables */
		ctx->tx_curr_skb = skb_out;
		/* set the pending count */
		if (n < CDC_NCM_RESTART_TIMER_DATAGRAM_CNT)
783
			ctx->tx_timer_pending = CDC_NCM_TIMER_PENDING_CNT;
A
Alexey Orishko 已提交
784 785 786 787 788 789 790 791 792 793 794 795 796
		goto exit_no_skb;

	} else {
		/* frame goes out */
		/* variables will be reset at next call */
	}

	/*
	 * If collected data size is less or equal CDC_NCM_MIN_TX_PKT bytes,
	 * we send buffers as it is. If we get more data, it would be more
	 * efficient for USB HS mobile device with DMA engine to receive a full
	 * size NTB, than canceling DMA transfer and receiving a short packet.
	 */
797 798 799
	if (skb_out->len > CDC_NCM_MIN_TX_PKT)
		/* final zero padding */
		memset(skb_put(skb_out, ctx->tx_max - skb_out->len), 0, ctx->tx_max - skb_out->len);
A
Alexey Orishko 已提交
800

801 802 803 804
	/* do we need to prevent a ZLP? */
	if (((skb_out->len % le16_to_cpu(ctx->out_ep->desc.wMaxPacketSize)) == 0) &&
	    (skb_out->len < le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize)) && skb_tailroom(skb_out))
		*skb_put(skb_out, 1) = 0;	/* force short packet */
A
Alexey Orishko 已提交
805

806 807 808
	/* set final frame length */
	nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data;
	nth16->wBlockLength = cpu_to_le16(skb_out->len);
A
Alexey Orishko 已提交
809 810 811

	/* return skb */
	ctx->tx_curr_skb = NULL;
812
	ctx->netdev->stats.tx_packets += ctx->tx_curr_frame_num;
A
Alexey Orishko 已提交
813 814 815
	return skb_out;

exit_no_skb:
816 817 818
	/* Start timer, if there is a remaining skb */
	if (ctx->tx_curr_skb != NULL)
		cdc_ncm_tx_timeout_start(ctx);
A
Alexey Orishko 已提交
819 820
	return NULL;
}
821
EXPORT_SYMBOL_GPL(cdc_ncm_fill_tx_frame);
A
Alexey Orishko 已提交
822 823 824 825

static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx)
{
	/* start timer, if not already started */
826 827 828 829
	if (!(hrtimer_active(&ctx->tx_timer) || atomic_read(&ctx->stop)))
		hrtimer_start(&ctx->tx_timer,
				ktime_set(0, CDC_NCM_TIMER_INTERVAL),
				HRTIMER_MODE_REL);
A
Alexey Orishko 已提交
830 831
}

832
static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *timer)
A
Alexey Orishko 已提交
833
{
834 835
	struct cdc_ncm_ctx *ctx =
			container_of(timer, struct cdc_ncm_ctx, tx_timer);
A
Alexey Orishko 已提交
836

837 838 839 840
	if (!atomic_read(&ctx->stop))
		tasklet_schedule(&ctx->bh);
	return HRTIMER_NORESTART;
}
A
Alexey Orishko 已提交
841

842 843 844
static void cdc_ncm_txpath_bh(unsigned long param)
{
	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)param;
A
Alexey Orishko 已提交
845

846 847 848
	spin_lock_bh(&ctx->mtx);
	if (ctx->tx_timer_pending != 0) {
		ctx->tx_timer_pending--;
A
Alexey Orishko 已提交
849
		cdc_ncm_tx_timeout_start(ctx);
850
		spin_unlock_bh(&ctx->mtx);
851
	} else if (ctx->netdev != NULL) {
852 853
		spin_unlock_bh(&ctx->mtx);
		netif_tx_lock_bh(ctx->netdev);
A
Alexey Orishko 已提交
854
		usbnet_start_xmit(NULL, ctx->netdev);
855
		netif_tx_unlock_bh(ctx->netdev);
B
Bjørn Mork 已提交
856 857
	} else {
		spin_unlock_bh(&ctx->mtx);
858
	}
A
Alexey Orishko 已提交
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
}

static struct sk_buff *
cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
{
	struct sk_buff *skb_out;
	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];

	/*
	 * The Ethernet API we are using does not support transmitting
	 * multiple Ethernet frames in a single call. This driver will
	 * accumulate multiple Ethernet frames and send out a larger
	 * USB frame when the USB buffer is full or when a single jiffies
	 * timeout happens.
	 */
	if (ctx == NULL)
		goto error;

877
	spin_lock_bh(&ctx->mtx);
878
	skb_out = cdc_ncm_fill_tx_frame(ctx, skb, cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN));
879
	spin_unlock_bh(&ctx->mtx);
A
Alexey Orishko 已提交
880 881 882 883 884 885 886 887 888
	return skb_out;

error:
	if (skb != NULL)
		dev_kfree_skb_any(skb);

	return NULL;
}

889
/* verify NTB header and return offset of first NDP, or negative error */
890
int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in)
A
Alexey Orishko 已提交
891
{
892
	struct usb_cdc_ncm_nth16 *nth16;
893 894
	int len;
	int ret = -EINVAL;
A
Alexey Orishko 已提交
895 896 897 898

	if (ctx == NULL)
		goto error;

899 900
	if (skb_in->len < (sizeof(struct usb_cdc_ncm_nth16) +
					sizeof(struct usb_cdc_ncm_ndp16))) {
A
Alexey Orishko 已提交
901 902 903 904
		pr_debug("frame too short\n");
		goto error;
	}

905
	nth16 = (struct usb_cdc_ncm_nth16 *)skb_in->data;
A
Alexey Orishko 已提交
906

907
	if (le32_to_cpu(nth16->dwSignature) != USB_CDC_NCM_NTH16_SIGN) {
A
Alexey Orishko 已提交
908
		pr_debug("invalid NTH16 signature <%u>\n",
909
					le32_to_cpu(nth16->dwSignature));
A
Alexey Orishko 已提交
910 911 912
		goto error;
	}

913 914 915 916
	len = le16_to_cpu(nth16->wBlockLength);
	if (len > ctx->rx_max) {
		pr_debug("unsupported NTB block length %u/%u\n", len,
								ctx->rx_max);
A
Alexey Orishko 已提交
917 918 919
		goto error;
	}

920 921 922 923 924 925 926 927
	if ((ctx->rx_seq + 1) != le16_to_cpu(nth16->wSequence) &&
		(ctx->rx_seq || le16_to_cpu(nth16->wSequence)) &&
		!((ctx->rx_seq == 0xffff) && !le16_to_cpu(nth16->wSequence))) {
		pr_debug("sequence number glitch prev=%d curr=%d\n",
				ctx->rx_seq, le16_to_cpu(nth16->wSequence));
	}
	ctx->rx_seq = le16_to_cpu(nth16->wSequence);

928 929 930 931
	ret = le16_to_cpu(nth16->wNdpIndex);
error:
	return ret;
}
932
EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_nth16);
933 934

/* verify NDP header and return number of datagrams, or negative error */
935
int cdc_ncm_rx_verify_ndp16(struct sk_buff *skb_in, int ndpoffset)
936 937 938 939
{
	struct usb_cdc_ncm_ndp16 *ndp16;
	int ret = -EINVAL;

B
Bjørn Mork 已提交
940 941
	if ((ndpoffset + sizeof(struct usb_cdc_ncm_ndp16)) > skb_in->len) {
		pr_debug("invalid NDP offset  <%u>\n", ndpoffset);
A
Alexey Orishko 已提交
942 943
		goto error;
	}
B
Bjørn Mork 已提交
944
	ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset);
A
Alexey Orishko 已提交
945

946
	if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) {
A
Alexey Orishko 已提交
947
		pr_debug("invalid DPT16 length <%u>\n",
948
					le32_to_cpu(ndp16->dwSignature));
949
		goto error;
A
Alexey Orishko 已提交
950 951
	}

952
	ret = ((le16_to_cpu(ndp16->wLength) -
A
Alexey Orishko 已提交
953 954
					sizeof(struct usb_cdc_ncm_ndp16)) /
					sizeof(struct usb_cdc_ncm_dpe16));
955
	ret--; /* we process NDP entries except for the last one */
A
Alexey Orishko 已提交
956

957
	if ((sizeof(struct usb_cdc_ncm_ndp16) + ret * (sizeof(struct usb_cdc_ncm_dpe16))) >
958
								skb_in->len) {
959 960
		pr_debug("Invalid nframes = %d\n", ret);
		ret = -EINVAL;
A
Alexey Orishko 已提交
961 962
	}

963 964 965
error:
	return ret;
}
966
EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp16);
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997

static int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
{
	struct sk_buff *skb;
	struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
	int len;
	int nframes;
	int x;
	int offset;
	struct usb_cdc_ncm_ndp16 *ndp16;
	struct usb_cdc_ncm_dpe16 *dpe16;
	int ndpoffset;
	int loopcount = 50; /* arbitrary max preventing infinite loop */

	ndpoffset = cdc_ncm_rx_verify_nth16(ctx, skb_in);
	if (ndpoffset < 0)
		goto error;

next_ndp:
	nframes = cdc_ncm_rx_verify_ndp16(skb_in, ndpoffset);
	if (nframes < 0)
		goto error;

	ndp16 = (struct usb_cdc_ncm_ndp16 *)(skb_in->data + ndpoffset);

	if (le32_to_cpu(ndp16->dwSignature) != USB_CDC_NCM_NDP16_NOCRC_SIGN) {
		pr_debug("invalid DPT16 signature <%u>\n",
			 le32_to_cpu(ndp16->dwSignature));
		goto err_ndp;
	}
	dpe16 = ndp16->dpe16;
A
Alexey Orishko 已提交
998

999 1000 1001
	for (x = 0; x < nframes; x++, dpe16++) {
		offset = le16_to_cpu(dpe16->wDatagramIndex);
		len = le16_to_cpu(dpe16->wDatagramLength);
A
Alexey Orishko 已提交
1002 1003 1004 1005 1006

		/*
		 * CDC NCM ch. 3.7
		 * All entries after first NULL entry are to be ignored
		 */
1007
		if ((offset == 0) || (len == 0)) {
A
Alexey Orishko 已提交
1008
			if (!x)
B
Bjørn Mork 已提交
1009
				goto err_ndp; /* empty NTB */
A
Alexey Orishko 已提交
1010 1011 1012 1013
			break;
		}

		/* sanity checking */
1014 1015
		if (((offset + len) > skb_in->len) ||
				(len > ctx->rx_max) || (len < ETH_HLEN)) {
A
Alexey Orishko 已提交
1016
			pr_debug("invalid frame detected (ignored)"
1017
					"offset[%u]=%u, length=%u, skb=%p\n",
1018
					x, offset, len, skb_in);
A
Alexey Orishko 已提交
1019
			if (!x)
B
Bjørn Mork 已提交
1020
				goto err_ndp;
A
Alexey Orishko 已提交
1021 1022 1023 1024
			break;

		} else {
			skb = skb_clone(skb_in, GFP_ATOMIC);
1025 1026
			if (!skb)
				goto error;
1027
			skb->len = len;
A
Alexey Orishko 已提交
1028
			skb->data = ((u8 *)skb_in->data) + offset;
1029
			skb_set_tail_pointer(skb, len);
A
Alexey Orishko 已提交
1030 1031 1032
			usbnet_skb_return(dev, skb);
		}
	}
B
Bjørn Mork 已提交
1033 1034 1035 1036 1037 1038
err_ndp:
	/* are there more NDPs to process? */
	ndpoffset = le16_to_cpu(ndp16->wNextNdpIndex);
	if (ndpoffset && loopcount--)
		goto next_ndp;

A
Alexey Orishko 已提交
1039 1040 1041 1042 1043 1044 1045
	return 1;
error:
	return 0;
}

static void
cdc_ncm_speed_change(struct cdc_ncm_ctx *ctx,
1046
		     struct usb_cdc_speed_change *data)
A
Alexey Orishko 已提交
1047
{
1048 1049
	uint32_t rx_speed = le32_to_cpu(data->DLBitRRate);
	uint32_t tx_speed = le32_to_cpu(data->ULBitRate);
A
Alexey Orishko 已提交
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089

	/*
	 * Currently the USB-NET API does not support reporting the actual
	 * device speed. Do print it instead.
	 */
	if ((tx_speed != ctx->tx_speed) || (rx_speed != ctx->rx_speed)) {
		ctx->tx_speed = tx_speed;
		ctx->rx_speed = rx_speed;

		if ((tx_speed > 1000000) && (rx_speed > 1000000)) {
			printk(KERN_INFO KBUILD_MODNAME
				": %s: %u mbit/s downlink "
				"%u mbit/s uplink\n",
				ctx->netdev->name,
				(unsigned int)(rx_speed / 1000000U),
				(unsigned int)(tx_speed / 1000000U));
		} else {
			printk(KERN_INFO KBUILD_MODNAME
				": %s: %u kbit/s downlink "
				"%u kbit/s uplink\n",
				ctx->netdev->name,
				(unsigned int)(rx_speed / 1000U),
				(unsigned int)(tx_speed / 1000U));
		}
	}
}

static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
{
	struct cdc_ncm_ctx *ctx;
	struct usb_cdc_notification *event;

	ctx = (struct cdc_ncm_ctx *)dev->data[0];

	if (urb->actual_length < sizeof(*event))
		return;

	/* test for split data in 8-byte chunks */
	if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
		cdc_ncm_speed_change(ctx,
1090
		      (struct usb_cdc_speed_change *)urb->transfer_buffer);
A
Alexey Orishko 已提交
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
		return;
	}

	event = urb->transfer_buffer;

	switch (event->bNotificationType) {
	case USB_CDC_NOTIFY_NETWORK_CONNECTION:
		/*
		 * According to the CDC NCM specification ch.7.1
		 * USB_CDC_NOTIFY_NETWORK_CONNECTION notification shall be
		 * sent by device after USB_CDC_NOTIFY_SPEED_CHANGE.
		 */
B
Bjørn Mork 已提交
1103
		ctx->connected = le16_to_cpu(event->wValue);
A
Alexey Orishko 已提交
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117

		printk(KERN_INFO KBUILD_MODNAME ": %s: network connection:"
			" %sconnected\n",
			ctx->netdev->name, ctx->connected ? "" : "dis");

		if (ctx->connected)
			netif_carrier_on(dev->net);
		else {
			netif_carrier_off(dev->net);
			ctx->tx_speed = ctx->rx_speed = 0;
		}
		break;

	case USB_CDC_NOTIFY_SPEED_CHANGE:
1118 1119
		if (urb->actual_length < (sizeof(*event) +
					sizeof(struct usb_cdc_speed_change)))
A
Alexey Orishko 已提交
1120 1121 1122
			set_bit(EVENT_STS_SPLIT, &dev->flags);
		else
			cdc_ncm_speed_change(ctx,
1123
				(struct usb_cdc_speed_change *) &event[1]);
A
Alexey Orishko 已提交
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
		break;

	default:
		dev_err(&dev->udev->dev, "NCM: unexpected "
			"notification 0x%02x!\n", event->bNotificationType);
		break;
	}
}

static int cdc_ncm_check_connect(struct usbnet *dev)
{
	struct cdc_ncm_ctx *ctx;

	ctx = (struct cdc_ncm_ctx *)dev->data[0];
	if (ctx == NULL)
		return 1;	/* disconnected */

	return !ctx->connected;
}

static int
cdc_ncm_probe(struct usb_interface *udev, const struct usb_device_id *prod)
{
	return usbnet_probe(udev, prod);
}

static void cdc_ncm_disconnect(struct usb_interface *intf)
{
	struct usbnet *dev = usb_get_intfdata(intf);

	if (dev == NULL)
		return;		/* already disconnected */

	usbnet_disconnect(intf);
}

static const struct driver_info cdc_ncm_info = {
	.description = "CDC NCM",
1162
	.flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET,
A
Alexey Orishko 已提交
1163 1164 1165
	.bind = cdc_ncm_bind,
	.unbind = cdc_ncm_unbind,
	.check_connect = cdc_ncm_check_connect,
O
Oliver Neukum 已提交
1166
	.manage_power = usbnet_manage_power,
A
Alexey Orishko 已提交
1167 1168 1169 1170 1171
	.status = cdc_ncm_status,
	.rx_fixup = cdc_ncm_rx_fixup,
	.tx_fixup = cdc_ncm_tx_fixup,
};

1172 1173 1174 1175 1176 1177 1178 1179
/* Same as cdc_ncm_info, but with FLAG_WWAN */
static const struct driver_info wwan_info = {
	.description = "Mobile Broadband Network Device",
	.flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET
			| FLAG_WWAN,
	.bind = cdc_ncm_bind,
	.unbind = cdc_ncm_unbind,
	.check_connect = cdc_ncm_check_connect,
O
Oliver Neukum 已提交
1180
	.manage_power = usbnet_manage_power,
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
	.status = cdc_ncm_status,
	.rx_fixup = cdc_ncm_rx_fixup,
	.tx_fixup = cdc_ncm_tx_fixup,
};

static const struct usb_device_id cdc_devs[] = {
	/* Ericsson MBM devices like F5521gw */
	{ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
		| USB_DEVICE_ID_MATCH_VENDOR,
	  .idVendor = 0x0bdb,
	  .bInterfaceClass = USB_CLASS_COMM,
	  .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
	  .bInterfaceProtocol = USB_CDC_PROTO_NONE,
	  .driver_info = (unsigned long) &wwan_info,
	},

1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
	/* Dell branded MBM devices like DW5550 */
	{ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
		| USB_DEVICE_ID_MATCH_VENDOR,
	  .idVendor = 0x413c,
	  .bInterfaceClass = USB_CLASS_COMM,
	  .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
	  .bInterfaceProtocol = USB_CDC_PROTO_NONE,
	  .driver_info = (unsigned long) &wwan_info,
	},

	/* Toshiba branded MBM devices */
	{ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
		| USB_DEVICE_ID_MATCH_VENDOR,
	  .idVendor = 0x0930,
	  .bInterfaceClass = USB_CLASS_COMM,
	  .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
	  .bInterfaceProtocol = USB_CDC_PROTO_NONE,
	  .driver_info = (unsigned long) &wwan_info,
	},

B
Bjørn Mork 已提交
1217 1218 1219 1220 1221 1222 1223 1224
	/* Huawei NCM devices disguised as vendor specific */
	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
	  .driver_info = (unsigned long)&wwan_info,
	},
	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
	  .driver_info = (unsigned long)&wwan_info,
	},

1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
	/* Generic CDC-NCM devices */
	{ USB_INTERFACE_INFO(USB_CLASS_COMM,
		USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
		.driver_info = (unsigned long)&cdc_ncm_info,
	},
	{
	},
};
MODULE_DEVICE_TABLE(usb, cdc_devs);

A
Alexey Orishko 已提交
1235 1236 1237 1238 1239 1240 1241
static struct usb_driver cdc_ncm_driver = {
	.name = "cdc_ncm",
	.id_table = cdc_devs,
	.probe = cdc_ncm_probe,
	.disconnect = cdc_ncm_disconnect,
	.suspend = usbnet_suspend,
	.resume = usbnet_resume,
1242
	.reset_resume =	usbnet_resume,
A
Alexey Orishko 已提交
1243
	.supports_autosuspend = 1,
1244
	.disable_hub_initiated_lpm = 1,
A
Alexey Orishko 已提交
1245 1246
};

1247
module_usb_driver(cdc_ncm_driver);
A
Alexey Orishko 已提交
1248 1249 1250 1251

MODULE_AUTHOR("Hans Petter Selasky");
MODULE_DESCRIPTION("USB CDC NCM host driver");
MODULE_LICENSE("Dual BSD/GPL");