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