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