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         int ret;
 323
 324         /* allocate interface ID(s) */
 325         id = usb_interface_id(c, f);
 326         if (id < 0)
 327                 return id;
 328         source_sink_intf_alt0.bInterfaceNumber = id;
 329         source_sink_intf_alt1.bInterfaceNumber = id;
 330
 331         /* allocate bulk endpoints */
 332         ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
 333         if (!ss->in_ep) {
 334 autoconf_fail:
 335                 ERROR(cdev, "%s: can't autoconfigure on %s\n",
 336                         f->name, cdev->gadget->name);
 337                 return -ENODEV;
 338         }
 339         ss->in_ep->driver_data = cdev;  /* claim */
 340
 341         ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
 342         if (!ss->out_ep)
 343                 goto autoconf_fail;
 344         ss->out_ep->driver_data = cdev; /* claim */
 345
 346         /* sanity check the isoc module parameters */
 347         if (isoc_interval < 1)
 348                 isoc_interval = 1;
 349         if (isoc_interval > 16)
 350                 isoc_interval = 16;
 351         if (isoc_mult > 2)
 352                 isoc_mult = 2;
 353         if (isoc_maxburst > 15)
 354                 isoc_maxburst = 15;
 355
 356         /* fill in the FS isoc descriptors from the module parameters */
 357         fs_iso_source_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
 358                                                 1023 : isoc_maxpacket;
 359         fs_iso_source_desc.bInterval = isoc_interval;
 360         fs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
 361                                                 1023 : isoc_maxpacket;
 362         fs_iso_sink_desc.bInterval = isoc_interval;
 363
 364         /* allocate iso endpoints */
 365         ss->iso_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_source_desc);
 366         if (!ss->iso_in_ep)
 367                 goto no_iso;
 368         ss->iso_in_ep->driver_data = cdev;      /* claim */
 369
 370         ss->iso_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_sink_desc);
 371         if (ss->iso_out_ep) {
 372                 ss->iso_out_ep->driver_data = cdev;     /* claim */
 373         } else {
 374                 ss->iso_in_ep->driver_data = NULL;
 375                 ss->iso_in_ep = NULL;
 376 no_iso:
 377                 /*
 378                  * We still want to work even if the UDC doesn't have isoc
 379                  * endpoints, so null out the alt interface that contains
 380                  * them and continue.
 381                  */
 382                 fs_source_sink_descs[FS_ALT_IFC_1_OFFSET] = NULL;
 383                 hs_source_sink_descs[HS_ALT_IFC_1_OFFSET] = NULL;
 384                 ss_source_sink_descs[SS_ALT_IFC_1_OFFSET] = NULL;
 385         }
 386
 387         if (isoc_maxpacket > 1024)
 388                 isoc_maxpacket = 1024;
 389
 390         /* support high speed hardware */
 391         hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
 392         hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
 393
 394         /*
 395          * Fill in the HS isoc descriptors from the module parameters.
 396          * We assume that the user knows what they are doing and won't
 397          * give parameters that their UDC doesn't support.
 398          */
 399         hs_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
 400         hs_iso_source_desc.wMaxPacketSize |= isoc_mult << 11;
 401         hs_iso_source_desc.bInterval = isoc_interval;
 402         hs_iso_source_desc.bEndpointAddress =
 403                 fs_iso_source_desc.bEndpointAddress;
 404
 405         hs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
 406         hs_iso_sink_desc.wMaxPacketSize |= isoc_mult << 11;
 407         hs_iso_sink_desc.bInterval = isoc_interval;
 408         hs_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 409
 410         /* support super speed hardware */
 411         ss_source_desc.bEndpointAddress =
 412                 fs_source_desc.bEndpointAddress;
 413         ss_sink_desc.bEndpointAddress =
 414                 fs_sink_desc.bEndpointAddress;
 415
 416         /*
 417          * Fill in the SS isoc descriptors from the module parameters.
 418          * We assume that the user knows what they are doing and won't
 419          * give parameters that their UDC doesn't support.
 420          */
 421         ss_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
 422         ss_iso_source_desc.bInterval = isoc_interval;
 423         ss_iso_source_comp_desc.bmAttributes = isoc_mult;
 424         ss_iso_source_comp_desc.bMaxBurst = isoc_maxburst;
 425         ss_iso_source_comp_desc.wBytesPerInterval =
 426                 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
 427         ss_iso_source_desc.bEndpointAddress =
 428                 fs_iso_source_desc.bEndpointAddress;
 429
 430         ss_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
 431         ss_iso_sink_desc.bInterval = isoc_interval;
 432         ss_iso_sink_comp_desc.bmAttributes = isoc_mult;
 433         ss_iso_sink_comp_desc.bMaxBurst = isoc_maxburst;
 434         ss_iso_sink_comp_desc.wBytesPerInterval =
 435                 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
 436         ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 437
 438         ret = usb_assign_descriptors(f, fs_source_sink_descs,
 439                         hs_source_sink_descs, ss_source_sink_descs);
 440         if (ret)
 441                 return ret;
 442
 443         DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s\n",
 444             (gadget_is_superspeed(c->cdev->gadget) ? "super" :
 445              (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
 446                         f->name, ss->in_ep->name, ss->out_ep->name,
 447                         ss->iso_in_ep ? ss->iso_in_ep->name : "<none>",
 448                         ss->iso_out_ep ? ss->iso_out_ep->name : "<none>");
 449         return 0;
 450 }
 451
 452 static void
 453 sourcesink_unbind(struct usb_configuration *c, struct usb_function *f)
 454 {
 455         usb_free_all_descriptors(f);
 456         kfree(func_to_ss(f));
 457 }
 458
 459 /* optionally require specific source/sink data patterns  */
 460 static int check_read_data(struct f_sourcesink *ss, struct usb_request *req)
 461 {
 462         unsigned                i;
 463         u8                      *buf = req->buf;
 464         struct usb_composite_dev *cdev = ss->function.config->cdev;
 465
 466         if (pattern == 2)
 467                 return 0;
 468
 469         for (i = 0; i < req->actual; i++, buf++) {
 470                 switch (pattern) {
 471
 472                 /* all-zeroes has no synchronization issues */
 473                 case 0:
 474                         if (*buf == 0)
 475                                 continue;
 476                         break;
 477
 478                 /* "mod63" stays in sync with short-terminated transfers,
 479                  * OR otherwise when host and gadget agree on how large
 480                  * each usb transfer request should be.  Resync is done
 481                  * with set_interface or set_config.  (We *WANT* it to
 482                  * get quickly out of sync if controllers or their drivers
 483                  * stutter for any reason, including buffer duplication...)
 484                  */
 485                 case 1:
 486                         if (*buf == (u8)(i % 63))
 487                                 continue;
 488                         break;
 489                 }
 490                 ERROR(cdev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
 491                 usb_ep_set_halt(ss->out_ep);
 492                 return -EINVAL;
 493         }
 494         return 0;
 495 }
 496
 497 static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
 498 {
 499         unsigned        i;
 500         u8              *buf = req->buf;
 501
 502         switch (pattern) {
 503         case 0:
 504                 memset(req->buf, 0, req->length);
 505                 break;
 506         case 1:
 507                 for  (i = 0; i < req->length; i++)
 508                         *buf++ = (u8) (i % 63);
 509                 break;
 510         case 2:
 511                 break;
 512         }
 513 }
 514
 515 static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
 516 {
 517         struct usb_composite_dev        *cdev;
 518         struct f_sourcesink             *ss = ep->driver_data;
 519         int                             status = req->status;
 520
 521         /* driver_data will be null if ep has been disabled */
 522         if (!ss)
 523                 return;
 524
 525         cdev = ss->function.config->cdev;
 526
 527         switch (status) {
 528
 529         case 0:                         /* normal completion? */
 530                 if (ep == ss->out_ep) {
 531                         check_read_data(ss, req);
 532                         if (pattern != 2)
 533                                 memset(req->buf, 0x55, req->length);
 534                 } else
 535                         reinit_write_data(ep, req);
 536                 break;
 537
 538         /* this endpoint is normally active while we're configured */
 539         case -ECONNABORTED:             /* hardware forced ep reset */
 540         case -ECONNRESET:               /* request dequeued */
 541         case -ESHUTDOWN:                /* disconnect from host */
 542                 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
 543                                 req->actual, req->length);
 544                 if (ep == ss->out_ep)
 545                         check_read_data(ss, req);
 546                 free_ep_req(ep, req);
 547                 return;
 548
 549         case -EOVERFLOW:                /* buffer overrun on read means that
 550                                          * we didn't provide a big enough
 551                                          * buffer.
 552                                          */
 553         default:
 554 #if 1
 555                 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
 556                                 status, req->actual, req->length);
 557 #endif
 558         case -EREMOTEIO:                /* short read */
 559                 break;
 560         }
 561
 562         status = usb_ep_queue(ep, req, GFP_ATOMIC);
 563         if (status) {
 564                 ERROR(cdev, "kill %s:  resubmit %d bytes --> %d\n",
 565                                 ep->name, req->length, status);
 566                 usb_ep_set_halt(ep);
 567                 /* FIXME recover later ... somehow */
 568         }
 569 }
 570
 571 static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
 572                 bool is_iso, int speed)
 573 {
 574         struct usb_ep           *ep;
 575         struct usb_request      *req;
 576         int                     i, size, status;
 577
 578         for (i = 0; i < 8; i++) {
 579                 if (is_iso) {
 580                         switch (speed) {
 581                         case USB_SPEED_SUPER:
 582                                 size = isoc_maxpacket * (isoc_mult + 1) *
 583                                                 (isoc_maxburst + 1);
 584                                 break;
 585                         case USB_SPEED_HIGH:
 586                                 size = isoc_maxpacket * (isoc_mult + 1);
 587                                 break;
 588                         default:
 589                                 size = isoc_maxpacket > 1023 ?
 590                                                 1023 : isoc_maxpacket;
 591                                 break;
 592                         }
 593                         ep = is_in ? ss->iso_in_ep : ss->iso_out_ep;
 594                         req = alloc_ep_req(ep, size);
 595                 } else {
 596                         ep = is_in ? ss->in_ep : ss->out_ep;
 597                         req = alloc_ep_req(ep, 0);
 598                 }
 599
 600                 if (!req)
 601                         return -ENOMEM;
 602
 603                 req->complete = source_sink_complete;
 604                 if (is_in)
 605                         reinit_write_data(ep, req);
 606                 else if (pattern != 2)
 607                         memset(req->buf, 0x55, req->length);
 608
 609                 status = usb_ep_queue(ep, req, GFP_ATOMIC);
 610                 if (status) {
 611                         struct usb_composite_dev        *cdev;
 612
 613                         cdev = ss->function.config->cdev;
 614                         ERROR(cdev, "start %s%s %s --> %d\n",
 615                               is_iso ? "ISO-" : "", is_in ? "IN" : "OUT",
 616                               ep->name, status);
 617                         free_ep_req(ep, req);
 618                 }
 619
 620                 if (!is_iso)
 621                         break;
 622         }
 623
 624         return status;
 625 }
 626
 627 static void disable_source_sink(struct f_sourcesink *ss)
 628 {
 629         struct usb_composite_dev        *cdev;
 630
 631         cdev = ss->function.config->cdev;
 632         disable_endpoints(cdev, ss->in_ep, ss->out_ep, ss->iso_in_ep,
 633                         ss->iso_out_ep);
 634         VDBG(cdev, "%s disabled\n", ss->function.name);
 635 }
 636
 637 static int
 638 enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss,
 639                 int alt)
 640 {
 641         int                                     result = 0;
 642         int                                     speed = cdev->gadget->speed;
 643         struct usb_ep                           *ep;
 644
 645         /* one bulk endpoint writes (sources) zeroes IN (to the host) */
 646         ep = ss->in_ep;
 647         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 648         if (result)
 649                 return result;
 650         result = usb_ep_enable(ep);
 651         if (result < 0)
 652                 return result;
 653         ep->driver_data = ss;
 654
 655         result = source_sink_start_ep(ss, true, false, speed);
 656         if (result < 0) {
 657 fail:
 658                 ep = ss->in_ep;
 659                 usb_ep_disable(ep);
 660                 ep->driver_data = NULL;
 661                 return result;
 662         }
 663
 664         /* one bulk endpoint reads (sinks) anything OUT (from the host) */
 665         ep = ss->out_ep;
 666         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 667         if (result)
 668                 goto fail;
 669         result = usb_ep_enable(ep);
 670         if (result < 0)
 671                 goto fail;
 672         ep->driver_data = ss;
 673
 674         result = source_sink_start_ep(ss, false, false, speed);
 675         if (result < 0) {
 676 fail2:
 677                 ep = ss->out_ep;
 678                 usb_ep_disable(ep);
 679                 ep->driver_data = NULL;
 680                 goto fail;
 681         }
 682
 683         if (alt == 0)
 684                 goto out;
 685
 686         /* one iso endpoint writes (sources) zeroes IN (to the host) */
 687         ep = ss->iso_in_ep;
 688         if (ep) {
 689                 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 690                 if (result)
 691                         goto fail2;
 692                 result = usb_ep_enable(ep);
 693                 if (result < 0)
 694                         goto fail2;
 695                 ep->driver_data = ss;
 696
 697                 result = source_sink_start_ep(ss, true, true, speed);
 698                 if (result < 0) {
 699 fail3:
 700                         ep = ss->iso_in_ep;
 701                         if (ep) {
 702                                 usb_ep_disable(ep);
 703                                 ep->driver_data = NULL;
 704                         }
 705                         goto fail2;
 706                 }
 707         }
 708
 709         /* one iso endpoint reads (sinks) anything OUT (from the host) */
 710         ep = ss->iso_out_ep;
 711         if (ep) {
 712                 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
 713                 if (result)
 714                         goto fail3;
 715                 result = usb_ep_enable(ep);
 716                 if (result < 0)
 717                         goto fail3;
 718                 ep->driver_data = ss;
 719
 720                 result = source_sink_start_ep(ss, false, true, speed);
 721                 if (result < 0) {
 722                         usb_ep_disable(ep);
 723                         ep->driver_data = NULL;
 724                         goto fail3;
 725                 }
 726         }
 727 out:
 728         ss->cur_alt = alt;
 729
 730         DBG(cdev, "%s enabled, alt intf %d\n", ss->function.name, alt);
 731         return result;
 732 }
 733
 734 static int sourcesink_set_alt(struct usb_function *f,
 735                 unsigned intf, unsigned alt)
 736 {
 737         struct f_sourcesink             *ss = func_to_ss(f);
 738         struct usb_composite_dev        *cdev = f->config->cdev;
 739
 740         if (ss->in_ep->driver_data)
 741                 disable_source_sink(ss);
 742         return enable_source_sink(cdev, ss, alt);
 743 }
 744
 745 static int sourcesink_get_alt(struct usb_function *f, unsigned intf)
 746 {
 747         struct f_sourcesink             *ss = func_to_ss(f);
 748
 749         return ss->cur_alt;
 750 }
 751
 752 static void sourcesink_disable(struct usb_function *f)
 753 {
 754         struct f_sourcesink     *ss = func_to_ss(f);
 755
 756         disable_source_sink(ss);
 757 }
 758
 759 /*-------------------------------------------------------------------------*/
 760
 761 static int __init sourcesink_bind_config(struct usb_configuration *c)
 762 {
 763         struct f_sourcesink     *ss;
 764         int                     status;
 765
 766         ss = kzalloc(sizeof *ss, GFP_KERNEL);
 767         if (!ss)
 768                 return -ENOMEM;
 769
 770         ss->function.name = "source/sink";
 771         ss->function.bind = sourcesink_bind;
 772         ss->function.unbind = sourcesink_unbind;
 773         ss->function.set_alt = sourcesink_set_alt;
 774         ss->function.get_alt = sourcesink_get_alt;
 775         ss->function.disable = sourcesink_disable;
 776
 777         status = usb_add_function(c, &ss->function);
 778         if (status)
 779                 kfree(ss);
 780         return status;
 781 }
 782
 783 static int sourcesink_setup(struct usb_configuration *c,
 784                 const struct usb_ctrlrequest *ctrl)
 785 {
 786         struct usb_request      *req = c->cdev->req;
 787         int                     value = -EOPNOTSUPP;
 788         u16                     w_index = le16_to_cpu(ctrl->wIndex);
 789         u16                     w_value = le16_to_cpu(ctrl->wValue);
 790         u16                     w_length = le16_to_cpu(ctrl->wLength);
 791
 792         req->length = USB_COMP_EP0_BUFSIZ;
 793
 794         /* composite driver infrastructure handles everything except
 795          * the two control test requests.
 796          */
 797         switch (ctrl->bRequest) {
 798
 799         /*
 800          * These are the same vendor-specific requests supported by
 801          * Intel's USB 2.0 compliance test devices.  We exceed that
 802          * device spec by allowing multiple-packet requests.
 803          *
 804          * NOTE:  the Control-OUT data stays in req->buf ... better
 805          * would be copying it into a scratch buffer, so that other
 806          * requests may safely intervene.
 807          */
 808         case 0x5b:      /* control WRITE test -- fill the buffer */
 809                 if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
 810                         goto unknown;
 811                 if (w_value || w_index)
 812                         break;
 813                 /* just read that many bytes into the buffer */
 814                 if (w_length > req->length)
 815                         break;
 816                 value = w_length;
 817                 break;
 818         case 0x5c:      /* control READ test -- return the buffer */
 819                 if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
 820                         goto unknown;
 821                 if (w_value || w_index)
 822                         break;
 823                 /* expect those bytes are still in the buffer; send back */
 824                 if (w_length > req->length)
 825                         break;
 826                 value = w_length;
 827                 break;
 828
 829         default:
 830 unknown:
 831                 VDBG(c->cdev,
 832                         "unknown control req%02x.%02x v%04x i%04x l%d\n",
 833                         ctrl->bRequestType, ctrl->bRequest,
 834                         w_value, w_index, w_length);
 835         }
 836
 837         /* respond with data transfer or status phase? */
 838         if (value >= 0) {
 839                 VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n",
 840                         ctrl->bRequestType, ctrl->bRequest,
 841                         w_value, w_index, w_length);
 842                 req->zero = 0;
 843                 req->length = value;
 844                 value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC);
 845                 if (value < 0)
 846                         ERROR(c->cdev, "source/sink response, err %d\n",
 847                                         value);
 848         }
 849
 850         /* device either stalls (value < 0) or reports success */
 851         return value;
 852 }
 853
 854 static struct usb_configuration sourcesink_driver = {
 855         .label                  = "source/sink",
 856         .strings                = sourcesink_strings,
 857         .setup                  = sourcesink_setup,
 858         .bConfigurationValue    = 3,
 859         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 860         /* .iConfiguration      = DYNAMIC */
 861 };
 862
 863 /**
 864  * sourcesink_add - add a source/sink testing configuration to a device
 865  * @cdev: the device to support the configuration
 866  */
 867 int __init sourcesink_add(struct usb_composite_dev *cdev, bool autoresume)
 868 {
 869         int id;
 870
 871         /* allocate string ID(s) */
 872         id = usb_string_id(cdev);
 873         if (id < 0)
 874                 return id;
 875         strings_sourcesink[0].id = id;
 876
 877         source_sink_intf_alt0.iInterface = id;
 878         source_sink_intf_alt1.iInterface = id;
 879         sourcesink_driver.iConfiguration = id;
 880
 881         /* support autoresume for remote wakeup testing */
 882         if (autoresume)
 883                 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 884
 885         /* support OTG systems */
 886         if (gadget_is_otg(cdev->gadget)) {
 887                 sourcesink_driver.descriptors = otg_desc;
 888                 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 889         }
 890
 891         return usb_add_config(cdev, &sourcesink_driver, sourcesink_bind_config);
 892 }