Linux Audio

Check our new training course

Loading...
v6.8
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * f_ncm.c -- USB CDC Network (NCM) link function driver
   4 *
   5 * Copyright (C) 2010 Nokia Corporation
   6 * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
   7 *
   8 * The driver borrows from f_ecm.c which is:
   9 *
  10 * Copyright (C) 2003-2005,2008 David Brownell
  11 * Copyright (C) 2008 Nokia Corporation
 
 
 
 
 
  12 */
  13
  14#include <linux/kernel.h>
  15#include <linux/interrupt.h>
  16#include <linux/module.h>
  17#include <linux/device.h>
  18#include <linux/etherdevice.h>
  19#include <linux/crc32.h>
  20
  21#include <linux/usb/cdc.h>
  22
  23#include "u_ether.h"
  24#include "u_ether_configfs.h"
  25#include "u_ncm.h"
  26#include "configfs.h"
  27
  28/*
  29 * This function is a "CDC Network Control Model" (CDC NCM) Ethernet link.
  30 * NCM is intended to be used with high-speed network attachments.
  31 *
  32 * Note that NCM requires the use of "alternate settings" for its data
  33 * interface.  This means that the set_alt() method has real work to do,
  34 * and also means that a get_alt() method is required.
  35 */
  36
  37/* to trigger crc/non-crc ndp signature */
  38
 
  39#define NCM_NDP_HDR_CRC		0x01000000
 
  40
  41enum ncm_notify_state {
  42	NCM_NOTIFY_NONE,		/* don't notify */
  43	NCM_NOTIFY_CONNECT,		/* issue CONNECT next */
  44	NCM_NOTIFY_SPEED,		/* issue SPEED_CHANGE next */
  45};
  46
  47struct f_ncm {
  48	struct gether			port;
  49	u8				ctrl_id, data_id;
  50
  51	char				ethaddr[14];
  52
  53	struct usb_ep			*notify;
  54	struct usb_request		*notify_req;
  55	u8				notify_state;
  56	atomic_t			notify_count;
  57	bool				is_open;
  58
  59	const struct ndp_parser_opts	*parser_opts;
  60	bool				is_crc;
  61	u32				ndp_sign;
  62
  63	/*
  64	 * for notification, it is accessed from both
  65	 * callback and ethernet open/close
  66	 */
  67	spinlock_t			lock;
  68
  69	struct net_device		*netdev;
  70
  71	/* For multi-frame NDP TX */
  72	struct sk_buff			*skb_tx_data;
  73	struct sk_buff			*skb_tx_ndp;
  74	u16				ndp_dgram_count;
 
 
  75	struct hrtimer			task_timer;
 
 
  76};
  77
  78static inline struct f_ncm *func_to_ncm(struct usb_function *f)
  79{
  80	return container_of(f, struct f_ncm, port.func);
  81}
  82
 
 
 
 
 
 
 
 
 
  83/*-------------------------------------------------------------------------*/
  84
  85/*
  86 * We cannot group frames so use just the minimal size which ok to put
  87 * one max-size ethernet frame.
  88 * If the host can group frames, allow it to do that, 16K is selected,
  89 * because it's used by default by the current linux host driver
  90 */
  91#define NTB_DEFAULT_IN_SIZE	16384
  92#define NTB_OUT_SIZE		16384
  93
  94/* Allocation for storing the NDP, 32 should suffice for a
  95 * 16k packet. This allows a maximum of 32 * 507 Byte packets to
  96 * be transmitted in a single 16kB skb, though when sending full size
  97 * packets this limit will be plenty.
  98 * Smaller packets are not likely to be trying to maximize the
  99 * throughput and will be mstly sending smaller infrequent frames.
 100 */
 101#define TX_MAX_NUM_DPE		32
 102
 103/* Delay for the transmit to wait before sending an unfilled NTB frame. */
 104#define TX_TIMEOUT_NSECS	300000
 105
 106/*
 107 * Although max mtu as dictated by u_ether is 15412 bytes, setting
 108 * max_segment_size to 15426 would not be efficient. If user chooses segment
 109 * size to be (>= 8192), then we can't aggregate more than one buffer in each
 110 * NTB (assuming each packet coming from network layer is >= 8192 bytes) as ep
 111 * maxpacket limit is 16384. So let max_segment_size be limited to 8000 to allow
 112 * at least 2 packets to be aggregated reducing wastage of NTB buffer space
 113 */
 114#define MAX_DATAGRAM_SIZE	8000
 115
 116#define FORMATS_SUPPORTED	(USB_CDC_NCM_NTB16_SUPPORTED |	\
 117				 USB_CDC_NCM_NTB32_SUPPORTED)
 118
 119static struct usb_cdc_ncm_ntb_parameters ntb_parameters = {
 120	.wLength = cpu_to_le16(sizeof(ntb_parameters)),
 121	.bmNtbFormatsSupported = cpu_to_le16(FORMATS_SUPPORTED),
 122	.dwNtbInMaxSize = cpu_to_le32(NTB_DEFAULT_IN_SIZE),
 123	.wNdpInDivisor = cpu_to_le16(4),
 124	.wNdpInPayloadRemainder = cpu_to_le16(0),
 125	.wNdpInAlignment = cpu_to_le16(4),
 126
 127	.dwNtbOutMaxSize = cpu_to_le32(NTB_OUT_SIZE),
 128	.wNdpOutDivisor = cpu_to_le16(4),
 129	.wNdpOutPayloadRemainder = cpu_to_le16(0),
 130	.wNdpOutAlignment = cpu_to_le16(4),
 131};
 132
 133/*
 134 * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
 135 * packet, to simplify cancellation; and a big transfer interval, to
 136 * waste less bandwidth.
 137 */
 138
 139#define NCM_STATUS_INTERVAL_MS		32
 140#define NCM_STATUS_BYTECOUNT		16	/* 8 byte header + data */
 141
 142static struct usb_interface_assoc_descriptor ncm_iad_desc = {
 143	.bLength =		sizeof ncm_iad_desc,
 144	.bDescriptorType =	USB_DT_INTERFACE_ASSOCIATION,
 145
 146	/* .bFirstInterface =	DYNAMIC, */
 147	.bInterfaceCount =	2,	/* control + data */
 148	.bFunctionClass =	USB_CLASS_COMM,
 149	.bFunctionSubClass =	USB_CDC_SUBCLASS_NCM,
 150	.bFunctionProtocol =	USB_CDC_PROTO_NONE,
 151	/* .iFunction =		DYNAMIC */
 152};
 153
 154/* interface descriptor: */
 155
 156static struct usb_interface_descriptor ncm_control_intf = {
 157	.bLength =		sizeof ncm_control_intf,
 158	.bDescriptorType =	USB_DT_INTERFACE,
 159
 160	/* .bInterfaceNumber = DYNAMIC */
 161	.bNumEndpoints =	1,
 162	.bInterfaceClass =	USB_CLASS_COMM,
 163	.bInterfaceSubClass =	USB_CDC_SUBCLASS_NCM,
 164	.bInterfaceProtocol =	USB_CDC_PROTO_NONE,
 165	/* .iInterface = DYNAMIC */
 166};
 167
 168static struct usb_cdc_header_desc ncm_header_desc = {
 169	.bLength =		sizeof ncm_header_desc,
 170	.bDescriptorType =	USB_DT_CS_INTERFACE,
 171	.bDescriptorSubType =	USB_CDC_HEADER_TYPE,
 172
 173	.bcdCDC =		cpu_to_le16(0x0110),
 174};
 175
 176static struct usb_cdc_union_desc ncm_union_desc = {
 177	.bLength =		sizeof(ncm_union_desc),
 178	.bDescriptorType =	USB_DT_CS_INTERFACE,
 179	.bDescriptorSubType =	USB_CDC_UNION_TYPE,
 180	/* .bMasterInterface0 =	DYNAMIC */
 181	/* .bSlaveInterface0 =	DYNAMIC */
 182};
 183
 184static struct usb_cdc_ether_desc ecm_desc = {
 185	.bLength =		sizeof ecm_desc,
 186	.bDescriptorType =	USB_DT_CS_INTERFACE,
 187	.bDescriptorSubType =	USB_CDC_ETHERNET_TYPE,
 188
 189	/* this descriptor actually adds value, surprise! */
 190	/* .iMACAddress = DYNAMIC */
 191	.bmEthernetStatistics =	cpu_to_le32(0), /* no statistics */
 
 192	.wNumberMCFilters =	cpu_to_le16(0),
 193	.bNumberPowerFilters =	0,
 194};
 195
 196#define NCAPS	(USB_CDC_NCM_NCAP_ETH_FILTER | USB_CDC_NCM_NCAP_CRC_MODE)
 197
 198static struct usb_cdc_ncm_desc ncm_desc = {
 199	.bLength =		sizeof ncm_desc,
 200	.bDescriptorType =	USB_DT_CS_INTERFACE,
 201	.bDescriptorSubType =	USB_CDC_NCM_TYPE,
 202
 203	.bcdNcmVersion =	cpu_to_le16(0x0100),
 204	/* can process SetEthernetPacketFilter */
 205	.bmNetworkCapabilities = NCAPS,
 206};
 207
 208/* the default data interface has no endpoints ... */
 209
 210static struct usb_interface_descriptor ncm_data_nop_intf = {
 211	.bLength =		sizeof ncm_data_nop_intf,
 212	.bDescriptorType =	USB_DT_INTERFACE,
 213
 214	.bInterfaceNumber =	1,
 215	.bAlternateSetting =	0,
 216	.bNumEndpoints =	0,
 217	.bInterfaceClass =	USB_CLASS_CDC_DATA,
 218	.bInterfaceSubClass =	0,
 219	.bInterfaceProtocol =	USB_CDC_NCM_PROTO_NTB,
 220	/* .iInterface = DYNAMIC */
 221};
 222
 223/* ... but the "real" data interface has two bulk endpoints */
 224
 225static struct usb_interface_descriptor ncm_data_intf = {
 226	.bLength =		sizeof ncm_data_intf,
 227	.bDescriptorType =	USB_DT_INTERFACE,
 228
 229	.bInterfaceNumber =	1,
 230	.bAlternateSetting =	1,
 231	.bNumEndpoints =	2,
 232	.bInterfaceClass =	USB_CLASS_CDC_DATA,
 233	.bInterfaceSubClass =	0,
 234	.bInterfaceProtocol =	USB_CDC_NCM_PROTO_NTB,
 235	/* .iInterface = DYNAMIC */
 236};
 237
 238/* full speed support: */
 239
 240static struct usb_endpoint_descriptor fs_ncm_notify_desc = {
 241	.bLength =		USB_DT_ENDPOINT_SIZE,
 242	.bDescriptorType =	USB_DT_ENDPOINT,
 243
 244	.bEndpointAddress =	USB_DIR_IN,
 245	.bmAttributes =		USB_ENDPOINT_XFER_INT,
 246	.wMaxPacketSize =	cpu_to_le16(NCM_STATUS_BYTECOUNT),
 247	.bInterval =		NCM_STATUS_INTERVAL_MS,
 248};
 249
 250static struct usb_endpoint_descriptor fs_ncm_in_desc = {
 251	.bLength =		USB_DT_ENDPOINT_SIZE,
 252	.bDescriptorType =	USB_DT_ENDPOINT,
 253
 254	.bEndpointAddress =	USB_DIR_IN,
 255	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 256};
 257
 258static struct usb_endpoint_descriptor fs_ncm_out_desc = {
 259	.bLength =		USB_DT_ENDPOINT_SIZE,
 260	.bDescriptorType =	USB_DT_ENDPOINT,
 261
 262	.bEndpointAddress =	USB_DIR_OUT,
 263	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 264};
 265
 266static struct usb_descriptor_header *ncm_fs_function[] = {
 267	(struct usb_descriptor_header *) &ncm_iad_desc,
 268	/* CDC NCM control descriptors */
 269	(struct usb_descriptor_header *) &ncm_control_intf,
 270	(struct usb_descriptor_header *) &ncm_header_desc,
 271	(struct usb_descriptor_header *) &ncm_union_desc,
 272	(struct usb_descriptor_header *) &ecm_desc,
 273	(struct usb_descriptor_header *) &ncm_desc,
 274	(struct usb_descriptor_header *) &fs_ncm_notify_desc,
 275	/* data interface, altsettings 0 and 1 */
 276	(struct usb_descriptor_header *) &ncm_data_nop_intf,
 277	(struct usb_descriptor_header *) &ncm_data_intf,
 278	(struct usb_descriptor_header *) &fs_ncm_in_desc,
 279	(struct usb_descriptor_header *) &fs_ncm_out_desc,
 280	NULL,
 281};
 282
 283/* high speed support: */
 284
 285static struct usb_endpoint_descriptor hs_ncm_notify_desc = {
 286	.bLength =		USB_DT_ENDPOINT_SIZE,
 287	.bDescriptorType =	USB_DT_ENDPOINT,
 288
 289	.bEndpointAddress =	USB_DIR_IN,
 290	.bmAttributes =		USB_ENDPOINT_XFER_INT,
 291	.wMaxPacketSize =	cpu_to_le16(NCM_STATUS_BYTECOUNT),
 292	.bInterval =		USB_MS_TO_HS_INTERVAL(NCM_STATUS_INTERVAL_MS),
 293};
 294static struct usb_endpoint_descriptor hs_ncm_in_desc = {
 295	.bLength =		USB_DT_ENDPOINT_SIZE,
 296	.bDescriptorType =	USB_DT_ENDPOINT,
 297
 298	.bEndpointAddress =	USB_DIR_IN,
 299	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 300	.wMaxPacketSize =	cpu_to_le16(512),
 301};
 302
 303static struct usb_endpoint_descriptor hs_ncm_out_desc = {
 304	.bLength =		USB_DT_ENDPOINT_SIZE,
 305	.bDescriptorType =	USB_DT_ENDPOINT,
 306
 307	.bEndpointAddress =	USB_DIR_OUT,
 308	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 309	.wMaxPacketSize =	cpu_to_le16(512),
 310};
 311
 312static struct usb_descriptor_header *ncm_hs_function[] = {
 313	(struct usb_descriptor_header *) &ncm_iad_desc,
 314	/* CDC NCM control descriptors */
 315	(struct usb_descriptor_header *) &ncm_control_intf,
 316	(struct usb_descriptor_header *) &ncm_header_desc,
 317	(struct usb_descriptor_header *) &ncm_union_desc,
 318	(struct usb_descriptor_header *) &ecm_desc,
 319	(struct usb_descriptor_header *) &ncm_desc,
 320	(struct usb_descriptor_header *) &hs_ncm_notify_desc,
 321	/* data interface, altsettings 0 and 1 */
 322	(struct usb_descriptor_header *) &ncm_data_nop_intf,
 323	(struct usb_descriptor_header *) &ncm_data_intf,
 324	(struct usb_descriptor_header *) &hs_ncm_in_desc,
 325	(struct usb_descriptor_header *) &hs_ncm_out_desc,
 326	NULL,
 327};
 328
 329
 330/* super speed support: */
 331
 332static struct usb_endpoint_descriptor ss_ncm_notify_desc = {
 333	.bLength =		USB_DT_ENDPOINT_SIZE,
 334	.bDescriptorType =	USB_DT_ENDPOINT,
 335
 336	.bEndpointAddress =	USB_DIR_IN,
 337	.bmAttributes =		USB_ENDPOINT_XFER_INT,
 338	.wMaxPacketSize =	cpu_to_le16(NCM_STATUS_BYTECOUNT),
 339	.bInterval =		USB_MS_TO_HS_INTERVAL(NCM_STATUS_INTERVAL_MS)
 340};
 341
 342static struct usb_ss_ep_comp_descriptor ss_ncm_notify_comp_desc = {
 343	.bLength =		sizeof(ss_ncm_notify_comp_desc),
 344	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
 345
 346	/* the following 3 values can be tweaked if necessary */
 347	/* .bMaxBurst =		0, */
 348	/* .bmAttributes =	0, */
 349	.wBytesPerInterval =	cpu_to_le16(NCM_STATUS_BYTECOUNT),
 350};
 351
 352static struct usb_endpoint_descriptor ss_ncm_in_desc = {
 353	.bLength =		USB_DT_ENDPOINT_SIZE,
 354	.bDescriptorType =	USB_DT_ENDPOINT,
 355
 356	.bEndpointAddress =	USB_DIR_IN,
 357	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 358	.wMaxPacketSize =	cpu_to_le16(1024),
 359};
 360
 361static struct usb_endpoint_descriptor ss_ncm_out_desc = {
 362	.bLength =		USB_DT_ENDPOINT_SIZE,
 363	.bDescriptorType =	USB_DT_ENDPOINT,
 364
 365	.bEndpointAddress =	USB_DIR_OUT,
 366	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 367	.wMaxPacketSize =	cpu_to_le16(1024),
 368};
 369
 370static struct usb_ss_ep_comp_descriptor ss_ncm_bulk_comp_desc = {
 371	.bLength =		sizeof(ss_ncm_bulk_comp_desc),
 372	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
 373
 374	/* the following 2 values can be tweaked if necessary */
 375	.bMaxBurst =		15,
 376	/* .bmAttributes =	0, */
 377};
 378
 379static struct usb_descriptor_header *ncm_ss_function[] = {
 380	(struct usb_descriptor_header *) &ncm_iad_desc,
 381	/* CDC NCM control descriptors */
 382	(struct usb_descriptor_header *) &ncm_control_intf,
 383	(struct usb_descriptor_header *) &ncm_header_desc,
 384	(struct usb_descriptor_header *) &ncm_union_desc,
 385	(struct usb_descriptor_header *) &ecm_desc,
 386	(struct usb_descriptor_header *) &ncm_desc,
 387	(struct usb_descriptor_header *) &ss_ncm_notify_desc,
 388	(struct usb_descriptor_header *) &ss_ncm_notify_comp_desc,
 389	/* data interface, altsettings 0 and 1 */
 390	(struct usb_descriptor_header *) &ncm_data_nop_intf,
 391	(struct usb_descriptor_header *) &ncm_data_intf,
 392	(struct usb_descriptor_header *) &ss_ncm_in_desc,
 393	(struct usb_descriptor_header *) &ss_ncm_bulk_comp_desc,
 394	(struct usb_descriptor_header *) &ss_ncm_out_desc,
 395	(struct usb_descriptor_header *) &ss_ncm_bulk_comp_desc,
 396	NULL,
 397};
 398
 399/* string descriptors: */
 400
 401#define STRING_CTRL_IDX	0
 402#define STRING_MAC_IDX	1
 403#define STRING_DATA_IDX	2
 404#define STRING_IAD_IDX	3
 405
 406static struct usb_string ncm_string_defs[] = {
 407	[STRING_CTRL_IDX].s = "CDC Network Control Model (NCM)",
 408	[STRING_MAC_IDX].s = "",
 409	[STRING_DATA_IDX].s = "CDC Network Data",
 410	[STRING_IAD_IDX].s = "CDC NCM",
 411	{  } /* end of list */
 412};
 413
 414static struct usb_gadget_strings ncm_string_table = {
 415	.language =		0x0409,	/* en-us */
 416	.strings =		ncm_string_defs,
 417};
 418
 419static struct usb_gadget_strings *ncm_strings[] = {
 420	&ncm_string_table,
 421	NULL,
 422};
 423
 424/*
 425 * Here are options for NCM Datagram Pointer table (NDP) parser.
 426 * There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
 427 * in NDP16 offsets and sizes fields are 1 16bit word wide,
 428 * in NDP32 -- 2 16bit words wide. Also signatures are different.
 429 * To make the parser code the same, put the differences in the structure,
 430 * and switch pointers to the structures when the format is changed.
 431 */
 432
 433struct ndp_parser_opts {
 434	u32		nth_sign;
 435	u32		ndp_sign;
 436	unsigned	nth_size;
 437	unsigned	ndp_size;
 438	unsigned	dpe_size;
 439	unsigned	ndplen_align;
 440	/* sizes in u16 units */
 441	unsigned	dgram_item_len; /* index or length */
 442	unsigned	block_length;
 443	unsigned	ndp_index;
 444	unsigned	reserved1;
 445	unsigned	reserved2;
 446	unsigned	next_ndp_index;
 447};
 448
 449static const struct ndp_parser_opts ndp16_opts = {
 450	.nth_sign = USB_CDC_NCM_NTH16_SIGN,
 451	.ndp_sign = USB_CDC_NCM_NDP16_NOCRC_SIGN,
 452	.nth_size = sizeof(struct usb_cdc_ncm_nth16),
 453	.ndp_size = sizeof(struct usb_cdc_ncm_ndp16),
 454	.dpe_size = sizeof(struct usb_cdc_ncm_dpe16),
 455	.ndplen_align = 4,
 456	.dgram_item_len = 1,
 457	.block_length = 1,
 458	.ndp_index = 1,
 459	.reserved1 = 0,
 460	.reserved2 = 0,
 461	.next_ndp_index = 1,
 462};
 463
 464static const struct ndp_parser_opts ndp32_opts = {
 465	.nth_sign = USB_CDC_NCM_NTH32_SIGN,
 466	.ndp_sign = USB_CDC_NCM_NDP32_NOCRC_SIGN,
 467	.nth_size = sizeof(struct usb_cdc_ncm_nth32),
 468	.ndp_size = sizeof(struct usb_cdc_ncm_ndp32),
 469	.dpe_size = sizeof(struct usb_cdc_ncm_dpe32),
 470	.ndplen_align = 8,
 471	.dgram_item_len = 2,
 472	.block_length = 2,
 473	.ndp_index = 2,
 474	.reserved1 = 1,
 475	.reserved2 = 2,
 476	.next_ndp_index = 2,
 477};
 
 
 
 
 478
 479static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
 480{
 481	switch (size) {
 482	case 1:
 483		put_unaligned_le16((u16)val, *p);
 484		break;
 485	case 2:
 486		put_unaligned_le32((u32)val, *p);
 487
 488		break;
 489	default:
 490		BUG();
 491	}
 492
 493	*p += size;
 494}
 495
 496static inline unsigned get_ncm(__le16 **p, unsigned size)
 497{
 498	unsigned tmp;
 499
 500	switch (size) {
 501	case 1:
 502		tmp = get_unaligned_le16(*p);
 503		break;
 504	case 2:
 505		tmp = get_unaligned_le32(*p);
 506		break;
 507	default:
 508		BUG();
 509	}
 510
 511	*p += size;
 512	return tmp;
 513}
 514
 515/*-------------------------------------------------------------------------*/
 516
 517static inline void ncm_reset_values(struct f_ncm *ncm)
 518{
 519	ncm->parser_opts = &ndp16_opts;
 520	ncm->is_crc = false;
 521	ncm->ndp_sign = ncm->parser_opts->ndp_sign;
 522	ncm->port.cdc_filter = DEFAULT_FILTER;
 523
 524	/* doesn't make sense for ncm, fixed size used */
 525	ncm->port.header_len = 0;
 526
 527	ncm->port.fixed_out_len = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
 528	ncm->port.fixed_in_len = NTB_DEFAULT_IN_SIZE;
 529}
 530
 531/*
 532 * Context: ncm->lock held
 533 */
 534static void ncm_do_notify(struct f_ncm *ncm)
 535{
 536	struct usb_request		*req = ncm->notify_req;
 537	struct usb_cdc_notification	*event;
 538	struct usb_composite_dev	*cdev = ncm->port.func.config->cdev;
 539	__le32				*data;
 540	int				status;
 541
 542	/* notification already in flight? */
 543	if (atomic_read(&ncm->notify_count))
 544		return;
 545
 546	event = req->buf;
 547	switch (ncm->notify_state) {
 548	case NCM_NOTIFY_NONE:
 549		return;
 550
 551	case NCM_NOTIFY_CONNECT:
 552		event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
 553		if (ncm->is_open)
 554			event->wValue = cpu_to_le16(1);
 555		else
 556			event->wValue = cpu_to_le16(0);
 557		event->wLength = 0;
 558		req->length = sizeof *event;
 559
 560		DBG(cdev, "notify connect %s\n",
 561				ncm->is_open ? "true" : "false");
 562		ncm->notify_state = NCM_NOTIFY_NONE;
 563		break;
 564
 565	case NCM_NOTIFY_SPEED:
 566		event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
 567		event->wValue = cpu_to_le16(0);
 568		event->wLength = cpu_to_le16(8);
 569		req->length = NCM_STATUS_BYTECOUNT;
 570
 571		/* SPEED_CHANGE data is up/down speeds in bits/sec */
 572		data = req->buf + sizeof *event;
 573		data[0] = cpu_to_le32(gether_bitrate(cdev->gadget));
 574		data[1] = data[0];
 575
 576		DBG(cdev, "notify speed %u\n", gether_bitrate(cdev->gadget));
 577		ncm->notify_state = NCM_NOTIFY_CONNECT;
 578		break;
 579	}
 580	event->bmRequestType = 0xA1;
 581	event->wIndex = cpu_to_le16(ncm->ctrl_id);
 582
 583	atomic_inc(&ncm->notify_count);
 584
 585	/*
 586	 * In double buffering if there is a space in FIFO,
 587	 * completion callback can be called right after the call,
 588	 * so unlocking
 589	 */
 590	spin_unlock(&ncm->lock);
 591	status = usb_ep_queue(ncm->notify, req, GFP_ATOMIC);
 592	spin_lock(&ncm->lock);
 593	if (status < 0) {
 594		atomic_dec(&ncm->notify_count);
 595		DBG(cdev, "notify --> %d\n", status);
 596	}
 597}
 598
 599/*
 600 * Context: ncm->lock held
 601 */
 602static void ncm_notify(struct f_ncm *ncm)
 603{
 604	/*
 605	 * NOTE on most versions of Linux, host side cdc-ethernet
 606	 * won't listen for notifications until its netdevice opens.
 607	 * The first notification then sits in the FIFO for a long
 608	 * time, and the second one is queued.
 609	 *
 610	 * If ncm_notify() is called before the second (CONNECT)
 611	 * notification is sent, then it will reset to send the SPEED
 612	 * notificaion again (and again, and again), but it's not a problem
 613	 */
 614	ncm->notify_state = NCM_NOTIFY_SPEED;
 615	ncm_do_notify(ncm);
 616}
 617
 618static void ncm_notify_complete(struct usb_ep *ep, struct usb_request *req)
 619{
 620	struct f_ncm			*ncm = req->context;
 621	struct usb_composite_dev	*cdev = ncm->port.func.config->cdev;
 622	struct usb_cdc_notification	*event = req->buf;
 623
 624	spin_lock(&ncm->lock);
 625	switch (req->status) {
 626	case 0:
 627		VDBG(cdev, "Notification %02x sent\n",
 628		     event->bNotificationType);
 629		atomic_dec(&ncm->notify_count);
 630		break;
 631	case -ECONNRESET:
 632	case -ESHUTDOWN:
 633		atomic_set(&ncm->notify_count, 0);
 634		ncm->notify_state = NCM_NOTIFY_NONE;
 635		break;
 636	default:
 637		DBG(cdev, "event %02x --> %d\n",
 638			event->bNotificationType, req->status);
 639		atomic_dec(&ncm->notify_count);
 640		break;
 641	}
 
 642	ncm_do_notify(ncm);
 643	spin_unlock(&ncm->lock);
 644}
 645
 646static void ncm_ep0out_complete(struct usb_ep *ep, struct usb_request *req)
 647{
 648	/* now for SET_NTB_INPUT_SIZE only */
 649	unsigned		in_size;
 650	struct usb_function	*f = req->context;
 651	struct f_ncm		*ncm = func_to_ncm(f);
 652	struct usb_composite_dev *cdev = f->config->cdev;
 653
 654	req->context = NULL;
 655	if (req->status || req->actual != req->length) {
 656		DBG(cdev, "Bad control-OUT transfer\n");
 657		goto invalid;
 658	}
 659
 660	in_size = get_unaligned_le32(req->buf);
 661	if (in_size < USB_CDC_NCM_NTB_MIN_IN_SIZE ||
 662	    in_size > le32_to_cpu(ntb_parameters.dwNtbInMaxSize)) {
 663		DBG(cdev, "Got wrong INPUT SIZE (%d) from host\n", in_size);
 664		goto invalid;
 665	}
 666
 667	ncm->port.fixed_in_len = in_size;
 668	VDBG(cdev, "Set NTB INPUT SIZE %d\n", in_size);
 669	return;
 670
 671invalid:
 672	usb_ep_set_halt(ep);
 673	return;
 674}
 675
 676static int ncm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 677{
 678	struct f_ncm		*ncm = func_to_ncm(f);
 679	struct usb_composite_dev *cdev = f->config->cdev;
 680	struct usb_request	*req = cdev->req;
 681	int			value = -EOPNOTSUPP;
 682	u16			w_index = le16_to_cpu(ctrl->wIndex);
 683	u16			w_value = le16_to_cpu(ctrl->wValue);
 684	u16			w_length = le16_to_cpu(ctrl->wLength);
 685
 686	/*
 687	 * composite driver infrastructure handles everything except
 688	 * CDC class messages; interface activation uses set_alt().
 689	 */
 690	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
 691	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 692			| USB_CDC_SET_ETHERNET_PACKET_FILTER:
 693		/*
 694		 * see 6.2.30: no data, wIndex = interface,
 695		 * wValue = packet filter bitmap
 696		 */
 697		if (w_length != 0 || w_index != ncm->ctrl_id)
 698			goto invalid;
 699		DBG(cdev, "packet filter %02x\n", w_value);
 700		/*
 701		 * REVISIT locking of cdc_filter.  This assumes the UDC
 702		 * driver won't have a concurrent packet TX irq running on
 703		 * another CPU; or that if it does, this write is atomic...
 704		 */
 705		ncm->port.cdc_filter = w_value;
 706		value = 0;
 707		break;
 708	/*
 709	 * and optionally:
 710	 * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
 711	 * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
 712	 * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
 713	 * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
 714	 * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
 715	 * case USB_CDC_GET_ETHERNET_STATISTIC:
 716	 */
 717
 718	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 719		| USB_CDC_GET_NTB_PARAMETERS:
 720
 721		if (w_length == 0 || w_value != 0 || w_index != ncm->ctrl_id)
 722			goto invalid;
 723		value = w_length > sizeof ntb_parameters ?
 724			sizeof ntb_parameters : w_length;
 725		memcpy(req->buf, &ntb_parameters, value);
 726		VDBG(cdev, "Host asked NTB parameters\n");
 727		break;
 728
 729	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 730		| USB_CDC_GET_NTB_INPUT_SIZE:
 731
 732		if (w_length < 4 || w_value != 0 || w_index != ncm->ctrl_id)
 733			goto invalid;
 734		put_unaligned_le32(ncm->port.fixed_in_len, req->buf);
 735		value = 4;
 736		VDBG(cdev, "Host asked INPUT SIZE, sending %d\n",
 737		     ncm->port.fixed_in_len);
 738		break;
 739
 740	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 741		| USB_CDC_SET_NTB_INPUT_SIZE:
 742	{
 743		if (w_length != 4 || w_value != 0 || w_index != ncm->ctrl_id)
 744			goto invalid;
 745		req->complete = ncm_ep0out_complete;
 746		req->length = w_length;
 747		req->context = f;
 748
 749		value = req->length;
 750		break;
 751	}
 752
 753	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 754		| USB_CDC_GET_NTB_FORMAT:
 755	{
 756		uint16_t format;
 757
 758		if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
 759			goto invalid;
 760		format = (ncm->parser_opts == &ndp16_opts) ? 0x0000 : 0x0001;
 761		put_unaligned_le16(format, req->buf);
 762		value = 2;
 763		VDBG(cdev, "Host asked NTB FORMAT, sending %d\n", format);
 764		break;
 765	}
 766
 767	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 768		| USB_CDC_SET_NTB_FORMAT:
 769	{
 770		if (w_length != 0 || w_index != ncm->ctrl_id)
 771			goto invalid;
 772		switch (w_value) {
 773		case 0x0000:
 774			ncm->parser_opts = &ndp16_opts;
 775			DBG(cdev, "NCM16 selected\n");
 776			break;
 777		case 0x0001:
 778			ncm->parser_opts = &ndp32_opts;
 779			DBG(cdev, "NCM32 selected\n");
 780			break;
 781		default:
 782			goto invalid;
 783		}
 784		value = 0;
 785		break;
 786	}
 787	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 788		| USB_CDC_GET_CRC_MODE:
 789	{
 790		uint16_t is_crc;
 791
 792		if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
 793			goto invalid;
 794		is_crc = ncm->is_crc ? 0x0001 : 0x0000;
 795		put_unaligned_le16(is_crc, req->buf);
 796		value = 2;
 797		VDBG(cdev, "Host asked CRC MODE, sending %d\n", is_crc);
 798		break;
 799	}
 800
 801	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 802		| USB_CDC_SET_CRC_MODE:
 803	{
 
 
 804		if (w_length != 0 || w_index != ncm->ctrl_id)
 805			goto invalid;
 806		switch (w_value) {
 807		case 0x0000:
 808			ncm->is_crc = false;
 
 809			DBG(cdev, "non-CRC mode selected\n");
 810			break;
 811		case 0x0001:
 812			ncm->is_crc = true;
 
 813			DBG(cdev, "CRC mode selected\n");
 814			break;
 815		default:
 816			goto invalid;
 817		}
 
 818		value = 0;
 819		break;
 820	}
 821
 822	/* and disabled in ncm descriptor: */
 823	/* case USB_CDC_GET_NET_ADDRESS: */
 824	/* case USB_CDC_SET_NET_ADDRESS: */
 825	/* case USB_CDC_GET_MAX_DATAGRAM_SIZE: */
 826	/* case USB_CDC_SET_MAX_DATAGRAM_SIZE: */
 827
 828	default:
 829invalid:
 830		DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
 831			ctrl->bRequestType, ctrl->bRequest,
 832			w_value, w_index, w_length);
 833	}
 834	ncm->ndp_sign = ncm->parser_opts->ndp_sign |
 835		(ncm->is_crc ? NCM_NDP_HDR_CRC : 0);
 836
 837	/* respond with data transfer or status phase? */
 838	if (value >= 0) {
 839		DBG(cdev, "ncm req%02x.%02x v%04x i%04x l%d\n",
 840			ctrl->bRequestType, ctrl->bRequest,
 841			w_value, w_index, w_length);
 842		req->zero = 0;
 843		req->length = value;
 844		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 845		if (value < 0)
 846			ERROR(cdev, "ncm req %02x.%02x response err %d\n",
 847					ctrl->bRequestType, ctrl->bRequest,
 848					value);
 849	}
 850
 851	/* device either stalls (value < 0) or reports success */
 852	return value;
 853}
 854
 855
 856static int ncm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 857{
 858	struct f_ncm		*ncm = func_to_ncm(f);
 859	struct usb_composite_dev *cdev = f->config->cdev;
 860
 861	/* Control interface has only altsetting 0 */
 862	if (intf == ncm->ctrl_id) {
 863		if (alt != 0)
 864			goto fail;
 865
 866		DBG(cdev, "reset ncm control %d\n", intf);
 867		usb_ep_disable(ncm->notify);
 868
 869		if (!(ncm->notify->desc)) {
 870			DBG(cdev, "init ncm ctrl %d\n", intf);
 871			if (config_ep_by_speed(cdev->gadget, f, ncm->notify))
 872				goto fail;
 873		}
 874		usb_ep_enable(ncm->notify);
 875
 876	/* Data interface has two altsettings, 0 and 1 */
 877	} else if (intf == ncm->data_id) {
 878		if (alt > 1)
 879			goto fail;
 880
 881		if (ncm->port.in_ep->enabled) {
 882			DBG(cdev, "reset ncm\n");
 
 883			ncm->netdev = NULL;
 884			gether_disconnect(&ncm->port);
 885			ncm_reset_values(ncm);
 886		}
 887
 888		/*
 889		 * CDC Network only sends data in non-default altsettings.
 890		 * Changing altsettings resets filters, statistics, etc.
 891		 */
 892		if (alt == 1) {
 893			struct net_device	*net;
 894
 895			if (!ncm->port.in_ep->desc ||
 896			    !ncm->port.out_ep->desc) {
 897				DBG(cdev, "init ncm\n");
 898				if (config_ep_by_speed(cdev->gadget, f,
 899						       ncm->port.in_ep) ||
 900				    config_ep_by_speed(cdev->gadget, f,
 901						       ncm->port.out_ep)) {
 902					ncm->port.in_ep->desc = NULL;
 903					ncm->port.out_ep->desc = NULL;
 904					goto fail;
 905				}
 906			}
 907
 908			/* TODO */
 909			/* Enable zlps by default for NCM conformance;
 910			 * override for musb_hdrc (avoids txdma ovhead)
 911			 */
 912			ncm->port.is_zlp_ok =
 913				gadget_is_zlp_supported(cdev->gadget);
 914			ncm->port.cdc_filter = DEFAULT_FILTER;
 915			DBG(cdev, "activate ncm\n");
 916			net = gether_connect(&ncm->port);
 917			if (IS_ERR(net))
 918				return PTR_ERR(net);
 919			ncm->netdev = net;
 
 920		}
 921
 922		spin_lock(&ncm->lock);
 923		ncm_notify(ncm);
 924		spin_unlock(&ncm->lock);
 925	} else
 926		goto fail;
 927
 928	return 0;
 929fail:
 930	return -EINVAL;
 931}
 932
 933/*
 934 * Because the data interface supports multiple altsettings,
 935 * this NCM function *MUST* implement a get_alt() method.
 936 */
 937static int ncm_get_alt(struct usb_function *f, unsigned intf)
 938{
 939	struct f_ncm		*ncm = func_to_ncm(f);
 940
 941	if (intf == ncm->ctrl_id)
 942		return 0;
 943	return ncm->port.in_ep->enabled ? 1 : 0;
 944}
 945
 946static struct sk_buff *package_for_tx(struct f_ncm *ncm)
 947{
 948	__le16		*ntb_iter;
 949	struct sk_buff	*skb2 = NULL;
 950	unsigned	ndp_pad;
 951	unsigned	ndp_index;
 952	unsigned	new_len;
 953
 954	const struct ndp_parser_opts *opts = ncm->parser_opts;
 955	const int ndp_align = le16_to_cpu(ntb_parameters.wNdpInAlignment);
 956	const int dgram_idx_len = 2 * 2 * opts->dgram_item_len;
 957
 958	/* Stop the timer */
 959	hrtimer_try_to_cancel(&ncm->task_timer);
 960
 961	ndp_pad = ALIGN(ncm->skb_tx_data->len, ndp_align) -
 962			ncm->skb_tx_data->len;
 963	ndp_index = ncm->skb_tx_data->len + ndp_pad;
 964	new_len = ndp_index + dgram_idx_len + ncm->skb_tx_ndp->len;
 965
 966	/* Set the final BlockLength and wNdpIndex */
 967	ntb_iter = (void *) ncm->skb_tx_data->data;
 968	/* Increment pointer to BlockLength */
 969	ntb_iter += 2 + 1 + 1;
 970	put_ncm(&ntb_iter, opts->block_length, new_len);
 971	put_ncm(&ntb_iter, opts->ndp_index, ndp_index);
 972
 973	/* Set the final NDP wLength */
 974	new_len = opts->ndp_size +
 975			(ncm->ndp_dgram_count * dgram_idx_len);
 976	ncm->ndp_dgram_count = 0;
 977	/* Increment from start to wLength */
 978	ntb_iter = (void *) ncm->skb_tx_ndp->data;
 979	ntb_iter += 2;
 980	put_unaligned_le16(new_len, ntb_iter);
 981
 982	/* Merge the skbs */
 983	swap(skb2, ncm->skb_tx_data);
 984	if (ncm->skb_tx_data) {
 985		dev_consume_skb_any(ncm->skb_tx_data);
 986		ncm->skb_tx_data = NULL;
 987	}
 988
 989	/* Insert NDP alignment. */
 990	skb_put_zero(skb2, ndp_pad);
 
 991
 992	/* Copy NTB across. */
 993	skb_put_data(skb2, ncm->skb_tx_ndp->data, ncm->skb_tx_ndp->len);
 994	dev_consume_skb_any(ncm->skb_tx_ndp);
 
 995	ncm->skb_tx_ndp = NULL;
 996
 997	/* Insert zero'd datagram. */
 998	skb_put_zero(skb2, dgram_idx_len);
 
 999
1000	return skb2;
1001}
1002
1003static struct sk_buff *ncm_wrap_ntb(struct gether *port,
1004				    struct sk_buff *skb)
1005{
1006	struct f_ncm	*ncm = func_to_ncm(&port->func);
1007	struct sk_buff	*skb2 = NULL;
 
 
 
 
1008
1009	if (skb) {
1010		int		ncb_len = 0;
1011		__le16		*ntb_data;
1012		__le16		*ntb_ndp;
1013		int		dgram_pad;
1014
1015		unsigned	max_size = ncm->port.fixed_in_len;
1016		const struct ndp_parser_opts *opts = ncm->parser_opts;
1017		const int ndp_align = le16_to_cpu(ntb_parameters.wNdpInAlignment);
1018		const int div = le16_to_cpu(ntb_parameters.wNdpInDivisor);
1019		const int rem = le16_to_cpu(ntb_parameters.wNdpInPayloadRemainder);
1020		const int dgram_idx_len = 2 * 2 * opts->dgram_item_len;
1021
 
 
 
 
1022		/* Add the CRC if required up front */
1023		if (ncm->is_crc) {
1024			uint32_t	crc;
1025			__le16		*crc_pos;
1026
1027			crc = ~crc32_le(~0,
1028					skb->data,
1029					skb->len);
1030			crc_pos = skb_put(skb, sizeof(uint32_t));
1031			put_unaligned_le32(crc, crc_pos);
1032		}
1033
1034		/* If the new skb is too big for the current NCM NTB then
1035		 * set the current stored skb to be sent now and clear it
1036		 * ready for new data.
1037		 * NOTE: Assume maximum align for speed of calculation.
1038		 */
1039		if (ncm->skb_tx_data
1040		    && (ncm->ndp_dgram_count >= TX_MAX_NUM_DPE
1041		    || (ncm->skb_tx_data->len +
1042		    div + rem + skb->len +
1043		    ncm->skb_tx_ndp->len + ndp_align + (2 * dgram_idx_len))
1044		    > max_size)) {
1045			skb2 = package_for_tx(ncm);
1046			if (!skb2)
1047				goto err;
1048		}
1049
1050		if (!ncm->skb_tx_data) {
1051			ncb_len = opts->nth_size;
1052			dgram_pad = ALIGN(ncb_len, div) + rem - ncb_len;
1053			ncb_len += dgram_pad;
1054
1055			/* Create a new skb for the NTH and datagrams. */
1056			ncm->skb_tx_data = alloc_skb(max_size, GFP_ATOMIC);
1057			if (!ncm->skb_tx_data)
1058				goto err;
1059
1060			ncm->skb_tx_data->dev = ncm->netdev;
1061			ntb_data = skb_put_zero(ncm->skb_tx_data, ncb_len);
1062			/* dwSignature */
1063			put_unaligned_le32(opts->nth_sign, ntb_data);
1064			ntb_data += 2;
1065			/* wHeaderLength */
1066			put_unaligned_le16(opts->nth_size, ntb_data++);
1067
1068			/* Allocate an skb for storing the NDP,
1069			 * TX_MAX_NUM_DPE should easily suffice for a
1070			 * 16k packet.
1071			 */
1072			ncm->skb_tx_ndp = alloc_skb((int)(opts->ndp_size
1073						    + opts->dpe_size
1074						    * TX_MAX_NUM_DPE),
1075						    GFP_ATOMIC);
1076			if (!ncm->skb_tx_ndp)
1077				goto err;
1078
1079			ncm->skb_tx_ndp->dev = ncm->netdev;
1080			ntb_ndp = skb_put(ncm->skb_tx_ndp, opts->ndp_size);
1081			memset(ntb_ndp, 0, ncb_len);
1082			/* dwSignature */
1083			put_unaligned_le32(ncm->ndp_sign, ntb_ndp);
1084			ntb_ndp += 2;
1085
1086			/* There is always a zeroed entry */
1087			ncm->ndp_dgram_count = 1;
1088
1089			/* Note: we skip opts->next_ndp_index */
1090
1091			/* Start the timer. */
1092			hrtimer_start(&ncm->task_timer, TX_TIMEOUT_NSECS,
1093				      HRTIMER_MODE_REL_SOFT);
1094		}
1095
 
 
 
 
 
1096		/* Add the datagram position entries */
1097		ntb_ndp = skb_put_zero(ncm->skb_tx_ndp, dgram_idx_len);
 
1098
1099		ncb_len = ncm->skb_tx_data->len;
1100		dgram_pad = ALIGN(ncb_len, div) + rem - ncb_len;
1101		ncb_len += dgram_pad;
1102
1103		/* (d)wDatagramIndex */
1104		put_ncm(&ntb_ndp, opts->dgram_item_len, ncb_len);
1105		/* (d)wDatagramLength */
1106		put_ncm(&ntb_ndp, opts->dgram_item_len, skb->len);
1107		ncm->ndp_dgram_count++;
1108
1109		/* Add the new data to the skb */
1110		skb_put_zero(ncm->skb_tx_data, dgram_pad);
1111		skb_put_data(ncm->skb_tx_data, skb->data, skb->len);
1112		dev_consume_skb_any(skb);
 
 
1113		skb = NULL;
1114
1115	} else if (ncm->skb_tx_data) {
1116		/* If we get here ncm_wrap_ntb() was called with NULL skb,
1117		 * because eth_start_xmit() was called with NULL skb by
1118		 * ncm_tx_timeout() - hence, this is our signal to flush/send.
1119		 */
1120		skb2 = package_for_tx(ncm);
1121		if (!skb2)
1122			goto err;
1123	}
1124
1125	return skb2;
1126
1127err:
1128	ncm->netdev->stats.tx_dropped++;
1129
1130	if (skb)
1131		dev_kfree_skb_any(skb);
1132	if (ncm->skb_tx_data)
1133		dev_kfree_skb_any(ncm->skb_tx_data);
1134	if (ncm->skb_tx_ndp)
1135		dev_kfree_skb_any(ncm->skb_tx_ndp);
1136
1137	return NULL;
1138}
1139
1140/*
1141 * The transmit should only be run if no skb data has been sent
1142 * for a certain duration.
1143 */
1144static enum hrtimer_restart ncm_tx_timeout(struct hrtimer *data)
1145{
1146	struct f_ncm *ncm = container_of(data, struct f_ncm, task_timer);
1147	struct net_device *netdev = READ_ONCE(ncm->netdev);
 
 
 
 
 
 
1148
1149	if (netdev) {
1150		/* XXX This allowance of a NULL skb argument to ndo_start_xmit
1151		 * XXX is not sane.  The gadget layer should be redesigned so
1152		 * XXX that the dev->wrap() invocations to build SKBs is transparent
1153		 * XXX and performed in some way outside of the ndo_start_xmit
1154		 * XXX interface.
1155		 *
1156		 * This will call directly into u_ether's eth_start_xmit()
1157		 */
1158		netdev->netdev_ops->ndo_start_xmit(NULL, netdev);
 
 
1159	}
 
 
 
 
 
 
 
 
 
 
1160	return HRTIMER_NORESTART;
1161}
1162
1163static int ncm_unwrap_ntb(struct gether *port,
1164			  struct sk_buff *skb,
1165			  struct sk_buff_head *list)
1166{
1167	struct f_ncm	*ncm = func_to_ncm(&port->func);
1168	unsigned char	*ntb_ptr = skb->data;
1169	__le16		*tmp;
1170	unsigned	index, index2;
1171	int		ndp_index;
1172	unsigned	dg_len, dg_len2;
1173	unsigned	ndp_len;
1174	unsigned	block_len;
1175	struct sk_buff	*skb2;
1176	int		ret = -EINVAL;
1177	unsigned	ntb_max = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
1178	unsigned	frame_max;
1179	const struct ndp_parser_opts *opts = ncm->parser_opts;
1180	unsigned	crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
1181	int		dgram_counter;
1182	int		to_process = skb->len;
1183	struct f_ncm_opts *ncm_opts;
1184
1185	ncm_opts = container_of(port->func.fi, struct f_ncm_opts, func_inst);
1186	frame_max = ncm_opts->max_segment_size;
1187
1188parse_ntb:
1189	tmp = (__le16 *)ntb_ptr;
1190
1191	/* dwSignature */
1192	if (get_unaligned_le32(tmp) != opts->nth_sign) {
1193		INFO(port->func.config->cdev, "Wrong NTH SIGN, skblen %d\n",
1194			skb->len);
1195		print_hex_dump(KERN_INFO, "HEAD:", DUMP_PREFIX_ADDRESS, 32, 1,
1196			       skb->data, 32, false);
1197
1198		goto err;
1199	}
1200	tmp += 2;
1201	/* wHeaderLength */
1202	if (get_unaligned_le16(tmp++) != opts->nth_size) {
1203		INFO(port->func.config->cdev, "Wrong NTB headersize\n");
1204		goto err;
1205	}
1206	tmp++; /* skip wSequence */
1207
1208	block_len = get_ncm(&tmp, opts->block_length);
1209	/* (d)wBlockLength */
1210	if (block_len > ntb_max) {
1211		INFO(port->func.config->cdev, "OUT size exceeded\n");
1212		goto err;
1213	}
1214
1215	ndp_index = get_ncm(&tmp, opts->ndp_index);
1216
1217	/* Run through all the NDP's in the NTB */
1218	do {
1219		/*
1220		 * NCM 3.2
1221		 * dwNdpIndex
1222		 */
1223		if (((ndp_index % 4) != 0) ||
1224				(ndp_index < opts->nth_size) ||
1225				(ndp_index > (block_len -
1226					      opts->ndp_size))) {
1227			INFO(port->func.config->cdev, "Bad index: %#X\n",
1228			     ndp_index);
1229			goto err;
1230		}
1231
1232		/*
1233		 * walk through NDP
1234		 * dwSignature
1235		 */
1236		tmp = (__le16 *)(ntb_ptr + ndp_index);
1237		if (get_unaligned_le32(tmp) != ncm->ndp_sign) {
1238			INFO(port->func.config->cdev, "Wrong NDP SIGN\n");
1239			goto err;
1240		}
1241		tmp += 2;
1242
1243		ndp_len = get_unaligned_le16(tmp++);
1244		/*
1245		 * NCM 3.3.1
1246		 * wLength
1247		 * entry is 2 items
1248		 * item size is 16/32 bits, opts->dgram_item_len * 2 bytes
1249		 * minimal: struct usb_cdc_ncm_ndpX + normal entry + zero entry
1250		 * Each entry is a dgram index and a dgram length.
1251		 */
1252		if ((ndp_len < opts->ndp_size
1253				+ 2 * 2 * (opts->dgram_item_len * 2)) ||
1254				(ndp_len % opts->ndplen_align != 0)) {
1255			INFO(port->func.config->cdev, "Bad NDP length: %#X\n",
1256			     ndp_len);
1257			goto err;
1258		}
1259		tmp += opts->reserved1;
1260		/* Check for another NDP (d)wNextNdpIndex */
1261		ndp_index = get_ncm(&tmp, opts->next_ndp_index);
1262		tmp += opts->reserved2;
1263
1264		ndp_len -= opts->ndp_size;
1265		index2 = get_ncm(&tmp, opts->dgram_item_len);
1266		dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
1267		dgram_counter = 0;
1268
1269		do {
1270			index = index2;
1271			/* wDatagramIndex[0] */
1272			if ((index < opts->nth_size) ||
1273					(index > block_len - opts->dpe_size)) {
1274				INFO(port->func.config->cdev,
1275				     "Bad index: %#X\n", index);
1276				goto err;
1277			}
1278
1279			dg_len = dg_len2;
1280			/*
1281			 * wDatagramLength[0]
1282			 * ethernet hdr + crc or larger than max frame size
1283			 */
1284			if ((dg_len < 14 + crc_len) ||
1285					(dg_len > frame_max)) {
1286				INFO(port->func.config->cdev,
1287				     "Bad dgram length: %#X\n", dg_len);
1288				goto err;
1289			}
1290			if (ncm->is_crc) {
1291				uint32_t crc, crc2;
1292
1293				crc = get_unaligned_le32(ntb_ptr +
1294							 index + dg_len -
1295							 crc_len);
1296				crc2 = ~crc32_le(~0,
1297						 ntb_ptr + index,
1298						 dg_len - crc_len);
1299				if (crc != crc2) {
1300					INFO(port->func.config->cdev,
1301					     "Bad CRC\n");
1302					goto err;
1303				}
1304			}
1305
1306			index2 = get_ncm(&tmp, opts->dgram_item_len);
1307			dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
1308
1309			/* wDatagramIndex[1] */
1310			if (index2 > block_len - opts->dpe_size) {
1311				INFO(port->func.config->cdev,
1312				     "Bad index: %#X\n", index2);
1313				goto err;
1314			}
1315
1316			/*
1317			 * Copy the data into a new skb.
1318			 * This ensures the truesize is correct
1319			 */
1320			skb2 = netdev_alloc_skb_ip_align(ncm->netdev,
1321							 dg_len - crc_len);
1322			if (skb2 == NULL)
1323				goto err;
1324			skb_put_data(skb2, ntb_ptr + index,
1325				     dg_len - crc_len);
1326
1327			skb_queue_tail(list, skb2);
1328
1329			ndp_len -= 2 * (opts->dgram_item_len * 2);
1330
1331			dgram_counter++;
 
1332			if (index2 == 0 || dg_len2 == 0)
1333				break;
1334		} while (ndp_len > 2 * (opts->dgram_item_len * 2));
1335	} while (ndp_index);
1336
 
 
1337	VDBG(port->func.config->cdev,
1338	     "Parsed NTB with %d frames\n", dgram_counter);
1339
1340	to_process -= block_len;
1341
1342	/*
1343	 * Windows NCM driver avoids USB ZLPs by adding a 1-byte
1344	 * zero pad as needed.
1345	 */
1346	if (to_process == 1 &&
1347	    (*(unsigned char *)(ntb_ptr + block_len) == 0x00)) {
1348		to_process--;
1349	} else if ((to_process > 0) && (block_len != 0)) {
1350		ntb_ptr = (unsigned char *)(ntb_ptr + block_len);
1351		goto parse_ntb;
1352	}
1353
1354	dev_consume_skb_any(skb);
1355
1356	return 0;
1357err:
1358	skb_queue_purge(list);
1359	dev_kfree_skb_any(skb);
1360	return ret;
1361}
1362
1363static void ncm_disable(struct usb_function *f)
1364{
1365	struct f_ncm		*ncm = func_to_ncm(f);
1366	struct usb_composite_dev *cdev = f->config->cdev;
1367
1368	DBG(cdev, "ncm deactivated\n");
1369
1370	if (ncm->port.in_ep->enabled) {
 
1371		ncm->netdev = NULL;
1372		gether_disconnect(&ncm->port);
1373	}
1374
1375	if (ncm->notify->enabled) {
1376		usb_ep_disable(ncm->notify);
1377		ncm->notify->desc = NULL;
1378	}
1379}
1380
1381/*-------------------------------------------------------------------------*/
1382
1383/*
1384 * Callbacks let us notify the host about connect/disconnect when the
1385 * net device is opened or closed.
1386 *
1387 * For testing, note that link states on this side include both opened
1388 * and closed variants of:
1389 *
1390 *   - disconnected/unconfigured
1391 *   - configured but inactive (data alt 0)
1392 *   - configured and active (data alt 1)
1393 *
1394 * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
1395 * SET_INTERFACE (altsetting).  Remember also that "configured" doesn't
1396 * imply the host is actually polling the notification endpoint, and
1397 * likewise that "active" doesn't imply it's actually using the data
1398 * endpoints for traffic.
1399 */
1400
1401static void ncm_open(struct gether *geth)
1402{
1403	struct f_ncm		*ncm = func_to_ncm(&geth->func);
1404
1405	DBG(ncm->port.func.config->cdev, "%s\n", __func__);
1406
1407	spin_lock(&ncm->lock);
1408	ncm->is_open = true;
1409	ncm_notify(ncm);
1410	spin_unlock(&ncm->lock);
1411}
1412
1413static void ncm_close(struct gether *geth)
1414{
1415	struct f_ncm		*ncm = func_to_ncm(&geth->func);
1416
1417	DBG(ncm->port.func.config->cdev, "%s\n", __func__);
1418
1419	spin_lock(&ncm->lock);
1420	ncm->is_open = false;
1421	ncm_notify(ncm);
1422	spin_unlock(&ncm->lock);
1423}
1424
1425/*-------------------------------------------------------------------------*/
1426
1427/* ethernet function driver setup/binding */
1428
1429static int ncm_bind(struct usb_configuration *c, struct usb_function *f)
1430{
1431	struct usb_composite_dev *cdev = c->cdev;
1432	struct f_ncm		*ncm = func_to_ncm(f);
1433	struct usb_string	*us;
1434	int			status = 0;
1435	struct usb_ep		*ep;
1436	struct f_ncm_opts	*ncm_opts;
1437
1438	if (!can_support_ecm(cdev->gadget))
1439		return -EINVAL;
1440
1441	ncm_opts = container_of(f->fi, struct f_ncm_opts, func_inst);
1442
1443	if (cdev->use_os_string) {
1444		f->os_desc_table = kzalloc(sizeof(*f->os_desc_table),
1445					   GFP_KERNEL);
1446		if (!f->os_desc_table)
1447			return -ENOMEM;
1448		f->os_desc_n = 1;
1449		f->os_desc_table[0].os_desc = &ncm_opts->ncm_os_desc;
1450	}
1451
1452	mutex_lock(&ncm_opts->lock);
1453	gether_set_gadget(ncm_opts->net, cdev->gadget);
1454	if (!ncm_opts->bound) {
1455		ncm_opts->net->mtu = (ncm_opts->max_segment_size - ETH_HLEN);
 
1456		status = gether_register_netdev(ncm_opts->net);
 
 
 
 
1457	}
1458	mutex_unlock(&ncm_opts->lock);
1459
1460	if (status)
1461		goto fail;
1462
1463	ncm_opts->bound = true;
1464
1465	us = usb_gstrings_attach(cdev, ncm_strings,
1466				 ARRAY_SIZE(ncm_string_defs));
1467	if (IS_ERR(us)) {
1468		status = PTR_ERR(us);
1469		goto fail;
1470	}
1471	ncm_control_intf.iInterface = us[STRING_CTRL_IDX].id;
1472	ncm_data_nop_intf.iInterface = us[STRING_DATA_IDX].id;
1473	ncm_data_intf.iInterface = us[STRING_DATA_IDX].id;
1474	ecm_desc.iMACAddress = us[STRING_MAC_IDX].id;
1475	ncm_iad_desc.iFunction = us[STRING_IAD_IDX].id;
1476
1477	/* allocate instance-specific interface IDs */
1478	status = usb_interface_id(c, f);
1479	if (status < 0)
1480		goto fail;
1481	ncm->ctrl_id = status;
1482	ncm_iad_desc.bFirstInterface = status;
1483
1484	ncm_control_intf.bInterfaceNumber = status;
1485	ncm_union_desc.bMasterInterface0 = status;
1486
1487	if (cdev->use_os_string)
1488		f->os_desc_table[0].if_id =
1489			ncm_iad_desc.bFirstInterface;
1490
1491	status = usb_interface_id(c, f);
1492	if (status < 0)
1493		goto fail;
1494	ncm->data_id = status;
1495
1496	ncm_data_nop_intf.bInterfaceNumber = status;
1497	ncm_data_intf.bInterfaceNumber = status;
1498	ncm_union_desc.bSlaveInterface0 = status;
1499
1500	ecm_desc.wMaxSegmentSize = cpu_to_le16(ncm_opts->max_segment_size);
1501
1502	status = -ENODEV;
1503
1504	/* allocate instance-specific endpoints */
1505	ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_in_desc);
1506	if (!ep)
1507		goto fail;
1508	ncm->port.in_ep = ep;
1509
1510	ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_out_desc);
1511	if (!ep)
1512		goto fail;
1513	ncm->port.out_ep = ep;
1514
1515	ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_notify_desc);
1516	if (!ep)
1517		goto fail;
1518	ncm->notify = ep;
1519
1520	status = -ENOMEM;
1521
1522	/* allocate notification request and buffer */
1523	ncm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
1524	if (!ncm->notify_req)
1525		goto fail;
1526	ncm->notify_req->buf = kmalloc(NCM_STATUS_BYTECOUNT, GFP_KERNEL);
1527	if (!ncm->notify_req->buf)
1528		goto fail;
1529	ncm->notify_req->context = ncm;
1530	ncm->notify_req->complete = ncm_notify_complete;
1531
1532	/*
1533	 * support all relevant hardware speeds... we expect that when
1534	 * hardware is dual speed, all bulk-capable endpoints work at
1535	 * both speeds
1536	 */
1537	hs_ncm_in_desc.bEndpointAddress = fs_ncm_in_desc.bEndpointAddress;
1538	hs_ncm_out_desc.bEndpointAddress = fs_ncm_out_desc.bEndpointAddress;
1539	hs_ncm_notify_desc.bEndpointAddress =
1540		fs_ncm_notify_desc.bEndpointAddress;
1541
1542	ss_ncm_in_desc.bEndpointAddress = fs_ncm_in_desc.bEndpointAddress;
1543	ss_ncm_out_desc.bEndpointAddress = fs_ncm_out_desc.bEndpointAddress;
1544	ss_ncm_notify_desc.bEndpointAddress =
1545		fs_ncm_notify_desc.bEndpointAddress;
1546
1547	status = usb_assign_descriptors(f, ncm_fs_function, ncm_hs_function,
1548			ncm_ss_function, ncm_ss_function);
1549	if (status)
1550		goto fail;
1551
1552	/*
1553	 * NOTE:  all that is done without knowing or caring about
1554	 * the network link ... which is unavailable to this code
1555	 * until we're activated via set_alt().
1556	 */
1557
1558	ncm->port.open = ncm_open;
1559	ncm->port.close = ncm_close;
1560
1561	hrtimer_init(&ncm->task_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_SOFT);
 
