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