drivers/usb/gadget/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
  20 #include "g_zero.h"
  21 #include "gadget_chips.h"
  22
  23
  24 /*
  25  * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
  26  * controller drivers.
  27  *
  28  * This just sinks bulk packets OUT to the peripheral and sources them IN
  29  * to the host, optionally with specific data patterns for integrity tests.
  30  * As such it supports basic functionality and load tests.
  31  *
  32  * In terms of control messaging, this supports all the standard requests
  33  * plus two that support control-OUT tests.  If the optional "autoresume"
  34  * mode is enabled, it provides good functional coverage for the "USBCV"
  35  * test harness from USB-IF.
  36  *
  37  * Note that because this doesn't queue more than one request at a time,
  38  * some other function must be used to test queueing logic.  The network
  39  * link (g_ether) is the best overall option for that, since its TX and RX
  40  * queues are relatively independent, will receive a range of packet sizes,
  41  * and can often be made to run out completely.  Those issues are important
  42  * when stress testing peripheral controller drivers.
  43  *
  44  *
  45  * This is currently packaged as a configuration driver, which can't be
  46  * combined with other functions to make composite devices.  However, it
  47  * can be combined with other independent configurations.
  48  */
  49 struct f_sourcesink {
  50         struct usb_function     function;
  51
  52         struct usb_ep           *in_ep;
  53         struct usb_ep           *out_ep;
  54         struct usb_ep           *iso_in_ep;
  55         struct usb_ep           *iso_out_ep;
  56         int                     cur_alt;
  57 };
  58
  59 static inline struct f_sourcesink *func_to_ss(struct usb_function *f)
  60 {
  61         return container_of(f, struct f_sourcesink, function);
  62 }
  63
  64 static unsigned pattern;
  65 module_param(pattern, uint, S_IRUGO|S_IWUSR);
  66 MODULE_PARM_DESC(pattern, "0 = all zeroes, 1 = mod63, 2 = none");
  67
  68 static unsigned isoc_interval = 4;
  69 module_param(isoc_interval, uint, S_IRUGO|S_IWUSR);
  70 MODULE_PARM_DESC(isoc_interval, "1 - 16");
  71
  72 static unsigned isoc_maxpacket = 1024;
  73 module_param(isoc_maxpacket, uint, S_IRUGO|S_IWUSR);
  74 MODULE_PARM_DESC(isoc_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)");
  75
  76 static unsigned isoc_mult;
  77 module_param(isoc_mult, uint, S_IRUGO|S_IWUSR);
  78 MODULE_PARM_DESC(isoc_mult, "0 - 2 (hs/ss only)");
  79
  80 static unsigned isoc_maxburst;
  81 module_param(isoc_maxburst, uint, S_IRUGO|S_IWUSR);
  82 MODULE_PARM_DESC(isoc_maxburst, "0 - 15 (ss only)");
  83
  84 /*-------------------------------------------------------------------------*/
  85
  86 static struct usb_interface_descriptor source_sink_intf_alt0 = {
  87         .bLength =              USB_DT_INTERFACE_SIZE,
  88         .bDescriptorType =      USB_DT_INTERFACE,
  89
  90         .bAlternateSetting =    0,
  91         .bNumEndpoints =        2,
  92         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
  93         /* .iInterface          = DYNAMIC */
  94 };
  95
  96 static struct usb_interface_descriptor source_sink_intf_alt1 = {
  97         .bLength =              USB_DT_INTERFACE_SIZE,
  98         .bDescriptorType =      USB_DT_INTERFACE,
  99
 100         .bAlternateSetting =    1,
 101         .bNumEndpoints =        4,
 102         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
 103         /* .iInterface          = DYNAMIC */
 104 };
 105
 106 /* full speed support: */
 107
 108 static struct usb_endpoint_descriptor fs_source_desc = {
 109         .bLength =              USB_DT_ENDPOINT_SIZE,
 110         .bDescriptorType =      USB_DT_ENDPOINT,
 111
 112         .bEndpointAddress =     USB_DIR_IN,
 113         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 114 };
 115
 116 static struct usb_endpoint_descriptor fs_sink_desc = {
 117         .bLength =              USB_DT_ENDPOINT_SIZE,
 118         .bDescriptorType =      USB_DT_ENDPOINT,
 119
 120         .bEndpointAddress =     USB_DIR_OUT,
 121         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 122 };
 123
 124 static struct usb_endpoint_descriptor fs_iso_source_desc = {
 125         .bLength =              USB_DT_ENDPOINT_SIZE,
 126         .bDescriptorType =      USB_DT_ENDPOINT,
 127
 128         .bEndpointAddress =     USB_DIR_IN,
 129         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 130         .wMaxPacketSize =       cpu_to_le16(1023),
 131         .bInterval =            4,
 132 };
 133
 134 static struct usb_endpoint_descriptor fs_iso_sink_desc = {
 135         .bLength =              USB_DT_ENDPOINT_SIZE,
 136         .bDescriptorType =      USB_DT_ENDPOINT,
 137
 138         .bEndpointAddress =     USB_DIR_OUT,
 139         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 140         .wMaxPacketSize =       cpu_to_le16(1023),
 141         .bInterval =            4,
 142 };
 143
 144 static struct usb_descriptor_header *fs_source_sink_descs[] = {
 145         (struct usb_descriptor_header *) &source_sink_intf_alt0,
 146         (struct usb_descriptor_header *) &fs_sink_desc,
 147         (struct usb_descriptor_header *) &fs_source_desc,
 148         (struct usb_descriptor_header *) &source_sink_intf_alt1,
 149 #define FS_ALT_IFC_1_OFFSET     3
 150         (struct usb_descriptor_header *) &fs_sink_desc,
 151         (struct usb_descriptor_header *) &fs_source_desc,
 152         (struct usb_descriptor_header *) &fs_iso_sink_desc,
 153         (struct usb_descriptor_header *) &fs_iso_source_desc,
 154         NULL,
 155 };
 156
 157 /* high speed support: */
 158
 159 static struct usb_endpoint_descriptor hs_source_desc = {
 160         .bLength =              USB_DT_ENDPOINT_SIZE,
 161         .bDescriptorType =      USB_DT_ENDPOINT,
 162
 163         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 164         .wMaxPacketSize =       cpu_to_le16(512),
 165 };
 166
 167 static struct usb_endpoint_descriptor hs_sink_desc = {
 168         .bLength =              USB_DT_ENDPOINT_SIZE,
 169         .bDescriptorType =      USB_DT_ENDPOINT,
 170
 171         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 172         .wMaxPacketSize =       cpu_to_le16(512),
 173 };
 174
 175 static struct usb_endpoint_descriptor hs_iso_source_desc = {
 176         .bLength =              USB_DT_ENDPOINT_SIZE,
 177         .bDescriptorType =      USB_DT_ENDPOINT,
 178
 179         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 180         .wMaxPacketSize =       cpu_to_le16(1024),
 181         .bInterval =            4,
 182 };
 183
 184 static struct usb_endpoint_descriptor hs_iso_sink_desc = {
 185         .bLength =              USB_DT_ENDPOINT_SIZE,
 186         .bDescriptorType =      USB_DT_ENDPOINT,
 187
 188         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 189         .wMaxPacketSize =       cpu_to_le16(1024),
 190         .bInterval =            4,
 191 };
 192
 193 static struct usb_descriptor_header *hs_source_sink_descs[] = {
 194         (struct usb_descriptor_header *) &source_sink_intf_alt0,
 195         (struct usb_descriptor_header *) &hs_source_desc,
 196         (struct usb_descriptor_header *) &hs_sink_desc,
 197         (struct usb_descriptor_header *) &source_sink_intf_alt1,
 198 #define HS_ALT_IFC_1_OFFSET     3
 199         (struct usb_descriptor_header *) &hs_source_desc,
 200         (struct usb_descriptor_header *) &hs_sink_desc,
 201         (struct usb_descriptor_header *) &hs_iso_source_desc,
 202         (struct usb_descriptor_header *) &hs_iso_sink_desc,
 203         NULL,
 204 };
 205
 206 /* super speed support: */
 207
 208 static struct usb_endpoint_descriptor ss_source_desc = {
 209         .bLength =              USB_DT_ENDPOINT_SIZE,
 210         .bDescriptorType =      USB_DT_ENDPOINT,
 211
 212         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 213         .wMaxPacketSize =       cpu_to_le16(1024),
 214 };
 215
 216 struct usb_ss_ep_comp_descriptor ss_source_comp_desc = {
 217         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 218         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 219
 220         .bMaxBurst =            0,
 221         .bmAttributes =         0,
 222         .wBytesPerInterval =    0,
 223 };
 224
 225 static struct usb_endpoint_descriptor ss_sink_desc = {
 226         .bLength =              USB_DT_ENDPOINT_SIZE,
 227         .bDescriptorType =      USB_DT_ENDPOINT,
 228
 229         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 230         .wMaxPacketSize =       cpu_to_le16(1024),
 231 };
 232
 233 struct usb_ss_ep_comp_descriptor ss_sink_comp_desc = {
 234         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 235         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 236
 237         .bMaxBurst =            0,
 238         .bmAttributes =         0,
 239         .wBytesPerInterval =    0,
 240 };
 241
 242 static struct usb_endpoint_descriptor ss_iso_source_desc = {
 243         .bLength =              USB_DT_ENDPOINT_SIZE,
 244         .bDescriptorType =      USB_DT_ENDPOINT,
 245
 246         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 247         .wMaxPacketSize =       cpu_to_le16(1024),
 248         .bInterval =            4,
 249 };
 250
 251 struct usb_ss_ep_comp_descriptor ss_iso_source_comp_desc = {
 252         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 253         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 254
 255         .bMaxBurst =            0,
 256         .bmAttributes =         0,
 257         .wBytesPerInterval =    cpu_to_le16(1024),
 258 };
 259
 260 static struct usb_endpoint_descriptor ss_iso_sink_desc = {
 261         .bLength =              USB_DT_ENDPOINT_SIZE,
 262         .bDescriptorType =      USB_DT_ENDPOINT,
 263
 264         .bmAttributes =         USB_ENDPOINT_XFER_ISOC,
 265         .wMaxPacketSize =       cpu_to_le16(1024),
 266         .bInterval =            4,
 267 };
 268
 269 struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc = {
 270         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 271         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 272
 273         .bMaxBurst =            0,
 274         .bmAttributes =         0,
 275         .wBytesPerInterval =    cpu_to_le16(1024),
 276 };
 277
 278 static struct usb_descriptor_header *ss_source_sink_descs[] = {
 279         (struct usb_descriptor_header *) &source_sink_intf_alt0,
 280         (struct usb_descriptor_header *) &ss_source_desc,
 281         (struct usb_descriptor_header *) &ss_source_comp_desc,
 282         (struct usb_descriptor_header *) &ss_sink_desc,
 283         (struct usb_descriptor_header *) &ss_sink_comp_desc,
 284         (struct usb_descriptor_header *) &source_sink_intf_alt1,
 285 #define SS_ALT_IFC_1_OFFSET     5
 286         (struct usb_descriptor_header *) &ss_source_desc,
 287         (struct usb_descriptor_header *) &ss_source_comp_desc,
 288         (struct usb_descriptor_header *) &ss_sink_desc,
 289         (struct usb_descriptor_header *) &ss_sink_comp_desc,
 290         (struct usb_descriptor_header *) &ss_iso_source_desc,
 291         (struct usb_descriptor_header *) &ss_iso_source_comp_desc,
 292         (struct usb_descriptor_header *) &ss_iso_sink_desc,
 293         (struct usb_descriptor_header *) &ss_iso_sink_comp_desc,
 294         NULL,
 295 };
 296
 297 /* function-specific strings: */
 298
 299 static struct usb_string strings_sourcesink[] = {
 300         [0].s = "source and sink data",
 301         {  }                    /* end of list */
 302 };
 303
 304 static struct usb_gadget_strings stringtab_sourcesink = {
 305         .language       = 0x0409,       /* en-us */
 306         .strings        = strings_sourcesink,
 307 };
 308
 309 static struct usb_gadget_strings *sourcesink_strings[] = {
 310         &stringtab_sourcesink,
 311         NULL,
 312 };
 313
 314 /*-------------------------------------------------------------------------*/
 315
 316 static int __init
 317 sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
 318 {
 319         struct usb_composite_dev *cdev = c->cdev;
 320         struct f_sourcesink     *ss = func_to_ss(f);
 321         int     id;
 322
 323         /* allocate interface ID(s) */
 324         id = usb_interface_id(c, f);
 325         if (id < 0)
 326                 return id;
 327         source_sink_intf_alt0.bInterfaceNumber = id;
 328         source_sink_intf_alt1.bInterfaceNumber = id;
 329
 330         /* allocate bulk endpoints */
 331         ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
 332         if (!ss->in_ep) {
 333 autoconf_fail:
 334                 ERROR(cdev, "%s: can't autoconfigure on %s\n",
 335                         f->name, cdev->gadget->name);
 336                 return -ENODEV;
 337         }
 338         ss->in_ep->driver_data = cdev;  /* claim */
 339
 340         ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
 341         if (!ss->out_ep)
 342                 goto autoconf_fail;
 343         ss->out_ep->driver_data = cdev; /* claim */
 344
 345         /* sanity check the isoc module parameters */
 346         if (isoc_interval < 1)
 347                 isoc_interval = 1;
 348         if (isoc_interval > 16)
 349                 isoc_interval = 16;
 350         if (isoc_mult > 2)
 351                 isoc_mult = 2;
 352         if (isoc_maxburst > 15)
 353                 isoc_maxburst = 15;
 354
 355         /* fill in the FS isoc descriptors from the module parameters */
 356         fs_iso_source_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
 357                                                 1023 : isoc_maxpacket;
 358         fs_iso_source_desc.bInterval = isoc_interval;
 359         fs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
 360                                                 1023 : isoc_maxpacket;
 361         fs_iso_sink_desc.bInterval = isoc_interval;
 362
 363         /* allocate iso endpoints */
 364         ss->iso_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_source_desc);
 365         if (!ss->iso_in_ep)
 366                 goto no_iso;
 367         ss->iso_in_ep->driver_data = cdev;      /* claim */
 368
 369         ss->iso_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_sink_desc);
 370         if (ss->iso_out_ep) {
 371                 ss->iso_out_ep->driver_data = cdev;     /* claim */
 372         } else {
 373                 ss->iso_in_ep->driver_data = NULL;
 374                 ss->iso_in_ep = NULL;
 375 no_iso:
 376                 /*
 377                  * We still want to work even if the UDC doesn't have isoc
 378                  * endpoints, so null out the alt interface that contains
 379                  * them and continue.
 380                  */
 381                 fs_source_sink_descs[FS_ALT_IFC_1_OFFSET] = NULL;
 382                 hs_source_sink_descs[HS_ALT_IFC_1_OFFSET] = NULL;
 383                 ss_source_sink_descs[SS_ALT_IFC_1_OFFSET] = NULL;
 384         }
 385
 386         if (isoc_maxpacket > 1024)
 387                 isoc_maxpacket = 1024;
 388
 389         /* support high speed hardware */
 390         if (gadget_is_dualspeed(c->cdev->gadget)) {
 391                 hs_source_desc.bEndpointAddress =
 392                                 fs_source_desc.bEndpointAddress;
 393                 hs_sink_desc.bEndpointAddress =
 394                                 fs_sink_desc.bEndpointAddress;
 395
 396                 /*
 397                  * Fill in the HS isoc descriptors from the module parameters.
 398                  * We assume that the user knows what they are doing and won't
 399                  * give parameters that their UDC doesn't support.
 400                  */
 401                 hs_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
 402                 hs_iso_source_desc.wMaxPacketSize |= isoc_mult << 11;
 403                 hs_iso_source_desc.bInterval = isoc_interval;
 404                 hs_iso_source_desc.bEndpointAddress =
 405                                 fs_iso_source_desc.bEndpointAddress;
 406
 407                 hs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
 408                 hs_iso_sink_desc.wMaxPacketSize |= isoc_mult << 11;
 409                 hs_iso_sink_desc.bInterval = isoc_interval;
 410                 hs_iso_sink_desc.bEndpointAddress =
 411                                 fs_iso_sink_desc.bEndpointAddress;
 412
 413                 f->hs_descriptors = hs_source_sink_descs;
 414         }
 415
 416         /* support super speed hardware */
 417         if (gadget_is_superspeed(c->cdev->gadget)) {
 418                 ss_source_desc.bEndpointAddress =
 419                                 fs_source_desc.bEndpointAddress;
 420                 ss_sink_desc.bEndpointAddress =
 421                                 fs_sink_desc.bEndpointAddress;
 422
 423                 /*
 424                  * Fill in the SS isoc descriptors from the module parameters.
 425                  * We assume that the user knows what they are doing and won't
 426                  * give parameters that their UDC doesn't support.
 427                  */
 428                 ss_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
 429                 ss_iso_source_desc.bInterval = isoc_interval;
 430                 ss_iso_source_comp_desc.bmAttributes = isoc_mult;
 431                 ss_iso_source_comp_desc.bMaxBurst = isoc_maxburst;
 432                 ss_iso_source_comp_desc.wBytesPerInterval =
 433                         isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
 434                 ss_iso_source_desc.bEndpointAddress =
 435                                 fs_iso_source_desc.bEndpointAddress;
 436
 437                 ss_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
 438                 ss_iso_sink_desc.bInterval = isoc_interval;
 439                 ss_iso_sink_comp_desc.bmAttributes = isoc_mult;
 440                 ss_iso_sink_comp_desc.bMaxBurst = isoc_maxburst;
 441                 ss_iso_sink_comp_desc.wBytesPerInterval =
 442                         isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
 443                 ss_iso_sink_desc.bEndpointAddress =
 444                                 fs_iso_sink_desc.bEndpointAddress;
 445
 446                 f->ss_descriptors = ss_source_sink_descs;
 447         }
 448
 449         DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s\n",
 450             (gadget_is_superspeed(c->cdev->gadget) ? "super" :
 451              (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
 452                         f->name, ss->in_ep->name, ss->out_ep->name,
 453                         ss->iso_in_ep ? ss->iso_in_ep->name : "<none>",
 454                         ss->iso_out_ep ? ss->iso_out_ep->name : "<none>");
 455         return 0;
 456 }
 457
 458 static void
 459 sourcesink_unbind(struct usb_configuration *c, struct usb_function *f)
 460 {
 461         kfree(func_to_ss(f));
 462 }
 463
 464 /* optionally require specific source/sink data patterns  */
 465 static int check_read_data(struct f_sourcesink *ss, struct usb_request *req)
 466 {
 467         unsigned                i;
 468         u8                      *buf = req->buf;
 469         struct usb_composite_dev *cdev = ss->function.config->cdev;
 470
 471         if (pattern == 2)
 472                 return 0;
 473
 474         for (i = 0; i < req->actual; i++, buf++) {
 475                 switch (pattern) {
 476
 477                 /* all-zeroes has no synchronization issues */
 478                 case 0:
 479                         if (*buf == 0)
 480                                 continue;
 481                         break;
 482
 483                 /* "mod63" stays in sync with short-terminated transfers,
 484                  * OR otherwise when host and gadget agree on how large
 485                  * each usb transfer request should be.  Resync is done
 486                  * with set_interface or set_config.  (We *WANT* it to
 487                  * get quickly out of sync if controllers or their drivers
 488                  * stutter for any reason, including buffer duplication...)
 489                  */
 490                 case 1:
 491                         if (*buf == (u8)(i % 63))
 492                                 continue;
 493                         break;
 494                 }
 495                 ERROR(cdev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
 496                 usb_ep_set_halt(ss->out_ep);
 497                 return -EINVAL;
 498         }
 499         return 0;
 500 }
 501
 502 static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
 503 {
 504         unsigned        i;
 505         u8              *buf = req->buf;
 506
 507         switch (pattern) {
 508         case 0:
 509                 memset(req->buf, 0, req->length);
 510                 break;
 511         case 1:
 512                 for  (i = 0; i < req->length; i++)
 513                         *buf++ = (u8) (i % 63);
 514                 break;
 515         case 2:
 516                 break;
 517         }
 518 }
 519
 520 static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
 521 {
 522         struct usb_composite_dev        *cdev;
 523         struct f_sourcesink             *ss = ep->driver_data;
 524         int                             status = req->status;
 525
 526         /* driver_data will be null if ep has been disabled */
 527         if (!ss)
 528                 return;
 529
 530         cdev = ss->function.config->cdev;
 531
 532         switch (status) {
 533
 534         case 0:                         /* normal completion? */
 535                 if (ep == ss->out_ep) {
 536                         check_read_data(ss, req);
 537                         if (pattern != 2)
 538                                 memset(req->buf, 0x55, req->length);
 539                 } else
 540                         reinit_write_data(ep, req);
 541                 break;
 542
 543         /* this endpoint is normally active while we're configured */
 544         case -ECONNABORTED:             /* hardware forced ep reset */
 545         case -ECONNRESET:               /* request dequeued */
 546         case -ESHUTDOWN:                /* disconnect from host */
 547                 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
 548                                 req->actual, req->length);
 549                 if (ep == ss->out_ep)
 550                         check_read_data(ss, req);
 551                 free_ep_req(ep, req);
 552                 return;
 553
 554         case -EOVERFLOW:                /* buffer overrun on read means that
 555                                          * we didn't provide a big enough
 556                                          * buffer.
 557                                          */
 558         default:
 559 #if 1
 560                 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
 561                                 status, req->actual, req->length);
 562 #endif
 563         case -EREMOTEIO:                /* short read */
 564                 break;
 565         }
 566
 567         status = usb_ep_queue(ep, req, GFP_ATOMIC);
 568         if (status) {
 569                 ERROR(cdev, "kill %s:  resubmit %d bytes --> %d\n",
 570                                 ep->name, req->length, status);
 571                 usb_ep_set_halt(ep);
 572                 /* FIXME recover later ... somehow */
 573         }
 574 }
 575
 576 static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
 577                 bool is_iso, int speed)
 578 {
 579         struct usb_ep           *ep;
 580         struct usb_request      *req;
 581         int                     i, size, status;
 582
 583         for (i = 0; i < 8; i++) {
 584                 if (is_iso) {
 585                         switch (speed) {
 586                         case USB_SPEED_SUPER:
 587                                 size = isoc_maxpacket * (isoc_mult + 1) *
 588                                                 (isoc_maxburst + 1);
 589                                 break;
 590                         case USB_SPEED_HIGH:
 591                                 size = isoc_maxpacket * (isoc_mult + 1);
 592                                 break;
 593                         default:
 594                                 size = isoc_maxpacket > 1023 ?
 595                                                 1023 : isoc_maxpacket;
 596                                 break;
 597                         }
 598                         ep = is_in ? ss->iso_in_ep : ss->iso_out_ep;
 599                         req = alloc_ep_req(ep, size);
 600                 } else {
 601                         ep = is_in ? ss->in_ep : ss->out_ep;
 602                         req = alloc_ep_req(ep, 0);
 603                 }
 604
 605                 if (!req)
 606                         return -ENOMEM;
 607
 608                 req->complete = source_sink_complete;
 609                 if (is_in)
 610                         reinit_write_data(ep, req);
 611                 else if (pattern != 2)
 612                         memset(req->buf, 0x55, req->length);
 613
 614                 status = usb_ep_queue(ep, req, GFP_ATOMIC);
 615                 if (status) {
 616                         struct usb_composite_dev        *cdev;
 617
 618                         cdev = ss->function.config->cdev;
 619                         ERROR(cdev, "start %s%s %s --> %d\n",
 620                               is_iso ? "ISO-" : "", is_in ? "IN" : "OUT",
 621                               ep->name, status);
 622                         free_ep_req(ep, req);
 623                 }
 624
 625                 if (!is_iso)
 626                         break;
 627         }
 628
 629         return status;
 630 }
 631
 632 static void disable_source_sink(struct f_sourcesink *ss)
 633 {
 634         struct usb_composite_dev        *cdev;
 635
 636         cdev = ss->function.config->cdev;
 637         disable_endpoints(cdev, ss->in_ep, ss->out_ep, ss->iso_in_ep,
 638                         ss->iso_out_ep);
 639         VDBG(cdev, "%s disabled\n", ss->function.name);
 640 }
 641
 642 static int
 643 enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss,
 644                 int alt)
 645 {
 646         int                                     result = 0;
 647         int                                     speed = cdev->gadget->speed;
 648         struct usb_ep                           *ep;
 649
 650         /* one bulk endpoint writes (sources) zeroes IN (to the host) */
 651         ep = ss->in_ep;
 652         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 653         if (result)
 654                 return result;
 655         result = usb_ep_enable(ep);
 656         if (result < 0)
 657                 return result;
 658         ep->driver_data = ss;
 659
 660         result = source_sink_start_ep(ss, true, false, speed);
 661         if (result < 0) {
 662 fail:
 663                 ep = ss->in_ep;
 664                 usb_ep_disable(ep);
 665                 ep->driver_data = NULL;
 666                 return result;
 667         }
 668
 669         /* one bulk endpoint reads (sinks) anything OUT (from the host) */
 670         ep = ss->out_ep;
 671         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 672         if (result)
 673                 goto fail;
 674         result = usb_ep_enable(ep);
 675         if (result < 0)
 676                 goto fail;
 677         ep->driver_data = ss;
 678
 679         result = source_sink_start_ep(ss, false, false, speed);
 680         if (result < 0) {
 681 fail2:
 682                 ep = ss->out_ep;
 683                 usb_ep_disable(ep);
 684                 ep->driver_data = NULL;
 685                 goto fail;
 686         }
 687
 688         if (alt == 0)
 689                 goto out;
 690
 691         /* one iso endpoint writes (sources) zeroes IN (to the host) */
 692         ep = ss->iso_in_ep;
 693         if (ep) {
 694                 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 695                 if (result)
 696                         goto fail2;
 697                 result = usb_ep_enable(ep);
 698                 if (result < 0)
 699                         goto fail2;
 700                 ep->driver_data = ss;
 701
 702                 result = source_sink_start_ep(ss, true, true, speed);
 703                 if (result < 0) {
 704 fail3:
 705                         ep = ss->iso_in_ep;
 706                         if (ep) {
 707                                 usb_ep_disable(ep);
 708                                 ep->driver_data = NULL;
 709                         }
 710                         goto fail2;
 711                 }
 712         }
 713
 714         /* one iso endpoint reads (sinks) anything OUT (from the host) */
 715         ep = ss->iso_out_ep;
 716         if (ep) {
 717                 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 718                 if (result)
 719                         goto fail3;
 720                 result = usb_ep_enable(ep);
 721                 if (result < 0)
 722                         goto fail3;
 723                 ep->driver_data = ss;
 724
 725                 result = source_sink_start_ep(ss, false, true, speed);
 726                 if (result < 0) {
 727                         usb_ep_disable(ep);
 728                         ep->driver_data = NULL;
 729                         goto fail3;
 730                 }
 731         }
 732 out:
 733         ss->cur_alt = alt;
 734
 735         DBG(cdev, "%s enabled, alt intf %d\n", ss->function.name, alt);
 736         return result;
 737 }
 738
 739 static int sourcesink_set_alt(struct usb_function *f,
 740                 unsigned intf, unsigned alt)
 741 {
 742         struct f_sourcesink             *ss = func_to_ss(f);
 743         struct usb_composite_dev        *cdev = f->config->cdev;
 744
 745         if (ss->in_ep->driver_data)
 746                 disable_source_sink(ss);
 747         return enable_source_sink(cdev, ss, alt);
 748 }
 749
 750 static int sourcesink_get_alt(struct usb_function *f, unsigned intf)
 751 {
 752         struct f_sourcesink             *ss = func_to_ss(f);
 753
 754         return ss->cur_alt;
 755 }
 756
 757 static void sourcesink_disable(struct usb_function *f)
 758 {
 759         struct f_sourcesink     *ss = func_to_ss(f);
 760
 761         disable_source_sink(ss);
 762 }
 763
 764 /*-------------------------------------------------------------------------*/
 765
 766 static int __init sourcesink_bind_config(struct usb_configuration *c)
 767 {
 768         struct f_sourcesink     *ss;
 769         int                     status;
 770
 771         ss = kzalloc(sizeof *ss, GFP_KERNEL);
 772         if (!ss)
 773                 return -ENOMEM;
 774
 775         ss->function.name = "source/sink";
 776         ss->function.descriptors = fs_source_sink_descs;
 777         ss->function.bind = sourcesink_bind;
 778         ss->function.unbind = sourcesink_unbind;
 779         ss->function.set_alt = sourcesink_set_alt;
 780         ss->function.get_alt = sourcesink_get_alt;
 781         ss->function.disable = sourcesink_disable;
 782
 783         status = usb_add_function(c, &ss->function);
 784         if (status)
 785                 kfree(ss);
 786         return status;
 787 }
 788
 789 static int sourcesink_setup(struct usb_configuration *c,
 790                 const struct usb_ctrlrequest *ctrl)
 791 {
 792         struct usb_request      *req = c->cdev->req;
 793         int                     value = -EOPNOTSUPP;
 794         u16                     w_index = le16_to_cpu(ctrl->wIndex);
 795         u16                     w_value = le16_to_cpu(ctrl->wValue);
 796         u16                     w_length = le16_to_cpu(ctrl->wLength);
 797
 798         req->length = USB_BUFSIZ;
 799
 800         /* composite driver infrastructure handles everything except
 801          * the two control test requests.
 802          */
 803         switch (ctrl->bRequest) {
 804
 805         /*
 806          * These are the same vendor-specific requests supported by
 807          * Intel's USB 2.0 compliance test devices.  We exceed that
 808          * device spec by allowing multiple-packet requests.
 809          *
 810          * NOTE:  the Control-OUT data stays in req->buf ... better
 811          * would be copying it into a scratch buffer, so that other
 812          * requests may safely intervene.
 813          */
 814         case 0x5b:      /* control WRITE test -- fill the buffer */
 815                 if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
 816                         goto unknown;
 817                 if (w_value || w_index)
 818                         break;
 819                 /* just read that many bytes into the buffer */
 820                 if (w_length > req->length)
 821                         break;
 822                 value = w_length;
 823                 break;
 824         case 0x5c:      /* control READ test -- return the buffer */
 825                 if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
 826                         goto unknown;
 827                 if (w_value || w_index)
 828                         break;
 829                 /* expect those bytes are still in the buffer; send back */
 830                 if (w_length > req->length)
 831                         break;
 832                 value = w_length;
 833                 break;
 834
 835         default:
 836 unknown:
 837                 VDBG(c->cdev,
 838                         "unknown control req%02x.%02x v%04x i%04x l%d\n",
 839                         ctrl->bRequestType, ctrl->bRequest,
 840                         w_value, w_index, w_length);
 841         }
 842
 843         /* respond with data transfer or status phase? */
 844         if (value >= 0) {
 845                 VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n",
 846                         ctrl->bRequestType, ctrl->bRequest,
 847                         w_value, w_index, w_length);
 848                 req->zero = 0;
 849                 req->length = value;
 850                 value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC);
 851                 if (value < 0)
 852                         ERROR(c->cdev, "source/sink response, err %d\n",
 853                                         value);
 854         }
 855
 856         /* device either stalls (value < 0) or reports success */
 857         return value;
 858 }
 859
 860 static struct usb_configuration sourcesink_driver = {
 861         .label                  = "source/sink",
 862         .strings                = sourcesink_strings,
 863         .setup                  = sourcesink_setup,
 864         .bConfigurationValue    = 3,
 865         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 866         /* .iConfiguration      = DYNAMIC */
 867 };
 868
 869 /**
 870  * sourcesink_add - add a source/sink testing configuration to a device
 871  * @cdev: the device to support the configuration
 872  */
 873 int __init sourcesink_add(struct usb_composite_dev *cdev, bool autoresume)
 874 {
 875         int id;
 876
 877         /* allocate string ID(s) */
 878         id = usb_string_id(cdev);
 879         if (id < 0)
 880                 return id;
 881         strings_sourcesink[0].id = id;
 882
 883         source_sink_intf_alt0.iInterface = id;
 884         source_sink_intf_alt1.iInterface = id;
 885         sourcesink_driver.iConfiguration = id;
 886
 887         /* support autoresume for remote wakeup testing */
 888         if (autoresume)
 889                 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 890
 891         /* support OTG systems */
 892         if (gadget_is_otg(cdev->gadget)) {
 893                 sourcesink_driver.descriptors = otg_desc;
 894                 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 895         }
 896
 897         return usb_add_config(cdev, &sourcesink_driver, sourcesink_bind_config);
 898 }