drivers/usb/gadget/function/f_sourcesink.c

   1 /*
   2  * f_sourcesink.c - USB peripheral source/sink configuration driver
   3  *
   4  * Copyright (C) 2003-2008 David Brownell
   5  * Copyright (C) 2008 by 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/device.h>
  18 #include <linux/module.h>
  19 #include <linux/usb/composite.h>
  20 #include <linux/err.h>
  21
  22 #include "g_zero.h"
  23 #include "gadget_chips.h"
  24 #include "u_f.h"
  25
  26 #define USB_MS_TO_SS_INTERVAL(x) USB_MS_TO_HS_INTERVAL(x)
  27
  28 enum eptype {
  29         EP_CONTROL = 0,
  30         EP_BULK,
  31         EP_ISOC,
  32         EP_INTERRUPT,
  33 };
  34
  35 /*
  36  * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
  37  * controller drivers.
  38  *
  39  * This just sinks bulk packets OUT to the peripheral and sources them IN
  40  * to the host, optionally with specific data patterns for integrity tests.
  41  * As such it supports basic functionality and load tests.
  42  *
  43  * In terms of control messaging, this supports all the standard requests
  44  * plus two that support control-OUT tests.  If the optional "autoresume"
  45  * mode is enabled, it provides good functional coverage for the "USBCV"
  46  * test harness from USB-IF.
  47  *
  48  * Note that because this doesn't queue more than one request at a time,
  49  * some other function must be used to test queueing logic.  The network
  50  * link (g_ether) is the best overall option for that, since its TX and RX
  51  * queues are relatively independent, will receive a range of packet sizes,
  52  * and can often be made to run out completely.  Those issues are important
  53  * when stress testing peripheral controller drivers.
  54  *
  55  *
  56  * This is currently packaged as a configuration driver, which can't be
  57  * combined with other functions to make composite devices.  However, it
  58  * can be combined with other independent configurations.
  59  */
  60 struct f_sourcesink {
  61         struct usb_function     function;
  62
  63         struct usb_ep           *in_ep;
  64         struct usb_ep           *out_ep;
  65         struct usb_ep           *iso_in_ep;
  66         struct usb_ep           *iso_out_ep;
  67         struct usb_ep           *int_in_ep;
  68         struct usb_ep           *int_out_ep;
  69         int                     cur_alt;
  70 };
  71
  72 static inline struct f_sourcesink *func_to_ss(struct usb_function *f)
  73 {
  74         return container_of(f, struct f_sourcesink, function);
  75 }
  76
  77 static unsigned pattern;
  78 static unsigned isoc_interval;
  79 static unsigned isoc_maxpacket;
  80 static unsigned isoc_mult;
  81 static unsigned isoc_maxburst;
  82 static unsigned int_interval; /* In ms */
  83 static unsigned int_maxpacket;
  84 static unsigned int_mult;
  85 static unsigned int_maxburst;
  86 static unsigned buflen;
  87
  88 /*-------------------------------------------------------------------------*/
  89
  90 static struct usb_interface_descriptor source_sink_intf_alt0 = {
  91         .bLength =              USB_DT_INTERFACE_SIZE,
  92         .bDescriptorType =      USB_DT_INTERFACE,
  93
  94         .bAlternateSetting =    0,
  95         .bNumEndpoints =        2,
  96         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
  97         /* .iInterface          = DYNAMIC */
  98 };
  99
 100 static struct usb_interface_descriptor source_sink_intf_alt1 = {
 101         .bLength =              USB_DT_INTERFACE_SIZE,
 102         .bDescriptorType =      USB_DT_INTERFACE,
 103
 104         .bAlternateSetting =    1,
 105         .bNumEndpoints =        4,
 106         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
 107         /* .iInterface          = DYNAMIC */
 108 };
 109
 110 static struct usb_interface_descriptor source_sink_intf_alt2 = {
 111         .bLength =              USB_DT_INTERFACE_SIZE,
 112         .bDescriptorType =      USB_DT_INTERFACE,
 113
 114         .bAlternateSetting =    2,
 115         .bNumEndpoints =        2,
 116         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
 117         /* .iInterface          = DYNAMIC */
 118 };
 119
 120 /* full speed support: */
 121
 122 static struct usb_endpoint_descriptor fs_source_desc = {
 123         .bLength =              USB_DT_ENDPOINT_SIZE,
 124         .bDescriptorType =      USB_DT_ENDPOINT,
 125
 126         .bEndpointAddress =     USB_DIR_IN,
 127         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 128 };
 129
 130 static struct usb_endpoint_descriptor fs_sink_desc = {
 131         .bLength =              USB_DT_ENDPOINT_SIZE,
 132         .bDescriptorType =      USB_DT_ENDPOINT,
 133
 134         .bEndpointAddress =     USB_DIR_OUT,
 135         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 136 };
 137
 138 static struct usb_endpoint_descriptor fs_iso_source_desc = {
 139         .bLength =              USB_DT_ENDPOINT_SIZE,
 140         .bDescriptorType =      USB_DT_ENDPOINT,
 141
 142         .bEndpointAddress =     USB_DIR_IN,
 143         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 144         .wMaxPacketSize =       cpu_to_le16(1023),
 145         .bInterval =            4,
 146 };
 147
 148 static struct usb_endpoint_descriptor fs_iso_sink_desc = {
 149         .bLength =              USB_DT_ENDPOINT_SIZE,
 150         .bDescriptorType =      USB_DT_ENDPOINT,
 151
 152         .bEndpointAddress =     USB_DIR_OUT,
 153         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 154         .wMaxPacketSize =       cpu_to_le16(1023),
 155         .bInterval =            4,
 156 };
 157
 158 static struct usb_endpoint_descriptor fs_int_source_desc = {
 159         .bLength =              USB_DT_ENDPOINT_SIZE,
 160         .bDescriptorType =      USB_DT_ENDPOINT,
 161
 162         .bEndpointAddress =     USB_DIR_IN,
 163         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 164         .wMaxPacketSize =       cpu_to_le16(64),
 165         .bInterval =            GZERO_INT_INTERVAL,
 166 };
 167
 168 static struct usb_endpoint_descriptor fs_int_sink_desc = {
 169         .bLength =              USB_DT_ENDPOINT_SIZE,
 170         .bDescriptorType =      USB_DT_ENDPOINT,
 171
 172         .bEndpointAddress =     USB_DIR_OUT,
 173         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 174         .wMaxPacketSize =       cpu_to_le16(64),
 175         .bInterval =            GZERO_INT_INTERVAL,
 176 };
 177
 178 static struct usb_descriptor_header *fs_source_sink_descs[] = {
 179         (struct usb_descriptor_header *) &source_sink_intf_alt0,
 180         (struct usb_descriptor_header *) &fs_sink_desc,
 181         (struct usb_descriptor_header *) &fs_source_desc,
 182         (struct usb_descriptor_header *) &source_sink_intf_alt1,
 183 #define FS_ALT_IFC_1_OFFSET     3
 184         (struct usb_descriptor_header *) &fs_sink_desc,
 185         (struct usb_descriptor_header *) &fs_source_desc,
 186         (struct usb_descriptor_header *) &fs_iso_sink_desc,
 187         (struct usb_descriptor_header *) &fs_iso_source_desc,
 188         (struct usb_descriptor_header *) &source_sink_intf_alt2,
 189 #define FS_ALT_IFC_2_OFFSET     8
 190         (struct usb_descriptor_header *) &fs_int_sink_desc,
 191         (struct usb_descriptor_header *) &fs_int_source_desc,
 192         NULL,
 193 };
 194
 195 /* high speed support: */
 196
 197 static struct usb_endpoint_descriptor hs_source_desc = {
 198         .bLength =              USB_DT_ENDPOINT_SIZE,
 199         .bDescriptorType =      USB_DT_ENDPOINT,
 200
 201         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 202         .wMaxPacketSize =       cpu_to_le16(512),
 203 };
 204
 205 static struct usb_endpoint_descriptor hs_sink_desc = {
 206         .bLength =              USB_DT_ENDPOINT_SIZE,
 207         .bDescriptorType =      USB_DT_ENDPOINT,
 208
 209         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 210         .wMaxPacketSize =       cpu_to_le16(512),
 211 };
 212
 213 static struct usb_endpoint_descriptor hs_iso_source_desc = {
 214         .bLength =              USB_DT_ENDPOINT_SIZE,
 215         .bDescriptorType =      USB_DT_ENDPOINT,
 216
 217         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 218         .wMaxPacketSize =       cpu_to_le16(1024),
 219         .bInterval =            4,
 220 };
 221
 222 static struct usb_endpoint_descriptor hs_iso_sink_desc = {
 223         .bLength =              USB_DT_ENDPOINT_SIZE,
 224         .bDescriptorType =      USB_DT_ENDPOINT,
 225
 226         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 227         .wMaxPacketSize =       cpu_to_le16(1024),
 228         .bInterval =            4,
 229 };
 230
 231 static struct usb_endpoint_descriptor hs_int_source_desc = {
 232         .bLength =              USB_DT_ENDPOINT_SIZE,
 233         .bDescriptorType =      USB_DT_ENDPOINT,
 234
 235         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 236         .wMaxPacketSize =       cpu_to_le16(1024),
 237         .bInterval =            USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
 238 };
 239
 240 static struct usb_endpoint_descriptor hs_int_sink_desc = {
 241         .bLength =              USB_DT_ENDPOINT_SIZE,
 242         .bDescriptorType =      USB_DT_ENDPOINT,
 243
 244         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 245         .wMaxPacketSize =       cpu_to_le16(1024),
 246         .bInterval =            USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
 247 };
 248
 249 static struct usb_descriptor_header *hs_source_sink_descs[] = {
 250         (struct usb_descriptor_header *) &source_sink_intf_alt0,
 251         (struct usb_descriptor_header *) &hs_source_desc,
 252         (struct usb_descriptor_header *) &hs_sink_desc,
 253         (struct usb_descriptor_header *) &source_sink_intf_alt1,
 254 #define HS_ALT_IFC_1_OFFSET     3
 255         (struct usb_descriptor_header *) &hs_source_desc,
 256         (struct usb_descriptor_header *) &hs_sink_desc,
 257         (struct usb_descriptor_header *) &hs_iso_source_desc,
 258         (struct usb_descriptor_header *) &hs_iso_sink_desc,
 259         (struct usb_descriptor_header *) &source_sink_intf_alt2,
 260 #define HS_ALT_IFC_2_OFFSET     8
 261         (struct usb_descriptor_header *) &hs_int_source_desc,
 262         (struct usb_descriptor_header *) &hs_int_sink_desc,
 263         NULL,
 264 };
 265
 266 /* super speed support: */
 267
 268 static struct usb_endpoint_descriptor ss_source_desc = {
 269         .bLength =              USB_DT_ENDPOINT_SIZE,
 270         .bDescriptorType =      USB_DT_ENDPOINT,
 271
 272         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 273         .wMaxPacketSize =       cpu_to_le16(1024),
 274 };
 275
 276 static struct usb_ss_ep_comp_descriptor ss_source_comp_desc = {
 277         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 278         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 279
 280         .bMaxBurst =            0,
 281         .bmAttributes =         0,
 282         .wBytesPerInterval =    0,
 283 };
 284
 285 static struct usb_endpoint_descriptor ss_sink_desc = {
 286         .bLength =              USB_DT_ENDPOINT_SIZE,
 287         .bDescriptorType =      USB_DT_ENDPOINT,
 288
 289         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 290         .wMaxPacketSize =       cpu_to_le16(1024),
 291 };
 292
 293 static struct usb_ss_ep_comp_descriptor ss_sink_comp_desc = {
 294         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 295         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 296
 297         .bMaxBurst =            0,
 298         .bmAttributes =         0,
 299         .wBytesPerInterval =    0,
 300 };
 301
 302 static struct usb_endpoint_descriptor ss_iso_source_desc = {
 303         .bLength =              USB_DT_ENDPOINT_SIZE,
 304         .bDescriptorType =      USB_DT_ENDPOINT,
 305
 306         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 307         .wMaxPacketSize =       cpu_to_le16(1024),
 308         .bInterval =            4,
 309 };
 310
 311 static struct usb_ss_ep_comp_descriptor ss_iso_source_comp_desc = {
 312         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 313         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 314
 315         .bMaxBurst =            0,
 316         .bmAttributes =         0,
 317         .wBytesPerInterval =    cpu_to_le16(1024),
 318 };
 319
 320 static struct usb_endpoint_descriptor ss_iso_sink_desc = {
 321         .bLength =              USB_DT_ENDPOINT_SIZE,
 322         .bDescriptorType =      USB_DT_ENDPOINT,
 323
 324         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 325         .wMaxPacketSize =       cpu_to_le16(1024),
 326         .bInterval =            4,
 327 };
 328
 329 static struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc = {
 330         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 331         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 332
 333         .bMaxBurst =            0,
 334         .bmAttributes =         0,
 335         .wBytesPerInterval =    cpu_to_le16(1024),
 336 };
 337
 338 static struct usb_endpoint_descriptor ss_int_source_desc = {
 339         .bLength =              USB_DT_ENDPOINT_SIZE,
 340         .bDescriptorType =      USB_DT_ENDPOINT,
 341
 342         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 343         .wMaxPacketSize =       cpu_to_le16(1024),
 344         .bInterval =            USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
 345 };
 346
 347 struct usb_ss_ep_comp_descriptor ss_int_source_comp_desc = {
 348         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 349         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 350
 351         .bMaxBurst =            0,
 352         .bmAttributes =         0,
 353         .wBytesPerInterval =    cpu_to_le16(1024),
 354 };
 355
 356 static struct usb_endpoint_descriptor ss_int_sink_desc = {
 357         .bLength =              USB_DT_ENDPOINT_SIZE,
 358         .bDescriptorType =      USB_DT_ENDPOINT,
 359
 360         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 361         .wMaxPacketSize =       cpu_to_le16(1024),
 362         .bInterval =            USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
 363 };
 364
 365 struct usb_ss_ep_comp_descriptor ss_int_sink_comp_desc = {
 366         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 367         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 368
 369         .bMaxBurst =            0,
 370         .bmAttributes =         0,
 371         .wBytesPerInterval =    cpu_to_le16(1024),
 372 };
 373
 374 static struct usb_descriptor_header *ss_source_sink_descs[] = {
 375         (struct usb_descriptor_header *) &source_sink_intf_alt0,
 376         (struct usb_descriptor_header *) &ss_source_desc,
 377         (struct usb_descriptor_header *) &ss_source_comp_desc,
 378         (struct usb_descriptor_header *) &ss_sink_desc,
 379         (struct usb_descriptor_header *) &ss_sink_comp_desc,
 380         (struct usb_descriptor_header *) &source_sink_intf_alt1,
 381 #define SS_ALT_IFC_1_OFFSET     5
 382         (struct usb_descriptor_header *) &ss_source_desc,
 383         (struct usb_descriptor_header *) &ss_source_comp_desc,
 384         (struct usb_descriptor_header *) &ss_sink_desc,
 385         (struct usb_descriptor_header *) &ss_sink_comp_desc,
 386         (struct usb_descriptor_header *) &ss_iso_source_desc,
 387         (struct usb_descriptor_header *) &ss_iso_source_comp_desc,
 388         (struct usb_descriptor_header *) &ss_iso_sink_desc,
 389         (struct usb_descriptor_header *) &ss_iso_sink_comp_desc,
 390         (struct usb_descriptor_header *) &source_sink_intf_alt2,
 391 #define SS_ALT_IFC_2_OFFSET     14
 392         (struct usb_descriptor_header *) &ss_int_source_desc,
 393         (struct usb_descriptor_header *) &ss_int_source_comp_desc,
 394         (struct usb_descriptor_header *) &ss_int_sink_desc,
 395         (struct usb_descriptor_header *) &ss_int_sink_comp_desc,
 396         NULL,
 397 };
 398
 399 /* function-specific strings: */
 400
 401 static struct usb_string strings_sourcesink[] = {
 402         [0].s = "source and sink data",
 403         {  }                    /* end of list */
 404 };
 405
 406 static struct usb_gadget_strings stringtab_sourcesink = {
 407         .language       = 0x0409,       /* en-us */
 408         .strings        = strings_sourcesink,
 409 };
 410
 411 static struct usb_gadget_strings *sourcesink_strings[] = {
 412         &stringtab_sourcesink,
 413         NULL,
 414 };
 415
 416 /*-------------------------------------------------------------------------*/
 417 static const char *get_ep_string(enum eptype ep_type)
 418 {
 419         switch (ep_type) {
 420         case EP_ISOC:
 421                 return "ISOC-";
 422         case EP_INTERRUPT:
 423                 return "INTERRUPT-";
 424         case EP_CONTROL:
 425                 return "CTRL-";
 426         case EP_BULK:
 427                 return "BULK-";
 428         default:
 429                 return "UNKNOWN-";
 430         }
 431 }
 432
 433 static inline struct usb_request *ss_alloc_ep_req(struct usb_ep *ep, int len)
 434 {
 435         return alloc_ep_req(ep, len, buflen);
 436 }
 437
 438 void free_ep_req(struct usb_ep *ep, struct usb_request *req)
 439 {
 440         kfree(req->buf);
 441         usb_ep_free_request(ep, req);
 442 }
 443
 444 static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)
 445 {
 446         int                     value;
 447
 448         if (ep->driver_data) {
 449                 value = usb_ep_disable(ep);
 450                 if (value < 0)
 451                         DBG(cdev, "disable %s --> %d\n",
 452                                         ep->name, value);
 453                 ep->driver_data = NULL;
 454         }
 455 }
 456
 457 void disable_endpoints(struct usb_composite_dev *cdev,
 458                 struct usb_ep *in, struct usb_ep *out,
 459                 struct usb_ep *iso_in, struct usb_ep *iso_out,
 460                 struct usb_ep *int_in, struct usb_ep *int_out)
 461 {
 462         disable_ep(cdev, in);
 463         disable_ep(cdev, out);
 464         if (iso_in)
 465                 disable_ep(cdev, iso_in);
 466         if (iso_out)
 467                 disable_ep(cdev, iso_out);
 468         if (int_in)
 469                 disable_ep(cdev, int_in);
 470         if (int_out)
 471                 disable_ep(cdev, int_out);
 472 }
 473
 474 static int
 475 sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
 476 {
 477         struct usb_composite_dev *cdev = c->cdev;
 478         struct f_sourcesink     *ss = func_to_ss(f);
 479         int     id;
 480         int ret;
 481
 482         /* allocate interface ID(s) */
 483         id = usb_interface_id(c, f);
 484         if (id < 0)
 485                 return id;
 486         source_sink_intf_alt0.bInterfaceNumber = id;
 487         source_sink_intf_alt1.bInterfaceNumber = id;
 488         source_sink_intf_alt2.bInterfaceNumber = id;
 489
 490         /* allocate bulk endpoints */
 491         ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
 492         if (!ss->in_ep) {
 493 autoconf_fail:
 494                 ERROR(cdev, "%s: can't autoconfigure on %s\n",
 495                         f->name, cdev->gadget->name);
 496                 return -ENODEV;
 497         }
 498         ss->in_ep->driver_data = cdev;  /* claim */
 499
 500         ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
 501         if (!ss->out_ep)
 502                 goto autoconf_fail;
 503         ss->out_ep->driver_data = cdev; /* claim */
 504
 505         /* sanity check the isoc module parameters */
 506         if (isoc_interval < 1)
 507                 isoc_interval = 1;
 508         if (isoc_interval > 16)
 509                 isoc_interval = 16;
 510         if (isoc_mult > 2)
 511                 isoc_mult = 2;
 512         if (isoc_maxburst > 15)
 513                 isoc_maxburst = 15;
 514
 515         /* fill in the FS isoc descriptors from the module parameters */
 516         fs_iso_source_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
 517                                                 1023 : isoc_maxpacket;
 518         fs_iso_source_desc.bInterval = isoc_interval;
 519         fs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
 520                                                 1023 : isoc_maxpacket;
 521         fs_iso_sink_desc.bInterval = isoc_interval;
 522
 523         /* allocate iso endpoints */
 524         ss->iso_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_source_desc);
 525         if (!ss->iso_in_ep)
 526                 goto no_iso;
 527         ss->iso_in_ep->driver_data = cdev;      /* claim */
 528
 529         ss->iso_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_sink_desc);
 530         if (ss->iso_out_ep) {
 531                 ss->iso_out_ep->driver_data = cdev;     /* claim */
 532         } else {
 533                 ss->iso_in_ep->driver_data = NULL;
 534                 ss->iso_in_ep = NULL;
 535 no_iso:
 536                 /*
 537                  * We still want to work even if the UDC doesn't have isoc
 538                  * endpoints, so null out the alt interface that contains
 539                  * them and continue.
 540                  */
 541                 fs_source_sink_descs[FS_ALT_IFC_1_OFFSET] = NULL;
 542                 hs_source_sink_descs[HS_ALT_IFC_1_OFFSET] = NULL;
 543                 ss_source_sink_descs[SS_ALT_IFC_1_OFFSET] = NULL;
 544         }
 545
 546         if (isoc_maxpacket > 1024)
 547                 isoc_maxpacket = 1024;
 548
 549         /* sanity check the interrupt module parameters */
 550         if (int_interval < 1)
 551                 int_interval = 1;
 552         if (int_interval > 4096)
 553                 int_interval = 4096;
 554         if (int_mult > 2)
 555                 int_mult = 2;
 556         if (int_maxburst > 15)
 557                 int_maxburst = 15;
 558
 559         /* fill in the FS interrupt descriptors from the module parameters */
 560         fs_int_source_desc.wMaxPacketSize = int_maxpacket > 64 ?
 561                                                 64 : int_maxpacket;
 562         fs_int_source_desc.bInterval = int_interval > 255 ?
 563                                                 255 : int_interval;
 564         fs_int_sink_desc.wMaxPacketSize = int_maxpacket > 64 ?
 565                                                 64 : int_maxpacket;
 566         fs_int_sink_desc.bInterval = int_interval > 255 ?
 567                                                 255 : int_interval;
 568
 569         /* allocate int endpoints */
 570         ss->int_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_source_desc);
 571         if (!ss->int_in_ep)
 572                 goto no_int;
 573         ss->int_in_ep->driver_data = cdev;      /* claim */
 574
 575         ss->int_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_sink_desc);
 576         if (ss->int_out_ep) {
 577                 ss->int_out_ep->driver_data = cdev;     /* claim */
 578         } else {
 579                 ss->int_in_ep->driver_data = NULL;
 580                 ss->int_in_ep = NULL;
 581 no_int:
 582                 fs_source_sink_descs[FS_ALT_IFC_2_OFFSET] = NULL;
 583                 hs_source_sink_descs[HS_ALT_IFC_2_OFFSET] = NULL;
 584                 ss_source_sink_descs[SS_ALT_IFC_2_OFFSET] = NULL;
 585         }
 586
 587         if (int_maxpacket > 1024)
 588                 int_maxpacket = 1024;
 589
 590         /* support high speed hardware */
 591         hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
 592         hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
 593
 594         /*
 595          * Fill in the HS isoc and interrupt descriptors from the module
 596          * parameters. We assume that the user knows what they are doing and
 597          * won't give parameters that their UDC doesn't support.
 598          */
 599         hs_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
 600         hs_iso_source_desc.wMaxPacketSize |= isoc_mult << 11;
 601         hs_iso_source_desc.bInterval = isoc_interval;
 602         hs_iso_source_desc.bEndpointAddress =
 603                 fs_iso_source_desc.bEndpointAddress;
 604
 605         hs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
 606         hs_iso_sink_desc.wMaxPacketSize |= isoc_mult << 11;
 607         hs_iso_sink_desc.bInterval = isoc_interval;
 608         hs_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 609
 610         hs_int_source_desc.wMaxPacketSize = int_maxpacket;
 611         hs_int_source_desc.wMaxPacketSize |= int_mult << 11;
 612         hs_int_source_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
 613         hs_int_source_desc.bEndpointAddress =
 614                 fs_int_source_desc.bEndpointAddress;
 615
 616         hs_int_sink_desc.wMaxPacketSize = int_maxpacket;
 617         hs_int_sink_desc.wMaxPacketSize |= int_mult << 11;
 618         hs_int_sink_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
 619         hs_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
 620
 621         /* support super speed hardware */
 622         ss_source_desc.bEndpointAddress =
 623                 fs_source_desc.bEndpointAddress;
 624         ss_sink_desc.bEndpointAddress =
 625                 fs_sink_desc.bEndpointAddress;
 626
 627         /*
 628          * Fill in the SS isoc and interrupt descriptors from the module
 629          * parameters. We assume that the user knows what they are doing and
 630          * won't give parameters that their UDC doesn't support.
 631          */
 632         ss_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
 633         ss_iso_source_desc.bInterval = isoc_interval;
 634         ss_iso_source_comp_desc.bmAttributes = isoc_mult;
 635         ss_iso_source_comp_desc.bMaxBurst = isoc_maxburst;
 636         ss_iso_source_comp_desc.wBytesPerInterval =
 637                 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
 638         ss_iso_source_desc.bEndpointAddress =
 639                 fs_iso_source_desc.bEndpointAddress;
 640
 641         ss_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
 642         ss_iso_sink_desc.bInterval = isoc_interval;
 643         ss_iso_sink_comp_desc.bmAttributes = isoc_mult;
 644         ss_iso_sink_comp_desc.bMaxBurst = isoc_maxburst;
 645         ss_iso_sink_comp_desc.wBytesPerInterval =
 646                 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
 647         ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 648
 649         ss_int_source_desc.wMaxPacketSize = int_maxpacket;
 650         ss_int_source_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
 651         ss_int_source_comp_desc.bmAttributes = int_mult;
 652         ss_int_source_comp_desc.bMaxBurst = int_maxburst;
 653         ss_int_source_comp_desc.wBytesPerInterval =
 654                 int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
 655         ss_int_source_desc.bEndpointAddress =
 656                 fs_int_source_desc.bEndpointAddress;
 657
 658         ss_int_sink_desc.wMaxPacketSize = int_maxpacket;
 659         ss_int_sink_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
 660         ss_int_sink_comp_desc.bmAttributes = int_mult;
 661         ss_int_sink_comp_desc.bMaxBurst = int_maxburst;
 662         ss_int_sink_comp_desc.wBytesPerInterval =
 663                 int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
 664         ss_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
 665
 666         ret = usb_assign_descriptors(f, fs_source_sink_descs,
 667                         hs_source_sink_descs, ss_source_sink_descs);
 668         if (ret)
 669                 return ret;
 670
 671         DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s, "
 672                         "INT-IN/%s, INT-OUT/%s\n",
 673             (gadget_is_superspeed(c->cdev->gadget) ? "super" :
 674              (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
 675                         f->name, ss->in_ep->name, ss->out_ep->name,
 676                         ss->iso_in_ep ? ss->iso_in_ep->name : "<none>",
 677                         ss->iso_out_ep ? ss->iso_out_ep->name : "<none>",
 678                         ss->int_in_ep ? ss->int_in_ep->name : "<none>",
 679                         ss->int_out_ep ? ss->int_out_ep->name : "<none>");
 680         return 0;
 681 }
 682
 683 static void
 684 sourcesink_free_func(struct usb_function *f)
 685 {
 686         struct f_ss_opts *opts;
 687
 688         opts = container_of(f->fi, struct f_ss_opts, func_inst);
 689
 690         mutex_lock(&opts->lock);
 691         opts->refcnt--;
 692         mutex_unlock(&opts->lock);
 693
 694         usb_free_all_descriptors(f);
 695         kfree(func_to_ss(f));
 696 }
 697
 698 /* optionally require specific source/sink data patterns  */
 699 static int check_read_data(struct f_sourcesink *ss, struct usb_request *req)
 700 {
 701         unsigned                i;
 702         u8                      *buf = req->buf;
 703         struct usb_composite_dev *cdev = ss->function.config->cdev;
 704
 705         if (pattern == 2)
 706                 return 0;
 707
 708         for (i = 0; i < req->actual; i++, buf++) {
 709                 switch (pattern) {
 710
 711                 /* all-zeroes has no synchronization issues */
 712                 case 0:
 713                         if (*buf == 0)
 714                                 continue;
 715                         break;
 716
 717                 /* "mod63" stays in sync with short-terminated transfers,
 718                  * OR otherwise when host and gadget agree on how large
 719                  * each usb transfer request should be.  Resync is done
 720                  * with set_interface or set_config.  (We *WANT* it to
 721                  * get quickly out of sync if controllers or their drivers
 722                  * stutter for any reason, including buffer duplication...)
 723                  */
 724                 case 1:
 725                         if (*buf == (u8)(i % 63))
 726                                 continue;
 727                         break;
 728                 }
 729                 ERROR(cdev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
 730                 usb_ep_set_halt(ss->out_ep);
 731                 return -EINVAL;
 732         }
 733         return 0;
 734 }
 735
 736 static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
 737 {
 738         unsigned        i;
 739         u8              *buf = req->buf;
 740
 741         switch (pattern) {
 742         case 0:
 743                 memset(req->buf, 0, req->length);
 744                 break;
 745         case 1:
 746                 for  (i = 0; i < req->length; i++)
 747                         *buf++ = (u8) (i % 63);
 748                 break;
 749         case 2:
 750                 break;
 751         }
 752 }
 753
 754 static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
 755 {
 756         struct usb_composite_dev        *cdev;
 757         struct f_sourcesink             *ss = ep->driver_data;
 758         int                             status = req->status;
 759
 760         /* driver_data will be null if ep has been disabled */
 761         if (!ss)
 762                 return;
 763
 764         cdev = ss->function.config->cdev;
 765
 766         switch (status) {
 767
 768         case 0:                         /* normal completion? */
 769                 if (ep == ss->out_ep) {
 770                         check_read_data(ss, req);
 771                         if (pattern != 2)
 772                                 memset(req->buf, 0x55, req->length);
 773                 }
 774                 break;
 775
 776         /* this endpoint is normally active while we're configured */
 777         case -ECONNABORTED:             /* hardware forced ep reset */
 778         case -ECONNRESET:               /* request dequeued */
 779         case -ESHUTDOWN:                /* disconnect from host */
 780                 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
 781                                 req->actual, req->length);
 782                 if (ep == ss->out_ep)
 783                         check_read_data(ss, req);
 784                 free_ep_req(ep, req);
 785                 return;
 786
 787         case -EOVERFLOW:                /* buffer overrun on read means that
 788                                          * we didn't provide a big enough
 789                                          * buffer.
 790                                          */
 791         default:
 792 #if 1
 793                 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
 794                                 status, req->actual, req->length);
 795 #endif
 796         case -EREMOTEIO:                /* short read */
 797                 break;
 798         }
 799
 800         status = usb_ep_queue(ep, req, GFP_ATOMIC);
 801         if (status) {
 802                 ERROR(cdev, "kill %s:  resubmit %d bytes --> %d\n",
 803                                 ep->name, req->length, status);
 804                 usb_ep_set_halt(ep);
 805                 /* FIXME recover later ... somehow */
 806         }
 807 }
 808
 809 static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
 810                 enum eptype ep_type, int speed)
 811 {
 812         struct usb_ep           *ep;
 813         struct usb_request      *req;
 814         int                     i, size, status;
 815
 816         for (i = 0; i < 8; i++) {
 817                 switch (ep_type) {
 818                 case EP_ISOC:
 819                         switch (speed) {
 820                         case USB_SPEED_SUPER:
 821                                 size = isoc_maxpacket * (isoc_mult + 1) *
 822                                                 (isoc_maxburst + 1);
 823                                 break;
 824                         case USB_SPEED_HIGH:
 825                                 size = isoc_maxpacket * (isoc_mult + 1);
 826                                 break;
 827                         default:
 828                                 size = isoc_maxpacket > 1023 ?
 829                                                 1023 : isoc_maxpacket;
 830                                 break;
 831                         }
 832                         ep = is_in ? ss->iso_in_ep : ss->iso_out_ep;
 833                         req = ss_alloc_ep_req(ep, size);
 834                         break;
 835                 case EP_INTERRUPT:
 836                         switch (speed) {
 837                         case USB_SPEED_SUPER:
 838                                 size = int_maxpacket * (int_mult + 1) *
 839                                                 (int_maxburst + 1);
 840                                 break;
 841                         case USB_SPEED_HIGH:
 842                                 size = int_maxpacket * (int_mult + 1);
 843                                 break;
 844                         default:
 845                                 size = int_maxpacket > 1023 ?
 846                                                 1023 : int_maxpacket;
 847                                 break;
 848                         }
 849                         ep = is_in ? ss->int_in_ep : ss->int_out_ep;
 850                         req = ss_alloc_ep_req(ep, size);
 851                         break;
 852                 default:
 853                         ep = is_in ? ss->in_ep : ss->out_ep;
 854                         req = ss_alloc_ep_req(ep, 0);
 855                         break;
 856                 }
 857
 858                 if (!req)
 859                         return -ENOMEM;
 860
 861                 req->complete = source_sink_complete;
 862                 if (is_in)
 863                         reinit_write_data(ep, req);
 864                 else if (pattern != 2)
 865                         memset(req->buf, 0x55, req->length);
 866
 867                 status = usb_ep_queue(ep, req, GFP_ATOMIC);
 868                 if (status) {
 869                         struct usb_composite_dev        *cdev;
 870
 871                         cdev = ss->function.config->cdev;
 872                         ERROR(cdev, "start %s%s %s --> %d\n",
 873                                 get_ep_string(ep_type), is_in ? "IN" : "OUT",
 874                                 ep->name, status);
 875                         free_ep_req(ep, req);
 876                 }
 877
 878                 if (!(ep_type == EP_ISOC))
 879                         break;
 880         }
 881
 882         return status;
 883 }
 884
 885 static void disable_source_sink(struct f_sourcesink *ss)
 886 {
 887         struct usb_composite_dev        *cdev;
 888
 889         cdev = ss->function.config->cdev;
 890         disable_endpoints(cdev, ss->in_ep, ss->out_ep, ss->iso_in_ep,
 891                         ss->iso_out_ep, ss->int_in_ep, ss->int_out_ep);
 892         VDBG(cdev, "%s disabled\n", ss->function.name);
 893 }
 894
 895 static int
 896 enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss,
 897                 int alt)
 898 {
 899         int                                     result = 0;
 900         int                                     speed = cdev->gadget->speed;
 901         struct usb_ep                           *ep;
 902
 903         if (alt == 2) {
 904                 /* Configure for periodic interrupt endpoint */
 905                 ep = ss->int_in_ep;
 906                 if (ep) {
 907                         result = config_ep_by_speed(cdev->gadget,
 908                                         &(ss->function), ep);
 909                         if (result)
 910                                 return result;
 911
 912                         result = usb_ep_enable(ep);
 913                         if (result < 0)
 914                                 return result;
 915
 916                         ep->driver_data = ss;
 917                         result = source_sink_start_ep(ss, true, EP_INTERRUPT,
 918                                         speed);
 919                         if (result < 0) {
 920 fail1:
 921                                 ep = ss->int_in_ep;
 922                                 if (ep) {
 923                                         usb_ep_disable(ep);
 924                                         ep->driver_data = NULL;
 925                                 }
 926                                 return result;
 927                         }
 928                 }
 929
 930                 /*
 931                  * one interrupt endpoint reads (sinks) anything OUT (from the
 932                  * host)
 933                  */
 934                 ep = ss->int_out_ep;
 935                 if (ep) {
 936                         result = config_ep_by_speed(cdev->gadget,
 937                                         &(ss->function), ep);
 938                         if (result)
 939                                 goto fail1;
 940
 941                         result = usb_ep_enable(ep);
 942                         if (result < 0)
 943                                 goto fail1;
 944
 945                         ep->driver_data = ss;
 946                         result = source_sink_start_ep(ss, false, EP_INTERRUPT,
 947                                         speed);
 948                         if (result < 0) {
 949                                 ep = ss->int_out_ep;
 950                                 usb_ep_disable(ep);
 951                                 ep->driver_data = NULL;
 952                                 goto fail1;
 953                         }
 954                 }
 955
 956                 goto out;
 957         }
 958
 959         /* one bulk endpoint writes (sources) zeroes IN (to the host) */
 960         ep = ss->in_ep;
 961         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 962         if (result)
 963                 return result;
 964         result = usb_ep_enable(ep);
 965         if (result < 0)
 966                 return result;
 967         ep->driver_data = ss;
 968
 969         result = source_sink_start_ep(ss, true, EP_BULK, speed);
 970         if (result < 0) {
 971 fail:
 972                 ep = ss->in_ep;
 973                 usb_ep_disable(ep);
 974                 ep->driver_data = NULL;
 975                 return result;
 976         }
 977
 978         /* one bulk endpoint reads (sinks) anything OUT (from the host) */
 979         ep = ss->out_ep;
 980         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 981         if (result)
 982                 goto fail;
 983         result = usb_ep_enable(ep);
 984         if (result < 0)
 985                 goto fail;
 986         ep->driver_data = ss;
 987
 988         result = source_sink_start_ep(ss, false, EP_BULK, speed);
 989         if (result < 0) {
 990 fail2:
 991                 ep = ss->out_ep;
 992                 usb_ep_disable(ep);
 993                 ep->driver_data = NULL;
 994                 goto fail;
 995         }
 996
 997         if (alt == 0)
 998                 goto out;
 999
1000         /* one iso endpoint writes (sources) zeroes IN (to the host) */
1001         ep = ss->iso_in_ep;
1002         if (ep) {
1003                 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
1004                 if (result)
1005                         goto fail2;
1006                 result = usb_ep_enable(ep);
1007                 if (result < 0)
1008                         goto fail2;
1009                 ep->driver_data = ss;
1010
1011                 result = source_sink_start_ep(ss, true, EP_ISOC, speed);
1012                 if (result < 0) {
1013 fail3:
1014                         ep = ss->iso_in_ep;
1015                         if (ep) {
1016                                 usb_ep_disable(ep);
1017                                 ep->driver_data = NULL;
1018                         }
1019                         goto fail2;
1020                 }
1021         }
1022
1023         /* one iso endpoint reads (sinks) anything OUT (from the host) */
1024         ep = ss->iso_out_ep;
1025         if (ep) {
1026                 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
1027                 if (result)
1028                         goto fail3;
1029                 result = usb_ep_enable(ep);
1030                 if (result < 0)
1031                         goto fail3;
1032                 ep->driver_data = ss;
1033
1034                 result = source_sink_start_ep(ss, false, EP_ISOC, speed);
1035                 if (result < 0) {
1036                         usb_ep_disable(ep);
1037                         ep->driver_data = NULL;
1038                         goto fail3;
1039                 }
1040         }
1041
1042 out:
1043         ss->cur_alt = alt;
1044
1045         DBG(cdev, "%s enabled, alt intf %d\n", ss->function.name, alt);
1046         return result;
1047 }
1048
1049 static int sourcesink_set_alt(struct usb_function *f,
1050                 unsigned intf, unsigned alt)
1051 {
1052         struct f_sourcesink             *ss = func_to_ss(f);
1053         struct usb_composite_dev        *cdev = f->config->cdev;
1054
1055         if (ss->in_ep->driver_data)
1056                 disable_source_sink(ss);
1057         else if (alt == 2 && ss->int_in_ep->driver_data)
1058                 disable_source_sink(ss);
1059         return enable_source_sink(cdev, ss, alt);
1060 }
1061
1062 static int sourcesink_get_alt(struct usb_function *f, unsigned intf)
1063 {
1064         struct f_sourcesink             *ss = func_to_ss(f);
1065
1066         return ss->cur_alt;
1067 }
1068
1069 static void sourcesink_disable(struct usb_function *f)
1070 {
1071         struct f_sourcesink     *ss = func_to_ss(f);
1072
1073         disable_source_sink(ss);
1074 }
1075
1076 /*-------------------------------------------------------------------------*/
1077
1078 static int sourcesink_setup(struct usb_function *f,
1079                 const struct usb_ctrlrequest *ctrl)
1080 {
1081         struct usb_configuration        *c = f->config;
1082         struct usb_request      *req = c->cdev->req;
1083         int                     value = -EOPNOTSUPP;
1084         u16                     w_index = le16_to_cpu(ctrl->wIndex);
1085         u16                     w_value = le16_to_cpu(ctrl->wValue);
1086         u16                     w_length = le16_to_cpu(ctrl->wLength);
1087
1088         req->length = USB_COMP_EP0_BUFSIZ;
1089
1090         /* composite driver infrastructure handles everything except
1091          * the two control test requests.
1092          */
1093         switch (ctrl->bRequest) {
1094
1095         /*
1096          * These are the same vendor-specific requests supported by
1097          * Intel's USB 2.0 compliance test devices.  We exceed that
1098          * device spec by allowing multiple-packet requests.
1099          *
1100          * NOTE:  the Control-OUT data stays in req->buf ... better
1101          * would be copying it into a scratch buffer, so that other
1102          * requests may safely intervene.
1103          */
1104         case 0x5b:      /* control WRITE test -- fill the buffer */
1105                 if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
1106                         goto unknown;
1107                 if (w_value || w_index)
1108                         break;
1109                 /* just read that many bytes into the buffer */
1110                 if (w_length > req->length)
1111                         break;
1112                 value = w_length;
1113                 break;
1114         case 0x5c:      /* control READ test -- return the buffer */
1115                 if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
1116                         goto unknown;
1117                 if (w_value || w_index)
1118                         break;
1119                 /* expect those bytes are still in the buffer; send back */
1120                 if (w_length > req->length)
1121                         break;
1122                 value = w_length;
1123                 break;
1124
1125         default:
1126 unknown:
1127                 VDBG(c->cdev,
1128                         "unknown control req%02x.%02x v%04x i%04x l%d\n",
1129                         ctrl->bRequestType, ctrl->bRequest,
1130                         w_value, w_index, w_length);
1131         }
1132
1133         /* respond with data transfer or status phase? */
1134         if (value >= 0) {
1135                 VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n",
1136                         ctrl->bRequestType, ctrl->bRequest,
1137                         w_value, w_index, w_length);
1138                 req->zero = 0;
1139                 req->length = value;
1140                 value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC);
1141                 if (value < 0)
1142                         ERROR(c->cdev, "source/sink response, err %d\n",
1143                                         value);
1144         }
1145
1146         /* device either stalls (value < 0) or reports success */
1147         return value;
1148 }
1149
1150 static struct usb_function *source_sink_alloc_func(
1151                 struct usb_function_instance *fi)
1152 {
1153         struct f_sourcesink     *ss;
1154         struct f_ss_opts        *ss_opts;
1155
1156         ss = kzalloc(sizeof(*ss), GFP_KERNEL);
1157         if (!ss)
1158                 return NULL;
1159
1160         ss_opts =  container_of(fi, struct f_ss_opts, func_inst);
1161
1162         mutex_lock(&ss_opts->lock);
1163         ss_opts->refcnt++;
1164         mutex_unlock(&ss_opts->lock);
1165
1166         pattern = ss_opts->pattern;
1167         isoc_interval = ss_opts->isoc_interval;
1168         isoc_maxpacket = ss_opts->isoc_maxpacket;
1169         isoc_mult = ss_opts->isoc_mult;
1170         isoc_maxburst = ss_opts->isoc_maxburst;
1171         int_interval = ss_opts->int_interval;
1172         int_maxpacket = ss_opts->int_maxpacket;
1173         int_mult = ss_opts->int_mult;
1174         int_maxburst = ss_opts->int_maxburst;
1175         buflen = ss_opts->bulk_buflen;
1176
1177         ss->function.name = "source/sink";
1178         ss->function.bind = sourcesink_bind;
1179         ss->function.set_alt = sourcesink_set_alt;
1180         ss->function.get_alt = sourcesink_get_alt;
1181         ss->function.disable = sourcesink_disable;
1182         ss->function.setup = sourcesink_setup;
1183         ss->function.strings = sourcesink_strings;
1184
1185         ss->function.free_func = sourcesink_free_func;
1186
1187         return &ss->function;
1188 }
1189
1190 static inline struct f_ss_opts *to_f_ss_opts(struct config_item *item)
1191 {
1192         return container_of(to_config_group(item), struct f_ss_opts,
1193                             func_inst.group);
1194 }
1195
1196 CONFIGFS_ATTR_STRUCT(f_ss_opts);
1197 CONFIGFS_ATTR_OPS(f_ss_opts);
1198
1199 static void ss_attr_release(struct config_item *item)
1200 {
1201         struct f_ss_opts *ss_opts = to_f_ss_opts(item);
1202
1203         usb_put_function_instance(&ss_opts->func_inst);
1204 }
1205
1206 static struct configfs_item_operations ss_item_ops = {
1207         .release                = ss_attr_release,
1208         .show_attribute         = f_ss_opts_attr_show,
1209         .store_attribute        = f_ss_opts_attr_store,
1210 };
1211
1212 static ssize_t f_ss_opts_pattern_show(struct f_ss_opts *opts, char *page)
1213 {
1214         int result;
1215
1216         mutex_lock(&opts->lock);
1217         result = sprintf(page, "%u", opts->pattern);
1218         mutex_unlock(&opts->lock);
1219
1220         return result;
1221 }
1222
1223 static ssize_t f_ss_opts_pattern_store(struct f_ss_opts *opts,
1224                                        const char *page, size_t len)
1225 {
1226         int ret;
1227         u8 num;
1228
1229         mutex_lock(&opts->lock);
1230         if (opts->refcnt) {
1231                 ret = -EBUSY;
1232                 goto end;
1233         }
1234
1235         ret = kstrtou8(page, 0, &num);
1236         if (ret)
1237                 goto end;
1238
1239         if (num != 0 && num != 1 && num != 2) {
1240                 ret = -EINVAL;
1241                 goto end;
1242         }
1243
1244         opts->pattern = num;
1245         ret = len;
1246 end:
1247         mutex_unlock(&opts->lock);
1248         return ret;
1249 }
1250
1251 static struct f_ss_opts_attribute f_ss_opts_pattern =
1252         __CONFIGFS_ATTR(pattern, S_IRUGO | S_IWUSR,
1253                         f_ss_opts_pattern_show,
1254                         f_ss_opts_pattern_store);
1255
1256 static ssize_t f_ss_opts_isoc_interval_show(struct f_ss_opts *opts, char *page)
1257 {
1258         int result;
1259
1260         mutex_lock(&opts->lock);
1261         result = sprintf(page, "%u", opts->isoc_interval);
1262         mutex_unlock(&opts->lock);
1263
1264         return result;
1265 }
1266
1267 static ssize_t f_ss_opts_isoc_interval_store(struct f_ss_opts *opts,
1268                                        const char *page, size_t len)
1269 {
1270         int ret;
1271         u8 num;
1272
1273         mutex_lock(&opts->lock);
1274         if (opts->refcnt) {
1275                 ret = -EBUSY;
1276                 goto end;
1277         }
1278
1279         ret = kstrtou8(page, 0, &num);
1280         if (ret)
1281                 goto end;
1282
1283         if (num > 16) {
1284                 ret = -EINVAL;
1285                 goto end;
1286         }
1287
1288         opts->isoc_interval = num;
1289         ret = len;
1290 end:
1291         mutex_unlock(&opts->lock);
1292         return ret;
1293 }
1294
1295 static struct f_ss_opts_attribute f_ss_opts_isoc_interval =
1296         __CONFIGFS_ATTR(isoc_interval, S_IRUGO | S_IWUSR,
1297                         f_ss_opts_isoc_interval_show,
1298                         f_ss_opts_isoc_interval_store);
1299
1300 static ssize_t f_ss_opts_isoc_maxpacket_show(struct f_ss_opts *opts, char *page)
1301 {
1302         int result;
1303
1304         mutex_lock(&opts->lock);
1305         result = sprintf(page, "%u", opts->isoc_maxpacket);
1306         mutex_unlock(&opts->lock);
1307
1308         return result;
1309 }
1310
1311 static ssize_t f_ss_opts_isoc_maxpacket_store(struct f_ss_opts *opts,
1312                                        const char *page, size_t len)
1313 {
1314         int ret;
1315         u16 num;
1316
1317         mutex_lock(&opts->lock);
1318         if (opts->refcnt) {
1319                 ret = -EBUSY;
1320                 goto end;
1321         }
1322
1323         ret = kstrtou16(page, 0, &num);
1324         if (ret)
1325                 goto end;
1326
1327         if (num > 1024) {
1328                 ret = -EINVAL;
1329                 goto end;
1330         }
1331
1332         opts->isoc_maxpacket = num;
1333         ret = len;
1334 end:
1335         mutex_unlock(&opts->lock);
1336         return ret;
1337 }
1338
1339 static struct f_ss_opts_attribute f_ss_opts_isoc_maxpacket =
1340         __CONFIGFS_ATTR(isoc_maxpacket, S_IRUGO | S_IWUSR,
1341                         f_ss_opts_isoc_maxpacket_show,
1342                         f_ss_opts_isoc_maxpacket_store);
1343
1344 static ssize_t f_ss_opts_isoc_mult_show(struct f_ss_opts *opts, char *page)
1345 {
1346         int result;
1347
1348         mutex_lock(&opts->lock);
1349         result = sprintf(page, "%u", opts->isoc_mult);
1350         mutex_unlock(&opts->lock);
1351
1352         return result;
1353 }
1354
1355 static ssize_t f_ss_opts_isoc_mult_store(struct f_ss_opts *opts,
1356                                        const char *page, size_t len)
1357 {
1358         int ret;
1359         u8 num;
1360
1361         mutex_lock(&opts->lock);
1362         if (opts->refcnt) {
1363                 ret = -EBUSY;
1364                 goto end;
1365         }
1366
1367         ret = kstrtou8(page, 0, &num);
1368         if (ret)
1369                 goto end;
1370
1371         if (num > 2) {
1372                 ret = -EINVAL;
1373                 goto end;
1374         }
1375
1376         opts->isoc_mult = num;
1377         ret = len;
1378 end:
1379         mutex_unlock(&opts->lock);
1380         return ret;
1381 }
1382
1383 static struct f_ss_opts_attribute f_ss_opts_isoc_mult =
1384         __CONFIGFS_ATTR(isoc_mult, S_IRUGO | S_IWUSR,
1385                         f_ss_opts_isoc_mult_show,
1386                         f_ss_opts_isoc_mult_store);
1387
1388 static ssize_t f_ss_opts_isoc_maxburst_show(struct f_ss_opts *opts, char *page)
1389 {
1390         int result;
1391
1392         mutex_lock(&opts->lock);
1393         result = sprintf(page, "%u", opts->isoc_maxburst);
1394         mutex_unlock(&opts->lock);
1395
1396         return result;
1397 }
1398
1399 static ssize_t f_ss_opts_isoc_maxburst_store(struct f_ss_opts *opts,
1400                                        const char *page, size_t len)
1401 {
1402         int ret;
1403         u8 num;
1404
1405         mutex_lock(&opts->lock);
1406         if (opts->refcnt) {
1407                 ret = -EBUSY;
1408                 goto end;
1409         }
1410
1411         ret = kstrtou8(page, 0, &num);
1412         if (ret)
1413                 goto end;
1414
1415         if (num > 15) {
1416                 ret = -EINVAL;
1417                 goto end;
1418         }
1419
1420         opts->isoc_maxburst = num;
1421         ret = len;
1422 end:
1423         mutex_unlock(&opts->lock);
1424         return ret;
1425 }
1426
1427 static struct f_ss_opts_attribute f_ss_opts_isoc_maxburst =
1428         __CONFIGFS_ATTR(isoc_maxburst, S_IRUGO | S_IWUSR,
1429                         f_ss_opts_isoc_maxburst_show,
1430                         f_ss_opts_isoc_maxburst_store);
1431
1432 static ssize_t f_ss_opts_bulk_buflen_show(struct f_ss_opts *opts, char *page)
1433 {
1434         int result;
1435
1436         mutex_lock(&opts->lock);
1437         result = sprintf(page, "%u", opts->bulk_buflen);
1438         mutex_unlock(&opts->lock);
1439
1440         return result;
1441 }
1442
1443 static ssize_t f_ss_opts_bulk_buflen_store(struct f_ss_opts *opts,
1444                                            const char *page, size_t len)
1445 {
1446         int ret;
1447         u32 num;
1448
1449         mutex_lock(&opts->lock);
1450         if (opts->refcnt) {
1451                 ret = -EBUSY;
1452                 goto end;
1453         }
1454
1455         ret = kstrtou32(page, 0, &num);
1456         if (ret)
1457                 goto end;
1458
1459         opts->bulk_buflen = num;
1460         ret = len;
1461 end:
1462         mutex_unlock(&opts->lock);
1463         return ret;
1464 }
1465
1466 static struct f_ss_opts_attribute f_ss_opts_bulk_buflen =
1467         __CONFIGFS_ATTR(buflen, S_IRUGO | S_IWUSR,
1468                         f_ss_opts_bulk_buflen_show,
1469                         f_ss_opts_bulk_buflen_store);
1470
1471 static ssize_t f_ss_opts_int_interval_show(struct f_ss_opts *opts, char *page)
1472 {
1473         int result;
1474
1475         mutex_lock(&opts->lock);
1476         result = sprintf(page, "%u", opts->int_interval);
1477         mutex_unlock(&opts->lock);
1478
1479         return result;
1480 }
1481
1482 static ssize_t f_ss_opts_int_interval_store(struct f_ss_opts *opts,
1483                                        const char *page, size_t len)
1484 {
1485         int ret;
1486         u32 num;
1487
1488         mutex_lock(&opts->lock);
1489         if (opts->refcnt) {
1490                 ret = -EBUSY;
1491                 goto end;
1492         }
1493
1494         ret = kstrtou32(page, 0, &num);
1495         if (ret)
1496                 goto end;
1497
1498         if (num > 4096) {
1499                 ret = -EINVAL;
1500                 goto end;
1501         }
1502
1503         opts->int_interval = num;
1504         ret = len;
1505 end:
1506         mutex_unlock(&opts->lock);
1507         return ret;
1508 }
1509
1510 static struct f_ss_opts_attribute f_ss_opts_int_interval =
1511         __CONFIGFS_ATTR(int_interval, S_IRUGO | S_IWUSR,
1512                         f_ss_opts_int_interval_show,
1513                         f_ss_opts_int_interval_store);
1514
1515 static ssize_t f_ss_opts_int_maxpacket_show(struct f_ss_opts *opts, char *page)
1516 {
1517         int result;
1518
1519         mutex_lock(&opts->lock);
1520         result = sprintf(page, "%u", opts->int_maxpacket);
1521         mutex_unlock(&opts->lock);
1522
1523         return result;
1524 }
1525
1526 static ssize_t f_ss_opts_int_maxpacket_store(struct f_ss_opts *opts,
1527                                        const char *page, size_t len)
1528 {
1529         int ret;
1530         u16 num;
1531
1532         mutex_lock(&opts->lock);
1533         if (opts->refcnt) {
1534                 ret = -EBUSY;
1535                 goto end;
1536         }
1537
1538         ret = kstrtou16(page, 0, &num);
1539         if (ret)
1540                 goto end;
1541
1542         if (num > 1024) {
1543                 ret = -EINVAL;
1544                 goto end;
1545         }
1546
1547         opts->int_maxpacket = num;
1548         ret = len;
1549 end:
1550         mutex_unlock(&opts->lock);
1551         return ret;
1552 }
1553
1554 static struct f_ss_opts_attribute f_ss_opts_int_maxpacket =
1555         __CONFIGFS_ATTR(int_maxpacket, S_IRUGO | S_IWUSR,
1556                         f_ss_opts_int_maxpacket_show,
1557                         f_ss_opts_int_maxpacket_store);
1558
1559 static ssize_t f_ss_opts_int_mult_show(struct f_ss_opts *opts, char *page)
1560 {
1561         int result;
1562
1563         mutex_lock(&opts->lock);
1564         result = sprintf(page, "%u", opts->int_mult);
1565         mutex_unlock(&opts->lock);
1566
1567         return result;
1568 }
1569
1570 static ssize_t f_ss_opts_int_mult_store(struct f_ss_opts *opts,
1571                                        const char *page, size_t len)
1572 {
1573         int ret;
1574         u8 num;
1575
1576         mutex_lock(&opts->lock);
1577         if (opts->refcnt) {
1578                 ret = -EBUSY;
1579                 goto end;
1580         }
1581
1582         ret = kstrtou8(page, 0, &num);
1583         if (ret)
1584                 goto end;
1585
1586         if (num > 2) {
1587                 ret = -EINVAL;
1588                 goto end;
1589         }
1590
1591         opts->int_mult = num;
1592         ret = len;
1593 end:
1594         mutex_unlock(&opts->lock);
1595         return ret;
1596 }
1597
1598 static struct f_ss_opts_attribute f_ss_opts_int_mult =
1599         __CONFIGFS_ATTR(int_mult, S_IRUGO | S_IWUSR,
1600                         f_ss_opts_int_mult_show,
1601                         f_ss_opts_int_mult_store);
1602
1603 static ssize_t f_ss_opts_int_maxburst_show(struct f_ss_opts *opts, char *page)
1604 {
1605         int result;
1606
1607         mutex_lock(&opts->lock);
1608         result = sprintf(page, "%u", opts->int_maxburst);
1609         mutex_unlock(&opts->lock);
1610
1611         return result;
1612 }
1613
1614 static ssize_t f_ss_opts_int_maxburst_store(struct f_ss_opts *opts,
1615                                        const char *page, size_t len)
1616 {
1617         int ret;
1618         u8 num;
1619
1620         mutex_lock(&opts->lock);
1621         if (opts->refcnt) {
1622                 ret = -EBUSY;
1623                 goto end;
1624         }
1625
1626         ret = kstrtou8(page, 0, &num);
1627         if (ret)
1628                 goto end;
1629
1630         if (num > 15) {
1631                 ret = -EINVAL;
1632                 goto end;
1633         }
1634
1635         opts->int_maxburst = num;
1636         ret = len;
1637 end:
1638         mutex_unlock(&opts->lock);
1639         return ret;
1640 }
1641
1642 static struct f_ss_opts_attribute f_ss_opts_int_maxburst =
1643         __CONFIGFS_ATTR(int_maxburst, S_IRUGO | S_IWUSR,
1644                         f_ss_opts_int_maxburst_show,
1645                         f_ss_opts_int_maxburst_store);
1646
1647 static struct configfs_attribute *ss_attrs[] = {
1648         &f_ss_opts_pattern.attr,
1649         &f_ss_opts_isoc_interval.attr,
1650         &f_ss_opts_isoc_maxpacket.attr,
1651         &f_ss_opts_isoc_mult.attr,
1652         &f_ss_opts_isoc_maxburst.attr,
1653         &f_ss_opts_bulk_buflen.attr,
1654         &f_ss_opts_int_interval.attr,
1655         &f_ss_opts_int_maxpacket.attr,
1656         &f_ss_opts_int_mult.attr,
1657         &f_ss_opts_int_maxburst.attr,
1658         NULL,
1659 };
1660
1661 static struct config_item_type ss_func_type = {
1662         .ct_item_ops    = &ss_item_ops,
1663         .ct_attrs       = ss_attrs,
1664         .ct_owner       = THIS_MODULE,
1665 };
1666
1667 static void source_sink_free_instance(struct usb_function_instance *fi)
1668 {
1669         struct f_ss_opts *ss_opts;
1670
1671         ss_opts = container_of(fi, struct f_ss_opts, func_inst);
1672         kfree(ss_opts);
1673 }
1674
1675 static struct usb_function_instance *source_sink_alloc_inst(void)
1676 {
1677         struct f_ss_opts *ss_opts;
1678
1679         ss_opts = kzalloc(sizeof(*ss_opts), GFP_KERNEL);
1680         if (!ss_opts)
1681                 return ERR_PTR(-ENOMEM);
1682         mutex_init(&ss_opts->lock);
1683         ss_opts->func_inst.free_func_inst = source_sink_free_instance;
1684         ss_opts->isoc_interval = GZERO_ISOC_INTERVAL;
1685         ss_opts->isoc_maxpacket = GZERO_ISOC_MAXPACKET;
1686         ss_opts->bulk_buflen = GZERO_BULK_BUFLEN;
1687         ss_opts->int_interval = GZERO_INT_INTERVAL;
1688         ss_opts->int_maxpacket = GZERO_INT_MAXPACKET;
1689
1690         config_group_init_type_name(&ss_opts->func_inst.group, "",
1691                                     &ss_func_type);
1692
1693         return &ss_opts->func_inst;
1694 }
1695 DECLARE_USB_FUNCTION(SourceSink, source_sink_alloc_inst,
1696                 source_sink_alloc_func);
1697
1698 static int __init sslb_modinit(void)
1699 {
1700         int ret;
1701
1702         ret = usb_function_register(&SourceSinkusb_func);
1703         if (ret)
1704                 return ret;
1705         ret = lb_modinit();
1706         if (ret)
1707                 usb_function_unregister(&SourceSinkusb_func);
1708         return ret;
1709 }
1710 static void __exit sslb_modexit(void)
1711 {
1712         usb_function_unregister(&SourceSinkusb_func);
1713         lb_modexit();
1714 }
1715 module_init(sslb_modinit);
1716 module_exit(sslb_modexit);
1717
1718 MODULE_LICENSE("GPL");