1562	ncm->task_timer.function = ncm_tx_timeout;
1563
1564	DBG(cdev, "CDC Network: IN/%s OUT/%s NOTIFY/%s\n",
 
1565			ncm->port.in_ep->name, ncm->port.out_ep->name,
1566			ncm->notify->name);
1567	return 0;
1568
1569fail:
1570	kfree(f->os_desc_table);
1571	f->os_desc_n = 0;
1572
1573	if (ncm->notify_req) {
1574		kfree(ncm->notify_req->buf);
1575		usb_ep_free_request(ncm->notify, ncm->notify_req);
1576	}
1577
1578	ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
1579
1580	return status;
1581}
1582
1583static inline struct f_ncm_opts *to_f_ncm_opts(struct config_item *item)
1584{
1585	return container_of(to_config_group(item), struct f_ncm_opts,
1586			    func_inst.group);
1587}
1588
1589/* f_ncm_item_ops */
1590USB_ETHERNET_CONFIGFS_ITEM(ncm);
1591
1592/* f_ncm_opts_dev_addr */
1593USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(ncm);
1594
1595/* f_ncm_opts_host_addr */
1596USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(ncm);
1597
1598/* f_ncm_opts_qmult */
1599USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(ncm);
1600
1601/* f_ncm_opts_ifname */
1602USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(ncm);
1603
1604static ssize_t ncm_opts_max_segment_size_show(struct config_item *item,
1605					      char *page)
1606{
1607	struct f_ncm_opts *opts = to_f_ncm_opts(item);
1608	u16 segment_size;
1609
1610	mutex_lock(&opts->lock);
1611	segment_size = opts->max_segment_size;
1612	mutex_unlock(&opts->lock);
1613
1614	return sysfs_emit(page, "%u\n", segment_size);
1615}
1616
1617static ssize_t ncm_opts_max_segment_size_store(struct config_item *item,
1618					       const char *page, size_t len)
1619{
1620	struct f_ncm_opts *opts = to_f_ncm_opts(item);
1621	u16 segment_size;
1622	int ret;
1623
1624	mutex_lock(&opts->lock);
1625	if (opts->refcnt) {
1626		ret = -EBUSY;
1627		goto out;
1628	}
1629
1630	ret = kstrtou16(page, 0, &segment_size);
1631	if (ret)
1632		goto out;
1633
1634	if (segment_size > MAX_DATAGRAM_SIZE) {
1635		ret = -EINVAL;
1636		goto out;
1637	}
1638
1639	opts->max_segment_size = segment_size;
1640	ret = len;
1641out:
1642	mutex_unlock(&opts->lock);
1643	return ret;
1644}
1645
1646CONFIGFS_ATTR(ncm_opts_, max_segment_size);
1647
1648static struct configfs_attribute *ncm_attrs[] = {
1649	&ncm_opts_attr_dev_addr,
1650	&ncm_opts_attr_host_addr,
1651	&ncm_opts_attr_qmult,
1652	&ncm_opts_attr_ifname,
1653	&ncm_opts_attr_max_segment_size,
1654	NULL,
1655};
1656
1657static const struct config_item_type ncm_func_type = {
1658	.ct_item_ops	= &ncm_item_ops,
1659	.ct_attrs	= ncm_attrs,
1660	.ct_owner	= THIS_MODULE,
1661};
1662
1663static void ncm_free_inst(struct usb_function_instance *f)
1664{
1665	struct f_ncm_opts *opts;
1666
1667	opts = container_of(f, struct f_ncm_opts, func_inst);
1668	if (opts->bound)
1669		gether_cleanup(netdev_priv(opts->net));
1670	else
1671		free_netdev(opts->net);
1672	kfree(opts->ncm_interf_group);
1673	kfree(opts);
1674}
1675
1676static struct usb_function_instance *ncm_alloc_inst(void)
1677{
1678	struct f_ncm_opts *opts;
1679	struct usb_os_desc *descs[1];
1680	char *names[1];
1681	struct config_group *ncm_interf_group;
1682
1683	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1684	if (!opts)
1685		return ERR_PTR(-ENOMEM);
1686	opts->ncm_os_desc.ext_compat_id = opts->ncm_ext_compat_id;
1687
1688	mutex_init(&opts->lock);
1689	opts->func_inst.free_func_inst = ncm_free_inst;
1690	opts->net = gether_setup_default();
1691	if (IS_ERR(opts->net)) {
1692		struct net_device *net = opts->net;
1693		kfree(opts);
1694		return ERR_CAST(net);
1695	}
1696	opts->max_segment_size = ETH_FRAME_LEN;
1697	INIT_LIST_HEAD(&opts->ncm_os_desc.ext_prop);
1698
1699	descs[0] = &opts->ncm_os_desc;
1700	names[0] = "ncm";
1701
1702	config_group_init_type_name(&opts->func_inst.group, "", &ncm_func_type);
1703	ncm_interf_group =
1704		usb_os_desc_prepare_interf_dir(&opts->func_inst.group, 1, descs,
1705					       names, THIS_MODULE);
1706	if (IS_ERR(ncm_interf_group)) {
1707		ncm_free_inst(&opts->func_inst);
1708		return ERR_CAST(ncm_interf_group);
1709	}
1710	opts->ncm_interf_group = ncm_interf_group;
1711
1712	return &opts->func_inst;
1713}
1714
1715static void ncm_free(struct usb_function *f)
1716{
1717	struct f_ncm *ncm;
1718	struct f_ncm_opts *opts;
1719
1720	ncm = func_to_ncm(f);
1721	opts = container_of(f->fi, struct f_ncm_opts, func_inst);
1722	kfree(ncm);
1723	mutex_lock(&opts->lock);
1724	opts->refcnt--;
1725	mutex_unlock(&opts->lock);
1726}
1727
1728static void ncm_unbind(struct usb_configuration *c, struct usb_function *f)
1729{
1730	struct f_ncm *ncm = func_to_ncm(f);
1731
1732	DBG(c->cdev, "ncm unbind\n");
1733
1734	hrtimer_cancel(&ncm->task_timer);
1735
1736	kfree(f->os_desc_table);
1737	f->os_desc_n = 0;
1738
1739	ncm_string_defs[0].id = 0;
1740	usb_free_all_descriptors(f);
1741
1742	if (atomic_read(&ncm->notify_count)) {
1743		usb_ep_dequeue(ncm->notify, ncm->notify_req);
1744		atomic_set(&ncm->notify_count, 0);
1745	}
1746
1747	kfree(ncm->notify_req->buf);
1748	usb_ep_free_request(ncm->notify, ncm->notify_req);
1749}
1750
1751static struct usb_function *ncm_alloc(struct usb_function_instance *fi)
1752{
1753	struct f_ncm		*ncm;
1754	struct f_ncm_opts	*opts;
1755	int status;
1756
1757	/* allocate and initialize one new instance */
1758	ncm = kzalloc(sizeof(*ncm), GFP_KERNEL);
1759	if (!ncm)
1760		return ERR_PTR(-ENOMEM);
1761
1762	opts = container_of(fi, struct f_ncm_opts, func_inst);
1763	mutex_lock(&opts->lock);
1764	opts->refcnt++;
1765
1766	/* export host's Ethernet address in CDC format */
1767	status = gether_get_host_addr_cdc(opts->net, ncm->ethaddr,
1768				      sizeof(ncm->ethaddr));
1769	if (status < 12) { /* strlen("01234567890a") */
1770		kfree(ncm);
1771		mutex_unlock(&opts->lock);
1772		return ERR_PTR(-EINVAL);
1773	}
1774	ncm_string_defs[STRING_MAC_IDX].s = ncm->ethaddr;
1775
1776	spin_lock_init(&ncm->lock);
1777	ncm_reset_values(ncm);
1778	ncm->port.ioport = netdev_priv(opts->net);
1779	mutex_unlock(&opts->lock);
1780	ncm->port.is_fixed = true;
1781	ncm->port.supports_multi_frame = true;
1782
1783	ncm->port.func.name = "cdc_network";
1784	/* descriptors are per-instance copies */
1785	ncm->port.func.bind = ncm_bind;
1786	ncm->port.func.unbind = ncm_unbind;
1787	ncm->port.func.set_alt = ncm_set_alt;
1788	ncm->port.func.get_alt = ncm_get_alt;
1789	ncm->port.func.setup = ncm_setup;
1790	ncm->port.func.disable = ncm_disable;
1791	ncm->port.func.free_func = ncm_free;
1792
1793	ncm->port.wrap = ncm_wrap_ntb;
1794	ncm->port.unwrap = ncm_unwrap_ntb;
1795
1796	return &ncm->port.func;
1797}
1798
1799DECLARE_USB_FUNCTION_INIT(ncm, ncm_alloc_inst, ncm_alloc);
1800MODULE_LICENSE("GPL");
1801MODULE_AUTHOR("Yauheni Kaliuta");
v4.6
 
   1/*
   2 * f_ncm.c -- USB CDC Network (NCM) link function driver
   3 *
   4 * Copyright (C) 2010 Nokia Corporation
   5 * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
   6 *
   7 * The driver borrows from f_ecm.c which is:
   8 *
   9 * Copyright (C) 2003-2005,2008 David Brownell
  10 * Copyright (C) 2008 Nokia Corporation
  11 *
  12 * This program is free software; you can redistribute it and/or modify
  13 * it under the terms of the GNU General Public License as published by
  14 * the Free Software Foundation; either version 2 of the License, or
  15 * (at your option) any later version.
  16 */
  17
  18#include <linux/kernel.h>
 
  19#include <linux/module.h>
  20#include <linux/device.h>
  21#include <linux/etherdevice.h>
  22#include <linux/crc32.h>
  23
  24#include <linux/usb/cdc.h>
  25
  26#include "u_ether.h"
  27#include "u_ether_configfs.h"
  28#include "u_ncm.h"
 
  29
  30/*
  31 * This function is a "CDC Network Control Model" (CDC NCM) Ethernet link.
  32 * NCM is intended to be used with high-speed network attachments.
  33 *
  34 * Note that NCM requires the use of "alternate settings" for its data
  35 * interface.  This means that the set_alt() method has real work to do,
  36 * and also means that a get_alt() method is required.
  37 */
  38
  39/* to trigger crc/non-crc ndp signature */
  40
  41#define NCM_NDP_HDR_CRC_MASK	0x01000000
  42#define NCM_NDP_HDR_CRC		0x01000000
  43#define NCM_NDP_HDR_NOCRC	0x00000000
  44
  45enum ncm_notify_state {
  46	NCM_NOTIFY_NONE,		/* don't notify */
  47	NCM_NOTIFY_CONNECT,		/* issue CONNECT next */
  48	NCM_NOTIFY_SPEED,		/* issue SPEED_CHANGE next */
  49};
  50
  51struct f_ncm {
  52	struct gether			port;
  53	u8				ctrl_id, data_id;
  54
  55	char				ethaddr[14];
  56
  57	struct usb_ep			*notify;
  58	struct usb_request		*notify_req;
  59	u8				notify_state;
 
  60	bool				is_open;
  61
  62	const struct ndp_parser_opts	*parser_opts;
  63	bool				is_crc;
  64	u32				ndp_sign;
  65
  66	/*
  67	 * for notification, it is accessed from both
  68	 * callback and ethernet open/close
  69	 */
  70	spinlock_t			lock;
  71
  72	struct net_device		*netdev;
  73
  74	/* For multi-frame NDP TX */
  75	struct sk_buff			*skb_tx_data;
  76	struct sk_buff			*skb_tx_ndp;
  77	u16				ndp_dgram_count;
  78	bool				timer_force_tx;
  79	struct tasklet_struct		tx_tasklet;
  80	struct hrtimer			task_timer;
  81
  82	bool				timer_stopping;
  83};
  84
  85static inline struct f_ncm *func_to_ncm(struct usb_function *f)
  86{
  87	return container_of(f, struct f_ncm, port.func);
  88}
  89
  90/* peak (theoretical) bulk transfer rate in bits-per-second */
  91static inline unsigned ncm_bitrate(struct usb_gadget *g)
  92{
  93	if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
  94		return 13 * 512 * 8 * 1000 * 8;
  95	else
  96		return 19 *  64 * 1 * 1000 * 8;
  97}
  98
  99/*-------------------------------------------------------------------------*/
 100
 101/*
 102 * We cannot group frames so use just the minimal size which ok to put
 103 * one max-size ethernet frame.
 104 * If the host can group frames, allow it to do that, 16K is selected,
 105 * because it's used by default by the current linux host driver
 106 */
 107#define NTB_DEFAULT_IN_SIZE	16384
 108#define NTB_OUT_SIZE		16384
 109
 110/* Allocation for storing the NDP, 32 should suffice for a
 111 * 16k packet. This allows a maximum of 32 * 507 Byte packets to
 112 * be transmitted in a single 16kB skb, though when sending full size
 113 * packets this limit will be plenty.
 114 * Smaller packets are not likely to be trying to maximize the
 115 * throughput and will be mstly sending smaller infrequent frames.
 116 */
 117#define TX_MAX_NUM_DPE		32
 118
 119/* Delay for the transmit to wait before sending an unfilled NTB frame. */
 120#define TX_TIMEOUT_NSECS	300000
 121
 
 
 
 
 
 
 
 
 
 
 122#define FORMATS_SUPPORTED	(USB_CDC_NCM_NTB16_SUPPORTED |	\
 123				 USB_CDC_NCM_NTB32_SUPPORTED)
 124
 125static struct usb_cdc_ncm_ntb_parameters ntb_parameters = {
 126	.wLength = cpu_to_le16(sizeof(ntb_parameters)),
 127	.bmNtbFormatsSupported = cpu_to_le16(FORMATS_SUPPORTED),
 128	.dwNtbInMaxSize = cpu_to_le32(NTB_DEFAULT_IN_SIZE),
 129	.wNdpInDivisor = cpu_to_le16(4),
 130	.wNdpInPayloadRemainder = cpu_to_le16(0),
 131	.wNdpInAlignment = cpu_to_le16(4),
 132
 133	.dwNtbOutMaxSize = cpu_to_le32(NTB_OUT_SIZE),
 134	.wNdpOutDivisor = cpu_to_le16(4),
 135	.wNdpOutPayloadRemainder = cpu_to_le16(0),
 136	.wNdpOutAlignment = cpu_to_le16(4),
 137};
 138
 139/*
 140 * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
 141 * packet, to simplify cancellation; and a big transfer interval, to
 142 * waste less bandwidth.
 143 */
 144
 145#define NCM_STATUS_INTERVAL_MS		32
 146#define NCM_STATUS_BYTECOUNT		16	/* 8 byte header + data */
 147
 148static struct usb_interface_assoc_descriptor ncm_iad_desc = {
 149	.bLength =		sizeof ncm_iad_desc,
 150	.bDescriptorType =	USB_DT_INTERFACE_ASSOCIATION,
 151
 152	/* .bFirstInterface =	DYNAMIC, */
 153	.bInterfaceCount =	2,	/* control + data */
 154	.bFunctionClass =	USB_CLASS_COMM,
 155	.bFunctionSubClass =	USB_CDC_SUBCLASS_NCM,
 156	.bFunctionProtocol =	USB_CDC_PROTO_NONE,
 157	/* .iFunction =		DYNAMIC */
 158};
 159
 160/* interface descriptor: */
 161
 162static struct usb_interface_descriptor ncm_control_intf = {
 163	.bLength =		sizeof ncm_control_intf,
 164	.bDescriptorType =	USB_DT_INTERFACE,
 165
 166	/* .bInterfaceNumber = DYNAMIC */
 167	.bNumEndpoints =	1,
 168	.bInterfaceClass =	USB_CLASS_COMM,
 169	.bInterfaceSubClass =	USB_CDC_SUBCLASS_NCM,
 170	.bInterfaceProtocol =	USB_CDC_PROTO_NONE,
 171	/* .iInterface = DYNAMIC */
 172};
 173
 174static struct usb_cdc_header_desc ncm_header_desc = {
 175	.bLength =		sizeof ncm_header_desc,
 176	.bDescriptorType =	USB_DT_CS_INTERFACE,
 177	.bDescriptorSubType =	USB_CDC_HEADER_TYPE,
 178
 179	.bcdCDC =		cpu_to_le16(0x0110),
 180};
 181
 182static struct usb_cdc_union_desc ncm_union_desc = {
 183	.bLength =		sizeof(ncm_union_desc),
 184	.bDescriptorType =	USB_DT_CS_INTERFACE,
 185	.bDescriptorSubType =	USB_CDC_UNION_TYPE,
 186	/* .bMasterInterface0 =	DYNAMIC */
 187	/* .bSlaveInterface0 =	DYNAMIC */
 188};
 189
 190static struct usb_cdc_ether_desc ecm_desc = {
 191	.bLength =		sizeof ecm_desc,
 192	.bDescriptorType =	USB_DT_CS_INTERFACE,
 193	.bDescriptorSubType =	USB_CDC_ETHERNET_TYPE,
 194
 195	/* this descriptor actually adds value, surprise! */
 196	/* .iMACAddress = DYNAMIC */
 197	.bmEthernetStatistics =	cpu_to_le32(0), /* no statistics */
 198	.wMaxSegmentSize =	cpu_to_le16(ETH_FRAME_LEN),
 199	.wNumberMCFilters =	cpu_to_le16(0),
 200	.bNumberPowerFilters =	0,
 201};
 202
 203#define NCAPS	(USB_CDC_NCM_NCAP_ETH_FILTER | USB_CDC_NCM_NCAP_CRC_MODE)
 204
 205static struct usb_cdc_ncm_desc ncm_desc = {
 206	.bLength =		sizeof ncm_desc,
 207	.bDescriptorType =	USB_DT_CS_INTERFACE,
 208	.bDescriptorSubType =	USB_CDC_NCM_TYPE,
 209
 210	.bcdNcmVersion =	cpu_to_le16(0x0100),
 211	/* can process SetEthernetPacketFilter */
 212	.bmNetworkCapabilities = NCAPS,
 213};
 214
 215/* the default data interface has no endpoints ... */
 216
 217static struct usb_interface_descriptor ncm_data_nop_intf = {
 218	.bLength =		sizeof ncm_data_nop_intf,
 219	.bDescriptorType =	USB_DT_INTERFACE,
 220
 221	.bInterfaceNumber =	1,
 222	.bAlternateSetting =	0,
 223	.bNumEndpoints =	0,
 224	.bInterfaceClass =	USB_CLASS_CDC_DATA,
 225	.bInterfaceSubClass =	0,
 226	.bInterfaceProtocol =	USB_CDC_NCM_PROTO_NTB,
 227	/* .iInterface = DYNAMIC */
 228};
 229
 230/* ... but the "real" data interface has two bulk endpoints */
 231
 232static struct usb_interface_descriptor ncm_data_intf = {
 233	.bLength =		sizeof ncm_data_intf,
 234	.bDescriptorType =	USB_DT_INTERFACE,
 235
 236	.bInterfaceNumber =	1,
 237	.bAlternateSetting =	1,
 238	.bNumEndpoints =	2,
 239	.bInterfaceClass =	USB_CLASS_CDC_DATA,
 240	.bInterfaceSubClass =	0,
 241	.bInterfaceProtocol =	USB_CDC_NCM_PROTO_NTB,
 242	/* .iInterface = DYNAMIC */
 243};
 244
 245/* full speed support: */
 246
 247static struct usb_endpoint_descriptor fs_ncm_notify_desc = {
 248	.bLength =		USB_DT_ENDPOINT_SIZE,
 249	.bDescriptorType =	USB_DT_ENDPOINT,
 250
 251	.bEndpointAddress =	USB_DIR_IN,
 252	.bmAttributes =		USB_ENDPOINT_XFER_INT,
 253	.wMaxPacketSize =	cpu_to_le16(NCM_STATUS_BYTECOUNT),
 254	.bInterval =		NCM_STATUS_INTERVAL_MS,
 255};
 256
 257static struct usb_endpoint_descriptor fs_ncm_in_desc = {
 258	.bLength =		USB_DT_ENDPOINT_SIZE,
 259	.bDescriptorType =	USB_DT_ENDPOINT,
 260
 261	.bEndpointAddress =	USB_DIR_IN,
 262	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 263};
 264
 265static struct usb_endpoint_descriptor fs_ncm_out_desc = {
 266	.bLength =		USB_DT_ENDPOINT_SIZE,
 267	.bDescriptorType =	USB_DT_ENDPOINT,
 268
 269	.bEndpointAddress =	USB_DIR_OUT,
 270	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 271};
 272
 273static struct usb_descriptor_header *ncm_fs_function[] = {
 274	(struct usb_descriptor_header *) &ncm_iad_desc,
 275	/* CDC NCM control descriptors */
 276	(struct usb_descriptor_header *) &ncm_control_intf,
 277	(struct usb_descriptor_header *) &ncm_header_desc,
 278	(struct usb_descriptor_header *) &ncm_union_desc,
 279	(struct usb_descriptor_header *) &ecm_desc,
 280	(struct usb_descriptor_header *) &ncm_desc,
 281	(struct usb_descriptor_header *) &fs_ncm_notify_desc,
 282	/* data interface, altsettings 0 and 1 */
 283	(struct usb_descriptor_header *) &ncm_data_nop_intf,
 284	(struct usb_descriptor_header *) &ncm_data_intf,
 285	(struct usb_descriptor_header *) &fs_ncm_in_desc,
 286	(struct usb_descriptor_header *) &fs_ncm_out_desc,
 287	NULL,
 288};
 289
 290/* high speed support: */
 291
 292static struct usb_endpoint_descriptor hs_ncm_notify_desc = {
 293	.bLength =		USB_DT_ENDPOINT_SIZE,
 294	.bDescriptorType =	USB_DT_ENDPOINT,
 295
 296	.bEndpointAddress =	USB_DIR_IN,
 297	.bmAttributes =		USB_ENDPOINT_XFER_INT,
 298	.wMaxPacketSize =	cpu_to_le16(NCM_STATUS_BYTECOUNT),
 299	.bInterval =		USB_MS_TO_HS_INTERVAL(NCM_STATUS_INTERVAL_MS),
 300};
 301static struct usb_endpoint_descriptor hs_ncm_in_desc = {
 302	.bLength =		USB_DT_ENDPOINT_SIZE,
 303	.bDescriptorType =	USB_DT_ENDPOINT,
 304
 305	.bEndpointAddress =	USB_DIR_IN,
 306	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 307	.wMaxPacketSize =	cpu_to_le16(512),
 308};
 309
 310static struct usb_endpoint_descriptor hs_ncm_out_desc = {
 311	.bLength =		USB_DT_ENDPOINT_SIZE,
 312	.bDescriptorType =	USB_DT_ENDPOINT,
 313
 314	.bEndpointAddress =	USB_DIR_OUT,
 315	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 316	.wMaxPacketSize =	cpu_to_le16(512),
 317};
 318
 319static struct usb_descriptor_header *ncm_hs_function[] = {
 320	(struct usb_descriptor_header *) &ncm_iad_desc,
 321	/* CDC NCM control descriptors */
 322	(struct usb_descriptor_header *) &ncm_control_intf,
 323	(struct usb_descriptor_header *) &ncm_header_desc,
 324	(struct usb_descriptor_header *) &ncm_union_desc,
 325	(struct usb_descriptor_header *) &ecm_desc,
 326	(struct usb_descriptor_header *) &ncm_desc,
 327	(struct usb_descriptor_header *) &hs_ncm_notify_desc,
 328	/* data interface, altsettings 0 and 1 */
 329	(struct usb_descriptor_header *) &ncm_data_nop_intf,
 330	(struct usb_descriptor_header *) &ncm_data_intf,
 331	(struct usb_descriptor_header *) &hs_ncm_in_desc,
 332	(struct usb_descriptor_header *) &hs_ncm_out_desc,
 333	NULL,
 334};
 335
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 336/* string descriptors: */
 337
 338#define STRING_CTRL_IDX	0
 339#define STRING_MAC_IDX	1
 340#define STRING_DATA_IDX	2
 341#define STRING_IAD_IDX	3
 342
 343static struct usb_string ncm_string_defs[] = {
 344	[STRING_CTRL_IDX].s = "CDC Network Control Model (NCM)",
 345	[STRING_MAC_IDX].s = "",
 346	[STRING_DATA_IDX].s = "CDC Network Data",
 347	[STRING_IAD_IDX].s = "CDC NCM",
 348	{  } /* end of list */
 349};
 350
 351static struct usb_gadget_strings ncm_string_table = {
 352	.language =		0x0409,	/* en-us */
 353	.strings =		ncm_string_defs,
 354};
 355
 356static struct usb_gadget_strings *ncm_strings[] = {
 357	&ncm_string_table,
 358	NULL,
 359};
 360
 361/*
 362 * Here are options for NCM Datagram Pointer table (NDP) parser.
 363 * There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
 364 * in NDP16 offsets and sizes fields are 1 16bit word wide,
 365 * in NDP32 -- 2 16bit words wide. Also signatures are different.
 366 * To make the parser code the same, put the differences in the structure,
 367 * and switch pointers to the structures when the format is changed.
 368 */
 369
 370struct ndp_parser_opts {
 371	u32		nth_sign;
 372	u32		ndp_sign;
 373	unsigned	nth_size;
 374	unsigned	ndp_size;
 375	unsigned	dpe_size;
 376	unsigned	ndplen_align;
 377	/* sizes in u16 units */
 378	unsigned	dgram_item_len; /* index or length */
 379	unsigned	block_length;
 380	unsigned	ndp_index;
 381	unsigned	reserved1;
 382	unsigned	reserved2;
 383	unsigned	next_ndp_index;
 384};
 385
 386#define INIT_NDP16_OPTS {					\
 387		.nth_sign = USB_CDC_NCM_NTH16_SIGN,		\
 388		.ndp_sign = USB_CDC_NCM_NDP16_NOCRC_SIGN,	\
 389		.nth_size = sizeof(struct usb_cdc_ncm_nth16),	\
 390		.ndp_size = sizeof(struct usb_cdc_ncm_ndp16),	\
 391		.dpe_size = sizeof(struct usb_cdc_ncm_dpe16),	\
 392		.ndplen_align = 4,				\
 393		.dgram_item_len = 1,				\
 394		.block_length = 1,				\
 395		.ndp_index = 1,					\
 396		.reserved1 = 0,					\
 397		.reserved2 = 0,					\
 398		.next_ndp_index = 1,				\
 399	}
 400
 401
 402#define INIT_NDP32_OPTS {					\
 403		.nth_sign = USB_CDC_NCM_NTH32_SIGN,		\
 404		.ndp_sign = USB_CDC_NCM_NDP32_NOCRC_SIGN,	\
 405		.nth_size = sizeof(struct usb_cdc_ncm_nth32),	\
 406		.ndp_size = sizeof(struct usb_cdc_ncm_ndp32),	\
 407		.dpe_size = sizeof(struct usb_cdc_ncm_dpe32),	\
 408		.ndplen_align = 8,				\
 409		.dgram_item_len = 2,				\
 410		.block_length = 2,				\
 411		.ndp_index = 2,					\
 412		.reserved1 = 1,					\
 413		.reserved2 = 2,					\
 414		.next_ndp_index = 2,				\
 415	}
 416
 417static const struct ndp_parser_opts ndp16_opts = INIT_NDP16_OPTS;
 418static const struct ndp_parser_opts ndp32_opts = INIT_NDP32_OPTS;
 419
 420static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
 421{
 422	switch (size) {
 423	case 1:
 424		put_unaligned_le16((u16)val, *p);
 425		break;
 426	case 2:
 427		put_unaligned_le32((u32)val, *p);
 428
 429		break;
 430	default:
 431		BUG();
 432	}
 433
 434	*p += size;
 435}
 436
 437static inline unsigned get_ncm(__le16 **p, unsigned size)
 438{
 439	unsigned tmp;
 440
 441	switch (size) {
 442	case 1:
 443		tmp = get_unaligned_le16(*p);
 444		break;
 445	case 2:
 446		tmp = get_unaligned_le32(*p);
 447		break;
 448	default:
 449		BUG();
 450	}
 451
 452	*p += size;
 453	return tmp;
 454}
 455
 456/*-------------------------------------------------------------------------*/
 457
 458static inline void ncm_reset_values(struct f_ncm *ncm)
 459{
 460	ncm->parser_opts = &ndp16_opts;
 461	ncm->is_crc = false;
 
 462	ncm->port.cdc_filter = DEFAULT_FILTER;
 463
 464	/* doesn't make sense for ncm, fixed size used */
 465	ncm->port.header_len = 0;
 466
 467	ncm->port.fixed_out_len = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
 468	ncm->port.fixed_in_len = NTB_DEFAULT_IN_SIZE;
 469}
 470
 471/*
 472 * Context: ncm->lock held
 473 */
 474static void ncm_do_notify(struct f_ncm *ncm)
 475{
 476	struct usb_request		*req = ncm->notify_req;
 477	struct usb_cdc_notification	*event;
 478	struct usb_composite_dev	*cdev = ncm->port.func.config->cdev;
 479	__le32				*data;
 480	int				status;
 481
 482	/* notification already in flight? */
 483	if (!req)
 484		return;
 485
 486	event = req->buf;
 487	switch (ncm->notify_state) {
 488	case NCM_NOTIFY_NONE:
 489		return;
 490
 491	case NCM_NOTIFY_CONNECT:
 492		event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
 493		if (ncm->is_open)
 494			event->wValue = cpu_to_le16(1);
 495		else
 496			event->wValue = cpu_to_le16(0);
 497		event->wLength = 0;
 498		req->length = sizeof *event;
 499
 500		DBG(cdev, "notify connect %s\n",
 501				ncm->is_open ? "true" : "false");
 502		ncm->notify_state = NCM_NOTIFY_NONE;
 503		break;
 504
 505	case NCM_NOTIFY_SPEED:
 506		event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
 507		event->wValue = cpu_to_le16(0);
 508		event->wLength = cpu_to_le16(8);
 509		req->length = NCM_STATUS_BYTECOUNT;
 510
 511		/* SPEED_CHANGE data is up/down speeds in bits/sec */
 512		data = req->buf + sizeof *event;
 513		data[0] = cpu_to_le32(ncm_bitrate(cdev->gadget));
 514		data[1] = data[0];
 515
 516		DBG(cdev, "notify speed %d\n", ncm_bitrate(cdev->gadget));
 517		ncm->notify_state = NCM_NOTIFY_CONNECT;
 518		break;
 519	}
 520	event->bmRequestType = 0xA1;
 521	event->wIndex = cpu_to_le16(ncm->ctrl_id);
 522
 523	ncm->notify_req = NULL;
 
 524	/*
 525	 * In double buffering if there is a space in FIFO,
 526	 * completion callback can be called right after the call,
 527	 * so unlocking
 528	 */
 529	spin_unlock(&ncm->lock);
 530	status = usb_ep_queue(ncm->notify, req, GFP_ATOMIC);
 531	spin_lock(&ncm->lock);
 532	if (status < 0) {
 533		ncm->notify_req = req;
 534		DBG(cdev, "notify --> %d\n", status);
 535	}
 536}
 537
 538/*
 539 * Context: ncm->lock held
 540 */
 541static void ncm_notify(struct f_ncm *ncm)
 542{
 543	/*
 544	 * NOTE on most versions of Linux, host side cdc-ethernet
 545	 * won't listen for notifications until its netdevice opens.
 546	 * The first notification then sits in the FIFO for a long
 547	 * time, and the second one is queued.
 548	 *
 549	 * If ncm_notify() is called before the second (CONNECT)
 550	 * notification is sent, then it will reset to send the SPEED
 551	 * notificaion again (and again, and again), but it's not a problem
 552	 */
 553	ncm->notify_state = NCM_NOTIFY_SPEED;
 554	ncm_do_notify(ncm);
 555}
 556
 557static void ncm_notify_complete(struct usb_ep *ep, struct usb_request *req)
 558{
 559	struct f_ncm			*ncm = req->context;
 560	struct usb_composite_dev	*cdev = ncm->port.func.config->cdev;
 561	struct usb_cdc_notification	*event = req->buf;
 562
 563	spin_lock(&ncm->lock);
 564	switch (req->status) {
 565	case 0:
 566		VDBG(cdev, "Notification %02x sent\n",
 567		     event->bNotificationType);
 
 568		break;
 569	case -ECONNRESET:
 570	case -ESHUTDOWN:
 
 571		ncm->notify_state = NCM_NOTIFY_NONE;
 572		break;
 573	default:
 574		DBG(cdev, "event %02x --> %d\n",
 575			event->bNotificationType, req->status);
 
 576		break;
 577	}
 578	ncm->notify_req = req;
 579	ncm_do_notify(ncm);
 580	spin_unlock(&ncm->lock);
 581}
 582
 583static void ncm_ep0out_complete(struct usb_ep *ep, struct usb_request *req)
 584{
 585	/* now for SET_NTB_INPUT_SIZE only */
 586	unsigned		in_size;
 587	struct usb_function	*f = req->context;
 588	struct f_ncm		*ncm = func_to_ncm(f);
 589	struct usb_composite_dev *cdev = f->config->cdev;
 590
 591	req->context = NULL;
 592	if (req->status || req->actual != req->length) {
 593		DBG(cdev, "Bad control-OUT transfer\n");
 594		goto invalid;
 595	}
 596
 597	in_size = get_unaligned_le32(req->buf);
 598	if (in_size < USB_CDC_NCM_NTB_MIN_IN_SIZE ||
 599	    in_size > le32_to_cpu(ntb_parameters.dwNtbInMaxSize)) {
 600		DBG(cdev, "Got wrong INPUT SIZE (%d) from host\n", in_size);
 601		goto invalid;
 602	}
 603
 604	ncm->port.fixed_in_len = in_size;
 605	VDBG(cdev, "Set NTB INPUT SIZE %d\n", in_size);
 606	return;
 607
 608invalid:
 609	usb_ep_set_halt(ep);
 610	return;
 611}
 612
 613static int ncm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 614{
 615	struct f_ncm		*ncm = func_to_ncm(f);
 616	struct usb_composite_dev *cdev = f->config->cdev;
 617	struct usb_request	*req = cdev->req;
 618	int			value = -EOPNOTSUPP;
 619	u16			w_index = le16_to_cpu(ctrl->wIndex);
 620	u16			w_value = le16_to_cpu(ctrl->wValue);
 621	u16			w_length = le16_to_cpu(ctrl->wLength);
 622
 623	/*
 624	 * composite driver infrastructure handles everything except
 625	 * CDC class messages; interface activation uses set_alt().
 626	 */
 627	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
 628	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 629			| USB_CDC_SET_ETHERNET_PACKET_FILTER:
 630		/*
 631		 * see 6.2.30: no data, wIndex = interface,
 632		 * wValue = packet filter bitmap
 633		 */
 634		if (w_length != 0 || w_index != ncm->ctrl_id)
 635			goto invalid;
 636		DBG(cdev, "packet filter %02x\n", w_value);
 637		/*
 638		 * REVISIT locking of cdc_filter.  This assumes the UDC
 639		 * driver won't have a concurrent packet TX irq running on
 640		 * another CPU; or that if it does, this write is atomic...
 641		 */
 642		ncm->port.cdc_filter = w_value;
 643		value = 0;
 644		break;
 645	/*
 646	 * and optionally:
 647	 * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
 648	 * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
 649	 * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
 650	 * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
 651	 * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
 652	 * case USB_CDC_GET_ETHERNET_STATISTIC:
 653	 */
 654
 655	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 656		| USB_CDC_GET_NTB_PARAMETERS:
 657
 658		if (w_length == 0 || w_value != 0 || w_index != ncm->ctrl_id)
 659			goto invalid;
 660		value = w_length > sizeof ntb_parameters ?
 661			sizeof ntb_parameters : w_length;
 662		memcpy(req->buf, &ntb_parameters, value);
 663		VDBG(cdev, "Host asked NTB parameters\n");
 664		break;
 665
 666	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 667		| USB_CDC_GET_NTB_INPUT_SIZE:
 668
 669		if (w_length < 4 || w_value != 0 || w_index != ncm->ctrl_id)
 670			goto invalid;
 671		put_unaligned_le32(ncm->port.fixed_in_len, req->buf);
 672		value = 4;
 673		VDBG(cdev, "Host asked INPUT SIZE, sending %d\n",
 674		     ncm->port.fixed_in_len);
 675		break;
 676
 677	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 678		| USB_CDC_SET_NTB_INPUT_SIZE:
 679	{
 680		if (w_length != 4 || w_value != 0 || w_index != ncm->ctrl_id)
 681			goto invalid;
 682		req->complete = ncm_ep0out_complete;
 683		req->length = w_length;
 684		req->context = f;
 685
 686		value = req->length;
 687		break;
 688	}
 689
 690	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 691		| USB_CDC_GET_NTB_FORMAT:
 692	{
 693		uint16_t format;
 694
 695		if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
 696			goto invalid;
 697		format = (ncm->parser_opts == &ndp16_opts) ? 0x0000 : 0x0001;
 698		put_unaligned_le16(format, req->buf);
 699		value = 2;
 700		VDBG(cdev, "Host asked NTB FORMAT, sending %d\n", format);
 701		break;
 702	}
 703
 704	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 705		| USB_CDC_SET_NTB_FORMAT:
 706	{
 707		if (w_length != 0 || w_index != ncm->ctrl_id)
 708			goto invalid;
 709		switch (w_value) {
 710		case 0x0000:
 711			ncm->parser_opts = &ndp16_opts;
 712			DBG(cdev, "NCM16 selected\n");
 713			break;
 714		case 0x0001:
 715			ncm->parser_opts = &ndp32_opts;
 716			DBG(cdev, "NCM32 selected\n");
 717			break;
 718		default:
 719			goto invalid;
 720		}
 721		value = 0;
 722		break;
 723	}
 724	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 725		| USB_CDC_GET_CRC_MODE:
 726	{
 727		uint16_t is_crc;
 728
 729		if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
 730			goto invalid;
 731		is_crc = ncm->is_crc ? 0x0001 : 0x0000;
 732		put_unaligned_le16(is_crc, req->buf);
 733		value = 2;
 734		VDBG(cdev, "Host asked CRC MODE, sending %d\n", is_crc);
 735		break;
 736	}
 737
 738	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 739		| USB_CDC_SET_CRC_MODE:
 740	{
 741		int ndp_hdr_crc = 0;
 742
 743		if (w_length != 0 || w_index != ncm->ctrl_id)
 744			goto invalid;
 745		switch (w_value) {
 746		case 0x0000:
 747			ncm->is_crc = false;
 748			ndp_hdr_crc = NCM_NDP_HDR_NOCRC;
 749			DBG(cdev, "non-CRC mode selected\n");
 750			break;
 751		case 0x0001:
 752			ncm->is_crc = true;
 753			ndp_hdr_crc = NCM_NDP_HDR_CRC;
 754			DBG(cdev, "CRC mode selected\n");
 755			break;
 756		default:
 757			goto invalid;
 758		}
 759		ncm->ndp_sign = ncm->parser_opts->ndp_sign | ndp_hdr_crc;
 760		value = 0;
 761		break;
 762	}
 763
 764	/* and disabled in ncm descriptor: */
 765	/* case USB_CDC_GET_NET_ADDRESS: */
 766	/* case USB_CDC_SET_NET_ADDRESS: */
 767	/* case USB_CDC_GET_MAX_DATAGRAM_SIZE: */
 768	/* case USB_CDC_SET_MAX_DATAGRAM_SIZE: */
 769
 770	default:
 771invalid:
 772		DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
 773			ctrl->bRequestType, ctrl->bRequest,
 774			w_value, w_index, w_length);
 775	}
 
 
 776
 777	/* respond with data transfer or status phase? */
 778	if (value >= 0) {
 779		DBG(cdev, "ncm req%02x.%02x v%04x i%04x l%d\n",
 780			ctrl->bRequestType, ctrl->bRequest,
 781			w_value, w_index, w_length);
 782		req->zero = 0;
 783		req->length = value;
 784		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 785		if (value < 0)
 786			ERROR(cdev, "ncm req %02x.%02x response err %d\n",
 787					ctrl->bRequestType, ctrl->bRequest,
 788					value);
 789	}
 790
 791	/* device either stalls (value < 0) or reports success */
 792	return value;
 793}
 794
 795
 796static int ncm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 797{
 798	struct f_ncm		*ncm = func_to_ncm(f);
 799	struct usb_composite_dev *cdev = f->config->cdev;
 800
 801	/* Control interface has only altsetting 0 */
 802	if (intf == ncm->ctrl_id) {
 803		if (alt != 0)
 804			goto fail;
 805
 806		DBG(cdev, "reset ncm control %d\n", intf);
 807		usb_ep_disable(ncm->notify);
 808
 809		if (!(ncm->notify->desc)) {
 810			DBG(cdev, "init ncm ctrl %d\n", intf);
 811			if (config_ep_by_speed(cdev->gadget, f, ncm->notify))
 812				goto fail;
 813		}
 814		usb_ep_enable(ncm->notify);
 815
 816	/* Data interface has two altsettings, 0 and 1 */
 817	} else if (intf == ncm->data_id) {
 818		if (alt > 1)
 819			goto fail;
 820
 821		if (ncm->port.in_ep->enabled) {
 822			DBG(cdev, "reset ncm\n");
 823			ncm->timer_stopping = true;
 824			ncm->netdev = NULL;
 825			gether_disconnect(&ncm->port);
 826			ncm_reset_values(ncm);
 827		}
 828
 829		/*
 830		 * CDC Network only sends data in non-default altsettings.
 831		 * Changing altsettings resets filters, statistics, etc.
 832		 */
 833		if (alt == 1) {
 834			struct net_device	*net;
 835
 836			if (!ncm->port.in_ep->desc ||
 837			    !ncm->port.out_ep->desc) {
 838				DBG(cdev, "init ncm\n");
 839				if (config_ep_by_speed(cdev->gadget, f,
 840						       ncm->port.in_ep) ||
 841				    config_ep_by_speed(cdev->gadget, f,
 842						       ncm->port.out_ep)) {
 843					ncm->port.in_ep->desc = NULL;
 844					ncm->port.out_ep->desc = NULL;
 845					goto fail;
 846				}
 847			}
 848
 849			/* TODO */
 850			/* Enable zlps by default for NCM conformance;
 851			 * override for musb_hdrc (avoids txdma ovhead)
 852			 */
 853			ncm->port.is_zlp_ok =
 854				gadget_is_zlp_supported(cdev->gadget);
 855			ncm->port.cdc_filter = DEFAULT_FILTER;
 856			DBG(cdev, "activate ncm\n");
 857			net = gether_connect(&ncm->port);
 858			if (IS_ERR(net))
 859				return PTR_ERR(net);
 860			ncm->netdev = net;
 861			ncm->timer_stopping = false;
 862		}
 863
 864		spin_lock(&ncm->lock);
 865		ncm_notify(ncm);
 866		spin_unlock(&ncm->lock);
 867	} else
 868		goto fail;
 869
 870	return 0;
 871fail:
 872	return -EINVAL;
 873}
 874
 875/*
 876 * Because the data interface supports multiple altsettings,
 877 * this NCM function *MUST* implement a get_alt() method.
 878 */
 879static int ncm_get_alt(struct usb_function *f, unsigned intf)
 880{
 881	struct f_ncm		*ncm = func_to_ncm(f);
 882
 883	if (intf == ncm->ctrl_id)
 884		return 0;
 885	return ncm->port.in_ep->enabled ? 1 : 0;
 886}
 887
 888static struct sk_buff *package_for_tx(struct f_ncm *ncm)
 889{
 890	__le16		*ntb_iter;
 891	struct sk_buff	*skb2 = NULL;
 892	unsigned	ndp_pad;
 893	unsigned	ndp_index;
 894	unsigned	new_len;
 895
 896	const struct ndp_parser_opts *opts = ncm->parser_opts;
 897	const int ndp_align = le16_to_cpu(ntb_parameters.wNdpInAlignment);
 898	const int dgram_idx_len = 2 * 2 * opts->dgram_item_len;
 899
 900	/* Stop the timer */
 901	hrtimer_try_to_cancel(&ncm->task_timer);
 902
 903	ndp_pad = ALIGN(ncm->skb_tx_data->len, ndp_align) -
 904			ncm->skb_tx_data->len;
 905	ndp_index = ncm->skb_tx_data->len + ndp_pad;
 906	new_len = ndp_index + dgram_idx_len + ncm->skb_tx_ndp->len;
 907
 908	/* Set the final BlockLength and wNdpIndex */
 909	ntb_iter = (void *) ncm->skb_tx_data->data;
 910	/* Increment pointer to BlockLength */
 911	ntb_iter += 2 + 1 + 1;
 912	put_ncm(&ntb_iter, opts->block_length, new_len);
 913	put_ncm(&ntb_iter, opts->ndp_index, ndp_index);
 914
 915	/* Set the final NDP wLength */
 916	new_len = opts->ndp_size +
 917			(ncm->ndp_dgram_count * dgram_idx_len);
 918	ncm->ndp_dgram_count = 0;
 919	/* Increment from start to wLength */
 920	ntb_iter = (void *) ncm->skb_tx_ndp->data;
 921	ntb_iter += 2;
 922	put_unaligned_le16(new_len, ntb_iter);
 923
 924	/* Merge the skbs */
 925	swap(skb2, ncm->skb_tx_data);
 926	if (ncm->skb_tx_data) {
 927		dev_kfree_skb_any(ncm->skb_tx_data);
 928		ncm->skb_tx_data = NULL;
 929	}
 930
 931	/* Insert NDP alignment. */
 932	ntb_iter = (void *) skb_put(skb2, ndp_pad);
 933	memset(ntb_iter, 0, ndp_pad);
 934
 935	/* Copy NTB across. */
 936	ntb_iter = (void *) skb_put(skb2, ncm->skb_tx_ndp->len);
 937	memcpy(ntb_iter, ncm->skb_tx_ndp->data, ncm->skb_tx_ndp->len);
 938	dev_kfree_skb_any(ncm->skb_tx_ndp);
 939	ncm->skb_tx_ndp = NULL;
 940
 941	/* Insert zero'd datagram. */
 942	ntb_iter = (void *) skb_put(skb2, dgram_idx_len);
 943	memset(ntb_iter, 0, dgram_idx_len);
 944
 945	return skb2;
 946}
 947
 948static struct sk_buff *ncm_wrap_ntb(struct gether *port,
 949				    struct sk_buff *skb)
 950{
 951	struct f_ncm	*ncm = func_to_ncm(&port->func);
 952	struct sk_buff	*skb2 = NULL;
 953	int		ncb_len = 0;
 954	__le16		*ntb_data;
 955	__le16		*ntb_ndp;
 956	int		dgram_pad;
 957
 958	unsigned	max_size = ncm->port.fixed_in_len;
 959	const struct ndp_parser_opts *opts = ncm->parser_opts;
 960	const int ndp_align = le16_to_cpu(ntb_parameters.wNdpInAlignment);
 961	const int div = le16_to_cpu(ntb_parameters.wNdpInDivisor);
 962	const int rem = le16_to_cpu(ntb_parameters.wNdpInPayloadRemainder);
 963	const int dgram_idx_len = 2 * 2 * opts->dgram_item_len;
 
 
 
 
 
 
 964
 965	if (!skb && !ncm->skb_tx_data)
 966		return NULL;
 967
 968	if (skb) {
 969		/* Add the CRC if required up front */
 970		if (ncm->is_crc) {
 971			uint32_t	crc;
 972			__le16		*crc_pos;
 973
 974			crc = ~crc32_le(~0,
 975					skb->data,
 976					skb->len);
 977			crc_pos = (void *) skb_put(skb, sizeof(uint32_t));
 978			put_unaligned_le32(crc, crc_pos);
 979		}
 980
 981		/* If the new skb is too big for the current NCM NTB then
 982		 * set the current stored skb to be sent now and clear it
 983		 * ready for new data.
 984		 * NOTE: Assume maximum align for speed of calculation.
 985		 */
 986		if (ncm->skb_tx_data
 987		    && (ncm->ndp_dgram_count >= TX_MAX_NUM_DPE
 988		    || (ncm->skb_tx_data->len +
 989		    div + rem + skb->len +
 990		    ncm->skb_tx_ndp->len + ndp_align + (2 * dgram_idx_len))
 991		    > max_size)) {
 992			skb2 = package_for_tx(ncm);
 993			if (!skb2)
 994				goto err;
 995		}
 996
 997		if (!ncm->skb_tx_data) {
 998			ncb_len = opts->nth_size;
 999			dgram_pad = ALIGN(ncb_len, div) + rem - ncb_len;
1000			ncb_len += dgram_pad;
1001
1002			/* Create a new skb for the NTH and datagrams. */
1003			ncm->skb_tx_data = alloc_skb(max_size, GFP_ATOMIC);
1004			if (!ncm->skb_tx_data)
1005				goto err;
1006
1007			ntb_data = (void *) skb_put(ncm->skb_tx_data, ncb_len);
1008			memset(ntb_data, 0, ncb_len);
1009			/* dwSignature */
1010			put_unaligned_le32(opts->nth_sign, ntb_data);
1011			ntb_data += 2;
1012			/* wHeaderLength */
1013			put_unaligned_le16(opts->nth_size, ntb_data++);
1014
1015			/* Allocate an skb for storing the NDP,
1016			 * TX_MAX_NUM_DPE should easily suffice for a
1017			 * 16k packet.
1018			 */
1019			ncm->skb_tx_ndp = alloc_skb((int)(opts->ndp_size
1020						    + opts->dpe_size
1021						    * TX_MAX_NUM_DPE),
1022						    GFP_ATOMIC);
1023			if (!ncm->skb_tx_ndp)
1024				goto err;
1025			ntb_ndp = (void *) skb_put(ncm->skb_tx_ndp,
1026						    opts->ndp_size);
 
1027			memset(ntb_ndp, 0, ncb_len);
1028			/* dwSignature */
1029			put_unaligned_le32(ncm->ndp_sign, ntb_ndp);
1030			ntb_ndp += 2;
1031
1032			/* There is always a zeroed entry */
1033			ncm->ndp_dgram_count = 1;
1034
1035			/* Note: we skip opts->next_ndp_index */
 
 
 
 
1036		}
1037
1038		/* Delay the timer. */
1039		hrtimer_start(&ncm->task_timer,
1040			      ktime_set(0, TX_TIMEOUT_NSECS),
1041			      HRTIMER_MODE_REL);
1042
1043		/* Add the datagram position entries */
1044		ntb_ndp = (void *) skb_put(ncm->skb_tx_ndp, dgram_idx_len);
1045		memset(ntb_ndp, 0, dgram_idx_len);
1046
1047		ncb_len = ncm->skb_tx_data->len;
1048		dgram_pad = ALIGN(ncb_len, div) + rem - ncb_len;
1049		ncb_len += dgram_pad;
1050
1051		/* (d)wDatagramIndex */
1052		put_ncm(&ntb_ndp, opts->dgram_item_len, ncb_len);
1053		/* (d)wDatagramLength */
1054		put_ncm(&ntb_ndp, opts->dgram_item_len, skb->len);
1055		ncm->ndp_dgram_count++;
1056
1057		/* Add the new data to the skb */
1058		ntb_data = (void *) skb_put(ncm->skb_tx_data, dgram_pad);
1059		memset(ntb_data, 0, dgram_pad);
1060		ntb_data = (void *) skb_put(ncm->skb_tx_data, skb->len);
1061		memcpy(ntb_data, skb->data, skb->len);
1062		dev_kfree_skb_any(skb);
1063		skb = NULL;
1064
1065	} else if (ncm->skb_tx_data && ncm->timer_force_tx) {
1066		/* If the tx was requested because of a timeout then send */
 
 
 
1067		skb2 = package_for_tx(ncm);
1068		if (!skb2)
1069			goto err;
1070	}
1071
1072	return skb2;
1073
1074err:
1075	ncm->netdev->stats.tx_dropped++;
1076
1077	if (skb)
1078		dev_kfree_skb_any(skb);
1079	if (ncm->skb_tx_data)
1080		dev_kfree_skb_any(ncm->skb_tx_data);
1081	if (ncm->skb_tx_ndp)
1082		dev_kfree_skb_any(ncm->skb_tx_ndp);
1083
1084	return NULL;
1085}
1086
1087/*
1088 * This transmits the NTB if there are frames waiting.
 
1089 */
1090static void ncm_tx_tasklet(unsigned long data)
1091{
1092	struct f_ncm	*ncm = (void *)data;
1093
1094	if (ncm->timer_stopping)
1095		return;
1096
1097	/* Only send if data is available. */
1098	if (ncm->skb_tx_data) {
1099		ncm->timer_force_tx = true;
1100
 
1101		/* XXX This allowance of a NULL skb argument to ndo_start_xmit
1102		 * XXX is not sane.  The gadget layer should be redesigned so
1103		 * XXX that the dev->wrap() invocations to build SKBs is transparent
1104		 * XXX and performed in some way outside of the ndo_start_xmit
1105		 * XXX interface.
 
 
1106		 */
1107		ncm->netdev->netdev_ops->ndo_start_xmit(NULL, ncm->netdev);
1108
1109		ncm->timer_force_tx = false;
1110	}
1111}
1112
1113/*
1114 * The transmit should only be run if no skb data has been sent
1115 * for a certain duration.
1116 */
1117static enum hrtimer_restart ncm_tx_timeout(struct hrtimer *data)
1118{
1119	struct f_ncm *ncm = container_of(data, struct f_ncm, task_timer);
1120	tasklet_schedule(&ncm->tx_tasklet);
1121	return HRTIMER_NORESTART;
1122}
1123
1124static int ncm_unwrap_ntb(struct gether *port,
1125			  struct sk_buff *skb,
1126			  struct sk_buff_head *list)
1127{
1128	struct f_ncm	*ncm = func_to_ncm(&port->func);
1129	__le16		*tmp = (void *) skb->data;
 
1130	unsigned	index, index2;
1131	int		ndp_index;
1132	unsigned	dg_len, dg_len2;
1133	unsigned	ndp_len;
 
1134	struct sk_buff	*skb2;
1135	int		ret = -EINVAL;
1136	unsigned	max_size = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
 
1137	const struct ndp_parser_opts *opts = ncm->parser_opts;
1138	unsigned	crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
1139	int		dgram_counter;
 
 
 
 
 
 
 
 
1140
1141	/* dwSignature */
1142	if (get_unaligned_le32(tmp) != opts->nth_sign) {
1143		INFO(port->func.config->cdev, "Wrong NTH SIGN, skblen %d\n",
1144			skb->len);
1145		print_hex_dump(KERN_INFO, "HEAD:", DUMP_PREFIX_ADDRESS, 32, 1,
1146			       skb->data, 32, false);
1147
1148		goto err;
1149	}
1150	tmp += 2;
1151	/* wHeaderLength */
1152	if (get_unaligned_le16(tmp++) != opts->nth_size) {
1153		INFO(port->func.config->cdev, "Wrong NTB headersize\n");
1154		goto err;
1155	}
1156	tmp++; /* skip wSequence */
1157
 
1158	/* (d)wBlockLength */
1159	if (get_ncm(&tmp, opts->block_length) > max_size) {
1160		INFO(port->func.config->cdev, "OUT size exceeded\n");
1161		goto err;
1162	}
1163
1164	ndp_index = get_ncm(&tmp, opts->ndp_index);
1165
1166	/* Run through all the NDP's in the NTB */
1167	do {
1168		/* NCM 3.2 */
1169		if (((ndp_index % 4) != 0) &&
1170				(ndp_index < opts->nth_size)) {
 
 
 
 
 
1171			INFO(port->func.config->cdev, "Bad index: %#X\n",
1172			     ndp_index);
1173			goto err;
1174		}
1175
1176		/* walk through NDP */
1177		tmp = (void *)(skb->data + ndp_index);
 
 
 
1178		if (get_unaligned_le32(tmp) != ncm->ndp_sign) {
1179			INFO(port->func.config->cdev, "Wrong NDP SIGN\n");
1180			goto err;
1181		}
1182		tmp += 2;
1183
1184		ndp_len = get_unaligned_le16(tmp++);
1185		/*
1186		 * NCM 3.3.1
 
1187		 * entry is 2 items
1188		 * item size is 16/32 bits, opts->dgram_item_len * 2 bytes
1189		 * minimal: struct usb_cdc_ncm_ndpX + normal entry + zero entry
1190		 * Each entry is a dgram index and a dgram length.
1191		 */
1192		if ((ndp_len < opts->ndp_size
1193				+ 2 * 2 * (opts->dgram_item_len * 2))
1194				|| (ndp_len % opts->ndplen_align != 0)) {
1195			INFO(port->func.config->cdev, "Bad NDP length: %#X\n",
1196			     ndp_len);
1197			goto err;
1198		}
1199		tmp += opts->reserved1;
1200		/* Check for another NDP (d)wNextNdpIndex */
1201		ndp_index = get_ncm(&tmp, opts->next_ndp_index);
1202		tmp += opts->reserved2;
1203
1204		ndp_len -= opts->ndp_size;
1205		index2 = get_ncm(&tmp, opts->dgram_item_len);
1206		dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
1207		dgram_counter = 0;
1208
1209		do {
1210			index = index2;
 
 
 
 
 
 
 
 
1211			dg_len = dg_len2;
1212			if (dg_len < 14 + crc_len) { /* ethernet hdr + crc */
 
 
 
 
 
1213				INFO(port->func.config->cdev,
1214				     "Bad dgram length: %#X\n", dg_len);
1215				goto err;
1216			}
1217			if (ncm->is_crc) {
1218				uint32_t crc, crc2;
1219
1220				crc = get_unaligned_le32(skb->data +
1221							 index + dg_len -
1222							 crc_len);
1223				crc2 = ~crc32_le(~0,
1224						 skb->data + index,
1225						 dg_len - crc_len);
1226				if (crc != crc2) {
1227					INFO(port->func.config->cdev,
1228					     "Bad CRC\n");
1229					goto err;
1230				}
1231			}
1232
1233			index2 = get_ncm(&tmp, opts->dgram_item_len);
1234			dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
1235
 
 
 
 
 
 
 
1236			/*
1237			 * Copy the data into a new skb.
1238			 * This ensures the truesize is correct
1239			 */
1240			skb2 = netdev_alloc_skb_ip_align(ncm->netdev,
1241							 dg_len - crc_len);
1242			if (skb2 == NULL)
1243				goto err;
1244			memcpy(skb_put(skb2, dg_len - crc_len),
1245			       skb->data + index, dg_len - crc_len);
1246
1247			skb_queue_tail(list, skb2);
1248
1249			ndp_len -= 2 * (opts->dgram_item_len * 2);
1250
1251			dgram_counter++;
1252
1253			if (index2 == 0 || dg_len2 == 0)
1254				break;
1255		} while (ndp_len > 2 * (opts->dgram_item_len * 2));
1256	} while (ndp_index);
1257
1258	dev_kfree_skb_any(skb);
1259
1260	VDBG(port->func.config->cdev,
1261	     "Parsed NTB with %d frames\n", dgram_counter);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1262	return 0;
1263err:
1264	skb_queue_purge(list);
1265	dev_kfree_skb_any(skb);
1266	return ret;
1267}
1268
1269static void ncm_disable(struct usb_function *f)
1270{
1271	struct f_ncm		*ncm = func_to_ncm(f);
1272	struct usb_composite_dev *cdev = f->config->cdev;
1273
1274	DBG(cdev, "ncm deactivated\n");
1275
1276	if (ncm->port.in_ep->enabled) {
1277		ncm->timer_stopping = true;
1278		ncm->netdev = NULL;
1279		gether_disconnect(&ncm->port);
1280	}
1281
1282	if (ncm->notify->enabled) {
1283		usb_ep_disable(ncm->notify);
1284		ncm->notify->desc = NULL;
1285	}
1286}
1287
1288/*-------------------------------------------------------------------------*/
1289
1290/*
1291 * Callbacks let us notify the host about connect/disconnect when the
1292 * net device is opened or closed.
1293 *
1294 * For testing, note that link states on this side include both opened
1295 * and closed variants of:
1296 *
1297 *   - disconnected/unconfigured
1298 *   - configured but inactive (data alt 0)
1299 *   - configured and active (data alt 1)
1300 *
1301 * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
1302 * SET_INTERFACE (altsetting).  Remember also that "configured" doesn't
1303 * imply the host is actually polling the notification endpoint, and
1304 * likewise that "active" doesn't imply it's actually using the data
1305 * endpoints for traffic.
1306 */
1307
1308static void ncm_open(struct gether *geth)
1309{
1310	struct f_ncm		*ncm = func_to_ncm(&geth->func);
1311
1312	DBG(ncm->port.func.config->cdev, "%s\n", __func__);
1313
1314	spin_lock(&ncm->lock);
1315	ncm->is_open = true;
1316	ncm_notify(ncm);
1317	spin_unlock(&ncm->lock);
1318}
1319
1320static void ncm_close(struct gether *geth)
1321{
1322	struct f_ncm		*ncm = func_to_ncm(&geth->func);
1323
1324	DBG(ncm->port.func.config->cdev, "%s\n", __func__);
1325
1326	spin_lock(&ncm->lock);
1327	ncm->is_open = false;
1328	ncm_notify(ncm);
1329	spin_unlock(&ncm->lock);
1330}
1331
1332/*-------------------------------------------------------------------------*/
1333
1334/* ethernet function driver setup/binding */
1335
1336static int ncm_bind(struct usb_configuration *c, struct usb_function *f)
1337{
1338	struct usb_composite_dev *cdev = c->cdev;
1339	struct f_ncm		*ncm = func_to_ncm(f);
1340	struct usb_string	*us;
1341	int			status;
1342	struct usb_ep		*ep;
1343	struct f_ncm_opts	*ncm_opts;
1344
1345	if (!can_support_ecm(cdev->gadget))
1346		return -EINVAL;
1347
1348	ncm_opts = container_of(f->fi, struct f_ncm_opts, func_inst);
1349	/*
1350	 * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
1351	 * configurations are bound in sequence with list_for_each_entry,
1352	 * in each configuration its functions are bound in sequence
1353	 * with list_for_each_entry, so we assume no race condition
1354	 * with regard to ncm_opts->bound access
1355	 */
 
 
 
 
 
1356	if (!ncm_opts->bound) {
1357		mutex_lock(&ncm_opts->lock);
1358		gether_set_gadget(ncm_opts->net, cdev->gadget);
1359		status = gether_register_netdev(ncm_opts->net);
1360		mutex_unlock(&ncm_opts->lock);
1361		if (status)
1362			return status;
1363		ncm_opts->bound = true;
1364	}
 
 
 
 
 
 
 
1365	us = usb_gstrings_attach(cdev, ncm_strings,
1366				 ARRAY_SIZE(ncm_string_defs));
1367	if (IS_ERR(us))
1368		return PTR_ERR(us);
 
 
1369	ncm_control_intf.iInterface = us[STRING_CTRL_IDX].id;
1370	ncm_data_nop_intf.iInterface = us[STRING_DATA_IDX].id;
1371	ncm_data_intf.iInterface = us[STRING_DATA_IDX].id;
1372	ecm_desc.iMACAddress = us[STRING_MAC_IDX].id;
1373	ncm_iad_desc.iFunction = us[STRING_IAD_IDX].id;
1374
1375	/* allocate instance-specific interface IDs */
1376	status = usb_interface_id(c, f);
1377	if (status < 0)
1378		goto fail;
1379	ncm->ctrl_id = status;
1380	ncm_iad_desc.bFirstInterface = status;
1381
1382	ncm_control_intf.bInterfaceNumber = status;
1383	ncm_union_desc.bMasterInterface0 = status;
1384
 
 
 
 
1385	status = usb_interface_id(c, f);
1386	if (status < 0)
1387		goto fail;
1388	ncm->data_id = status;
1389
1390	ncm_data_nop_intf.bInterfaceNumber = status;
1391	ncm_data_intf.bInterfaceNumber = status;
1392	ncm_union_desc.bSlaveInterface0 = status;
1393
 
 
1394	status = -ENODEV;
1395
1396	/* allocate instance-specific endpoints */
1397	ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_in_desc);
1398	if (!ep)
1399		goto fail;
1400	ncm->port.in_ep = ep;
1401
1402	ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_out_desc);
1403	if (!ep)
1404		goto fail;
1405	ncm->port.out_ep = ep;
1406
1407	ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_notify_desc);
1408	if (!ep)
1409		goto fail;
1410	ncm->notify = ep;
1411
1412	status = -ENOMEM;
1413
1414	/* allocate notification request and buffer */
1415	ncm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
1416	if (!ncm->notify_req)
1417		goto fail;
1418	ncm->notify_req->buf = kmalloc(NCM_STATUS_BYTECOUNT, GFP_KERNEL);
1419	if (!ncm->notify_req->buf)
1420		goto fail;
1421	ncm->notify_req->context = ncm;
1422	ncm->notify_req->complete = ncm_notify_complete;
1423
1424	/*
1425	 * support all relevant hardware speeds... we expect that when
1426	 * hardware is dual speed, all bulk-capable endpoints work at
1427	 * both speeds
1428	 */
1429	hs_ncm_in_desc.bEndpointAddress = fs_ncm_in_desc.bEndpointAddress;
1430	hs_ncm_out_desc.bEndpointAddress = fs_ncm_out_desc.bEndpointAddress;
1431	hs_ncm_notify_desc.bEndpointAddress =
1432		fs_ncm_notify_desc.bEndpointAddress;
1433
 
 
 
 
 
