1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * f_ecm.c -- USB CDC Ethernet (ECM) link function driver
4  *
5  * Copyright (C) 2003-2005,2008 David Brownell
6  * Copyright (C) 2008 Nokia Corporation
7  */
8 
9 /* #define VERBOSE_DEBUG */
10 
11 #include <linux/slab.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/device.h>
15 #include <linux/etherdevice.h>
16 
17 #include "u_ether.h"
18 #include "u_ether_configfs.h"
19 #include "u_ecm.h"
20 
21 
22 /*
23  * This function is a "CDC Ethernet Networking Control Model" (CDC ECM)
24  * Ethernet link.  The data transfer model is simple (packets sent and
25  * received over bulk endpoints using normal short packet termination),
26  * and the control model exposes various data and optional notifications.
27  *
28  * ECM is well standardized and (except for Microsoft) supported by most
29  * operating systems with USB host support.  It's the preferred interop
30  * solution for Ethernet over USB, at least for firmware based solutions.
31  * (Hardware solutions tend to be more minimalist.)  A newer and simpler
32  * "Ethernet Emulation Model" (CDC EEM) hasn't yet caught on.
33  *
34  * Note that ECM 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 
40 enum ecm_notify_state {
41 	ECM_NOTIFY_NONE,		/* don't notify */
42 	ECM_NOTIFY_CONNECT,		/* issue CONNECT next */
43 	ECM_NOTIFY_SPEED,		/* issue SPEED_CHANGE next */
44 };
45 
46 struct f_ecm {
47 	struct gether			port;
48 	u8				ctrl_id, data_id;
49 
50 	char				ethaddr[14];
51 
52 	struct usb_ep			*notify;
53 	struct usb_request		*notify_req;
54 	u8				notify_state;
55 	atomic_t			notify_count;
56 	bool				is_open;
57 
58 	/* FIXME is_open needs some irq-ish locking
59 	 * ... possibly the same as port.ioport
60 	 */
61 };
62 
63 static inline struct f_ecm *func_to_ecm(struct usb_function *f)
64 {
65 	return container_of(f, struct f_ecm, port.func);
66 }
67 
68 /*-------------------------------------------------------------------------*/
69 
70 /*
71  * Include the status endpoint if we can, even though it's optional.
72  *
73  * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
74  * packet, to simplify cancellation; and a big transfer interval, to
75  * waste less bandwidth.
76  *
77  * Some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
78  * if they ignore the connect/disconnect notifications that real aether
79  * can provide.  More advanced cdc configurations might want to support
80  * encapsulated commands (vendor-specific, using control-OUT).
81  */
82 
83 #define ECM_STATUS_INTERVAL_MS		32
84 #define ECM_STATUS_BYTECOUNT		16	/* 8 byte header + data */
85 
86 
87 /* interface descriptor: */
88 
89 static struct usb_interface_assoc_descriptor
90 ecm_iad_descriptor = {
91 	.bLength =		sizeof ecm_iad_descriptor,
92 	.bDescriptorType =	USB_DT_INTERFACE_ASSOCIATION,
93 
94 	/* .bFirstInterface =	DYNAMIC, */
95 	.bInterfaceCount =	2,	/* control + data */
96 	.bFunctionClass =	USB_CLASS_COMM,
97 	.bFunctionSubClass =	USB_CDC_SUBCLASS_ETHERNET,
98 	.bFunctionProtocol =	USB_CDC_PROTO_NONE,
99 	/* .iFunction =		DYNAMIC */
100 };
101 
102 
103 static struct usb_interface_descriptor ecm_control_intf = {
104 	.bLength =		sizeof ecm_control_intf,
105 	.bDescriptorType =	USB_DT_INTERFACE,
106 
107 	/* .bInterfaceNumber = DYNAMIC */
108 	/* status endpoint is optional; this could be patched later */
109 	.bNumEndpoints =	1,
110 	.bInterfaceClass =	USB_CLASS_COMM,
111 	.bInterfaceSubClass =	USB_CDC_SUBCLASS_ETHERNET,
112 	.bInterfaceProtocol =	USB_CDC_PROTO_NONE,
113 	/* .iInterface = DYNAMIC */
114 };
115 
116 static struct usb_cdc_header_desc ecm_header_desc = {
117 	.bLength =		sizeof ecm_header_desc,
118 	.bDescriptorType =	USB_DT_CS_INTERFACE,
119 	.bDescriptorSubType =	USB_CDC_HEADER_TYPE,
120 
121 	.bcdCDC =		cpu_to_le16(0x0110),
122 };
123 
124 static struct usb_cdc_union_desc ecm_union_desc = {
125 	.bLength =		sizeof(ecm_union_desc),
126 	.bDescriptorType =	USB_DT_CS_INTERFACE,
127 	.bDescriptorSubType =	USB_CDC_UNION_TYPE,
128 	/* .bMasterInterface0 =	DYNAMIC */
129 	/* .bSlaveInterface0 =	DYNAMIC */
130 };
131 
132 static struct usb_cdc_ether_desc ecm_desc = {
133 	.bLength =		sizeof ecm_desc,
134 	.bDescriptorType =	USB_DT_CS_INTERFACE,
135 	.bDescriptorSubType =	USB_CDC_ETHERNET_TYPE,
136 
137 	/* this descriptor actually adds value, surprise! */
138 	/* .iMACAddress = DYNAMIC */
139 	.bmEthernetStatistics =	cpu_to_le32(0), /* no statistics */
140 	.wMaxSegmentSize =	cpu_to_le16(ETH_FRAME_LEN),
141 	.wNumberMCFilters =	cpu_to_le16(0),
142 	.bNumberPowerFilters =	0,
143 };
144 
145 /* the default data interface has no endpoints ... */
146 
147 static struct usb_interface_descriptor ecm_data_nop_intf = {
148 	.bLength =		sizeof ecm_data_nop_intf,
149 	.bDescriptorType =	USB_DT_INTERFACE,
150 
151 	.bInterfaceNumber =	1,
152 	.bAlternateSetting =	0,
153 	.bNumEndpoints =	0,
154 	.bInterfaceClass =	USB_CLASS_CDC_DATA,
155 	.bInterfaceSubClass =	0,
156 	.bInterfaceProtocol =	0,
157 	/* .iInterface = DYNAMIC */
158 };
159 
160 /* ... but the "real" data interface has two bulk endpoints */
161 
162 static struct usb_interface_descriptor ecm_data_intf = {
163 	.bLength =		sizeof ecm_data_intf,
164 	.bDescriptorType =	USB_DT_INTERFACE,
165 
166 	.bInterfaceNumber =	1,
167 	.bAlternateSetting =	1,
168 	.bNumEndpoints =	2,
169 	.bInterfaceClass =	USB_CLASS_CDC_DATA,
170 	.bInterfaceSubClass =	0,
171 	.bInterfaceProtocol =	0,
172 	/* .iInterface = DYNAMIC */
173 };
174 
175 /* full speed support: */
176 
177 static struct usb_endpoint_descriptor fs_ecm_notify_desc = {
178 	.bLength =		USB_DT_ENDPOINT_SIZE,
179 	.bDescriptorType =	USB_DT_ENDPOINT,
180 
181 	.bEndpointAddress =	USB_DIR_IN,
182 	.bmAttributes =		USB_ENDPOINT_XFER_INT,
183 	.wMaxPacketSize =	cpu_to_le16(ECM_STATUS_BYTECOUNT),
184 	.bInterval =		ECM_STATUS_INTERVAL_MS,
185 };
186 
187 static struct usb_endpoint_descriptor fs_ecm_in_desc = {
188 	.bLength =		USB_DT_ENDPOINT_SIZE,
189 	.bDescriptorType =	USB_DT_ENDPOINT,
190 
191 	.bEndpointAddress =	USB_DIR_IN,
192 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
193 };
194 
195 static struct usb_endpoint_descriptor fs_ecm_out_desc = {
196 	.bLength =		USB_DT_ENDPOINT_SIZE,
197 	.bDescriptorType =	USB_DT_ENDPOINT,
198 
199 	.bEndpointAddress =	USB_DIR_OUT,
200 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
201 };
202 
203 static struct usb_descriptor_header *ecm_fs_function[] = {
204 	/* CDC ECM control descriptors */
205 	(struct usb_descriptor_header *) &ecm_iad_descriptor,
206 	(struct usb_descriptor_header *) &ecm_control_intf,
207 	(struct usb_descriptor_header *) &ecm_header_desc,
208 	(struct usb_descriptor_header *) &ecm_union_desc,
209 	(struct usb_descriptor_header *) &ecm_desc,
210 
211 	/* NOTE: status endpoint might need to be removed */
212 	(struct usb_descriptor_header *) &fs_ecm_notify_desc,
213 
214 	/* data interface, altsettings 0 and 1 */
215 	(struct usb_descriptor_header *) &ecm_data_nop_intf,
216 	(struct usb_descriptor_header *) &ecm_data_intf,
217 	(struct usb_descriptor_header *) &fs_ecm_in_desc,
218 	(struct usb_descriptor_header *) &fs_ecm_out_desc,
219 	NULL,
220 };
221 
222 /* high speed support: */
223 
224 static struct usb_endpoint_descriptor hs_ecm_notify_desc = {
225 	.bLength =		USB_DT_ENDPOINT_SIZE,
226 	.bDescriptorType =	USB_DT_ENDPOINT,
227 
228 	.bEndpointAddress =	USB_DIR_IN,
229 	.bmAttributes =		USB_ENDPOINT_XFER_INT,
230 	.wMaxPacketSize =	cpu_to_le16(ECM_STATUS_BYTECOUNT),
231 	.bInterval =		USB_MS_TO_HS_INTERVAL(ECM_STATUS_INTERVAL_MS),
232 };
233 
234 static struct usb_endpoint_descriptor hs_ecm_in_desc = {
235 	.bLength =		USB_DT_ENDPOINT_SIZE,
236 	.bDescriptorType =	USB_DT_ENDPOINT,
237 
238 	.bEndpointAddress =	USB_DIR_IN,
239 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
240 	.wMaxPacketSize =	cpu_to_le16(512),
241 };
242 
243 static struct usb_endpoint_descriptor hs_ecm_out_desc = {
244 	.bLength =		USB_DT_ENDPOINT_SIZE,
245 	.bDescriptorType =	USB_DT_ENDPOINT,
246 
247 	.bEndpointAddress =	USB_DIR_OUT,
248 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
249 	.wMaxPacketSize =	cpu_to_le16(512),
250 };
251 
252 static struct usb_descriptor_header *ecm_hs_function[] = {
253 	/* CDC ECM control descriptors */
254 	(struct usb_descriptor_header *) &ecm_iad_descriptor,
255 	(struct usb_descriptor_header *) &ecm_control_intf,
256 	(struct usb_descriptor_header *) &ecm_header_desc,
257 	(struct usb_descriptor_header *) &ecm_union_desc,
258 	(struct usb_descriptor_header *) &ecm_desc,
259 
260 	/* NOTE: status endpoint might need to be removed */
261 	(struct usb_descriptor_header *) &hs_ecm_notify_desc,
262 
263 	/* data interface, altsettings 0 and 1 */
264 	(struct usb_descriptor_header *) &ecm_data_nop_intf,
265 	(struct usb_descriptor_header *) &ecm_data_intf,
266 	(struct usb_descriptor_header *) &hs_ecm_in_desc,
267 	(struct usb_descriptor_header *) &hs_ecm_out_desc,
268 	NULL,
269 };
270 
271 /* super speed support: */
272 
273 static struct usb_endpoint_descriptor ss_ecm_notify_desc = {
274 	.bLength =		USB_DT_ENDPOINT_SIZE,
275 	.bDescriptorType =	USB_DT_ENDPOINT,
276 
277 	.bEndpointAddress =	USB_DIR_IN,
278 	.bmAttributes =		USB_ENDPOINT_XFER_INT,
279 	.wMaxPacketSize =	cpu_to_le16(ECM_STATUS_BYTECOUNT),
280 	.bInterval =		USB_MS_TO_HS_INTERVAL(ECM_STATUS_INTERVAL_MS),
281 };
282 
283 static struct usb_ss_ep_comp_descriptor ss_ecm_intr_comp_desc = {
284 	.bLength =		sizeof ss_ecm_intr_comp_desc,
285 	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
286 
287 	/* the following 3 values can be tweaked if necessary */
288 	/* .bMaxBurst =		0, */
289 	/* .bmAttributes =	0, */
290 	.wBytesPerInterval =	cpu_to_le16(ECM_STATUS_BYTECOUNT),
291 };
292 
293 static struct usb_endpoint_descriptor ss_ecm_in_desc = {
294 	.bLength =		USB_DT_ENDPOINT_SIZE,
295 	.bDescriptorType =	USB_DT_ENDPOINT,
296 
297 	.bEndpointAddress =	USB_DIR_IN,
298 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
299 	.wMaxPacketSize =	cpu_to_le16(1024),
300 };
301 
302 static struct usb_endpoint_descriptor ss_ecm_out_desc = {
303 	.bLength =		USB_DT_ENDPOINT_SIZE,
304 	.bDescriptorType =	USB_DT_ENDPOINT,
305 
306 	.bEndpointAddress =	USB_DIR_OUT,
307 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
308 	.wMaxPacketSize =	cpu_to_le16(1024),
309 };
310 
311 static struct usb_ss_ep_comp_descriptor ss_ecm_bulk_comp_desc = {
312 	.bLength =		sizeof ss_ecm_bulk_comp_desc,
313 	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
314 
315 	/* the following 2 values can be tweaked if necessary */
316 	/* .bMaxBurst =		0, */
317 	/* .bmAttributes =	0, */
318 };
319 
320 static struct usb_descriptor_header *ecm_ss_function[] = {
321 	/* CDC ECM control descriptors */
322 	(struct usb_descriptor_header *) &ecm_iad_descriptor,
323 	(struct usb_descriptor_header *) &ecm_control_intf,
324 	(struct usb_descriptor_header *) &ecm_header_desc,
325 	(struct usb_descriptor_header *) &ecm_union_desc,
326 	(struct usb_descriptor_header *) &ecm_desc,
327 
328 	/* NOTE: status endpoint might need to be removed */
329 	(struct usb_descriptor_header *) &ss_ecm_notify_desc,
330 	(struct usb_descriptor_header *) &ss_ecm_intr_comp_desc,
331 
332 	/* data interface, altsettings 0 and 1 */
333 	(struct usb_descriptor_header *) &ecm_data_nop_intf,
334 	(struct usb_descriptor_header *) &ecm_data_intf,
335 	(struct usb_descriptor_header *) &ss_ecm_in_desc,
336 	(struct usb_descriptor_header *) &ss_ecm_bulk_comp_desc,
337 	(struct usb_descriptor_header *) &ss_ecm_out_desc,
338 	(struct usb_descriptor_header *) &ss_ecm_bulk_comp_desc,
339 	NULL,
340 };
341 
342 /* string descriptors: */
343 
344 static struct usb_string ecm_string_defs[] = {
345 	[0].s = "CDC Ethernet Control Model (ECM)",
346 	[1].s = "",
347 	[2].s = "CDC Ethernet Data",
348 	[3].s = "CDC ECM",
349 	{  } /* end of list */
350 };
351 
352 static struct usb_gadget_strings ecm_string_table = {
353 	.language =		0x0409,	/* en-us */
354 	.strings =		ecm_string_defs,
355 };
356 
357 static struct usb_gadget_strings *ecm_strings[] = {
358 	&ecm_string_table,
359 	NULL,
360 };
361 
362 /*-------------------------------------------------------------------------*/
363 
364 static void ecm_do_notify(struct f_ecm *ecm)
365 {
366 	struct usb_request		*req = ecm->notify_req;
367 	struct usb_cdc_notification	*event;
368 	struct usb_composite_dev	*cdev = ecm->port.func.config->cdev;
369 	__le32				*data;
370 	int				status;
371 
372 	/* notification already in flight? */
373 	if (atomic_read(&ecm->notify_count))
374 		return;
375 
376 	event = req->buf;
377 	switch (ecm->notify_state) {
378 	case ECM_NOTIFY_NONE:
379 		return;
380 
381 	case ECM_NOTIFY_CONNECT:
382 		event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
383 		if (ecm->is_open)
384 			event->wValue = cpu_to_le16(1);
385 		else
386 			event->wValue = cpu_to_le16(0);
387 		event->wLength = 0;
388 		req->length = sizeof *event;
389 
390 		DBG(cdev, "notify connect %s\n",
391 				ecm->is_open ? "true" : "false");
392 		ecm->notify_state = ECM_NOTIFY_SPEED;
393 		break;
394 
395 	case ECM_NOTIFY_SPEED:
396 		event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
397 		event->wValue = cpu_to_le16(0);
398 		event->wLength = cpu_to_le16(8);
399 		req->length = ECM_STATUS_BYTECOUNT;
400 
401 		/* SPEED_CHANGE data is up/down speeds in bits/sec */
402 		data = req->buf + sizeof *event;
403 		data[0] = cpu_to_le32(gether_bitrate(cdev->gadget));
404 		data[1] = data[0];
405 
406 		DBG(cdev, "notify speed %d\n", gether_bitrate(cdev->gadget));
407 		ecm->notify_state = ECM_NOTIFY_NONE;
408 		break;
409 	}
410 	event->bmRequestType = 0xA1;
411 	event->wIndex = cpu_to_le16(ecm->ctrl_id);
412 
413 	atomic_inc(&ecm->notify_count);
414 	status = usb_ep_queue(ecm->notify, req, GFP_ATOMIC);
415 	if (status < 0) {
416 		atomic_dec(&ecm->notify_count);
417 		DBG(cdev, "notify --> %d\n", status);
418 	}
419 }
420 
421 static void ecm_notify(struct f_ecm *ecm)
422 {
423 	/* NOTE on most versions of Linux, host side cdc-ethernet
424 	 * won't listen for notifications until its netdevice opens.
425 	 * The first notification then sits in the FIFO for a long
426 	 * time, and the second one is queued.
427 	 */
428 	ecm->notify_state = ECM_NOTIFY_CONNECT;
429 	ecm_do_notify(ecm);
430 }
431 
432 static void ecm_notify_complete(struct usb_ep *ep, struct usb_request *req)
433 {
434 	struct f_ecm			*ecm = req->context;
435 	struct usb_composite_dev	*cdev = ecm->port.func.config->cdev;
436 	struct usb_cdc_notification	*event = req->buf;
437 
438 	switch (req->status) {
439 	case 0:
440 		/* no fault */
441 		atomic_dec(&ecm->notify_count);
442 		break;
443 	case -ECONNRESET:
444 	case -ESHUTDOWN:
445 		atomic_set(&ecm->notify_count, 0);
446 		ecm->notify_state = ECM_NOTIFY_NONE;
447 		break;
448 	default:
449 		DBG(cdev, "event %02x --> %d\n",
450 			event->bNotificationType, req->status);
451 		atomic_dec(&ecm->notify_count);
452 		break;
453 	}
454 	ecm_do_notify(ecm);
455 }
456 
457 static int ecm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
458 {
459 	struct f_ecm		*ecm = func_to_ecm(f);
460 	struct usb_composite_dev *cdev = f->config->cdev;
461 	struct usb_request	*req = cdev->req;
462 	int			value = -EOPNOTSUPP;
463 	u16			w_index = le16_to_cpu(ctrl->wIndex);
464 	u16			w_value = le16_to_cpu(ctrl->wValue);
465 	u16			w_length = le16_to_cpu(ctrl->wLength);
466 
467 	/* composite driver infrastructure handles everything except
468 	 * CDC class messages; interface activation uses set_alt().
469 	 */
470 	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
471 	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
472 			| USB_CDC_SET_ETHERNET_PACKET_FILTER:
473 		/* see 6.2.30: no data, wIndex = interface,
474 		 * wValue = packet filter bitmap
475 		 */
476 		if (w_length != 0 || w_index != ecm->ctrl_id)
477 			goto invalid;
478 		DBG(cdev, "packet filter %02x\n", w_value);
479 		/* REVISIT locking of cdc_filter.  This assumes the UDC
480 		 * driver won't have a concurrent packet TX irq running on
481 		 * another CPU; or that if it does, this write is atomic...
482 		 */
483 		ecm->port.cdc_filter = w_value;
484 		value = 0;
485 		break;
486 
487 	/* and optionally:
488 	 * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
489 	 * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
490 	 * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
491 	 * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
492 	 * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
493 	 * case USB_CDC_GET_ETHERNET_STATISTIC:
494 	 */
495 
496 	default:
497 invalid:
498 		DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
499 			ctrl->bRequestType, ctrl->bRequest,
500 			w_value, w_index, w_length);
501 	}
502 
503 	/* respond with data transfer or status phase? */
504 	if (value >= 0) {
505 		DBG(cdev, "ecm req%02x.%02x v%04x i%04x l%d\n",
506 			ctrl->bRequestType, ctrl->bRequest,
507 			w_value, w_index, w_length);
508 		req->zero = 0;
509 		req->length = value;
510 		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
511 		if (value < 0)
512 			ERROR(cdev, "ecm req %02x.%02x response err %d\n",
513 					ctrl->bRequestType, ctrl->bRequest,
514 					value);
515 	}
516 
517 	/* device either stalls (value < 0) or reports success */
518 	return value;
519 }
520 
521 
522 static int ecm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
523 {
524 	struct f_ecm		*ecm = func_to_ecm(f);
525 	struct usb_composite_dev *cdev = f->config->cdev;
526 
527 	/* Control interface has only altsetting 0 */
528 	if (intf == ecm->ctrl_id) {
529 		if (alt != 0)
530 			goto fail;
531 
532 		VDBG(cdev, "reset ecm control %d\n", intf);
533 		usb_ep_disable(ecm->notify);
534 		if (!(ecm->notify->desc)) {
535 			VDBG(cdev, "init ecm ctrl %d\n", intf);
536 			if (config_ep_by_speed(cdev->gadget, f, ecm->notify))
537 				goto fail;
538 		}
539 		usb_ep_enable(ecm->notify);
540 
541 	/* Data interface has two altsettings, 0 and 1 */
542 	} else if (intf == ecm->data_id) {
543 		if (alt > 1)
544 			goto fail;
545 
546 		if (ecm->port.in_ep->enabled) {
547 			DBG(cdev, "reset ecm\n");
548 			gether_disconnect(&ecm->port);
549 		}
550 
551 		if (!ecm->port.in_ep->desc ||
552 		    !ecm->port.out_ep->desc) {
553 			DBG(cdev, "init ecm\n");
554 			if (config_ep_by_speed(cdev->gadget, f,
555 					       ecm->port.in_ep) ||
556 			    config_ep_by_speed(cdev->gadget, f,
557 					       ecm->port.out_ep)) {
558 				ecm->port.in_ep->desc = NULL;
559 				ecm->port.out_ep->desc = NULL;
560 				goto fail;
561 			}
562 		}
563 
564 		/* CDC Ethernet only sends data in non-default altsettings.
565 		 * Changing altsettings resets filters, statistics, etc.
566 		 */
567 		if (alt == 1) {
568 			struct net_device	*net;
569 
570 			/* Enable zlps by default for ECM conformance;
571 			 * override for musb_hdrc (avoids txdma ovhead).
572 			 */
573 			ecm->port.is_zlp_ok =
574 				gadget_is_zlp_supported(cdev->gadget);
575 			ecm->port.cdc_filter = DEFAULT_FILTER;
576 			DBG(cdev, "activate ecm\n");
577 			net = gether_connect(&ecm->port);
578 			if (IS_ERR(net))
579 				return PTR_ERR(net);
580 		}
581 
582 		/* NOTE this can be a minor disagreement with the ECM spec,
583 		 * which says speed notifications will "always" follow
584 		 * connection notifications.  But we allow one connect to
585 		 * follow another (if the first is in flight), and instead
586 		 * just guarantee that a speed notification is always sent.
587 		 */
588 		ecm_notify(ecm);
589 	} else
590 		goto fail;
591 
592 	return 0;
593 fail:
594 	return -EINVAL;
595 }
596 
597 /* Because the data interface supports multiple altsettings,
598  * this ECM function *MUST* implement a get_alt() method.
599  */
600 static int ecm_get_alt(struct usb_function *f, unsigned intf)
601 {
602 	struct f_ecm		*ecm = func_to_ecm(f);
603 
604 	if (intf == ecm->ctrl_id)
605 		return 0;
606 	return ecm->port.in_ep->enabled ? 1 : 0;
607 }
608 
609 static void ecm_disable(struct usb_function *f)
610 {
611 	struct f_ecm		*ecm = func_to_ecm(f);
612 	struct usb_composite_dev *cdev = f->config->cdev;
613 
614 	DBG(cdev, "ecm deactivated\n");
615 
616 	if (ecm->port.in_ep->enabled) {
617 		gether_disconnect(&ecm->port);
618 	} else {
619 		ecm->port.in_ep->desc = NULL;
620 		ecm->port.out_ep->desc = NULL;
621 	}
622 
623 	usb_ep_disable(ecm->notify);
624 	ecm->notify->desc = NULL;
625 }
626 
627 /*-------------------------------------------------------------------------*/
628 
629 /*
630  * Callbacks let us notify the host about connect/disconnect when the
631  * net device is opened or closed.
632  *
633  * For testing, note that link states on this side include both opened
634  * and closed variants of:
635  *
636  *   - disconnected/unconfigured
637  *   - configured but inactive (data alt 0)
638  *   - configured and active (data alt 1)
639  *
640  * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
641  * SET_INTERFACE (altsetting).  Remember also that "configured" doesn't
642  * imply the host is actually polling the notification endpoint, and
643  * likewise that "active" doesn't imply it's actually using the data
644  * endpoints for traffic.
645  */
646 
647 static void ecm_open(struct gether *geth)
648 {
649 	struct f_ecm		*ecm = func_to_ecm(&geth->func);
650 
651 	DBG(ecm->port.func.config->cdev, "%s\n", __func__);
652 
653 	ecm->is_open = true;
654 	ecm_notify(ecm);
655 }
656 
657 static void ecm_close(struct gether *geth)
658 {
659 	struct f_ecm		*ecm = func_to_ecm(&geth->func);
660 
661 	DBG(ecm->port.func.config->cdev, "%s\n", __func__);
662 
663 	ecm->is_open = false;
664 	ecm_notify(ecm);
665 }
666 
667 /*-------------------------------------------------------------------------*/
668 
669 /* ethernet function driver setup/binding */
670 
671 static int
672 ecm_bind(struct usb_configuration *c, struct usb_function *f)
673 {
674 	struct usb_composite_dev *cdev = c->cdev;
675 	struct f_ecm		*ecm = func_to_ecm(f);
676 	struct usb_string	*us;
677 	int			status = 0;
678 	struct usb_ep		*ep;
679 
680 	struct f_ecm_opts	*ecm_opts;
681 
682 	if (!can_support_ecm(cdev->gadget))
683 		return -EINVAL;
684 
685 	ecm_opts = container_of(f->fi, struct f_ecm_opts, func_inst);
686 
687 	mutex_lock(&ecm_opts->lock);
688 
689 	gether_set_gadget(ecm_opts->net, cdev->gadget);
690 
691 	if (!ecm_opts->bound) {
692 		status = gether_register_netdev(ecm_opts->net);
693 		ecm_opts->bound = true;
694 	}
695 
696 	mutex_unlock(&ecm_opts->lock);
697 	if (status)
698 		return status;
699 
700 	ecm_string_defs[1].s = ecm->ethaddr;
701 
702 	us = usb_gstrings_attach(cdev, ecm_strings,
703 				 ARRAY_SIZE(ecm_string_defs));
704 	if (IS_ERR(us))
705 		return PTR_ERR(us);
706 	ecm_control_intf.iInterface = us[0].id;
707 	ecm_data_intf.iInterface = us[2].id;
708 	ecm_desc.iMACAddress = us[1].id;
709 	ecm_iad_descriptor.iFunction = us[3].id;
710 
711 	/* allocate instance-specific interface IDs */
712 	status = usb_interface_id(c, f);
713 	if (status < 0)
714 		goto fail;
715 	ecm->ctrl_id = status;
716 	ecm_iad_descriptor.bFirstInterface = status;
717 
718 	ecm_control_intf.bInterfaceNumber = status;
719 	ecm_union_desc.bMasterInterface0 = status;
720 
721 	status = usb_interface_id(c, f);
722 	if (status < 0)
723 		goto fail;
724 	ecm->data_id = status;
725 
726 	ecm_data_nop_intf.bInterfaceNumber = status;
727 	ecm_data_intf.bInterfaceNumber = status;
728 	ecm_union_desc.bSlaveInterface0 = status;
729 
730 	status = -ENODEV;
731 
732 	/* allocate instance-specific endpoints */
733 	ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_in_desc);
734 	if (!ep)
735 		goto fail;
736 	ecm->port.in_ep = ep;
737 
738 	ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_out_desc);
739 	if (!ep)
740 		goto fail;
741 	ecm->port.out_ep = ep;
742 
743 	/* NOTE:  a status/notification endpoint is *OPTIONAL* but we
744 	 * don't treat it that way.  It's simpler, and some newer CDC
745 	 * profiles (wireless handsets) no longer treat it as optional.
746 	 */
747 	ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_notify_desc);
748 	if (!ep)
749 		goto fail;
750 	ecm->notify = ep;
751 
752 	status = -ENOMEM;
753 
754 	/* allocate notification request and buffer */
755 	ecm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
756 	if (!ecm->notify_req)
757 		goto fail;
758 	ecm->notify_req->buf = kmalloc(ECM_STATUS_BYTECOUNT, GFP_KERNEL);
759 	if (!ecm->notify_req->buf)
760 		goto fail;
761 	ecm->notify_req->context = ecm;
762 	ecm->notify_req->complete = ecm_notify_complete;
763 
764 	/* support all relevant hardware speeds... we expect that when
765 	 * hardware is dual speed, all bulk-capable endpoints work at
766 	 * both speeds
767 	 */
768 	hs_ecm_in_desc.bEndpointAddress = fs_ecm_in_desc.bEndpointAddress;
769 	hs_ecm_out_desc.bEndpointAddress = fs_ecm_out_desc.bEndpointAddress;
770 	hs_ecm_notify_desc.bEndpointAddress =
771 		fs_ecm_notify_desc.bEndpointAddress;
772 
773 	ss_ecm_in_desc.bEndpointAddress = fs_ecm_in_desc.bEndpointAddress;
774 	ss_ecm_out_desc.bEndpointAddress = fs_ecm_out_desc.bEndpointAddress;
775 	ss_ecm_notify_desc.bEndpointAddress =
776 		fs_ecm_notify_desc.bEndpointAddress;
777 
778 	status = usb_assign_descriptors(f, ecm_fs_function, ecm_hs_function,
779 			ecm_ss_function, ecm_ss_function);
780 	if (status)
781 		goto fail;
782 
783 	/* NOTE:  all that is done without knowing or caring about
784 	 * the network link ... which is unavailable to this code
785 	 * until we're activated via set_alt().
786 	 */
787 
788 	ecm->port.open = ecm_open;
789 	ecm->port.close = ecm_close;
790 
791 	DBG(cdev, "CDC Ethernet: IN/%s OUT/%s NOTIFY/%s\n",
792 			ecm->port.in_ep->name, ecm->port.out_ep->name,
793 			ecm->notify->name);
794 	return 0;
795 
796 fail:
797 	if (ecm->notify_req) {
798 		kfree(ecm->notify_req->buf);
799 		usb_ep_free_request(ecm->notify, ecm->notify_req);
800 	}
801 
802 	ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
803 
804 	return status;
805 }
806 
807 static inline struct f_ecm_opts *to_f_ecm_opts(struct config_item *item)
808 {
809 	return container_of(to_config_group(item), struct f_ecm_opts,
810 			    func_inst.group);
811 }
812 
813 /* f_ecm_item_ops */
814 USB_ETHERNET_CONFIGFS_ITEM(ecm);
815 
816 /* f_ecm_opts_dev_addr */
817 USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(ecm);
818 
819 /* f_ecm_opts_host_addr */
820 USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(ecm);
821 
822 /* f_ecm_opts_qmult */
823 USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(ecm);
824 
825 /* f_ecm_opts_ifname */
826 USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(ecm);
827 
828 static struct configfs_attribute *ecm_attrs[] = {
829 	&ecm_opts_attr_dev_addr,
830 	&ecm_opts_attr_host_addr,
831 	&ecm_opts_attr_qmult,
832 	&ecm_opts_attr_ifname,
833 	NULL,
834 };
835 
836 static const struct config_item_type ecm_func_type = {
837 	.ct_item_ops	= &ecm_item_ops,
838 	.ct_attrs	= ecm_attrs,
839 	.ct_owner	= THIS_MODULE,
840 };
841 
842 static void ecm_free_inst(struct usb_function_instance *f)
843 {
844 	struct f_ecm_opts *opts;
845 
846 	opts = container_of(f, struct f_ecm_opts, func_inst);
847 	if (opts->bound)
848 		gether_cleanup(netdev_priv(opts->net));
849 	else
850 		free_netdev(opts->net);
851 	kfree(opts);
852 }
853 
854 static struct usb_function_instance *ecm_alloc_inst(void)
855 {
856 	struct f_ecm_opts *opts;
857 
858 	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
859 	if (!opts)
860 		return ERR_PTR(-ENOMEM);
861 	mutex_init(&opts->lock);
862 	opts->func_inst.free_func_inst = ecm_free_inst;
863 	opts->net = gether_setup_default();
864 	if (IS_ERR(opts->net)) {
865 		struct net_device *net = opts->net;
866 		kfree(opts);
867 		return ERR_CAST(net);
868 	}
869 
870 	config_group_init_type_name(&opts->func_inst.group, "", &ecm_func_type);
871 
872 	return &opts->func_inst;
873 }
874 
875 static void ecm_suspend(struct usb_function *f)
876 {
877 	struct f_ecm *ecm = func_to_ecm(f);
878 	struct usb_composite_dev *cdev = ecm->port.func.config->cdev;
879 
880 	DBG(cdev, "ECM Suspend\n");
881 
882 	gether_suspend(&ecm->port);
883 }
884 
885 static void ecm_resume(struct usb_function *f)
886 {
887 	struct f_ecm *ecm = func_to_ecm(f);
888 	struct usb_composite_dev *cdev = ecm->port.func.config->cdev;
889 
890 	DBG(cdev, "ECM Resume\n");
891 
892 	gether_resume(&ecm->port);
893 }
894 
895 static void ecm_free(struct usb_function *f)
896 {
897 	struct f_ecm *ecm;
898 	struct f_ecm_opts *opts;
899 
900 	ecm = func_to_ecm(f);
901 	opts = container_of(f->fi, struct f_ecm_opts, func_inst);
902 	kfree(ecm);
903 	mutex_lock(&opts->lock);
904 	opts->refcnt--;
905 	mutex_unlock(&opts->lock);
906 }
907 
908 static void ecm_unbind(struct usb_configuration *c, struct usb_function *f)
909 {
910 	struct f_ecm		*ecm = func_to_ecm(f);
911 
912 	DBG(c->cdev, "ecm unbind\n");
913 
914 	usb_free_all_descriptors(f);
915 
916 	if (atomic_read(&ecm->notify_count)) {
917 		usb_ep_dequeue(ecm->notify, ecm->notify_req);
918 		atomic_set(&ecm->notify_count, 0);
919 	}
920 
921 	kfree(ecm->notify_req->buf);
922 	usb_ep_free_request(ecm->notify, ecm->notify_req);
923 }
924 
925 static struct usb_function *ecm_alloc(struct usb_function_instance *fi)
926 {
927 	struct f_ecm	*ecm;
928 	struct f_ecm_opts *opts;
929 	int status;
930 
931 	/* allocate and initialize one new instance */
932 	ecm = kzalloc(sizeof(*ecm), GFP_KERNEL);
933 	if (!ecm)
934 		return ERR_PTR(-ENOMEM);
935 
936 	opts = container_of(fi, struct f_ecm_opts, func_inst);
937 	mutex_lock(&opts->lock);
938 	opts->refcnt++;
939 
940 	/* export host's Ethernet address in CDC format */
941 	status = gether_get_host_addr_cdc(opts->net, ecm->ethaddr,
942 					  sizeof(ecm->ethaddr));
943 	if (status < 12) {
944 		kfree(ecm);
945 		mutex_unlock(&opts->lock);
946 		return ERR_PTR(-EINVAL);
947 	}
948 
949 	ecm->port.ioport = netdev_priv(opts->net);
950 	mutex_unlock(&opts->lock);
951 	ecm->port.cdc_filter = DEFAULT_FILTER;
952 
953 	ecm->port.func.name = "cdc_ethernet";
954 	/* descriptors are per-instance copies */
955 	ecm->port.func.bind = ecm_bind;
956 	ecm->port.func.unbind = ecm_unbind;
957 	ecm->port.func.set_alt = ecm_set_alt;
958 	ecm->port.func.get_alt = ecm_get_alt;
959 	ecm->port.func.setup = ecm_setup;
960 	ecm->port.func.disable = ecm_disable;
961 	ecm->port.func.free_func = ecm_free;
962 	ecm->port.func.suspend = ecm_suspend;
963 	ecm->port.func.resume = ecm_resume;
964 
965 	return &ecm->port.func;
966 }
967 
968 DECLARE_USB_FUNCTION_INIT(ecm, ecm_alloc_inst, ecm_alloc);
969 MODULE_LICENSE("GPL");
970 MODULE_AUTHOR("David Brownell");
971