drivers/usb/gadget/function/f_loopback.c

   1 /*
   2  * f_loopback.c - USB peripheral loopback 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/err.h>
  20 #include <linux/usb/composite.h>
  21
  22 #include "g_zero.h"
  23 #include "u_f.h"
  24
  25 /*
  26  * LOOPBACK FUNCTION ... a testing vehicle for USB peripherals,
  27  *
  28  * This takes messages of various sizes written OUT to a device, and loops
  29  * them back so they can be read IN from it.  It has been used by certain
  30  * test applications.  It supports limited testing of data queueing logic.
  31  *
  32  *
  33  * This is currently packaged as a configuration driver, which can't be
  34  * combined with other functions to make composite devices.  However, it
  35  * can be combined with other independent configurations.
  36  */
  37 struct f_loopback {
  38         struct usb_function     function;
  39
  40         struct usb_ep           *in_ep;
  41         struct usb_ep           *out_ep;
  42 };
  43
  44 static inline struct f_loopback *func_to_loop(struct usb_function *f)
  45 {
  46         return container_of(f, struct f_loopback, function);
  47 }
  48
  49 static unsigned qlen;
  50 static unsigned buflen;
  51
  52 /*-------------------------------------------------------------------------*/
  53
  54 static struct usb_interface_descriptor loopback_intf = {
  55         .bLength =              sizeof loopback_intf,
  56         .bDescriptorType =      USB_DT_INTERFACE,
  57
  58         .bNumEndpoints =        2,
  59         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
  60         /* .iInterface = DYNAMIC */
  61 };
  62
  63 /* full speed support: */
  64
  65 static struct usb_endpoint_descriptor fs_loop_source_desc = {
  66         .bLength =              USB_DT_ENDPOINT_SIZE,
  67         .bDescriptorType =      USB_DT_ENDPOINT,
  68
  69         .bEndpointAddress =     USB_DIR_IN,
  70         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
  71 };
  72
  73 static struct usb_endpoint_descriptor fs_loop_sink_desc = {
  74         .bLength =              USB_DT_ENDPOINT_SIZE,
  75         .bDescriptorType =      USB_DT_ENDPOINT,
  76
  77         .bEndpointAddress =     USB_DIR_OUT,
  78         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
  79 };
  80
  81 static struct usb_descriptor_header *fs_loopback_descs[] = {
  82         (struct usb_descriptor_header *) &loopback_intf,
  83         (struct usb_descriptor_header *) &fs_loop_sink_desc,
  84         (struct usb_descriptor_header *) &fs_loop_source_desc,
  85         NULL,
  86 };
  87
  88 /* high speed support: */
  89
  90 static struct usb_endpoint_descriptor hs_loop_source_desc = {
  91         .bLength =              USB_DT_ENDPOINT_SIZE,
  92         .bDescriptorType =      USB_DT_ENDPOINT,
  93
  94         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
  95         .wMaxPacketSize =       cpu_to_le16(512),
  96 };
  97
  98 static struct usb_endpoint_descriptor hs_loop_sink_desc = {
  99         .bLength =              USB_DT_ENDPOINT_SIZE,
 100         .bDescriptorType =      USB_DT_ENDPOINT,
 101
 102         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 103         .wMaxPacketSize =       cpu_to_le16(512),
 104 };
 105
 106 static struct usb_descriptor_header *hs_loopback_descs[] = {
 107         (struct usb_descriptor_header *) &loopback_intf,
 108         (struct usb_descriptor_header *) &hs_loop_source_desc,
 109         (struct usb_descriptor_header *) &hs_loop_sink_desc,
 110         NULL,
 111 };
 112
 113 /* super speed support: */
 114
 115 static struct usb_endpoint_descriptor ss_loop_source_desc = {
 116         .bLength =              USB_DT_ENDPOINT_SIZE,
 117         .bDescriptorType =      USB_DT_ENDPOINT,
 118
 119         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 120         .wMaxPacketSize =       cpu_to_le16(1024),
 121 };
 122
 123 static struct usb_ss_ep_comp_descriptor ss_loop_source_comp_desc = {
 124         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 125         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 126         .bMaxBurst =            0,
 127         .bmAttributes =         0,
 128         .wBytesPerInterval =    0,
 129 };
 130
 131 static struct usb_endpoint_descriptor ss_loop_sink_desc = {
 132         .bLength =              USB_DT_ENDPOINT_SIZE,
 133         .bDescriptorType =      USB_DT_ENDPOINT,
 134
 135         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 136         .wMaxPacketSize =       cpu_to_le16(1024),
 137 };
 138
 139 static struct usb_ss_ep_comp_descriptor ss_loop_sink_comp_desc = {
 140         .bLength =              USB_DT_SS_EP_COMP_SIZE,
 141         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 142         .bMaxBurst =            0,
 143         .bmAttributes =         0,
 144         .wBytesPerInterval =    0,
 145 };
 146
 147 static struct usb_descriptor_header *ss_loopback_descs[] = {
 148         (struct usb_descriptor_header *) &loopback_intf,
 149         (struct usb_descriptor_header *) &ss_loop_source_desc,
 150         (struct usb_descriptor_header *) &ss_loop_source_comp_desc,
 151         (struct usb_descriptor_header *) &ss_loop_sink_desc,
 152         (struct usb_descriptor_header *) &ss_loop_sink_comp_desc,
 153         NULL,
 154 };
 155
 156 /* function-specific strings: */
 157
 158 static struct usb_string strings_loopback[] = {
 159         [0].s = "loop input to output",
 160         {  }                    /* end of list */
 161 };
 162
 163 static struct usb_gadget_strings stringtab_loop = {
 164         .language       = 0x0409,       /* en-us */
 165         .strings        = strings_loopback,
 166 };
 167
 168 static struct usb_gadget_strings *loopback_strings[] = {
 169         &stringtab_loop,
 170         NULL,
 171 };
 172
 173 /*-------------------------------------------------------------------------*/
 174
 175 static int loopback_bind(struct usb_configuration *c, struct usb_function *f)
 176 {
 177         struct usb_composite_dev *cdev = c->cdev;
 178         struct f_loopback       *loop = func_to_loop(f);
 179         int                     id;
 180         int ret;
 181
 182         /* allocate interface ID(s) */
 183         id = usb_interface_id(c, f);
 184         if (id < 0)
 185                 return id;
 186         loopback_intf.bInterfaceNumber = id;
 187
 188         id = usb_string_id(cdev);
 189         if (id < 0)
 190                 return id;
 191         strings_loopback[0].id = id;
 192         loopback_intf.iInterface = id;
 193
 194         /* allocate endpoints */
 195
 196         loop->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_source_desc);
 197         if (!loop->in_ep) {
 198 autoconf_fail:
 199                 ERROR(cdev, "%s: can't autoconfigure on %s\n",
 200                         f->name, cdev->gadget->name);
 201                 return -ENODEV;
 202         }
 203         loop->in_ep->driver_data = cdev;        /* claim */
 204
 205         loop->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_sink_desc);
 206         if (!loop->out_ep)
 207                 goto autoconf_fail;
 208         loop->out_ep->driver_data = cdev;       /* claim */
 209
 210         /* support high speed hardware */
 211         hs_loop_source_desc.bEndpointAddress =
 212                 fs_loop_source_desc.bEndpointAddress;
 213         hs_loop_sink_desc.bEndpointAddress = fs_loop_sink_desc.bEndpointAddress;
 214
 215         /* support super speed hardware */
 216         ss_loop_source_desc.bEndpointAddress =
 217                 fs_loop_source_desc.bEndpointAddress;
 218         ss_loop_sink_desc.bEndpointAddress = fs_loop_sink_desc.bEndpointAddress;
 219
 220         ret = usb_assign_descriptors(f, fs_loopback_descs, hs_loopback_descs,
 221                         ss_loopback_descs);
 222         if (ret)
 223                 return ret;
 224
 225         DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
 226             (gadget_is_superspeed(c->cdev->gadget) ? "super" :
 227              (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
 228                         f->name, loop->in_ep->name, loop->out_ep->name);
 229         return 0;
 230 }
 231
 232 static void lb_free_func(struct usb_function *f)
 233 {
 234         struct f_lb_opts *opts;
 235
 236         opts = container_of(f->fi, struct f_lb_opts, func_inst);
 237
 238         mutex_lock(&opts->lock);
 239         opts->refcnt--;
 240         mutex_unlock(&opts->lock);
 241
 242         usb_free_all_descriptors(f);
 243         kfree(func_to_loop(f));
 244 }
 245
 246 static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
 247 {
 248         struct f_loopback       *loop = ep->driver_data;
 249         struct usb_composite_dev *cdev = loop->function.config->cdev;
 250         int                     status = req->status;
 251
 252         switch (status) {
 253
 254         case 0:                         /* normal completion? */
 255                 if (ep == loop->out_ep) {
 256                         req->zero = (req->actual < req->length);
 257                         req->length = req->actual;
 258                 }
 259
 260                 /* queue the buffer for some later OUT packet */
 261                 req->length = buflen;
 262                 status = usb_ep_queue(ep, req, GFP_ATOMIC);
 263                 if (status == 0)
 264                         return;
 265
 266                 /* "should never get here" */
 267                 /* FALLTHROUGH */
 268
 269         default:
 270                 ERROR(cdev, "%s loop complete --> %d, %d/%d\n", ep->name,
 271                                 status, req->actual, req->length);
 272                 /* FALLTHROUGH */
 273
 274         /* NOTE:  since this driver doesn't maintain an explicit record
 275          * of requests it submitted (just maintains qlen count), we
 276          * rely on the hardware driver to clean up on disconnect or
 277          * endpoint disable.
 278          */
 279         case -ECONNABORTED:             /* hardware forced ep reset */
 280         case -ECONNRESET:               /* request dequeued */
 281         case -ESHUTDOWN:                /* disconnect from host */
 282                 free_ep_req(ep, req);
 283                 return;
 284         }
 285 }
 286
 287 static void disable_loopback(struct f_loopback *loop)
 288 {
 289         struct usb_composite_dev        *cdev;
 290
 291         cdev = loop->function.config->cdev;
 292         disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL);
 293         VDBG(cdev, "%s disabled\n", loop->function.name);
 294 }
 295
 296 static inline struct usb_request *lb_alloc_ep_req(struct usb_ep *ep, int len)
 297 {
 298         return alloc_ep_req(ep, len, buflen);
 299 }
 300
 301 static int enable_endpoint(struct usb_composite_dev *cdev, struct f_loopback *loop,
 302                 struct usb_ep *ep)
 303 {
 304         struct usb_request                      *req;
 305         unsigned                                i;
 306         int                                     result;
 307
 308         /*
 309          * one endpoint writes data back IN to the host while another endpoint
 310          * just reads OUT packets
 311          */
 312         result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
 313         if (result)
 314                 goto fail0;
 315         result = usb_ep_enable(ep);
 316         if (result < 0)
 317                 goto fail0;
 318         ep->driver_data = loop;
 319
 320         /*
 321          * allocate a bunch of read buffers and queue them all at once.
 322          * we buffer at most 'qlen' transfers; fewer if any need more
 323          * than 'buflen' bytes each.
 324          */
 325         for (i = 0; i < qlen && result == 0; i++) {
 326                 req = lb_alloc_ep_req(ep, 0);
 327                 if (!req)
 328                         goto fail1;
 329
 330                 req->complete = loopback_complete;
 331                 result = usb_ep_queue(ep, req, GFP_ATOMIC);
 332                 if (result) {
 333                         ERROR(cdev, "%s queue req --> %d\n",
 334                                         ep->name, result);
 335                         goto fail1;
 336                 }
 337         }
 338
 339         return 0;
 340
 341 fail1:
 342         usb_ep_disable(ep);
 343
 344 fail0:
 345         return result;
 346 }
 347
 348 static int
 349 enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
 350 {
 351         int                                     result = 0;
 352
 353         result = enable_endpoint(cdev, loop, loop->in_ep);
 354         if (result)
 355                 return result;
 356
 357         result = enable_endpoint(cdev, loop, loop->out_ep);
 358         if (result)
 359                 return result;
 360
 361         DBG(cdev, "%s enabled\n", loop->function.name);
 362         return result;
 363 }
 364
 365 static int loopback_set_alt(struct usb_function *f,
 366                 unsigned intf, unsigned alt)
 367 {
 368         struct f_loopback       *loop = func_to_loop(f);
 369         struct usb_composite_dev *cdev = f->config->cdev;
 370
 371         /* we know alt is zero */
 372         if (loop->in_ep->driver_data)
 373                 disable_loopback(loop);
 374         return enable_loopback(cdev, loop);
 375 }
 376
 377 static void loopback_disable(struct usb_function *f)
 378 {
 379         struct f_loopback       *loop = func_to_loop(f);
 380
 381         disable_loopback(loop);
 382 }
 383
 384 static struct usb_function *loopback_alloc(struct usb_function_instance *fi)
 385 {
 386         struct f_loopback       *loop;
 387         struct f_lb_opts        *lb_opts;
 388
 389         loop = kzalloc(sizeof *loop, GFP_KERNEL);
 390         if (!loop)
 391                 return ERR_PTR(-ENOMEM);
 392
 393         lb_opts = container_of(fi, struct f_lb_opts, func_inst);
 394
 395         mutex_lock(&lb_opts->lock);
 396         lb_opts->refcnt++;
 397         mutex_unlock(&lb_opts->lock);
 398
 399         buflen = lb_opts->bulk_buflen;
 400         qlen = lb_opts->qlen;
 401         if (!qlen)
 402                 qlen = 32;
 403
 404         loop->function.name = "loopback";
 405         loop->function.bind = loopback_bind;
 406         loop->function.set_alt = loopback_set_alt;
 407         loop->function.disable = loopback_disable;
 408         loop->function.strings = loopback_strings;
 409
 410         loop->function.free_func = lb_free_func;
 411
 412         return &loop->function;
 413 }
 414
 415 static inline struct f_lb_opts *to_f_lb_opts(struct config_item *item)
 416 {
 417         return container_of(to_config_group(item), struct f_lb_opts,
 418                             func_inst.group);
 419 }
 420
 421 CONFIGFS_ATTR_STRUCT(f_lb_opts);
 422 CONFIGFS_ATTR_OPS(f_lb_opts);
 423
 424 static void lb_attr_release(struct config_item *item)
 425 {
 426         struct f_lb_opts *lb_opts = to_f_lb_opts(item);
 427
 428         usb_put_function_instance(&lb_opts->func_inst);
 429 }
 430
 431 static struct configfs_item_operations lb_item_ops = {
 432         .release                = lb_attr_release,
 433         .show_attribute         = f_lb_opts_attr_show,
 434         .store_attribute        = f_lb_opts_attr_store,
 435 };
 436
 437 static ssize_t f_lb_opts_qlen_show(struct f_lb_opts *opts, char *page)
 438 {
 439         int result;
 440
 441         mutex_lock(&opts->lock);
 442         result = sprintf(page, "%d", opts->qlen);
 443         mutex_unlock(&opts->lock);
 444
 445         return result;
 446 }
 447
 448 static ssize_t f_lb_opts_qlen_store(struct f_lb_opts *opts,
 449                                     const char *page, size_t len)
 450 {
 451         int ret;
 452         u32 num;
 453
 454         mutex_lock(&opts->lock);
 455         if (opts->refcnt) {
 456                 ret = -EBUSY;
 457                 goto end;
 458         }
 459
 460         ret = kstrtou32(page, 0, &num);
 461         if (ret)
 462                 goto end;
 463
 464         opts->qlen = num;
 465         ret = len;
 466 end:
 467         mutex_unlock(&opts->lock);
 468         return ret;
 469 }
 470
 471 static struct f_lb_opts_attribute f_lb_opts_qlen =
 472         __CONFIGFS_ATTR(qlen, S_IRUGO | S_IWUSR,
 473                         f_lb_opts_qlen_show,
 474                         f_lb_opts_qlen_store);
 475
 476 static ssize_t f_lb_opts_bulk_buflen_show(struct f_lb_opts *opts, char *page)
 477 {
 478         int result;
 479
 480         mutex_lock(&opts->lock);
 481         result = sprintf(page, "%d", opts->bulk_buflen);
 482         mutex_unlock(&opts->lock);
 483
 484         return result;
 485 }
 486
 487 static ssize_t f_lb_opts_bulk_buflen_store(struct f_lb_opts *opts,
 488                                     const char *page, size_t len)
 489 {
 490         int ret;
 491         u32 num;
 492
 493         mutex_lock(&opts->lock);
 494         if (opts->refcnt) {
 495                 ret = -EBUSY;
 496                 goto end;
 497         }
 498
 499         ret = kstrtou32(page, 0, &num);
 500         if (ret)
 501                 goto end;
 502
 503         opts->bulk_buflen = num;
 504         ret = len;
 505 end:
 506         mutex_unlock(&opts->lock);
 507         return ret;
 508 }
 509
 510 static struct f_lb_opts_attribute f_lb_opts_bulk_buflen =
 511         __CONFIGFS_ATTR(buflen, S_IRUGO | S_IWUSR,
 512                         f_lb_opts_bulk_buflen_show,
 513                         f_lb_opts_bulk_buflen_store);
 514
 515 static struct configfs_attribute *lb_attrs[] = {
 516         &f_lb_opts_qlen.attr,
 517         &f_lb_opts_bulk_buflen.attr,
 518         NULL,
 519 };
 520
 521 static struct config_item_type lb_func_type = {
 522         .ct_item_ops    = &lb_item_ops,
 523         .ct_attrs       = lb_attrs,
 524         .ct_owner       = THIS_MODULE,
 525 };
 526
 527 static void lb_free_instance(struct usb_function_instance *fi)
 528 {
 529         struct f_lb_opts *lb_opts;
 530
 531         lb_opts = container_of(fi, struct f_lb_opts, func_inst);
 532         kfree(lb_opts);
 533 }
 534
 535 static struct usb_function_instance *loopback_alloc_instance(void)
 536 {
 537         struct f_lb_opts *lb_opts;
 538
 539         lb_opts = kzalloc(sizeof(*lb_opts), GFP_KERNEL);
 540         if (!lb_opts)
 541                 return ERR_PTR(-ENOMEM);
 542         mutex_init(&lb_opts->lock);
 543         lb_opts->func_inst.free_func_inst = lb_free_instance;
 544         lb_opts->bulk_buflen = GZERO_BULK_BUFLEN;
 545         lb_opts->qlen = GZERO_QLEN;
 546
 547         config_group_init_type_name(&lb_opts->func_inst.group, "",
 548                                     &lb_func_type);
 549
 550         return  &lb_opts->func_inst;
 551 }
 552 DECLARE_USB_FUNCTION(Loopback, loopback_alloc_instance, loopback_alloc);
 553
 554 int __init lb_modinit(void)
 555 {
 556         int ret;
 557
 558         ret = usb_function_register(&Loopbackusb_func);
 559         if (ret)
 560                 return ret;
 561         return ret;
 562 }
 563 void __exit lb_modexit(void)
 564 {
 565         usb_function_unregister(&Loopbackusb_func);
 566 }
 567
 568 MODULE_LICENSE("GPL");