1434	status = usb_assign_descriptors(f, ncm_fs_function, ncm_hs_function,
1435			NULL, NULL);
1436	if (status)
1437		goto fail;
1438
1439	/*
1440	 * NOTE:  all that is done without knowing or caring about
1441	 * the network link ... which is unavailable to this code
1442	 * until we're activated via set_alt().
1443	 */
1444
1445	ncm->port.open = ncm_open;
1446	ncm->port.close = ncm_close;
1447
1448	tasklet_init(&ncm->tx_tasklet, ncm_tx_tasklet, (unsigned long) ncm);
1449	hrtimer_init(&ncm->task_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1450	ncm->task_timer.function = ncm_tx_timeout;
1451
1452	DBG(cdev, "CDC Network: %s speed IN/%s OUT/%s NOTIFY/%s\n",
1453			gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
1454			ncm->port.in_ep->name, ncm->port.out_ep->name,
1455			ncm->notify->name);
1456	return 0;
1457
1458fail:
 
 
 
1459	if (ncm->notify_req) {
1460		kfree(ncm->notify_req->buf);
1461		usb_ep_free_request(ncm->notify, ncm->notify_req);
1462	}
1463
1464	ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
1465
1466	return status;
1467}
1468
1469static inline struct f_ncm_opts *to_f_ncm_opts(struct config_item *item)
1470{
1471	return container_of(to_config_group(item), struct f_ncm_opts,
1472			    func_inst.group);
1473}
1474
1475/* f_ncm_item_ops */
1476USB_ETHERNET_CONFIGFS_ITEM(ncm);
1477
1478/* f_ncm_opts_dev_addr */
1479USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(ncm);
1480
1481/* f_ncm_opts_host_addr */
1482USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(ncm);
1483
1484/* f_ncm_opts_qmult */
1485USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(ncm);
1486
1487/* f_ncm_opts_ifname */
1488USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(ncm);
1489
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1490static struct configfs_attribute *ncm_attrs[] = {
1491	&ncm_opts_attr_dev_addr,
1492	&ncm_opts_attr_host_addr,
1493	&ncm_opts_attr_qmult,
1494	&ncm_opts_attr_ifname,
 
1495	NULL,
1496};
1497
1498static struct config_item_type ncm_func_type = {
1499	.ct_item_ops	= &ncm_item_ops,
1500	.ct_attrs	= ncm_attrs,
1501	.ct_owner	= THIS_MODULE,
1502};
1503
1504static void ncm_free_inst(struct usb_function_instance *f)
1505{
1506	struct f_ncm_opts *opts;
1507
1508	opts = container_of(f, struct f_ncm_opts, func_inst);
1509	if (opts->bound)
1510		gether_cleanup(netdev_priv(opts->net));
1511	else
1512		free_netdev(opts->net);
 
1513	kfree(opts);
1514}
1515
1516static struct usb_function_instance *ncm_alloc_inst(void)
1517{
1518	struct f_ncm_opts *opts;
 
 
 
1519
1520	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1521	if (!opts)
1522		return ERR_PTR(-ENOMEM);
 
 
1523	mutex_init(&opts->lock);
1524	opts->func_inst.free_func_inst = ncm_free_inst;
1525	opts->net = gether_setup_default();
1526	if (IS_ERR(opts->net)) {
1527		struct net_device *net = opts->net;
1528		kfree(opts);
1529		return ERR_CAST(net);
1530	}
 
 
 
 
 
1531
1532	config_group_init_type_name(&opts->func_inst.group, "", &ncm_func_type);
 
 
 
 
 
 
 
 
1533
1534	return &opts->func_inst;
1535}
1536
1537static void ncm_free(struct usb_function *f)
1538{
1539	struct f_ncm *ncm;
1540	struct f_ncm_opts *opts;
1541
1542	ncm = func_to_ncm(f);
1543	opts = container_of(f->fi, struct f_ncm_opts, func_inst);
1544	kfree(ncm);
1545	mutex_lock(&opts->lock);
1546	opts->refcnt--;
1547	mutex_unlock(&opts->lock);
1548}
1549
1550static void ncm_unbind(struct usb_configuration *c, struct usb_function *f)
1551{
1552	struct f_ncm *ncm = func_to_ncm(f);
1553
1554	DBG(c->cdev, "ncm unbind\n");
1555
1556	hrtimer_cancel(&ncm->task_timer);
1557	tasklet_kill(&ncm->tx_tasklet);
 
 
1558
1559	ncm_string_defs[0].id = 0;
1560	usb_free_all_descriptors(f);
 
 
 
 
 
1561
1562	kfree(ncm->notify_req->buf);
1563	usb_ep_free_request(ncm->notify, ncm->notify_req);
1564}
1565
1566static struct usb_function *ncm_alloc(struct usb_function_instance *fi)
1567{
1568	struct f_ncm		*ncm;
1569	struct f_ncm_opts	*opts;
1570	int status;
1571
1572	/* allocate and initialize one new instance */
1573	ncm = kzalloc(sizeof(*ncm), GFP_KERNEL);
1574	if (!ncm)
1575		return ERR_PTR(-ENOMEM);
1576
1577	opts = container_of(fi, struct f_ncm_opts, func_inst);
1578	mutex_lock(&opts->lock);
1579	opts->refcnt++;
1580
1581	/* export host's Ethernet address in CDC format */
1582	status = gether_get_host_addr_cdc(opts->net, ncm->ethaddr,
1583				      sizeof(ncm->ethaddr));
1584	if (status < 12) { /* strlen("01234567890a") */
1585		kfree(ncm);
1586		mutex_unlock(&opts->lock);
1587		return ERR_PTR(-EINVAL);
1588	}
1589	ncm_string_defs[STRING_MAC_IDX].s = ncm->ethaddr;
1590
1591	spin_lock_init(&ncm->lock);
1592	ncm_reset_values(ncm);
1593	ncm->port.ioport = netdev_priv(opts->net);
1594	mutex_unlock(&opts->lock);
1595	ncm->port.is_fixed = true;
1596	ncm->port.supports_multi_frame = true;
1597
1598	ncm->port.func.name = "cdc_network";
1599	/* descriptors are per-instance copies */
1600	ncm->port.func.bind = ncm_bind;
1601	ncm->port.func.unbind = ncm_unbind;
1602	ncm->port.func.set_alt = ncm_set_alt;
1603	ncm->port.func.get_alt = ncm_get_alt;
1604	ncm->port.func.setup = ncm_setup;
1605	ncm->port.func.disable = ncm_disable;
1606	ncm->port.func.free_func = ncm_free;
1607
1608	ncm->port.wrap = ncm_wrap_ntb;
1609	ncm->port.unwrap = ncm_unwrap_ntb;
1610
1611	return &ncm->port.func;
1612}
1613
1614DECLARE_USB_FUNCTION_INIT(ncm, ncm_alloc_inst, ncm_alloc);
1615MODULE_LICENSE("GPL");
1616MODULE_AUTHOR("Yauheni Kaliuta");