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