1 /* 2 * f_sourcesink.c - USB peripheral source/sink 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/usb/composite.h> 20 #include <linux/err.h> 21 22 #include "g_zero.h" 23 #include "u_f.h" 24 25 /* 26 * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral 27 * controller drivers. 28 * 29 * This just sinks bulk packets OUT to the peripheral and sources them IN 30 * to the host, optionally with specific data patterns for integrity tests. 31 * As such it supports basic functionality and load tests. 32 * 33 * In terms of control messaging, this supports all the standard requests 34 * plus two that support control-OUT tests. If the optional "autoresume" 35 * mode is enabled, it provides good functional coverage for the "USBCV" 36 * test harness from USB-IF. 37 * 38 * Note that because this doesn't queue more than one request at a time, 39 * some other function must be used to test queueing logic. The network 40 * link (g_ether) is the best overall option for that, since its TX and RX 41 * queues are relatively independent, will receive a range of packet sizes, 42 * and can often be made to run out completely. Those issues are important 43 * when stress testing peripheral controller drivers. 44 */ 45 struct f_sourcesink { 46 struct usb_function function; 47 48 struct usb_ep *in_ep; 49 struct usb_ep *out_ep; 50 struct usb_ep *iso_in_ep; 51 struct usb_ep *iso_out_ep; 52 int cur_alt; 53 54 unsigned pattern; 55 unsigned isoc_interval; 56 unsigned isoc_maxpacket; 57 unsigned isoc_mult; 58 unsigned isoc_maxburst; 59 unsigned buflen; 60 }; 61 62 static inline struct f_sourcesink *func_to_ss(struct usb_function *f) 63 { 64 return container_of(f, struct f_sourcesink, function); 65 } 66 67 /*-------------------------------------------------------------------------*/ 68 69 static struct usb_interface_descriptor source_sink_intf_alt0 = { 70 .bLength = USB_DT_INTERFACE_SIZE, 71 .bDescriptorType = USB_DT_INTERFACE, 72 73 .bAlternateSetting = 0, 74 .bNumEndpoints = 2, 75 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 76 /* .iInterface = DYNAMIC */ 77 }; 78 79 static struct usb_interface_descriptor source_sink_intf_alt1 = { 80 .bLength = USB_DT_INTERFACE_SIZE, 81 .bDescriptorType = USB_DT_INTERFACE, 82 83 .bAlternateSetting = 1, 84 .bNumEndpoints = 4, 85 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 86 /* .iInterface = DYNAMIC */ 87 }; 88 89 /* full speed support: */ 90 91 static struct usb_endpoint_descriptor fs_source_desc = { 92 .bLength = USB_DT_ENDPOINT_SIZE, 93 .bDescriptorType = USB_DT_ENDPOINT, 94 95 .bEndpointAddress = USB_DIR_IN, 96 .bmAttributes = USB_ENDPOINT_XFER_BULK, 97 }; 98 99 static struct usb_endpoint_descriptor fs_sink_desc = { 100 .bLength = USB_DT_ENDPOINT_SIZE, 101 .bDescriptorType = USB_DT_ENDPOINT, 102 103 .bEndpointAddress = USB_DIR_OUT, 104 .bmAttributes = USB_ENDPOINT_XFER_BULK, 105 }; 106 107 static struct usb_endpoint_descriptor fs_iso_source_desc = { 108 .bLength = USB_DT_ENDPOINT_SIZE, 109 .bDescriptorType = USB_DT_ENDPOINT, 110 111 .bEndpointAddress = USB_DIR_IN, 112 .bmAttributes = USB_ENDPOINT_XFER_ISOC, 113 .wMaxPacketSize = cpu_to_le16(1023), 114 .bInterval = 4, 115 }; 116 117 static struct usb_endpoint_descriptor fs_iso_sink_desc = { 118 .bLength = USB_DT_ENDPOINT_SIZE, 119 .bDescriptorType = USB_DT_ENDPOINT, 120 121 .bEndpointAddress = USB_DIR_OUT, 122 .bmAttributes = USB_ENDPOINT_XFER_ISOC, 123 .wMaxPacketSize = cpu_to_le16(1023), 124 .bInterval = 4, 125 }; 126 127 static struct usb_descriptor_header *fs_source_sink_descs[] = { 128 (struct usb_descriptor_header *) &source_sink_intf_alt0, 129 (struct usb_descriptor_header *) &fs_sink_desc, 130 (struct usb_descriptor_header *) &fs_source_desc, 131 (struct usb_descriptor_header *) &source_sink_intf_alt1, 132 #define FS_ALT_IFC_1_OFFSET 3 133 (struct usb_descriptor_header *) &fs_sink_desc, 134 (struct usb_descriptor_header *) &fs_source_desc, 135 (struct usb_descriptor_header *) &fs_iso_sink_desc, 136 (struct usb_descriptor_header *) &fs_iso_source_desc, 137 NULL, 138 }; 139 140 /* high speed support: */ 141 142 static struct usb_endpoint_descriptor hs_source_desc = { 143 .bLength = USB_DT_ENDPOINT_SIZE, 144 .bDescriptorType = USB_DT_ENDPOINT, 145 146 .bmAttributes = USB_ENDPOINT_XFER_BULK, 147 .wMaxPacketSize = cpu_to_le16(512), 148 }; 149 150 static struct usb_endpoint_descriptor hs_sink_desc = { 151 .bLength = USB_DT_ENDPOINT_SIZE, 152 .bDescriptorType = USB_DT_ENDPOINT, 153 154 .bmAttributes = USB_ENDPOINT_XFER_BULK, 155 .wMaxPacketSize = cpu_to_le16(512), 156 }; 157 158 static struct usb_endpoint_descriptor hs_iso_source_desc = { 159 .bLength = USB_DT_ENDPOINT_SIZE, 160 .bDescriptorType = USB_DT_ENDPOINT, 161 162 .bmAttributes = USB_ENDPOINT_XFER_ISOC, 163 .wMaxPacketSize = cpu_to_le16(1024), 164 .bInterval = 4, 165 }; 166 167 static struct usb_endpoint_descriptor hs_iso_sink_desc = { 168 .bLength = USB_DT_ENDPOINT_SIZE, 169 .bDescriptorType = USB_DT_ENDPOINT, 170 171 .bmAttributes = USB_ENDPOINT_XFER_ISOC, 172 .wMaxPacketSize = cpu_to_le16(1024), 173 .bInterval = 4, 174 }; 175 176 static struct usb_descriptor_header *hs_source_sink_descs[] = { 177 (struct usb_descriptor_header *) &source_sink_intf_alt0, 178 (struct usb_descriptor_header *) &hs_source_desc, 179 (struct usb_descriptor_header *) &hs_sink_desc, 180 (struct usb_descriptor_header *) &source_sink_intf_alt1, 181 #define HS_ALT_IFC_1_OFFSET 3 182 (struct usb_descriptor_header *) &hs_source_desc, 183 (struct usb_descriptor_header *) &hs_sink_desc, 184 (struct usb_descriptor_header *) &hs_iso_source_desc, 185 (struct usb_descriptor_header *) &hs_iso_sink_desc, 186 NULL, 187 }; 188 189 /* super speed support: */ 190 191 static struct usb_endpoint_descriptor ss_source_desc = { 192 .bLength = USB_DT_ENDPOINT_SIZE, 193 .bDescriptorType = USB_DT_ENDPOINT, 194 195 .bmAttributes = USB_ENDPOINT_XFER_BULK, 196 .wMaxPacketSize = cpu_to_le16(1024), 197 }; 198 199 static struct usb_ss_ep_comp_descriptor ss_source_comp_desc = { 200 .bLength = USB_DT_SS_EP_COMP_SIZE, 201 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, 202 203 .bMaxBurst = 0, 204 .bmAttributes = 0, 205 .wBytesPerInterval = 0, 206 }; 207 208 static struct usb_endpoint_descriptor ss_sink_desc = { 209 .bLength = USB_DT_ENDPOINT_SIZE, 210 .bDescriptorType = USB_DT_ENDPOINT, 211 212 .bmAttributes = USB_ENDPOINT_XFER_BULK, 213 .wMaxPacketSize = cpu_to_le16(1024), 214 }; 215 216 static struct usb_ss_ep_comp_descriptor ss_sink_comp_desc = { 217 .bLength = USB_DT_SS_EP_COMP_SIZE, 218 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, 219 220 .bMaxBurst = 0, 221 .bmAttributes = 0, 222 .wBytesPerInterval = 0, 223 }; 224 225 static struct usb_endpoint_descriptor ss_iso_source_desc = { 226 .bLength = USB_DT_ENDPOINT_SIZE, 227 .bDescriptorType = USB_DT_ENDPOINT, 228 229 .bmAttributes = USB_ENDPOINT_XFER_ISOC, 230 .wMaxPacketSize = cpu_to_le16(1024), 231 .bInterval = 4, 232 }; 233 234 static struct usb_ss_ep_comp_descriptor ss_iso_source_comp_desc = { 235 .bLength = USB_DT_SS_EP_COMP_SIZE, 236 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, 237 238 .bMaxBurst = 0, 239 .bmAttributes = 0, 240 .wBytesPerInterval = cpu_to_le16(1024), 241 }; 242 243 static struct usb_endpoint_descriptor ss_iso_sink_desc = { 244 .bLength = USB_DT_ENDPOINT_SIZE, 245 .bDescriptorType = USB_DT_ENDPOINT, 246 247 .bmAttributes = USB_ENDPOINT_XFER_ISOC, 248 .wMaxPacketSize = cpu_to_le16(1024), 249 .bInterval = 4, 250 }; 251 252 static struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc = { 253 .bLength = USB_DT_SS_EP_COMP_SIZE, 254 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, 255 256 .bMaxBurst = 0, 257 .bmAttributes = 0, 258 .wBytesPerInterval = cpu_to_le16(1024), 259 }; 260 261 static struct usb_descriptor_header *ss_source_sink_descs[] = { 262 (struct usb_descriptor_header *) &source_sink_intf_alt0, 263 (struct usb_descriptor_header *) &ss_source_desc, 264 (struct usb_descriptor_header *) &ss_source_comp_desc, 265 (struct usb_descriptor_header *) &ss_sink_desc, 266 (struct usb_descriptor_header *) &ss_sink_comp_desc, 267 (struct usb_descriptor_header *) &source_sink_intf_alt1, 268 #define SS_ALT_IFC_1_OFFSET 5 269 (struct usb_descriptor_header *) &ss_source_desc, 270 (struct usb_descriptor_header *) &ss_source_comp_desc, 271 (struct usb_descriptor_header *) &ss_sink_desc, 272 (struct usb_descriptor_header *) &ss_sink_comp_desc, 273 (struct usb_descriptor_header *) &ss_iso_source_desc, 274 (struct usb_descriptor_header *) &ss_iso_source_comp_desc, 275 (struct usb_descriptor_header *) &ss_iso_sink_desc, 276 (struct usb_descriptor_header *) &ss_iso_sink_comp_desc, 277 NULL, 278 }; 279 280 /* function-specific strings: */ 281 282 static struct usb_string strings_sourcesink[] = { 283 [0].s = "source and sink data", 284 { } /* end of list */ 285 }; 286 287 static struct usb_gadget_strings stringtab_sourcesink = { 288 .language = 0x0409, /* en-us */ 289 .strings = strings_sourcesink, 290 }; 291 292 static struct usb_gadget_strings *sourcesink_strings[] = { 293 &stringtab_sourcesink, 294 NULL, 295 }; 296 297 /*-------------------------------------------------------------------------*/ 298 299 static inline struct usb_request *ss_alloc_ep_req(struct usb_ep *ep, int len) 300 { 301 struct f_sourcesink *ss = ep->driver_data; 302 303 return alloc_ep_req(ep, len, ss->buflen); 304 } 305 306 void free_ep_req(struct usb_ep *ep, struct usb_request *req) 307 { 308 kfree(req->buf); 309 usb_ep_free_request(ep, req); 310 } 311 312 static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep) 313 { 314 int value; 315 316 value = usb_ep_disable(ep); 317 if (value < 0) 318 DBG(cdev, "disable %s --> %d\n", ep->name, value); 319 } 320 321 void disable_endpoints(struct usb_composite_dev *cdev, 322 struct usb_ep *in, struct usb_ep *out, 323 struct usb_ep *iso_in, struct usb_ep *iso_out) 324 { 325 disable_ep(cdev, in); 326 disable_ep(cdev, out); 327 if (iso_in) 328 disable_ep(cdev, iso_in); 329 if (iso_out) 330 disable_ep(cdev, iso_out); 331 } 332 333 static int 334 sourcesink_bind(struct usb_configuration *c, struct usb_function *f) 335 { 336 struct usb_composite_dev *cdev = c->cdev; 337 struct f_sourcesink *ss = func_to_ss(f); 338 int id; 339 int ret; 340 341 /* allocate interface ID(s) */ 342 id = usb_interface_id(c, f); 343 if (id < 0) 344 return id; 345 source_sink_intf_alt0.bInterfaceNumber = id; 346 source_sink_intf_alt1.bInterfaceNumber = id; 347 348 /* allocate bulk endpoints */ 349 ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc); 350 if (!ss->in_ep) { 351 autoconf_fail: 352 ERROR(cdev, "%s: can't autoconfigure on %s\n", 353 f->name, cdev->gadget->name); 354 return -ENODEV; 355 } 356 357 ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc); 358 if (!ss->out_ep) 359 goto autoconf_fail; 360 361 /* sanity check the isoc module parameters */ 362 if (ss->isoc_interval < 1) 363 ss->isoc_interval = 1; 364 if (ss->isoc_interval > 16) 365 ss->isoc_interval = 16; 366 if (ss->isoc_mult > 2) 367 ss->isoc_mult = 2; 368 if (ss->isoc_maxburst > 15) 369 ss->isoc_maxburst = 15; 370 371 /* fill in the FS isoc descriptors from the module parameters */ 372 fs_iso_source_desc.wMaxPacketSize = ss->isoc_maxpacket > 1023 ? 373 1023 : ss->isoc_maxpacket; 374 fs_iso_source_desc.bInterval = ss->isoc_interval; 375 fs_iso_sink_desc.wMaxPacketSize = ss->isoc_maxpacket > 1023 ? 376 1023 : ss->isoc_maxpacket; 377 fs_iso_sink_desc.bInterval = ss->isoc_interval; 378 379 /* allocate iso endpoints */ 380 ss->iso_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_source_desc); 381 if (!ss->iso_in_ep) 382 goto no_iso; 383 384 ss->iso_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_sink_desc); 385 if (!ss->iso_out_ep) { 386 usb_ep_autoconfig_release(ss->iso_in_ep); 387 ss->iso_in_ep = NULL; 388 no_iso: 389 /* 390 * We still want to work even if the UDC doesn't have isoc 391 * endpoints, so null out the alt interface that contains 392 * them and continue. 393 */ 394 fs_source_sink_descs[FS_ALT_IFC_1_OFFSET] = NULL; 395 hs_source_sink_descs[HS_ALT_IFC_1_OFFSET] = NULL; 396 ss_source_sink_descs[SS_ALT_IFC_1_OFFSET] = NULL; 397 } 398 399 if (ss->isoc_maxpacket > 1024) 400 ss->isoc_maxpacket = 1024; 401 402 /* support high speed hardware */ 403 hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress; 404 hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress; 405 406 /* 407 * Fill in the HS isoc descriptors from the module parameters. 408 * We assume that the user knows what they are doing and won't 409 * give parameters that their UDC doesn't support. 410 */ 411 hs_iso_source_desc.wMaxPacketSize = ss->isoc_maxpacket; 412 hs_iso_source_desc.wMaxPacketSize |= ss->isoc_mult << 11; 413 hs_iso_source_desc.bInterval = ss->isoc_interval; 414 hs_iso_source_desc.bEndpointAddress = 415 fs_iso_source_desc.bEndpointAddress; 416 417 hs_iso_sink_desc.wMaxPacketSize = ss->isoc_maxpacket; 418 hs_iso_sink_desc.wMaxPacketSize |= ss->isoc_mult << 11; 419 hs_iso_sink_desc.bInterval = ss->isoc_interval; 420 hs_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress; 421 422 /* support super speed hardware */ 423 ss_source_desc.bEndpointAddress = 424 fs_source_desc.bEndpointAddress; 425 ss_sink_desc.bEndpointAddress = 426 fs_sink_desc.bEndpointAddress; 427 428 /* 429 * Fill in the SS isoc descriptors from the module parameters. 430 * We assume that the user knows what they are doing and won't 431 * give parameters that their UDC doesn't support. 432 */ 433 ss_iso_source_desc.wMaxPacketSize = ss->isoc_maxpacket; 434 ss_iso_source_desc.bInterval = ss->isoc_interval; 435 ss_iso_source_comp_desc.bmAttributes = ss->isoc_mult; 436 ss_iso_source_comp_desc.bMaxBurst = ss->isoc_maxburst; 437 ss_iso_source_comp_desc.wBytesPerInterval = ss->isoc_maxpacket * 438 (ss->isoc_mult + 1) * (ss->isoc_maxburst + 1); 439 ss_iso_source_desc.bEndpointAddress = 440 fs_iso_source_desc.bEndpointAddress; 441 442 ss_iso_sink_desc.wMaxPacketSize = ss->isoc_maxpacket; 443 ss_iso_sink_desc.bInterval = ss->isoc_interval; 444 ss_iso_sink_comp_desc.bmAttributes = ss->isoc_mult; 445 ss_iso_sink_comp_desc.bMaxBurst = ss->isoc_maxburst; 446 ss_iso_sink_comp_desc.wBytesPerInterval = ss->isoc_maxpacket * 447 (ss->isoc_mult + 1) * (ss->isoc_maxburst + 1); 448 ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress; 449 450 ret = usb_assign_descriptors(f, fs_source_sink_descs, 451 hs_source_sink_descs, ss_source_sink_descs); 452 if (ret) 453 return ret; 454 455 DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s\n", 456 (gadget_is_superspeed(c->cdev->gadget) ? "super" : 457 (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")), 458 f->name, ss->in_ep->name, ss->out_ep->name, 459 ss->iso_in_ep ? ss->iso_in_ep->name : "<none>", 460 ss->iso_out_ep ? ss->iso_out_ep->name : "<none>"); 461 return 0; 462 } 463 464 static void 465 sourcesink_free_func(struct usb_function *f) 466 { 467 struct f_ss_opts *opts; 468 469 opts = container_of(f->fi, struct f_ss_opts, func_inst); 470 471 mutex_lock(&opts->lock); 472 opts->refcnt--; 473 mutex_unlock(&opts->lock); 474 475 usb_free_all_descriptors(f); 476 kfree(func_to_ss(f)); 477 } 478 479 /* optionally require specific source/sink data patterns */ 480 static int check_read_data(struct f_sourcesink *ss, struct usb_request *req) 481 { 482 unsigned i; 483 u8 *buf = req->buf; 484 struct usb_composite_dev *cdev = ss->function.config->cdev; 485 int max_packet_size = le16_to_cpu(ss->out_ep->desc->wMaxPacketSize); 486 487 if (ss->pattern == 2) 488 return 0; 489 490 for (i = 0; i < req->actual; i++, buf++) { 491 switch (ss->pattern) { 492 493 /* all-zeroes has no synchronization issues */ 494 case 0: 495 if (*buf == 0) 496 continue; 497 break; 498 499 /* "mod63" stays in sync with short-terminated transfers, 500 * OR otherwise when host and gadget agree on how large 501 * each usb transfer request should be. Resync is done 502 * with set_interface or set_config. (We *WANT* it to 503 * get quickly out of sync if controllers or their drivers 504 * stutter for any reason, including buffer duplication...) 505 */ 506 case 1: 507 if (*buf == (u8)((i % max_packet_size) % 63)) 508 continue; 509 break; 510 } 511 ERROR(cdev, "bad OUT byte, buf[%d] = %d\n", i, *buf); 512 usb_ep_set_halt(ss->out_ep); 513 return -EINVAL; 514 } 515 return 0; 516 } 517 518 static void reinit_write_data(struct usb_ep *ep, struct usb_request *req) 519 { 520 unsigned i; 521 u8 *buf = req->buf; 522 int max_packet_size = le16_to_cpu(ep->desc->wMaxPacketSize); 523 struct f_sourcesink *ss = ep->driver_data; 524 525 switch (ss->pattern) { 526 case 0: 527 memset(req->buf, 0, req->length); 528 break; 529 case 1: 530 for (i = 0; i < req->length; i++) 531 *buf++ = (u8) ((i % max_packet_size) % 63); 532 break; 533 case 2: 534 break; 535 } 536 } 537 538 static void source_sink_complete(struct usb_ep *ep, struct usb_request *req) 539 { 540 struct usb_composite_dev *cdev; 541 struct f_sourcesink *ss = ep->driver_data; 542 int status = req->status; 543 544 /* driver_data will be null if ep has been disabled */ 545 if (!ss) 546 return; 547 548 cdev = ss->function.config->cdev; 549 550 switch (status) { 551 552 case 0: /* normal completion? */ 553 if (ep == ss->out_ep) { 554 check_read_data(ss, req); 555 if (ss->pattern != 2) 556 memset(req->buf, 0x55, req->length); 557 } 558 break; 559 560 /* this endpoint is normally active while we're configured */ 561 case -ECONNABORTED: /* hardware forced ep reset */ 562 case -ECONNRESET: /* request dequeued */ 563 case -ESHUTDOWN: /* disconnect from host */ 564 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status, 565 req->actual, req->length); 566 if (ep == ss->out_ep) 567 check_read_data(ss, req); 568 free_ep_req(ep, req); 569 return; 570 571 case -EOVERFLOW: /* buffer overrun on read means that 572 * we didn't provide a big enough 573 * buffer. 574 */ 575 default: 576 #if 1 577 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name, 578 status, req->actual, req->length); 579 #endif 580 case -EREMOTEIO: /* short read */ 581 break; 582 } 583 584 status = usb_ep_queue(ep, req, GFP_ATOMIC); 585 if (status) { 586 ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n", 587 ep->name, req->length, status); 588 usb_ep_set_halt(ep); 589 /* FIXME recover later ... somehow */ 590 } 591 } 592 593 static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in, 594 bool is_iso, int speed) 595 { 596 struct usb_ep *ep; 597 struct usb_request *req; 598 int i, size, status; 599 600 for (i = 0; i < 8; i++) { 601 if (is_iso) { 602 switch (speed) { 603 case USB_SPEED_SUPER: 604 size = ss->isoc_maxpacket * 605 (ss->isoc_mult + 1) * 606 (ss->isoc_maxburst + 1); 607 break; 608 case USB_SPEED_HIGH: 609 size = ss->isoc_maxpacket * (ss->isoc_mult + 1); 610 break; 611 default: 612 size = ss->isoc_maxpacket > 1023 ? 613 1023 : ss->isoc_maxpacket; 614 break; 615 } 616 ep = is_in ? ss->iso_in_ep : ss->iso_out_ep; 617 req = ss_alloc_ep_req(ep, size); 618 } else { 619 ep = is_in ? ss->in_ep : ss->out_ep; 620 req = ss_alloc_ep_req(ep, 0); 621 } 622 623 if (!req) 624 return -ENOMEM; 625 626 req->complete = source_sink_complete; 627 if (is_in) 628 reinit_write_data(ep, req); 629 else if (ss->pattern != 2) 630 memset(req->buf, 0x55, req->length); 631 632 status = usb_ep_queue(ep, req, GFP_ATOMIC); 633 if (status) { 634 struct usb_composite_dev *cdev; 635 636 cdev = ss->function.config->cdev; 637 ERROR(cdev, "start %s%s %s --> %d\n", 638 is_iso ? "ISO-" : "", is_in ? "IN" : "OUT", 639 ep->name, status); 640 free_ep_req(ep, req); 641 } 642 643 if (!is_iso) 644 break; 645 } 646 647 return status; 648 } 649 650 static void disable_source_sink(struct f_sourcesink *ss) 651 { 652 struct usb_composite_dev *cdev; 653 654 cdev = ss->function.config->cdev; 655 disable_endpoints(cdev, ss->in_ep, ss->out_ep, ss->iso_in_ep, 656 ss->iso_out_ep); 657 VDBG(cdev, "%s disabled\n", ss->function.name); 658 } 659 660 static int 661 enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss, 662 int alt) 663 { 664 int result = 0; 665 int speed = cdev->gadget->speed; 666 struct usb_ep *ep; 667 668 /* one bulk endpoint writes (sources) zeroes IN (to the host) */ 669 ep = ss->in_ep; 670 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep); 671 if (result) 672 return result; 673 result = usb_ep_enable(ep); 674 if (result < 0) 675 return result; 676 ep->driver_data = ss; 677 678 result = source_sink_start_ep(ss, true, false, speed); 679 if (result < 0) { 680 fail: 681 ep = ss->in_ep; 682 usb_ep_disable(ep); 683 return result; 684 } 685 686 /* one bulk endpoint reads (sinks) anything OUT (from the host) */ 687 ep = ss->out_ep; 688 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep); 689 if (result) 690 goto fail; 691 result = usb_ep_enable(ep); 692 if (result < 0) 693 goto fail; 694 ep->driver_data = ss; 695 696 result = source_sink_start_ep(ss, false, false, speed); 697 if (result < 0) { 698 fail2: 699 ep = ss->out_ep; 700 usb_ep_disable(ep); 701 goto fail; 702 } 703 704 if (alt == 0) 705 goto out; 706 707 /* one iso endpoint writes (sources) zeroes IN (to the host) */ 708 ep = ss->iso_in_ep; 709 if (ep) { 710 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep); 711 if (result) 712 goto fail2; 713 result = usb_ep_enable(ep); 714 if (result < 0) 715 goto fail2; 716 ep->driver_data = ss; 717 718 result = source_sink_start_ep(ss, true, true, speed); 719 if (result < 0) { 720 fail3: 721 ep = ss->iso_in_ep; 722 if (ep) 723 usb_ep_disable(ep); 724 goto fail2; 725 } 726 } 727 728 /* one iso endpoint reads (sinks) anything OUT (from the host) */ 729 ep = ss->iso_out_ep; 730 if (ep) { 731 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep); 732 if (result) 733 goto fail3; 734 result = usb_ep_enable(ep); 735 if (result < 0) 736 goto fail3; 737 ep->driver_data = ss; 738 739 result = source_sink_start_ep(ss, false, true, speed); 740 if (result < 0) { 741 usb_ep_disable(ep); 742 goto fail3; 743 } 744 } 745 out: 746 ss->cur_alt = alt; 747 748 DBG(cdev, "%s enabled, alt intf %d\n", ss->function.name, alt); 749 return result; 750 } 751 752 static int sourcesink_set_alt(struct usb_function *f, 753 unsigned intf, unsigned alt) 754 { 755 struct f_sourcesink *ss = func_to_ss(f); 756 struct usb_composite_dev *cdev = f->config->cdev; 757 758 disable_source_sink(ss); 759 return enable_source_sink(cdev, ss, alt); 760 } 761 762 static int sourcesink_get_alt(struct usb_function *f, unsigned intf) 763 { 764 struct f_sourcesink *ss = func_to_ss(f); 765 766 return ss->cur_alt; 767 } 768 769 static void sourcesink_disable(struct usb_function *f) 770 { 771 struct f_sourcesink *ss = func_to_ss(f); 772 773 disable_source_sink(ss); 774 } 775 776 /*-------------------------------------------------------------------------*/ 777 778 static int sourcesink_setup(struct usb_function *f, 779 const struct usb_ctrlrequest *ctrl) 780 { 781 struct usb_configuration *c = f->config; 782 struct usb_request *req = c->cdev->req; 783 int value = -EOPNOTSUPP; 784 u16 w_index = le16_to_cpu(ctrl->wIndex); 785 u16 w_value = le16_to_cpu(ctrl->wValue); 786 u16 w_length = le16_to_cpu(ctrl->wLength); 787 788 req->length = USB_COMP_EP0_BUFSIZ; 789 790 /* composite driver infrastructure handles everything except 791 * the two control test requests. 792 */ 793 switch (ctrl->bRequest) { 794 795 /* 796 * These are the same vendor-specific requests supported by 797 * Intel's USB 2.0 compliance test devices. We exceed that 798 * device spec by allowing multiple-packet requests. 799 * 800 * NOTE: the Control-OUT data stays in req->buf ... better 801 * would be copying it into a scratch buffer, so that other 802 * requests may safely intervene. 803 */ 804 case 0x5b: /* control WRITE test -- fill the buffer */ 805 if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR)) 806 goto unknown; 807 if (w_value || w_index) 808 break; 809 /* just read that many bytes into the buffer */ 810 if (w_length > req->length) 811 break; 812 value = w_length; 813 break; 814 case 0x5c: /* control READ test -- return the buffer */ 815 if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR)) 816 goto unknown; 817 if (w_value || w_index) 818 break; 819 /* expect those bytes are still in the buffer; send back */ 820 if (w_length > req->length) 821 break; 822 value = w_length; 823 break; 824 825 default: 826 unknown: 827 VDBG(c->cdev, 828 "unknown control req%02x.%02x v%04x i%04x l%d\n", 829 ctrl->bRequestType, ctrl->bRequest, 830 w_value, w_index, w_length); 831 } 832 833 /* respond with data transfer or status phase? */ 834 if (value >= 0) { 835 VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n", 836 ctrl->bRequestType, ctrl->bRequest, 837 w_value, w_index, w_length); 838 req->zero = 0; 839 req->length = value; 840 value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC); 841 if (value < 0) 842 ERROR(c->cdev, "source/sink response, err %d\n", 843 value); 844 } 845 846 /* device either stalls (value < 0) or reports success */ 847 return value; 848 } 849 850 static struct usb_function *source_sink_alloc_func( 851 struct usb_function_instance *fi) 852 { 853 struct f_sourcesink *ss; 854 struct f_ss_opts *ss_opts; 855 856 ss = kzalloc(sizeof(*ss), GFP_KERNEL); 857 if (!ss) 858 return NULL; 859 860 ss_opts = container_of(fi, struct f_ss_opts, func_inst); 861 862 mutex_lock(&ss_opts->lock); 863 ss_opts->refcnt++; 864 mutex_unlock(&ss_opts->lock); 865 866 ss->pattern = ss_opts->pattern; 867 ss->isoc_interval = ss_opts->isoc_interval; 868 ss->isoc_maxpacket = ss_opts->isoc_maxpacket; 869 ss->isoc_mult = ss_opts->isoc_mult; 870 ss->isoc_maxburst = ss_opts->isoc_maxburst; 871 ss->buflen = ss_opts->bulk_buflen; 872 873 ss->function.name = "source/sink"; 874 ss->function.bind = sourcesink_bind; 875 ss->function.set_alt = sourcesink_set_alt; 876 ss->function.get_alt = sourcesink_get_alt; 877 ss->function.disable = sourcesink_disable; 878 ss->function.setup = sourcesink_setup; 879 ss->function.strings = sourcesink_strings; 880 881 ss->function.free_func = sourcesink_free_func; 882 883 return &ss->function; 884 } 885 886 static inline struct f_ss_opts *to_f_ss_opts(struct config_item *item) 887 { 888 return container_of(to_config_group(item), struct f_ss_opts, 889 func_inst.group); 890 } 891 892 static void ss_attr_release(struct config_item *item) 893 { 894 struct f_ss_opts *ss_opts = to_f_ss_opts(item); 895 896 usb_put_function_instance(&ss_opts->func_inst); 897 } 898 899 static struct configfs_item_operations ss_item_ops = { 900 .release = ss_attr_release, 901 }; 902 903 static ssize_t f_ss_opts_pattern_show(struct config_item *item, char *page) 904 { 905 struct f_ss_opts *opts = to_f_ss_opts(item); 906 int result; 907 908 mutex_lock(&opts->lock); 909 result = sprintf(page, "%u\n", opts->pattern); 910 mutex_unlock(&opts->lock); 911 912 return result; 913 } 914 915 static ssize_t f_ss_opts_pattern_store(struct config_item *item, 916 const char *page, size_t len) 917 { 918 struct f_ss_opts *opts = to_f_ss_opts(item); 919 int ret; 920 u8 num; 921 922 mutex_lock(&opts->lock); 923 if (opts->refcnt) { 924 ret = -EBUSY; 925 goto end; 926 } 927 928 ret = kstrtou8(page, 0, &num); 929 if (ret) 930 goto end; 931 932 if (num != 0 && num != 1 && num != 2) { 933 ret = -EINVAL; 934 goto end; 935 } 936 937 opts->pattern = num; 938 ret = len; 939 end: 940 mutex_unlock(&opts->lock); 941 return ret; 942 } 943 944 CONFIGFS_ATTR(f_ss_opts_, pattern); 945 946 static ssize_t f_ss_opts_isoc_interval_show(struct config_item *item, char *page) 947 { 948 struct f_ss_opts *opts = to_f_ss_opts(item); 949 int result; 950 951 mutex_lock(&opts->lock); 952 result = sprintf(page, "%u\n", opts->isoc_interval); 953 mutex_unlock(&opts->lock); 954 955 return result; 956 } 957 958 static ssize_t f_ss_opts_isoc_interval_store(struct config_item *item, 959 const char *page, size_t len) 960 { 961 struct f_ss_opts *opts = to_f_ss_opts(item); 962 int ret; 963 u8 num; 964 965 mutex_lock(&opts->lock); 966 if (opts->refcnt) { 967 ret = -EBUSY; 968 goto end; 969 } 970 971 ret = kstrtou8(page, 0, &num); 972 if (ret) 973 goto end; 974 975 if (num > 16) { 976 ret = -EINVAL; 977 goto end; 978 } 979 980 opts->isoc_interval = num; 981 ret = len; 982 end: 983 mutex_unlock(&opts->lock); 984 return ret; 985 } 986 987 CONFIGFS_ATTR(f_ss_opts_, isoc_interval); 988 989 static ssize_t f_ss_opts_isoc_maxpacket_show(struct config_item *item, char *page) 990 { 991 struct f_ss_opts *opts = to_f_ss_opts(item); 992 int result; 993 994 mutex_lock(&opts->lock); 995 result = sprintf(page, "%u\n", opts->isoc_maxpacket); 996 mutex_unlock(&opts->lock); 997 998 return result; 999 } 1000 1001 static ssize_t f_ss_opts_isoc_maxpacket_store(struct config_item *item, 1002 const char *page, size_t len) 1003 { 1004 struct f_ss_opts *opts = to_f_ss_opts(item); 1005 int ret; 1006 u16 num; 1007 1008 mutex_lock(&opts->lock); 1009 if (opts->refcnt) { 1010 ret = -EBUSY; 1011 goto end; 1012 } 1013 1014 ret = kstrtou16(page, 0, &num); 1015 if (ret) 1016 goto end; 1017 1018 if (num > 1024) { 1019 ret = -EINVAL; 1020 goto end; 1021 } 1022 1023 opts->isoc_maxpacket = num; 1024 ret = len; 1025 end: 1026 mutex_unlock(&opts->lock); 1027 return ret; 1028 } 1029 1030 CONFIGFS_ATTR(f_ss_opts_, isoc_maxpacket); 1031 1032 static ssize_t f_ss_opts_isoc_mult_show(struct config_item *item, char *page) 1033 { 1034 struct f_ss_opts *opts = to_f_ss_opts(item); 1035 int result; 1036 1037 mutex_lock(&opts->lock); 1038 result = sprintf(page, "%u\n", opts->isoc_mult); 1039 mutex_unlock(&opts->lock); 1040 1041 return result; 1042 } 1043 1044 static ssize_t f_ss_opts_isoc_mult_store(struct config_item *item, 1045 const char *page, size_t len) 1046 { 1047 struct f_ss_opts *opts = to_f_ss_opts(item); 1048 int ret; 1049 u8 num; 1050 1051 mutex_lock(&opts->lock); 1052 if (opts->refcnt) { 1053 ret = -EBUSY; 1054 goto end; 1055 } 1056 1057 ret = kstrtou8(page, 0, &num); 1058 if (ret) 1059 goto end; 1060 1061 if (num > 2) { 1062 ret = -EINVAL; 1063 goto end; 1064 } 1065 1066 opts->isoc_mult = num; 1067 ret = len; 1068 end: 1069 mutex_unlock(&opts->lock); 1070 return ret; 1071 } 1072 1073 CONFIGFS_ATTR(f_ss_opts_, isoc_mult); 1074 1075 static ssize_t f_ss_opts_isoc_maxburst_show(struct config_item *item, char *page) 1076 { 1077 struct f_ss_opts *opts = to_f_ss_opts(item); 1078 int result; 1079 1080 mutex_lock(&opts->lock); 1081 result = sprintf(page, "%u\n", opts->isoc_maxburst); 1082 mutex_unlock(&opts->lock); 1083 1084 return result; 1085 } 1086 1087 static ssize_t f_ss_opts_isoc_maxburst_store(struct config_item *item, 1088 const char *page, size_t len) 1089 { 1090 struct f_ss_opts *opts = to_f_ss_opts(item); 1091 int ret; 1092 u8 num; 1093 1094 mutex_lock(&opts->lock); 1095 if (opts->refcnt) { 1096 ret = -EBUSY; 1097 goto end; 1098 } 1099 1100 ret = kstrtou8(page, 0, &num); 1101 if (ret) 1102 goto end; 1103 1104 if (num > 15) { 1105 ret = -EINVAL; 1106 goto end; 1107 } 1108 1109 opts->isoc_maxburst = num; 1110 ret = len; 1111 end: 1112 mutex_unlock(&opts->lock); 1113 return ret; 1114 } 1115 1116 CONFIGFS_ATTR(f_ss_opts_, isoc_maxburst); 1117 1118 static ssize_t f_ss_opts_bulk_buflen_show(struct config_item *item, char *page) 1119 { 1120 struct f_ss_opts *opts = to_f_ss_opts(item); 1121 int result; 1122 1123 mutex_lock(&opts->lock); 1124 result = sprintf(page, "%u\n", opts->bulk_buflen); 1125 mutex_unlock(&opts->lock); 1126 1127 return result; 1128 } 1129 1130 static ssize_t f_ss_opts_bulk_buflen_store(struct config_item *item, 1131 const char *page, size_t len) 1132 { 1133 struct f_ss_opts *opts = to_f_ss_opts(item); 1134 int ret; 1135 u32 num; 1136 1137 mutex_lock(&opts->lock); 1138 if (opts->refcnt) { 1139 ret = -EBUSY; 1140 goto end; 1141 } 1142 1143 ret = kstrtou32(page, 0, &num); 1144 if (ret) 1145 goto end; 1146 1147 opts->bulk_buflen = num; 1148 ret = len; 1149 end: 1150 mutex_unlock(&opts->lock); 1151 return ret; 1152 } 1153 1154 CONFIGFS_ATTR(f_ss_opts_, bulk_buflen); 1155 1156 static struct configfs_attribute *ss_attrs[] = { 1157 &f_ss_opts_attr_pattern, 1158 &f_ss_opts_attr_isoc_interval, 1159 &f_ss_opts_attr_isoc_maxpacket, 1160 &f_ss_opts_attr_isoc_mult, 1161 &f_ss_opts_attr_isoc_maxburst, 1162 &f_ss_opts_attr_bulk_buflen, 1163 NULL, 1164 }; 1165 1166 static struct config_item_type ss_func_type = { 1167 .ct_item_ops = &ss_item_ops, 1168 .ct_attrs = ss_attrs, 1169 .ct_owner = THIS_MODULE, 1170 }; 1171 1172 static void source_sink_free_instance(struct usb_function_instance *fi) 1173 { 1174 struct f_ss_opts *ss_opts; 1175 1176 ss_opts = container_of(fi, struct f_ss_opts, func_inst); 1177 kfree(ss_opts); 1178 } 1179 1180 static struct usb_function_instance *source_sink_alloc_inst(void) 1181 { 1182 struct f_ss_opts *ss_opts; 1183 1184 ss_opts = kzalloc(sizeof(*ss_opts), GFP_KERNEL); 1185 if (!ss_opts) 1186 return ERR_PTR(-ENOMEM); 1187 mutex_init(&ss_opts->lock); 1188 ss_opts->func_inst.free_func_inst = source_sink_free_instance; 1189 ss_opts->isoc_interval = GZERO_ISOC_INTERVAL; 1190 ss_opts->isoc_maxpacket = GZERO_ISOC_MAXPACKET; 1191 ss_opts->bulk_buflen = GZERO_BULK_BUFLEN; 1192 1193 config_group_init_type_name(&ss_opts->func_inst.group, "", 1194 &ss_func_type); 1195 1196 return &ss_opts->func_inst; 1197 } 1198 DECLARE_USB_FUNCTION(SourceSink, source_sink_alloc_inst, 1199 source_sink_alloc_func); 1200 1201 static int __init sslb_modinit(void) 1202 { 1203 int ret; 1204 1205 ret = usb_function_register(&SourceSinkusb_func); 1206 if (ret) 1207 return ret; 1208 ret = lb_modinit(); 1209 if (ret) 1210 usb_function_unregister(&SourceSinkusb_func); 1211 return ret; 1212 } 1213 static void __exit sslb_modexit(void) 1214 { 1215 usb_function_unregister(&SourceSinkusb_func); 1216 lb_modexit(); 1217 } 1218 module_init(sslb_modinit); 1219 module_exit(sslb_modexit); 1220 1221 MODULE_LICENSE("GPL"); 1222