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"); 569