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