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