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 /* loop this OUT packet back IN to the host */ 257 req->zero = (req->actual < req->length); 258 req->length = req->actual; 259 status = usb_ep_queue(loop->in_ep, req, GFP_ATOMIC); 260 if (status == 0) 261 return; 262 263 /* "should never get here" */ 264 ERROR(cdev, "can't loop %s to %s: %d\n", 265 ep->name, loop->in_ep->name, 266 status); 267 } 268 269 /* queue the buffer for some later OUT packet */ 270 req->length = buflen; 271 status = usb_ep_queue(loop->out_ep, req, GFP_ATOMIC); 272 if (status == 0) 273 return; 274 275 /* "should never get here" */ 276 /* FALLTHROUGH */ 277 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_ep_req(ep, req); 292 return; 293 } 294 } 295 296 static void disable_loopback(struct f_loopback *loop) 297 { 298 struct usb_composite_dev *cdev; 299 300 cdev = loop->function.config->cdev; 301 disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL); 302 VDBG(cdev, "%s disabled\n", loop->function.name); 303 } 304 305 static inline struct usb_request *lb_alloc_ep_req(struct usb_ep *ep, int len) 306 { 307 return alloc_ep_req(ep, len, buflen); 308 } 309 310 static int 311 enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop) 312 { 313 int result = 0; 314 struct usb_ep *ep; 315 struct usb_request *req; 316 unsigned i; 317 318 /* one endpoint writes data back IN to the host */ 319 ep = loop->in_ep; 320 result = config_ep_by_speed(cdev->gadget, &(loop->function), ep); 321 if (result) 322 return result; 323 result = usb_ep_enable(ep); 324 if (result < 0) 325 return result; 326 ep->driver_data = loop; 327 328 /* one endpoint just reads OUT packets */ 329 ep = loop->out_ep; 330 result = config_ep_by_speed(cdev->gadget, &(loop->function), ep); 331 if (result) 332 goto fail0; 333 334 result = usb_ep_enable(ep); 335 if (result < 0) { 336 fail0: 337 ep = loop->in_ep; 338 usb_ep_disable(ep); 339 ep->driver_data = NULL; 340 return result; 341 } 342 ep->driver_data = loop; 343 344 /* allocate a bunch of read buffers and queue them all at once. 345 * we buffer at most 'qlen' transfers; fewer if any need more 346 * than 'buflen' bytes each. 347 */ 348 for (i = 0; i < qlen && result == 0; i++) { 349 req = lb_alloc_ep_req(ep, 0); 350 if (req) { 351 req->complete = loopback_complete; 352 result = usb_ep_queue(ep, req, GFP_ATOMIC); 353 if (result) 354 ERROR(cdev, "%s queue req --> %d\n", 355 ep->name, result); 356 } else { 357 usb_ep_disable(ep); 358 ep->driver_data = NULL; 359 result = -ENOMEM; 360 goto fail0; 361 } 362 } 363 364 DBG(cdev, "%s enabled\n", loop->function.name); 365 return result; 366 } 367 368 static int loopback_set_alt(struct usb_function *f, 369 unsigned intf, unsigned alt) 370 { 371 struct f_loopback *loop = func_to_loop(f); 372 struct usb_composite_dev *cdev = f->config->cdev; 373 374 /* we know alt is zero */ 375 if (loop->in_ep->driver_data) 376 disable_loopback(loop); 377 return enable_loopback(cdev, loop); 378 } 379 380 static void loopback_disable(struct usb_function *f) 381 { 382 struct f_loopback *loop = func_to_loop(f); 383 384 disable_loopback(loop); 385 } 386 387 static struct usb_function *loopback_alloc(struct usb_function_instance *fi) 388 { 389 struct f_loopback *loop; 390 struct f_lb_opts *lb_opts; 391 392 loop = kzalloc(sizeof *loop, GFP_KERNEL); 393 if (!loop) 394 return ERR_PTR(-ENOMEM); 395 396 lb_opts = container_of(fi, struct f_lb_opts, func_inst); 397 398 mutex_lock(&lb_opts->lock); 399 lb_opts->refcnt++; 400 mutex_unlock(&lb_opts->lock); 401 402 buflen = lb_opts->bulk_buflen; 403 qlen = lb_opts->qlen; 404 if (!qlen) 405 qlen = 32; 406 407 loop->function.name = "loopback"; 408 loop->function.bind = loopback_bind; 409 loop->function.set_alt = loopback_set_alt; 410 loop->function.disable = loopback_disable; 411 loop->function.strings = loopback_strings; 412 413 loop->function.free_func = lb_free_func; 414 415 return &loop->function; 416 } 417 418 static inline struct f_lb_opts *to_f_lb_opts(struct config_item *item) 419 { 420 return container_of(to_config_group(item), struct f_lb_opts, 421 func_inst.group); 422 } 423 424 CONFIGFS_ATTR_STRUCT(f_lb_opts); 425 CONFIGFS_ATTR_OPS(f_lb_opts); 426 427 static void lb_attr_release(struct config_item *item) 428 { 429 struct f_lb_opts *lb_opts = to_f_lb_opts(item); 430 431 usb_put_function_instance(&lb_opts->func_inst); 432 } 433 434 static struct configfs_item_operations lb_item_ops = { 435 .release = lb_attr_release, 436 .show_attribute = f_lb_opts_attr_show, 437 .store_attribute = f_lb_opts_attr_store, 438 }; 439 440 static ssize_t f_lb_opts_qlen_show(struct f_lb_opts *opts, char *page) 441 { 442 int result; 443 444 mutex_lock(&opts->lock); 445 result = sprintf(page, "%d", opts->qlen); 446 mutex_unlock(&opts->lock); 447 448 return result; 449 } 450 451 static ssize_t f_lb_opts_qlen_store(struct f_lb_opts *opts, 452 const char *page, size_t len) 453 { 454 int ret; 455 u32 num; 456 457 mutex_lock(&opts->lock); 458 if (opts->refcnt) { 459 ret = -EBUSY; 460 goto end; 461 } 462 463 ret = kstrtou32(page, 0, &num); 464 if (ret) 465 goto end; 466 467 opts->qlen = num; 468 ret = len; 469 end: 470 mutex_unlock(&opts->lock); 471 return ret; 472 } 473 474 static struct f_lb_opts_attribute f_lb_opts_qlen = 475 __CONFIGFS_ATTR(qlen, S_IRUGO | S_IWUSR, 476 f_lb_opts_qlen_show, 477 f_lb_opts_qlen_store); 478 479 static ssize_t f_lb_opts_bulk_buflen_show(struct f_lb_opts *opts, char *page) 480 { 481 int result; 482 483 mutex_lock(&opts->lock); 484 result = sprintf(page, "%d", opts->bulk_buflen); 485 mutex_unlock(&opts->lock); 486 487 return result; 488 } 489 490 static ssize_t f_lb_opts_bulk_buflen_store(struct f_lb_opts *opts, 491 const char *page, size_t len) 492 { 493 int ret; 494 u32 num; 495 496 mutex_lock(&opts->lock); 497 if (opts->refcnt) { 498 ret = -EBUSY; 499 goto end; 500 } 501 502 ret = kstrtou32(page, 0, &num); 503 if (ret) 504 goto end; 505 506 opts->bulk_buflen = num; 507 ret = len; 508 end: 509 mutex_unlock(&opts->lock); 510 return ret; 511 } 512 513 static struct f_lb_opts_attribute f_lb_opts_bulk_buflen = 514 __CONFIGFS_ATTR(buflen, S_IRUGO | S_IWUSR, 515 f_lb_opts_bulk_buflen_show, 516 f_lb_opts_bulk_buflen_store); 517 518 static struct configfs_attribute *lb_attrs[] = { 519 &f_lb_opts_qlen.attr, 520 &f_lb_opts_bulk_buflen.attr, 521 NULL, 522 }; 523 524 static struct config_item_type lb_func_type = { 525 .ct_item_ops = &lb_item_ops, 526 .ct_attrs = lb_attrs, 527 .ct_owner = THIS_MODULE, 528 }; 529 530 static void lb_free_instance(struct usb_function_instance *fi) 531 { 532 struct f_lb_opts *lb_opts; 533 534 lb_opts = container_of(fi, struct f_lb_opts, func_inst); 535 kfree(lb_opts); 536 } 537 538 static struct usb_function_instance *loopback_alloc_instance(void) 539 { 540 struct f_lb_opts *lb_opts; 541 542 lb_opts = kzalloc(sizeof(*lb_opts), GFP_KERNEL); 543 if (!lb_opts) 544 return ERR_PTR(-ENOMEM); 545 mutex_init(&lb_opts->lock); 546 lb_opts->func_inst.free_func_inst = lb_free_instance; 547 lb_opts->bulk_buflen = GZERO_BULK_BUFLEN; 548 lb_opts->qlen = GZERO_QLEN; 549 550 config_group_init_type_name(&lb_opts->func_inst.group, "", 551 &lb_func_type); 552 553 return &lb_opts->func_inst; 554 } 555 DECLARE_USB_FUNCTION(Loopback, loopback_alloc_instance, loopback_alloc); 556 557 int __init lb_modinit(void) 558 { 559 int ret; 560 561 ret = usb_function_register(&Loopbackusb_func); 562 if (ret) 563 return ret; 564 return ret; 565 } 566 void __exit lb_modexit(void) 567 { 568 usb_function_unregister(&Loopbackusb_func); 569 } 570 571 MODULE_LICENSE("GPL"); 572