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