drivers/usb/gadget/function/f_ecm.c

   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");