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 627 usb_ep_disable(ecm->notify); 628 ecm->notify->desc = NULL; 629 } 630 631 /*-------------------------------------------------------------------------*/ 632 633 /* 634 * Callbacks let us notify the host about connect/disconnect when the 635 * net device is opened or closed. 636 * 637 * For testing, note that link states on this side include both opened 638 * and closed variants of: 639 * 640 * - disconnected/unconfigured 641 * - configured but inactive (data alt 0) 642 * - configured and active (data alt 1) 643 * 644 * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and 645 * SET_INTERFACE (altsetting). Remember also that "configured" doesn't 646 * imply the host is actually polling the notification endpoint, and 647 * likewise that "active" doesn't imply it's actually using the data 648 * endpoints for traffic. 649 */ 650 651 static void ecm_open(struct gether *geth) 652 { 653 struct f_ecm *ecm = func_to_ecm(&geth->func); 654 655 DBG(ecm->port.func.config->cdev, "%s\n", __func__); 656 657 ecm->is_open = true; 658 ecm_notify(ecm); 659 } 660 661 static void ecm_close(struct gether *geth) 662 { 663 struct f_ecm *ecm = func_to_ecm(&geth->func); 664 665 DBG(ecm->port.func.config->cdev, "%s\n", __func__); 666 667 ecm->is_open = false; 668 ecm_notify(ecm); 669 } 670 671 /*-------------------------------------------------------------------------*/ 672 673 /* ethernet function driver setup/binding */ 674 675 static int 676 ecm_bind(struct usb_configuration *c, struct usb_function *f) 677 { 678 struct usb_composite_dev *cdev = c->cdev; 679 struct f_ecm *ecm = func_to_ecm(f); 680 struct usb_string *us; 681 int status; 682 struct usb_ep *ep; 683 684 struct f_ecm_opts *ecm_opts; 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 /* 692 * in drivers/usb/gadget/configfs.c:configfs_composite_bind() 693 * configurations are bound in sequence with list_for_each_entry, 694 * in each configuration its functions are bound in sequence 695 * with list_for_each_entry, so we assume no race condition 696 * with regard to ecm_opts->bound access 697 */ 698 if (!ecm_opts->bound) { 699 mutex_lock(&ecm_opts->lock); 700 gether_set_gadget(ecm_opts->net, cdev->gadget); 701 status = gether_register_netdev(ecm_opts->net); 702 mutex_unlock(&ecm_opts->lock); 703 if (status) 704 return status; 705 ecm_opts->bound = true; 706 } 707 708 ecm_string_defs[1].s = ecm->ethaddr; 709 710 us = usb_gstrings_attach(cdev, ecm_strings, 711 ARRAY_SIZE(ecm_string_defs)); 712 if (IS_ERR(us)) 713 return PTR_ERR(us); 714 ecm_control_intf.iInterface = us[0].id; 715 ecm_data_intf.iInterface = us[2].id; 716 ecm_desc.iMACAddress = us[1].id; 717 ecm_iad_descriptor.iFunction = us[3].id; 718 719 /* allocate instance-specific interface IDs */ 720 status = usb_interface_id(c, f); 721 if (status < 0) 722 goto fail; 723 ecm->ctrl_id = status; 724 ecm_iad_descriptor.bFirstInterface = status; 725 726 ecm_control_intf.bInterfaceNumber = status; 727 ecm_union_desc.bMasterInterface0 = status; 728 729 status = usb_interface_id(c, f); 730 if (status < 0) 731 goto fail; 732 ecm->data_id = status; 733 734 ecm_data_nop_intf.bInterfaceNumber = status; 735 ecm_data_intf.bInterfaceNumber = status; 736 ecm_union_desc.bSlaveInterface0 = status; 737 738 status = -ENODEV; 739 740 /* allocate instance-specific endpoints */ 741 ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_in_desc); 742 if (!ep) 743 goto fail; 744 ecm->port.in_ep = ep; 745 746 ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_out_desc); 747 if (!ep) 748 goto fail; 749 ecm->port.out_ep = ep; 750 751 /* NOTE: a status/notification endpoint is *OPTIONAL* but we 752 * don't treat it that way. It's simpler, and some newer CDC 753 * profiles (wireless handsets) no longer treat it as optional. 754 */ 755 ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_notify_desc); 756 if (!ep) 757 goto fail; 758 ecm->notify = ep; 759 760 status = -ENOMEM; 761 762 /* allocate notification request and buffer */ 763 ecm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL); 764 if (!ecm->notify_req) 765 goto fail; 766 ecm->notify_req->buf = kmalloc(ECM_STATUS_BYTECOUNT, GFP_KERNEL); 767 if (!ecm->notify_req->buf) 768 goto fail; 769 ecm->notify_req->context = ecm; 770 ecm->notify_req->complete = ecm_notify_complete; 771 772 /* support all relevant hardware speeds... we expect that when 773 * hardware is dual speed, all bulk-capable endpoints work at 774 * both speeds 775 */ 776 hs_ecm_in_desc.bEndpointAddress = fs_ecm_in_desc.bEndpointAddress; 777 hs_ecm_out_desc.bEndpointAddress = fs_ecm_out_desc.bEndpointAddress; 778 hs_ecm_notify_desc.bEndpointAddress = 779 fs_ecm_notify_desc.bEndpointAddress; 780 781 ss_ecm_in_desc.bEndpointAddress = fs_ecm_in_desc.bEndpointAddress; 782 ss_ecm_out_desc.bEndpointAddress = fs_ecm_out_desc.bEndpointAddress; 783 ss_ecm_notify_desc.bEndpointAddress = 784 fs_ecm_notify_desc.bEndpointAddress; 785 786 status = usb_assign_descriptors(f, ecm_fs_function, ecm_hs_function, 787 ecm_ss_function, NULL); 788 if (status) 789 goto fail; 790 791 /* NOTE: all that is done without knowing or caring about 792 * the network link ... which is unavailable to this code 793 * until we're activated via set_alt(). 794 */ 795 796 ecm->port.open = ecm_open; 797 ecm->port.close = ecm_close; 798 799 DBG(cdev, "CDC Ethernet: %s speed IN/%s OUT/%s NOTIFY/%s\n", 800 gadget_is_superspeed(c->cdev->gadget) ? "super" : 801 gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full", 802 ecm->port.in_ep->name, ecm->port.out_ep->name, 803 ecm->notify->name); 804 return 0; 805 806 fail: 807 if (ecm->notify_req) { 808 kfree(ecm->notify_req->buf); 809 usb_ep_free_request(ecm->notify, ecm->notify_req); 810 } 811 812 ERROR(cdev, "%s: can't bind, err %d\n", f->name, status); 813 814 return status; 815 } 816 817 static inline struct f_ecm_opts *to_f_ecm_opts(struct config_item *item) 818 { 819 return container_of(to_config_group(item), struct f_ecm_opts, 820 func_inst.group); 821 } 822 823 /* f_ecm_item_ops */ 824 USB_ETHERNET_CONFIGFS_ITEM(ecm); 825 826 /* f_ecm_opts_dev_addr */ 827 USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(ecm); 828 829 /* f_ecm_opts_host_addr */ 830 USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(ecm); 831 832 /* f_ecm_opts_qmult */ 833 USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(ecm); 834 835 /* f_ecm_opts_ifname */ 836 USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(ecm); 837 838 static struct configfs_attribute *ecm_attrs[] = { 839 &ecm_opts_attr_dev_addr, 840 &ecm_opts_attr_host_addr, 841 &ecm_opts_attr_qmult, 842 &ecm_opts_attr_ifname, 843 NULL, 844 }; 845 846 static const struct config_item_type ecm_func_type = { 847 .ct_item_ops = &ecm_item_ops, 848 .ct_attrs = ecm_attrs, 849 .ct_owner = THIS_MODULE, 850 }; 851 852 static void ecm_free_inst(struct usb_function_instance *f) 853 { 854 struct f_ecm_opts *opts; 855 856 opts = container_of(f, struct f_ecm_opts, func_inst); 857 if (opts->bound) 858 gether_cleanup(netdev_priv(opts->net)); 859 else 860 free_netdev(opts->net); 861 kfree(opts); 862 } 863 864 static struct usb_function_instance *ecm_alloc_inst(void) 865 { 866 struct f_ecm_opts *opts; 867 868 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 869 if (!opts) 870 return ERR_PTR(-ENOMEM); 871 mutex_init(&opts->lock); 872 opts->func_inst.free_func_inst = ecm_free_inst; 873 opts->net = gether_setup_default(); 874 if (IS_ERR(opts->net)) { 875 struct net_device *net = opts->net; 876 kfree(opts); 877 return ERR_CAST(net); 878 } 879 880 config_group_init_type_name(&opts->func_inst.group, "", &ecm_func_type); 881 882 return &opts->func_inst; 883 } 884 885 static void ecm_free(struct usb_function *f) 886 { 887 struct f_ecm *ecm; 888 struct f_ecm_opts *opts; 889 890 ecm = func_to_ecm(f); 891 opts = container_of(f->fi, struct f_ecm_opts, func_inst); 892 kfree(ecm); 893 mutex_lock(&opts->lock); 894 opts->refcnt--; 895 mutex_unlock(&opts->lock); 896 } 897 898 static void ecm_unbind(struct usb_configuration *c, struct usb_function *f) 899 { 900 struct f_ecm *ecm = func_to_ecm(f); 901 902 DBG(c->cdev, "ecm unbind\n"); 903 904 usb_free_all_descriptors(f); 905 906 kfree(ecm->notify_req->buf); 907 usb_ep_free_request(ecm->notify, ecm->notify_req); 908 } 909 910 static struct usb_function *ecm_alloc(struct usb_function_instance *fi) 911 { 912 struct f_ecm *ecm; 913 struct f_ecm_opts *opts; 914 int status; 915 916 /* allocate and initialize one new instance */ 917 ecm = kzalloc(sizeof(*ecm), GFP_KERNEL); 918 if (!ecm) 919 return ERR_PTR(-ENOMEM); 920 921 opts = container_of(fi, struct f_ecm_opts, func_inst); 922 mutex_lock(&opts->lock); 923 opts->refcnt++; 924 925 /* export host's Ethernet address in CDC format */ 926 status = gether_get_host_addr_cdc(opts->net, ecm->ethaddr, 927 sizeof(ecm->ethaddr)); 928 if (status < 12) { 929 kfree(ecm); 930 mutex_unlock(&opts->lock); 931 return ERR_PTR(-EINVAL); 932 } 933 934 ecm->port.ioport = netdev_priv(opts->net); 935 mutex_unlock(&opts->lock); 936 ecm->port.cdc_filter = DEFAULT_FILTER; 937 938 ecm->port.func.name = "cdc_ethernet"; 939 /* descriptors are per-instance copies */ 940 ecm->port.func.bind = ecm_bind; 941 ecm->port.func.unbind = ecm_unbind; 942 ecm->port.func.set_alt = ecm_set_alt; 943 ecm->port.func.get_alt = ecm_get_alt; 944 ecm->port.func.setup = ecm_setup; 945 ecm->port.func.disable = ecm_disable; 946 ecm->port.func.free_func = ecm_free; 947 948 return &ecm->port.func; 949 } 950 951 DECLARE_USB_FUNCTION_INIT(ecm, ecm_alloc_inst, ecm_alloc); 952 MODULE_LICENSE("GPL"); 953 MODULE_AUTHOR("David Brownell"); 954