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