usb_generic.c revision 187180
1/* $FreeBSD: head/sys/dev/usb2/core/usb2_generic.c 187180 2009-01-13 19:04:58Z thompsa $ */ 2/*- 3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <dev/usb2/include/usb2_defs.h> 28#include <dev/usb2/include/usb2_mfunc.h> 29#include <dev/usb2/include/usb2_standard.h> 30#include <dev/usb2/include/usb2_ioctl.h> 31#include <dev/usb2/include/usb2_error.h> 32 33#define USB_DEBUG_VAR ugen_debug 34 35#include <dev/usb2/core/usb2_core.h> 36#include <dev/usb2/core/usb2_mbuf.h> 37#include <dev/usb2/core/usb2_dev.h> 38#include <dev/usb2/core/usb2_process.h> 39#include <dev/usb2/core/usb2_device.h> 40#include <dev/usb2/core/usb2_debug.h> 41#include <dev/usb2/core/usb2_request.h> 42#include <dev/usb2/core/usb2_busdma.h> 43#include <dev/usb2/core/usb2_util.h> 44#include <dev/usb2/core/usb2_hub.h> 45#include <dev/usb2/core/usb2_generic.h> 46#include <dev/usb2/core/usb2_transfer.h> 47 48#include <dev/usb2/controller/usb2_controller.h> 49#include <dev/usb2/controller/usb2_bus.h> 50 51/* defines */ 52 53#define UGEN_BULK_FS_BUFFER_SIZE (64*32) /* bytes */ 54#define UGEN_BULK_HS_BUFFER_SIZE (1024*32) /* bytes */ 55#define UGEN_HW_FRAMES 50 /* number of milliseconds per transfer */ 56 57/* function prototypes */ 58 59static usb2_callback_t ugen_read_clear_stall_callback; 60static usb2_callback_t ugen_write_clear_stall_callback; 61static usb2_callback_t ugen_default_read_callback; 62static usb2_callback_t ugen_default_write_callback; 63static usb2_callback_t ugen_isoc_read_callback; 64static usb2_callback_t ugen_isoc_write_callback; 65static usb2_callback_t ugen_default_fs_callback; 66 67static usb2_fifo_open_t ugen_open; 68static usb2_fifo_close_t ugen_close; 69static usb2_fifo_ioctl_t ugen_ioctl; 70static usb2_fifo_ioctl_t ugen_ioctl_post; 71static usb2_fifo_cmd_t ugen_start_read; 72static usb2_fifo_cmd_t ugen_start_write; 73static usb2_fifo_cmd_t ugen_stop_io; 74 75static int ugen_transfer_setup(struct usb2_fifo *, 76 const struct usb2_config *, uint8_t); 77static int ugen_open_pipe_write(struct usb2_fifo *); 78static int ugen_open_pipe_read(struct usb2_fifo *); 79static int ugen_set_config(struct usb2_fifo *, uint8_t); 80static int ugen_set_interface(struct usb2_fifo *, uint8_t, uint8_t); 81static int ugen_get_cdesc(struct usb2_fifo *, struct usb2_gen_descriptor *); 82static int ugen_get_sdesc(struct usb2_fifo *, struct usb2_gen_descriptor *); 83static int usb2_gen_fill_deviceinfo(struct usb2_fifo *, 84 struct usb2_device_info *); 85static int ugen_re_enumerate(struct usb2_fifo *); 86static int ugen_iface_ioctl(struct usb2_fifo *, u_long, void *, int); 87static uint8_t ugen_fs_get_complete(struct usb2_fifo *, uint8_t *); 88static int ugen_fs_uninit(struct usb2_fifo *f); 89 90/* structures */ 91 92struct usb2_fifo_methods usb2_ugen_methods = { 93 .f_open = &ugen_open, 94 .f_close = &ugen_close, 95 .f_ioctl = &ugen_ioctl, 96 .f_ioctl_post = &ugen_ioctl_post, 97 .f_start_read = &ugen_start_read, 98 .f_stop_read = &ugen_stop_io, 99 .f_start_write = &ugen_start_write, 100 .f_stop_write = &ugen_stop_io, 101}; 102 103#if USB_DEBUG 104static int ugen_debug = 0; 105 106SYSCTL_NODE(_hw_usb2, OID_AUTO, ugen, CTLFLAG_RW, 0, "USB generic"); 107SYSCTL_INT(_hw_usb2_ugen, OID_AUTO, debug, CTLFLAG_RW, &ugen_debug, 108 0, "Debug level"); 109#endif 110 111 112/* prototypes */ 113 114static int 115ugen_transfer_setup(struct usb2_fifo *f, 116 const struct usb2_config *setup, uint8_t n_setup) 117{ 118 struct usb2_pipe *pipe = f->priv_sc0; 119 struct usb2_device *udev = f->udev; 120 uint8_t iface_index = pipe->iface_index; 121 int error; 122 123 mtx_unlock(f->priv_mtx); 124 125 /* 126 * "usb2_transfer_setup()" can sleep so one needs to make a wrapper, 127 * exiting the mutex and checking things 128 */ 129 error = usb2_transfer_setup(udev, &iface_index, f->xfer, 130 setup, n_setup, f, f->priv_mtx); 131 if (error == 0) { 132 133 if (f->xfer[0]->nframes == 1) { 134 error = usb2_fifo_alloc_buffer(f, 135 f->xfer[0]->max_data_length, 2); 136 } else { 137 error = usb2_fifo_alloc_buffer(f, 138 f->xfer[0]->max_frame_size, 139 2 * f->xfer[0]->nframes); 140 } 141 if (error) { 142 usb2_transfer_unsetup(f->xfer, n_setup); 143 } 144 } 145 mtx_lock(f->priv_mtx); 146 147 return (error); 148} 149 150static int 151ugen_open(struct usb2_fifo *f, int fflags, struct thread *td) 152{ 153 struct usb2_pipe *pipe = f->priv_sc0; 154 struct usb2_endpoint_descriptor *ed = pipe->edesc; 155 uint8_t type; 156 157 DPRINTFN(6, "flag=0x%x\n", fflags); 158 159 mtx_lock(f->priv_mtx); 160 switch (usb2_get_speed(f->udev)) { 161 case USB_SPEED_LOW: 162 case USB_SPEED_FULL: 163 f->nframes = UGEN_HW_FRAMES; 164 f->bufsize = UGEN_BULK_FS_BUFFER_SIZE; 165 break; 166 default: 167 f->nframes = UGEN_HW_FRAMES * 8; 168 f->bufsize = UGEN_BULK_HS_BUFFER_SIZE; 169 break; 170 } 171 172 type = ed->bmAttributes & UE_XFERTYPE; 173 if (type == UE_INTERRUPT) { 174 f->bufsize = 0; /* use "wMaxPacketSize" */ 175 } 176 f->timeout = USB_NO_TIMEOUT; 177 f->flag_short = 0; 178 f->fifo_zlp = 0; 179 mtx_unlock(f->priv_mtx); 180 181 return (0); 182} 183 184static void 185ugen_close(struct usb2_fifo *f, int fflags, struct thread *td) 186{ 187 DPRINTFN(6, "flag=0x%x\n", fflags); 188 189 /* cleanup */ 190 191 mtx_lock(f->priv_mtx); 192 usb2_transfer_stop(f->xfer[0]); 193 usb2_transfer_stop(f->xfer[1]); 194 mtx_unlock(f->priv_mtx); 195 196 usb2_transfer_unsetup(f->xfer, 2); 197 usb2_fifo_free_buffer(f); 198 199 if (ugen_fs_uninit(f)) { 200 /* ignore any errors - we are closing */ 201 DPRINTFN(6, "no FIFOs\n"); 202 } 203} 204 205static int 206ugen_open_pipe_write(struct usb2_fifo *f) 207{ 208 struct usb2_config usb2_config[2]; 209 struct usb2_pipe *pipe = f->priv_sc0; 210 struct usb2_endpoint_descriptor *ed = pipe->edesc; 211 212 mtx_assert(f->priv_mtx, MA_OWNED); 213 214 if (f->xfer[0] || f->xfer[1]) { 215 /* transfers are already opened */ 216 return (0); 217 } 218 bzero(usb2_config, sizeof(usb2_config)); 219 220 usb2_config[1].type = UE_CONTROL; 221 usb2_config[1].endpoint = 0; 222 usb2_config[1].direction = UE_DIR_ANY; 223 usb2_config[1].mh.timeout = 1000; /* 1 second */ 224 usb2_config[1].mh.interval = 50;/* 50 milliseconds */ 225 usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request); 226 usb2_config[1].mh.callback = &ugen_write_clear_stall_callback; 227 228 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; 229 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 230 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN); 231 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; 232 usb2_config[0].mh.flags.proxy_buffer = 1; 233 234 switch (ed->bmAttributes & UE_XFERTYPE) { 235 case UE_INTERRUPT: 236 case UE_BULK: 237 if (f->flag_short) { 238 usb2_config[0].mh.flags.force_short_xfer = 1; 239 } 240 usb2_config[0].mh.callback = &ugen_default_write_callback; 241 usb2_config[0].mh.timeout = f->timeout; 242 usb2_config[0].mh.frames = 1; 243 usb2_config[0].mh.bufsize = f->bufsize; 244 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 245 if (ugen_transfer_setup(f, usb2_config, 2)) { 246 return (EIO); 247 } 248 /* first transfer does not clear stall */ 249 f->flag_stall = 0; 250 break; 251 252 case UE_ISOCHRONOUS: 253 usb2_config[0].mh.flags.short_xfer_ok = 1; 254 usb2_config[0].mh.bufsize = 0; /* use default */ 255 usb2_config[0].mh.frames = f->nframes; 256 usb2_config[0].mh.callback = &ugen_isoc_write_callback; 257 usb2_config[0].mh.timeout = 0; 258 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 259 260 /* clone configuration */ 261 usb2_config[1] = usb2_config[0]; 262 263 if (ugen_transfer_setup(f, usb2_config, 2)) { 264 return (EIO); 265 } 266 break; 267 default: 268 return (EINVAL); 269 } 270 return (0); 271} 272 273static int 274ugen_open_pipe_read(struct usb2_fifo *f) 275{ 276 struct usb2_config usb2_config[2]; 277 struct usb2_pipe *pipe = f->priv_sc0; 278 struct usb2_endpoint_descriptor *ed = pipe->edesc; 279 280 mtx_assert(f->priv_mtx, MA_OWNED); 281 282 if (f->xfer[0] || f->xfer[1]) { 283 /* transfers are already opened */ 284 return (0); 285 } 286 bzero(usb2_config, sizeof(usb2_config)); 287 288 usb2_config[1].type = UE_CONTROL; 289 usb2_config[1].endpoint = 0; 290 usb2_config[1].direction = UE_DIR_ANY; 291 usb2_config[1].mh.timeout = 1000; /* 1 second */ 292 usb2_config[1].mh.interval = 50;/* 50 milliseconds */ 293 usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request); 294 usb2_config[1].mh.callback = &ugen_read_clear_stall_callback; 295 296 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; 297 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 298 usb2_config[0].direction = UE_DIR_IN; 299 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; 300 usb2_config[0].mh.flags.proxy_buffer = 1; 301 302 switch (ed->bmAttributes & UE_XFERTYPE) { 303 case UE_INTERRUPT: 304 case UE_BULK: 305 if (f->flag_short) { 306 usb2_config[0].mh.flags.short_xfer_ok = 1; 307 } 308 usb2_config[0].mh.timeout = f->timeout; 309 usb2_config[0].mh.frames = 1; 310 usb2_config[0].mh.callback = &ugen_default_read_callback; 311 usb2_config[0].mh.bufsize = f->bufsize; 312 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 313 314 if (ugen_transfer_setup(f, usb2_config, 2)) { 315 return (EIO); 316 } 317 /* first transfer does not clear stall */ 318 f->flag_stall = 0; 319 break; 320 321 case UE_ISOCHRONOUS: 322 usb2_config[0].mh.flags.short_xfer_ok = 1; 323 usb2_config[0].mh.bufsize = 0; /* use default */ 324 usb2_config[0].mh.frames = f->nframes; 325 usb2_config[0].mh.callback = &ugen_isoc_read_callback; 326 usb2_config[0].mh.timeout = 0; 327 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 328 329 /* clone configuration */ 330 usb2_config[1] = usb2_config[0]; 331 332 if (ugen_transfer_setup(f, usb2_config, 2)) { 333 return (EIO); 334 } 335 break; 336 337 default: 338 return (EINVAL); 339 } 340 return (0); 341} 342 343static void 344ugen_start_read(struct usb2_fifo *f) 345{ 346 /* check that pipes are open */ 347 if (ugen_open_pipe_read(f)) { 348 /* signal error */ 349 usb2_fifo_put_data_error(f); 350 } 351 /* start transfers */ 352 usb2_transfer_start(f->xfer[0]); 353 usb2_transfer_start(f->xfer[1]); 354} 355 356static void 357ugen_start_write(struct usb2_fifo *f) 358{ 359 /* check that pipes are open */ 360 if (ugen_open_pipe_write(f)) { 361 /* signal error */ 362 usb2_fifo_get_data_error(f); 363 } 364 /* start transfers */ 365 usb2_transfer_start(f->xfer[0]); 366 usb2_transfer_start(f->xfer[1]); 367} 368 369static void 370ugen_stop_io(struct usb2_fifo *f) 371{ 372 /* stop transfers */ 373 usb2_transfer_stop(f->xfer[0]); 374 usb2_transfer_stop(f->xfer[1]); 375} 376 377static void 378ugen_default_read_callback(struct usb2_xfer *xfer) 379{ 380 struct usb2_fifo *f = xfer->priv_sc; 381 struct usb2_mbuf *m; 382 383 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 384 385 switch (USB_GET_STATE(xfer)) { 386 case USB_ST_TRANSFERRED: 387 if (xfer->actlen == 0) { 388 if (f->fifo_zlp != 4) { 389 f->fifo_zlp++; 390 } else { 391 /* 392 * Throttle a little bit we have multiple ZLPs 393 * in a row! 394 */ 395 xfer->interval = 64; /* ms */ 396 } 397 } else { 398 /* clear throttle */ 399 xfer->interval = 0; 400 f->fifo_zlp = 0; 401 } 402 usb2_fifo_put_data(f, xfer->frbuffers, 0, 403 xfer->actlen, 1); 404 405 case USB_ST_SETUP: 406 if (f->flag_stall) { 407 usb2_transfer_start(f->xfer[1]); 408 break; 409 } 410 USB_IF_POLL(&f->free_q, m); 411 if (m) { 412 xfer->frlengths[0] = xfer->max_data_length; 413 usb2_start_hardware(xfer); 414 } 415 break; 416 417 default: /* Error */ 418 if (xfer->error != USB_ERR_CANCELLED) { 419 f->flag_stall = 1; 420 f->fifo_zlp = 0; 421 usb2_transfer_start(f->xfer[1]); 422 } 423 break; 424 } 425} 426 427static void 428ugen_default_write_callback(struct usb2_xfer *xfer) 429{ 430 struct usb2_fifo *f = xfer->priv_sc; 431 uint32_t actlen; 432 433 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 434 435 switch (USB_GET_STATE(xfer)) { 436 case USB_ST_SETUP: 437 case USB_ST_TRANSFERRED: 438 /* 439 * If writing is in stall, just jump to clear stall 440 * callback and solve the situation. 441 */ 442 if (f->flag_stall) { 443 usb2_transfer_start(f->xfer[1]); 444 break; 445 } 446 /* 447 * Write data, setup and perform hardware transfer. 448 */ 449 if (usb2_fifo_get_data(f, xfer->frbuffers, 0, 450 xfer->max_data_length, &actlen, 0)) { 451 xfer->frlengths[0] = actlen; 452 usb2_start_hardware(xfer); 453 } 454 break; 455 456 default: /* Error */ 457 if (xfer->error != USB_ERR_CANCELLED) { 458 f->flag_stall = 1; 459 usb2_transfer_start(f->xfer[1]); 460 } 461 break; 462 } 463} 464 465static void 466ugen_read_clear_stall_callback(struct usb2_xfer *xfer) 467{ 468 struct usb2_fifo *f = xfer->priv_sc; 469 struct usb2_xfer *xfer_other = f->xfer[0]; 470 471 if (f->flag_stall == 0) { 472 /* nothing to do */ 473 return; 474 } 475 if (usb2_clear_stall_callback(xfer, xfer_other)) { 476 DPRINTFN(5, "f=%p: stall cleared\n", f); 477 f->flag_stall = 0; 478 usb2_transfer_start(xfer_other); 479 } 480} 481 482static void 483ugen_write_clear_stall_callback(struct usb2_xfer *xfer) 484{ 485 struct usb2_fifo *f = xfer->priv_sc; 486 struct usb2_xfer *xfer_other = f->xfer[0]; 487 488 if (f->flag_stall == 0) { 489 /* nothing to do */ 490 return; 491 } 492 if (usb2_clear_stall_callback(xfer, xfer_other)) { 493 DPRINTFN(5, "f=%p: stall cleared\n", f); 494 f->flag_stall = 0; 495 usb2_transfer_start(xfer_other); 496 } 497} 498 499static void 500ugen_isoc_read_callback(struct usb2_xfer *xfer) 501{ 502 struct usb2_fifo *f = xfer->priv_sc; 503 uint32_t offset; 504 uint16_t n; 505 506 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 507 508 switch (USB_GET_STATE(xfer)) { 509 case USB_ST_TRANSFERRED: 510 511 DPRINTFN(6, "actlen=%d\n", xfer->actlen); 512 513 offset = 0; 514 515 for (n = 0; n != xfer->aframes; n++) { 516 usb2_fifo_put_data(f, xfer->frbuffers, offset, 517 xfer->frlengths[n], 1); 518 offset += xfer->max_frame_size; 519 } 520 521 case USB_ST_SETUP: 522tr_setup: 523 for (n = 0; n != xfer->nframes; n++) { 524 /* setup size for next transfer */ 525 xfer->frlengths[n] = xfer->max_frame_size; 526 } 527 usb2_start_hardware(xfer); 528 break; 529 530 default: /* Error */ 531 if (xfer->error == USB_ERR_CANCELLED) { 532 break; 533 } 534 goto tr_setup; 535 } 536} 537 538static void 539ugen_isoc_write_callback(struct usb2_xfer *xfer) 540{ 541 struct usb2_fifo *f = xfer->priv_sc; 542 uint32_t actlen; 543 uint32_t offset; 544 uint16_t n; 545 546 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 547 548 switch (USB_GET_STATE(xfer)) { 549 case USB_ST_TRANSFERRED: 550 case USB_ST_SETUP: 551tr_setup: 552 offset = 0; 553 for (n = 0; n != xfer->nframes; n++) { 554 if (usb2_fifo_get_data(f, xfer->frbuffers, offset, 555 xfer->max_frame_size, &actlen, 1)) { 556 xfer->frlengths[n] = actlen; 557 offset += actlen; 558 } else { 559 break; 560 } 561 } 562 563 for (; n != xfer->nframes; n++) { 564 /* fill in zero frames */ 565 xfer->frlengths[n] = 0; 566 } 567 usb2_start_hardware(xfer); 568 break; 569 570 default: /* Error */ 571 if (xfer->error == USB_ERR_CANCELLED) { 572 break; 573 } 574 goto tr_setup; 575 } 576} 577 578static int 579ugen_set_config(struct usb2_fifo *f, uint8_t index) 580{ 581 DPRINTFN(2, "index %u\n", index); 582 583 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 584 /* not possible in device side mode */ 585 return (ENOTTY); 586 } 587 if (f->udev->curr_config_index == index) { 588 /* no change needed */ 589 return (0); 590 } 591 /* make sure all FIFO's are gone */ 592 /* else there can be a deadlock */ 593 if (ugen_fs_uninit(f)) { 594 /* ignore any errors */ 595 DPRINTFN(6, "no FIFOs\n"); 596 } 597 /* change setting - will free generic FIFOs, if any */ 598 if (usb2_set_config_index(f->udev, index)) { 599 return (EIO); 600 } 601 /* probe and attach */ 602 if (usb2_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) { 603 return (EIO); 604 } 605 return (0); 606} 607 608static int 609ugen_set_interface(struct usb2_fifo *f, 610 uint8_t iface_index, uint8_t alt_index) 611{ 612 DPRINTFN(2, "%u, %u\n", iface_index, alt_index); 613 614 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 615 /* not possible in device side mode */ 616 return (ENOTTY); 617 } 618 /* make sure all FIFO's are gone */ 619 /* else there can be a deadlock */ 620 if (ugen_fs_uninit(f)) { 621 /* ignore any errors */ 622 DPRINTFN(6, "no FIFOs\n"); 623 } 624 /* change setting - will free generic FIFOs, if any */ 625 if (usb2_set_alt_interface_index(f->udev, iface_index, alt_index)) { 626 return (EIO); 627 } 628 /* probe and attach */ 629 if (usb2_probe_and_attach(f->udev, iface_index)) { 630 return (EIO); 631 } 632 return (0); 633} 634 635/*------------------------------------------------------------------------* 636 * ugen_get_cdesc 637 * 638 * This function will retrieve the complete configuration descriptor 639 * at the given index. 640 *------------------------------------------------------------------------*/ 641static int 642ugen_get_cdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd) 643{ 644 struct usb2_config_descriptor *cdesc; 645 struct usb2_device *udev = f->udev; 646 int error; 647 uint16_t len; 648 uint8_t free_data; 649 650 DPRINTFN(6, "\n"); 651 652 if (ugd->ugd_data == NULL) { 653 /* userland pointer should not be zero */ 654 return (EINVAL); 655 } 656 if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) || 657 (ugd->ugd_config_index == udev->curr_config_index)) { 658 cdesc = usb2_get_config_descriptor(udev); 659 if (cdesc == NULL) { 660 return (ENXIO); 661 } 662 free_data = 0; 663 664 } else { 665 if (usb2_req_get_config_desc_full(udev, 666 &Giant, &cdesc, M_USBDEV, 667 ugd->ugd_config_index)) { 668 return (ENXIO); 669 } 670 free_data = 1; 671 } 672 673 len = UGETW(cdesc->wTotalLength); 674 if (len > ugd->ugd_maxlen) { 675 len = ugd->ugd_maxlen; 676 } 677 DPRINTFN(6, "len=%u\n", len); 678 679 ugd->ugd_actlen = len; 680 ugd->ugd_offset = 0; 681 682 error = copyout(cdesc, ugd->ugd_data, len); 683 684 if (free_data) { 685 free(cdesc, M_USBDEV); 686 } 687 return (error); 688} 689 690static int 691ugen_get_sdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd) 692{ 693 void *ptr = f->udev->bus->scratch[0].data; 694 uint16_t size = sizeof(f->udev->bus->scratch[0].data); 695 int error; 696 697 if (usb2_req_get_string_desc(f->udev, &Giant, ptr, 698 size, ugd->ugd_lang_id, ugd->ugd_string_index)) { 699 error = EINVAL; 700 } else { 701 702 if (size > ((uint8_t *)ptr)[0]) { 703 size = ((uint8_t *)ptr)[0]; 704 } 705 if (size > ugd->ugd_maxlen) { 706 size = ugd->ugd_maxlen; 707 } 708 ugd->ugd_actlen = size; 709 ugd->ugd_offset = 0; 710 711 error = copyout(ptr, ugd->ugd_data, size); 712 } 713 return (error); 714} 715 716/*------------------------------------------------------------------------* 717 * usb2_gen_fill_devicenames 718 * 719 * This function dumps information about an USB device names to 720 * userland. 721 * 722 * Returns: 723 * 0: Success 724 * Else: Failure 725 *------------------------------------------------------------------------*/ 726static int 727usb2_gen_fill_devicenames(struct usb2_fifo *f, struct usb2_device_names *dn) 728{ 729 struct usb2_interface *iface; 730 const char *ptr; 731 char *dst; 732 char buf[32]; 733 int error = 0; 734 int len; 735 int max_len; 736 uint8_t i; 737 uint8_t first = 1; 738 739 max_len = dn->udn_devnames_len; 740 dst = dn->udn_devnames_ptr; 741 742 if (max_len == 0) { 743 return (EINVAL); 744 } 745 /* put a zero there */ 746 error = copyout("", dst, 1); 747 if (error) { 748 return (error); 749 } 750 for (i = 0;; i++) { 751 iface = usb2_get_iface(f->udev, i); 752 if (iface == NULL) { 753 break; 754 } 755 if ((iface->subdev != NULL) && 756 device_is_attached(iface->subdev)) { 757 ptr = device_get_nameunit(iface->subdev); 758 if (!first) { 759 strlcpy(buf, ", ", sizeof(buf)); 760 } else { 761 buf[0] = 0; 762 } 763 strlcat(buf, ptr, sizeof(buf)); 764 len = strlen(buf) + 1; 765 if (len > max_len) { 766 break; 767 } 768 error = copyout(buf, dst, len); 769 if (error) { 770 return (error); 771 } 772 len--; 773 dst += len; 774 max_len -= len; 775 first = 0; 776 } 777 } 778 return (0); 779} 780 781/*------------------------------------------------------------------------* 782 * usb2_gen_fill_deviceinfo 783 * 784 * This function dumps information about an USB device to the 785 * structure pointed to by the "di" argument. 786 * 787 * Returns: 788 * 0: Success 789 * Else: Failure 790 *------------------------------------------------------------------------*/ 791static int 792usb2_gen_fill_deviceinfo(struct usb2_fifo *f, struct usb2_device_info *di) 793{ 794 struct usb2_device *udev; 795 struct usb2_device *hub; 796 797 udev = f->udev; 798 799 bzero(di, sizeof(di[0])); 800 801 di->udi_bus = device_get_unit(udev->bus->bdev); 802 di->udi_addr = udev->address; 803 di->udi_index = udev->device_index; 804 strlcpy(di->udi_serial, udev->serial, 805 sizeof(di->udi_serial)); 806 strlcpy(di->udi_vendor, udev->manufacturer, 807 sizeof(di->udi_vendor)); 808 strlcpy(di->udi_product, udev->product, 809 sizeof(di->udi_product)); 810 usb2_printBCD(di->udi_release, sizeof(di->udi_release), 811 UGETW(udev->ddesc.bcdDevice)); 812 di->udi_vendorNo = UGETW(udev->ddesc.idVendor); 813 di->udi_productNo = UGETW(udev->ddesc.idProduct); 814 di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice); 815 di->udi_class = udev->ddesc.bDeviceClass; 816 di->udi_subclass = udev->ddesc.bDeviceSubClass; 817 di->udi_protocol = udev->ddesc.bDeviceProtocol; 818 di->udi_config_no = udev->curr_config_no; 819 di->udi_config_index = udev->curr_config_index; 820 di->udi_power = udev->flags.self_powered ? 0 : udev->power; 821 di->udi_speed = udev->speed; 822 di->udi_mode = udev->flags.usb2_mode; 823 di->udi_power_mode = udev->power_mode; 824 if (udev->flags.suspended) { 825 di->udi_suspended = 1; 826 } else { 827 di->udi_suspended = 0; 828 } 829 830 hub = udev->parent_hub; 831 if (hub) { 832 di->udi_hubaddr = hub->address; 833 di->udi_hubindex = hub->device_index; 834 di->udi_hubport = udev->port_no; 835 } 836 return (0); 837} 838 839/*------------------------------------------------------------------------* 840 * ugen_check_request 841 * 842 * Return values: 843 * 0: Access allowed 844 * Else: No access 845 *------------------------------------------------------------------------*/ 846static int 847ugen_check_request(struct usb2_device *udev, struct usb2_device_request *req) 848{ 849 struct usb2_pipe *pipe; 850 int error; 851 852 /* 853 * Avoid requests that would damage the bus integrity: 854 */ 855 if (((req->bmRequestType == UT_WRITE_DEVICE) && 856 (req->bRequest == UR_SET_ADDRESS)) || 857 ((req->bmRequestType == UT_WRITE_DEVICE) && 858 (req->bRequest == UR_SET_CONFIG)) || 859 ((req->bmRequestType == UT_WRITE_INTERFACE) && 860 (req->bRequest == UR_SET_INTERFACE))) { 861 /* 862 * These requests can be useful for testing USB drivers. 863 */ 864 error = priv_check(curthread, PRIV_DRIVER); 865 if (error) { 866 return (error); 867 } 868 } 869 /* 870 * Special case - handle clearing of stall 871 */ 872 if (req->bmRequestType == UT_WRITE_ENDPOINT) { 873 874 pipe = usb2_get_pipe_by_addr(udev, req->wIndex[0]); 875 if (pipe == NULL) { 876 return (EINVAL); 877 } 878 if (usb2_check_thread_perm(udev, curthread, FREAD | FWRITE, 879 pipe->iface_index, req->wIndex[0] & UE_ADDR)) { 880 return (EPERM); 881 } 882 if ((req->bRequest == UR_CLEAR_FEATURE) && 883 (UGETW(req->wValue) == UF_ENDPOINT_HALT)) { 884 usb2_clear_data_toggle(udev, pipe); 885 } 886 } 887 /* TODO: add more checks to verify the interface index */ 888 889 return (0); 890} 891 892int 893ugen_do_request(struct usb2_fifo *f, struct usb2_ctl_request *ur) 894{ 895 int error; 896 uint16_t len; 897 uint16_t actlen; 898 899 if (ugen_check_request(f->udev, &ur->ucr_request)) { 900 return (EPERM); 901 } 902 len = UGETW(ur->ucr_request.wLength); 903 904 /* check if "ucr_data" is valid */ 905 if (len != 0) { 906 if (ur->ucr_data == NULL) { 907 return (EFAULT); 908 } 909 } 910 /* do the USB request */ 911 error = usb2_do_request_flags 912 (f->udev, NULL, &ur->ucr_request, ur->ucr_data, 913 (ur->ucr_flags & USB_SHORT_XFER_OK) | 914 USB_USER_DATA_PTR, &actlen, 915 USB_DEFAULT_TIMEOUT); 916 917 ur->ucr_actlen = actlen; 918 919 if (error) { 920 error = EIO; 921 } 922 return (error); 923} 924 925/*------------------------------------------------------------------------ 926 * ugen_re_enumerate 927 *------------------------------------------------------------------------*/ 928static int 929ugen_re_enumerate(struct usb2_fifo *f) 930{ 931 struct usb2_device *udev = f->udev; 932 int error; 933 934 /* 935 * This request can be useful for testing USB drivers: 936 */ 937 error = priv_check(curthread, PRIV_DRIVER); 938 if (error) { 939 return (error); 940 } 941 /* get the device unconfigured */ 942 error = ugen_set_config(f, USB_UNCONFIG_INDEX); 943 if (error) { 944 return (error); 945 } 946 /* do a bus-reset */ 947 mtx_lock(f->priv_mtx); 948 error = usb2_req_re_enumerate(udev, f->priv_mtx); 949 mtx_unlock(f->priv_mtx); 950 951 if (error) { 952 return (ENXIO); 953 } 954 /* restore configuration to index 0 */ 955 error = ugen_set_config(f, 0); 956 if (error) { 957 return (error); 958 } 959 return (0); 960} 961 962int 963ugen_fs_uninit(struct usb2_fifo *f) 964{ 965 if (f->fs_xfer == NULL) { 966 return (EINVAL); 967 } 968 usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max); 969 free(f->fs_xfer, M_USB); 970 f->fs_xfer = NULL; 971 f->fs_ep_max = 0; 972 f->fs_ep_ptr = NULL; 973 f->flag_iscomplete = 0; 974 usb2_fifo_free_buffer(f); 975 return (0); 976} 977 978static uint8_t 979ugen_fs_get_complete(struct usb2_fifo *f, uint8_t *pindex) 980{ 981 struct usb2_mbuf *m; 982 983 USB_IF_DEQUEUE(&f->used_q, m); 984 985 if (m) { 986 *pindex = *((uint8_t *)(m->cur_data_ptr)); 987 988 USB_IF_ENQUEUE(&f->free_q, m); 989 990 return (0); /* success */ 991 } else { 992 993 *pindex = 0; /* fix compiler warning */ 994 995 f->flag_iscomplete = 0; 996 } 997 return (1); /* failure */ 998} 999 1000static void 1001ugen_fs_set_complete(struct usb2_fifo *f, uint8_t index) 1002{ 1003 struct usb2_mbuf *m; 1004 1005 USB_IF_DEQUEUE(&f->free_q, m); 1006 1007 if (m == NULL) { 1008 /* can happen during close */ 1009 DPRINTF("out of buffers\n"); 1010 return; 1011 } 1012 USB_MBUF_RESET(m); 1013 1014 *((uint8_t *)(m->cur_data_ptr)) = index; 1015 1016 USB_IF_ENQUEUE(&f->used_q, m); 1017 1018 f->flag_iscomplete = 1; 1019 1020 usb2_fifo_wakeup(f); 1021} 1022 1023static int 1024ugen_fs_copy_in(struct usb2_fifo *f, uint8_t ep_index) 1025{ 1026 struct usb2_device_request *req; 1027 struct usb2_xfer *xfer; 1028 struct usb2_fs_endpoint fs_ep; 1029 void *uaddr; /* userland pointer */ 1030 void *kaddr; 1031 uint32_t offset; 1032 uint32_t length; 1033 uint32_t n; 1034 uint32_t rem; 1035 int error; 1036 uint8_t isread; 1037 1038 if (ep_index >= f->fs_ep_max) { 1039 return (EINVAL); 1040 } 1041 xfer = f->fs_xfer[ep_index]; 1042 if (xfer == NULL) { 1043 return (EINVAL); 1044 } 1045 mtx_lock(f->priv_mtx); 1046 if (usb2_transfer_pending(xfer)) { 1047 mtx_unlock(f->priv_mtx); 1048 return (EBUSY); /* should not happen */ 1049 } 1050 mtx_unlock(f->priv_mtx); 1051 1052 error = copyin(f->fs_ep_ptr + 1053 ep_index, &fs_ep, sizeof(fs_ep)); 1054 if (error) { 1055 return (error); 1056 } 1057 /* security checks */ 1058 1059 if (fs_ep.nFrames > xfer->max_frame_count) { 1060 xfer->error = USB_ERR_INVAL; 1061 goto complete; 1062 } 1063 if (fs_ep.nFrames == 0) { 1064 xfer->error = USB_ERR_INVAL; 1065 goto complete; 1066 } 1067 error = copyin(fs_ep.ppBuffer, 1068 &uaddr, sizeof(uaddr)); 1069 if (error) { 1070 return (error); 1071 } 1072 /* reset first frame */ 1073 usb2_set_frame_offset(xfer, 0, 0); 1074 1075 if (xfer->flags_int.control_xfr) { 1076 1077 req = xfer->frbuffers[0].buffer; 1078 1079 error = copyin(fs_ep.pLength, 1080 &length, sizeof(length)); 1081 if (error) { 1082 return (error); 1083 } 1084 if (length >= sizeof(*req)) { 1085 xfer->error = USB_ERR_INVAL; 1086 goto complete; 1087 } 1088 if (length != 0) { 1089 error = copyin(uaddr, req, length); 1090 if (error) { 1091 return (error); 1092 } 1093 } 1094 if (ugen_check_request(f->udev, req)) { 1095 xfer->error = USB_ERR_INVAL; 1096 goto complete; 1097 } 1098 xfer->frlengths[0] = length; 1099 1100 /* Host mode only ! */ 1101 if ((req->bmRequestType & 1102 (UT_READ | UT_WRITE)) == UT_READ) { 1103 isread = 1; 1104 } else { 1105 isread = 0; 1106 } 1107 n = 1; 1108 offset = sizeof(*req); 1109 1110 } else { 1111 /* Device and Host mode */ 1112 if (USB_GET_DATA_ISREAD(xfer)) { 1113 isread = 1; 1114 } else { 1115 isread = 0; 1116 } 1117 n = 0; 1118 offset = 0; 1119 } 1120 1121 rem = xfer->max_data_length; 1122 xfer->nframes = fs_ep.nFrames; 1123 xfer->timeout = fs_ep.timeout; 1124 if (xfer->timeout > 65535) { 1125 xfer->timeout = 65535; 1126 } 1127 if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK) 1128 xfer->flags.short_xfer_ok = 1; 1129 else 1130 xfer->flags.short_xfer_ok = 0; 1131 1132 if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK) 1133 xfer->flags.short_frames_ok = 1; 1134 else 1135 xfer->flags.short_frames_ok = 0; 1136 1137 if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT) 1138 xfer->flags.force_short_xfer = 1; 1139 else 1140 xfer->flags.force_short_xfer = 0; 1141 1142 if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL) 1143 xfer->flags.stall_pipe = 1; 1144 else 1145 xfer->flags.stall_pipe = 0; 1146 1147 for (; n != xfer->nframes; n++) { 1148 1149 error = copyin(fs_ep.pLength + n, 1150 &length, sizeof(length)); 1151 if (error) { 1152 break; 1153 } 1154 xfer->frlengths[n] = length; 1155 1156 if (length > rem) { 1157 xfer->error = USB_ERR_INVAL; 1158 goto complete; 1159 } 1160 rem -= length; 1161 1162 if (!isread) { 1163 1164 /* we need to know the source buffer */ 1165 error = copyin(fs_ep.ppBuffer + n, 1166 &uaddr, sizeof(uaddr)); 1167 if (error) { 1168 break; 1169 } 1170 if (xfer->flags_int.isochronous_xfr) { 1171 /* get kernel buffer address */ 1172 kaddr = xfer->frbuffers[0].buffer; 1173 kaddr = USB_ADD_BYTES(kaddr, offset); 1174 } else { 1175 /* set current frame offset */ 1176 usb2_set_frame_offset(xfer, offset, n); 1177 1178 /* get kernel buffer address */ 1179 kaddr = xfer->frbuffers[n].buffer; 1180 } 1181 1182 /* move data */ 1183 error = copyin(uaddr, kaddr, length); 1184 if (error) { 1185 break; 1186 } 1187 } 1188 offset += length; 1189 } 1190 return (error); 1191 1192complete: 1193 mtx_lock(f->priv_mtx); 1194 ugen_fs_set_complete(f, ep_index); 1195 mtx_unlock(f->priv_mtx); 1196 return (0); 1197} 1198 1199static int 1200ugen_fs_copy_out(struct usb2_fifo *f, uint8_t ep_index) 1201{ 1202 struct usb2_device_request *req; 1203 struct usb2_xfer *xfer; 1204 struct usb2_fs_endpoint fs_ep; 1205 struct usb2_fs_endpoint *fs_ep_uptr; /* userland ptr */ 1206 void *uaddr; /* userland ptr */ 1207 void *kaddr; 1208 uint32_t offset; 1209 uint32_t length; 1210 uint32_t temp; 1211 uint32_t n; 1212 uint32_t rem; 1213 int error; 1214 uint8_t isread; 1215 1216 if (ep_index >= f->fs_ep_max) { 1217 return (EINVAL); 1218 } 1219 xfer = f->fs_xfer[ep_index]; 1220 if (xfer == NULL) { 1221 return (EINVAL); 1222 } 1223 mtx_lock(f->priv_mtx); 1224 if (usb2_transfer_pending(xfer)) { 1225 mtx_unlock(f->priv_mtx); 1226 return (EBUSY); /* should not happen */ 1227 } 1228 mtx_unlock(f->priv_mtx); 1229 1230 fs_ep_uptr = f->fs_ep_ptr + ep_index; 1231 error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep)); 1232 if (error) { 1233 return (error); 1234 } 1235 fs_ep.status = xfer->error; 1236 fs_ep.aFrames = xfer->aframes; 1237 fs_ep.isoc_time_complete = xfer->isoc_time_complete; 1238 if (xfer->error) { 1239 goto complete; 1240 } 1241 if (xfer->flags_int.control_xfr) { 1242 req = xfer->frbuffers[0].buffer; 1243 1244 /* Host mode only ! */ 1245 if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) { 1246 isread = 1; 1247 } else { 1248 isread = 0; 1249 } 1250 if (xfer->nframes == 0) 1251 n = 0; /* should never happen */ 1252 else 1253 n = 1; 1254 } else { 1255 /* Device and Host mode */ 1256 if (USB_GET_DATA_ISREAD(xfer)) { 1257 isread = 1; 1258 } else { 1259 isread = 0; 1260 } 1261 n = 0; 1262 } 1263 1264 /* Update lengths and copy out data */ 1265 1266 rem = xfer->max_data_length; 1267 offset = 0; 1268 1269 for (; n != xfer->nframes; n++) { 1270 1271 /* get initial length into "temp" */ 1272 error = copyin(fs_ep.pLength + n, 1273 &temp, sizeof(temp)); 1274 if (error) { 1275 return (error); 1276 } 1277 if (temp > rem) { 1278 /* the userland length has been corrupted */ 1279 DPRINTF("corrupt userland length " 1280 "%u > %u\n", temp, rem); 1281 fs_ep.status = USB_ERR_INVAL; 1282 goto complete; 1283 } 1284 rem -= temp; 1285 1286 /* get actual transfer length */ 1287 length = xfer->frlengths[n]; 1288 if (length > temp) { 1289 /* data overflow */ 1290 fs_ep.status = USB_ERR_INVAL; 1291 DPRINTF("data overflow %u > %u\n", 1292 length, temp); 1293 goto complete; 1294 } 1295 if (isread) { 1296 1297 /* we need to know the destination buffer */ 1298 error = copyin(fs_ep.ppBuffer + n, 1299 &uaddr, sizeof(uaddr)); 1300 if (error) { 1301 return (error); 1302 } 1303 if (xfer->flags_int.isochronous_xfr) { 1304 /* only one frame buffer */ 1305 kaddr = USB_ADD_BYTES( 1306 xfer->frbuffers[0].buffer, offset); 1307 } else { 1308 /* multiple frame buffers */ 1309 kaddr = xfer->frbuffers[n].buffer; 1310 } 1311 1312 /* move data */ 1313 error = copyout(kaddr, uaddr, length); 1314 if (error) { 1315 return (error); 1316 } 1317 } 1318 /* 1319 * Update offset according to initial length, which is 1320 * needed by isochronous transfers! 1321 */ 1322 offset += temp; 1323 1324 /* update length */ 1325 error = copyout(&length, 1326 fs_ep.pLength + n, sizeof(length)); 1327 if (error) { 1328 return (error); 1329 } 1330 } 1331 1332complete: 1333 /* update "aFrames" */ 1334 error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames, 1335 sizeof(fs_ep.aFrames)); 1336 if (error) 1337 goto done; 1338 1339 /* update "isoc_time_complete" */ 1340 error = copyout(&fs_ep.isoc_time_complete, 1341 &fs_ep_uptr->isoc_time_complete, 1342 sizeof(fs_ep.isoc_time_complete)); 1343 if (error) 1344 goto done; 1345 /* update "status" */ 1346 error = copyout(&fs_ep.status, &fs_ep_uptr->status, 1347 sizeof(fs_ep.status)); 1348done: 1349 return (error); 1350} 1351 1352static uint8_t 1353ugen_fifo_in_use(struct usb2_fifo *f, int fflags) 1354{ 1355 struct usb2_fifo *f_rx; 1356 struct usb2_fifo *f_tx; 1357 1358 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX]; 1359 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX]; 1360 1361 if ((fflags & FREAD) && f_rx && 1362 (f_rx->xfer[0] || f_rx->xfer[1])) { 1363 return (1); /* RX FIFO in use */ 1364 } 1365 if ((fflags & FWRITE) && f_tx && 1366 (f_tx->xfer[0] || f_tx->xfer[1])) { 1367 return (1); /* TX FIFO in use */ 1368 } 1369 return (0); /* not in use */ 1370} 1371 1372static int 1373ugen_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags, 1374 struct thread *td) 1375{ 1376 struct usb2_config usb2_config[1]; 1377 struct usb2_device_request req; 1378 union { 1379 struct usb2_fs_complete *pcomp; 1380 struct usb2_fs_start *pstart; 1381 struct usb2_fs_stop *pstop; 1382 struct usb2_fs_open *popen; 1383 struct usb2_fs_close *pclose; 1384 struct usb2_fs_clear_stall_sync *pstall; 1385 void *addr; 1386 } u; 1387 struct usb2_pipe *pipe; 1388 struct usb2_endpoint_descriptor *ed; 1389 int error = 0; 1390 uint8_t iface_index; 1391 uint8_t isread; 1392 uint8_t ep_index; 1393 1394 u.addr = addr; 1395 1396 DPRINTFN(6, "cmd=0x%08lx\n", cmd); 1397 1398 switch (cmd) { 1399 case USB_FS_COMPLETE: 1400 mtx_lock(f->priv_mtx); 1401 error = ugen_fs_get_complete(f, &ep_index); 1402 mtx_unlock(f->priv_mtx); 1403 1404 if (error) { 1405 error = EBUSY; 1406 break; 1407 } 1408 u.pcomp->ep_index = ep_index; 1409 error = ugen_fs_copy_out(f, u.pcomp->ep_index); 1410 break; 1411 1412 case USB_FS_START: 1413 error = ugen_fs_copy_in(f, u.pstart->ep_index); 1414 if (error) { 1415 break; 1416 } 1417 mtx_lock(f->priv_mtx); 1418 usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]); 1419 mtx_unlock(f->priv_mtx); 1420 break; 1421 1422 case USB_FS_STOP: 1423 if (u.pstop->ep_index >= f->fs_ep_max) { 1424 error = EINVAL; 1425 break; 1426 } 1427 mtx_lock(f->priv_mtx); 1428 usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]); 1429 mtx_unlock(f->priv_mtx); 1430 break; 1431 1432 case USB_FS_OPEN: 1433 if (u.popen->ep_index >= f->fs_ep_max) { 1434 error = EINVAL; 1435 break; 1436 } 1437 if (f->fs_xfer[u.popen->ep_index] != NULL) { 1438 error = EBUSY; 1439 break; 1440 } 1441 if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) { 1442 u.popen->max_bufsize = USB_FS_MAX_BUFSIZE; 1443 } 1444 if (u.popen->max_frames > USB_FS_MAX_FRAMES) { 1445 u.popen->max_frames = USB_FS_MAX_FRAMES; 1446 break; 1447 } 1448 if (u.popen->max_frames == 0) { 1449 error = EINVAL; 1450 break; 1451 } 1452 pipe = usb2_get_pipe_by_addr(f->udev, u.popen->ep_no); 1453 if (pipe == NULL) { 1454 error = EINVAL; 1455 break; 1456 } 1457 ed = pipe->edesc; 1458 if (ed == NULL) { 1459 error = ENXIO; 1460 break; 1461 } 1462 iface_index = pipe->iface_index; 1463 1464 error = usb2_check_thread_perm(f->udev, curthread, fflags, 1465 iface_index, u.popen->ep_no); 1466 if (error) { 1467 break; 1468 } 1469 bzero(usb2_config, sizeof(usb2_config)); 1470 1471 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; 1472 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 1473 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN); 1474 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; 1475 usb2_config[0].mh.flags.proxy_buffer = 1; 1476 usb2_config[0].mh.callback = &ugen_default_fs_callback; 1477 usb2_config[0].mh.timeout = 0; /* no timeout */ 1478 usb2_config[0].mh.frames = u.popen->max_frames; 1479 usb2_config[0].mh.bufsize = u.popen->max_bufsize; 1480 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 1481 1482 if (usb2_config[0].type == UE_CONTROL) { 1483 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 1484 error = EINVAL; 1485 break; 1486 } 1487 } else { 1488 1489 isread = ((usb2_config[0].endpoint & 1490 (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN); 1491 1492 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 1493 isread = !isread; 1494 } 1495 /* check permissions */ 1496 if (isread) { 1497 if (!(fflags & FREAD)) { 1498 error = EPERM; 1499 break; 1500 } 1501 } else { 1502 if (!(fflags & FWRITE)) { 1503 error = EPERM; 1504 break; 1505 } 1506 } 1507 } 1508 error = usb2_transfer_setup(f->udev, &iface_index, 1509 f->fs_xfer + u.popen->ep_index, usb2_config, 1, 1510 f, f->priv_mtx); 1511 if (error == 0) { 1512 /* update maximums */ 1513 u.popen->max_packet_length = 1514 f->fs_xfer[u.popen->ep_index]->max_frame_size; 1515 u.popen->max_bufsize = 1516 f->fs_xfer[u.popen->ep_index]->max_data_length; 1517 f->fs_xfer[u.popen->ep_index]->priv_fifo = 1518 ((uint8_t *)0) + u.popen->ep_index; 1519 } else { 1520 error = ENOMEM; 1521 } 1522 break; 1523 1524 case USB_FS_CLOSE: 1525 if (u.pclose->ep_index >= f->fs_ep_max) { 1526 error = EINVAL; 1527 break; 1528 } 1529 if (f->fs_xfer[u.pclose->ep_index] == NULL) { 1530 error = EINVAL; 1531 break; 1532 } 1533 usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1); 1534 break; 1535 1536 case USB_FS_CLEAR_STALL_SYNC: 1537 if (u.pstall->ep_index >= f->fs_ep_max) { 1538 error = EINVAL; 1539 break; 1540 } 1541 if (f->fs_xfer[u.pstall->ep_index] == NULL) { 1542 error = EINVAL; 1543 break; 1544 } 1545 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 1546 error = EINVAL; 1547 break; 1548 } 1549 mtx_lock(f->priv_mtx); 1550 error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]); 1551 mtx_unlock(f->priv_mtx); 1552 1553 if (error) { 1554 return (EBUSY); 1555 } 1556 pipe = f->fs_xfer[u.pstall->ep_index]->pipe; 1557 1558 /* setup a clear-stall packet */ 1559 req.bmRequestType = UT_WRITE_ENDPOINT; 1560 req.bRequest = UR_CLEAR_FEATURE; 1561 USETW(req.wValue, UF_ENDPOINT_HALT); 1562 req.wIndex[0] = pipe->edesc->bEndpointAddress; 1563 req.wIndex[1] = 0; 1564 USETW(req.wLength, 0); 1565 1566 error = usb2_do_request(f->udev, NULL, &req, NULL); 1567 if (error == 0) { 1568 usb2_clear_data_toggle(f->udev, pipe); 1569 } else { 1570 error = ENXIO; 1571 } 1572 break; 1573 1574 default: 1575 error = ENOIOCTL; 1576 break; 1577 } 1578 1579 DPRINTFN(6, "error=%d\n", error); 1580 1581 return (error); 1582} 1583 1584static int 1585ugen_set_short_xfer(struct usb2_fifo *f, void *addr) 1586{ 1587 uint8_t t; 1588 1589 if (*(int *)addr) 1590 t = 1; 1591 else 1592 t = 0; 1593 1594 if (f->flag_short == t) { 1595 /* same value like before - accept */ 1596 return (0); 1597 } 1598 if (f->xfer[0] || f->xfer[1]) { 1599 /* cannot change this during transfer */ 1600 return (EBUSY); 1601 } 1602 f->flag_short = t; 1603 return (0); 1604} 1605 1606static int 1607ugen_set_timeout(struct usb2_fifo *f, void *addr) 1608{ 1609 f->timeout = *(int *)addr; 1610 if (f->timeout > 65535) { 1611 /* limit user input */ 1612 f->timeout = 65535; 1613 } 1614 return (0); 1615} 1616 1617static int 1618ugen_get_frame_size(struct usb2_fifo *f, void *addr) 1619{ 1620 if (f->xfer[0]) { 1621 *(int *)addr = f->xfer[0]->max_frame_size; 1622 } else { 1623 return (EINVAL); 1624 } 1625 return (0); 1626} 1627 1628static int 1629ugen_set_buffer_size(struct usb2_fifo *f, void *addr) 1630{ 1631 uint32_t t; 1632 1633 if (*(int *)addr < 1024) 1634 t = 1024; 1635 else if (*(int *)addr < (256 * 1024)) 1636 t = *(int *)addr; 1637 else 1638 t = 256 * 1024; 1639 1640 if (f->bufsize == t) { 1641 /* same value like before - accept */ 1642 return (0); 1643 } 1644 if (f->xfer[0] || f->xfer[1]) { 1645 /* cannot change this during transfer */ 1646 return (EBUSY); 1647 } 1648 f->bufsize = t; 1649 return (0); 1650} 1651 1652static int 1653ugen_get_buffer_size(struct usb2_fifo *f, void *addr) 1654{ 1655 *(int *)addr = f->bufsize; 1656 return (0); 1657} 1658 1659static int 1660ugen_get_iface_desc(struct usb2_fifo *f, 1661 struct usb2_interface_descriptor *idesc) 1662{ 1663 struct usb2_interface *iface; 1664 1665 iface = usb2_get_iface(f->udev, f->iface_index); 1666 if (iface && iface->idesc) { 1667 *idesc = *(iface->idesc); 1668 } else { 1669 return (EIO); 1670 } 1671 return (0); 1672} 1673 1674static int 1675ugen_get_endpoint_desc(struct usb2_fifo *f, 1676 struct usb2_endpoint_descriptor *ed) 1677{ 1678 struct usb2_pipe *pipe; 1679 1680 pipe = f->priv_sc0; 1681 1682 if (pipe && pipe->edesc) { 1683 *ed = *pipe->edesc; 1684 } else { 1685 return (EINVAL); 1686 } 1687 return (0); 1688} 1689 1690static int 1691ugen_set_power_mode(struct usb2_fifo *f, int mode) 1692{ 1693 struct usb2_device *udev = f->udev; 1694 int err; 1695 uint8_t old_mode; 1696 1697 if ((udev == NULL) || 1698 (udev->parent_hub == NULL)) { 1699 return (EINVAL); 1700 } 1701 err = priv_check(curthread, PRIV_ROOT); 1702 if (err) 1703 return (err); 1704 1705 /* get old power mode */ 1706 old_mode = udev->power_mode; 1707 1708 /* if no change, then just return */ 1709 if (old_mode == mode) 1710 return (0); 1711 1712 switch (mode) { 1713 case USB_POWER_MODE_OFF: 1714 /* get the device unconfigured */ 1715 err = ugen_set_config(f, USB_UNCONFIG_INDEX); 1716 if (err) { 1717 DPRINTFN(0, "Could not unconfigure " 1718 "device (ignored)\n"); 1719 } 1720 1721 /* clear port enable */ 1722 err = usb2_req_clear_port_feature(udev->parent_hub, 1723 NULL, udev->port_no, UHF_PORT_ENABLE); 1724 break; 1725 1726 case USB_POWER_MODE_ON: 1727 case USB_POWER_MODE_SAVE: 1728 break; 1729 1730 case USB_POWER_MODE_RESUME: 1731 err = usb2_req_clear_port_feature(udev->parent_hub, 1732 NULL, udev->port_no, UHF_PORT_SUSPEND); 1733 mode = USB_POWER_MODE_SAVE; 1734 break; 1735 1736 case USB_POWER_MODE_SUSPEND: 1737 err = usb2_req_set_port_feature(udev->parent_hub, 1738 NULL, udev->port_no, UHF_PORT_SUSPEND); 1739 mode = USB_POWER_MODE_SAVE; 1740 break; 1741 1742 default: 1743 return (EINVAL); 1744 } 1745 1746 if (err) 1747 return (ENXIO); /* I/O failure */ 1748 1749 /* if we are powered off we need to re-enumerate first */ 1750 if (old_mode == USB_POWER_MODE_OFF) { 1751 err = ugen_re_enumerate(f); 1752 if (err) 1753 return (err); 1754 } 1755 1756 /* set new power mode */ 1757 usb2_set_power_mode(udev, mode); 1758 1759 return (0); /* success */ 1760} 1761 1762static int 1763ugen_get_power_mode(struct usb2_fifo *f) 1764{ 1765 struct usb2_device *udev = f->udev; 1766 1767 if ((udev == NULL) || 1768 (udev->parent_hub == NULL)) { 1769 return (USB_POWER_MODE_ON); 1770 } 1771 return (udev->power_mode); 1772} 1773 1774static int 1775ugen_do_port_feature(struct usb2_fifo *f, uint8_t port_no, 1776 uint8_t set, uint16_t feature) 1777{ 1778 struct usb2_device *udev = f->udev; 1779 struct usb2_hub *hub; 1780 int err; 1781 1782 err = priv_check(curthread, PRIV_ROOT); 1783 if (err) { 1784 return (err); 1785 } 1786 if (port_no == 0) { 1787 return (EINVAL); 1788 } 1789 if ((udev == NULL) || 1790 (udev->hub == NULL)) { 1791 return (EINVAL); 1792 } 1793 hub = udev->hub; 1794 1795 if (port_no > hub->nports) { 1796 return (EINVAL); 1797 } 1798 if (set) 1799 err = usb2_req_set_port_feature(udev, 1800 NULL, port_no, feature); 1801 else 1802 err = usb2_req_clear_port_feature(udev, 1803 NULL, port_no, feature); 1804 1805 if (err) 1806 return (ENXIO); /* failure */ 1807 1808 return (0); /* success */ 1809} 1810 1811static int 1812ugen_iface_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags) 1813{ 1814 struct usb2_fifo *f_rx; 1815 struct usb2_fifo *f_tx; 1816 int error = 0; 1817 1818 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX]; 1819 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX]; 1820 1821 switch (cmd) { 1822 case USB_SET_RX_SHORT_XFER: 1823 if (fflags & FREAD) { 1824 error = ugen_set_short_xfer(f_rx, addr); 1825 } else { 1826 error = EINVAL; 1827 } 1828 break; 1829 1830 case USB_SET_TX_FORCE_SHORT: 1831 if (fflags & FWRITE) { 1832 error = ugen_set_short_xfer(f_tx, addr); 1833 } else { 1834 error = EINVAL; 1835 } 1836 break; 1837 1838 case USB_SET_RX_TIMEOUT: 1839 if (fflags & FREAD) { 1840 error = ugen_set_timeout(f_rx, addr); 1841 } else { 1842 error = EINVAL; 1843 } 1844 break; 1845 1846 case USB_SET_TX_TIMEOUT: 1847 if (fflags & FWRITE) { 1848 error = ugen_set_timeout(f_tx, addr); 1849 } else { 1850 error = EINVAL; 1851 } 1852 break; 1853 1854 case USB_GET_RX_FRAME_SIZE: 1855 if (fflags & FREAD) { 1856 error = ugen_get_frame_size(f_rx, addr); 1857 } else { 1858 error = EINVAL; 1859 } 1860 break; 1861 1862 case USB_GET_TX_FRAME_SIZE: 1863 if (fflags & FWRITE) { 1864 error = ugen_get_frame_size(f_tx, addr); 1865 } else { 1866 error = EINVAL; 1867 } 1868 break; 1869 1870 case USB_SET_RX_BUFFER_SIZE: 1871 if (fflags & FREAD) { 1872 error = ugen_set_buffer_size(f_rx, addr); 1873 } else { 1874 error = EINVAL; 1875 } 1876 break; 1877 1878 case USB_SET_TX_BUFFER_SIZE: 1879 if (fflags & FWRITE) { 1880 error = ugen_set_buffer_size(f_tx, addr); 1881 } else { 1882 error = EINVAL; 1883 } 1884 break; 1885 1886 case USB_GET_RX_BUFFER_SIZE: 1887 if (fflags & FREAD) { 1888 error = ugen_get_buffer_size(f_rx, addr); 1889 } else { 1890 error = EINVAL; 1891 } 1892 break; 1893 1894 case USB_GET_TX_BUFFER_SIZE: 1895 if (fflags & FWRITE) { 1896 error = ugen_get_buffer_size(f_tx, addr); 1897 } else { 1898 error = EINVAL; 1899 } 1900 break; 1901 1902 case USB_GET_RX_INTERFACE_DESC: 1903 if (fflags & FREAD) { 1904 error = ugen_get_iface_desc(f_rx, addr); 1905 } else { 1906 error = EINVAL; 1907 } 1908 break; 1909 1910 case USB_GET_TX_INTERFACE_DESC: 1911 if (fflags & FWRITE) { 1912 error = ugen_get_iface_desc(f_tx, addr); 1913 } else { 1914 error = EINVAL; 1915 } 1916 break; 1917 1918 case USB_GET_RX_ENDPOINT_DESC: 1919 if (fflags & FREAD) { 1920 error = ugen_get_endpoint_desc(f_rx, addr); 1921 } else { 1922 error = EINVAL; 1923 } 1924 break; 1925 1926 case USB_GET_TX_ENDPOINT_DESC: 1927 if (fflags & FWRITE) { 1928 error = ugen_get_endpoint_desc(f_tx, addr); 1929 } else { 1930 error = EINVAL; 1931 } 1932 break; 1933 1934 case USB_SET_RX_STALL_FLAG: 1935 if ((fflags & FREAD) && (*(int *)addr)) { 1936 f_rx->flag_stall = 1; 1937 } 1938 break; 1939 1940 case USB_SET_TX_STALL_FLAG: 1941 if ((fflags & FWRITE) && (*(int *)addr)) { 1942 f_tx->flag_stall = 1; 1943 } 1944 break; 1945 1946 default: 1947 error = ENOIOCTL; 1948 break; 1949 } 1950 return (error); 1951} 1952 1953static int 1954ugen_ioctl_post(struct usb2_fifo *f, u_long cmd, void *addr, int fflags, 1955 struct thread *td) 1956{ 1957 union { 1958 struct usb2_interface_descriptor *idesc; 1959 struct usb2_alt_interface *ai; 1960 struct usb2_device_descriptor *ddesc; 1961 struct usb2_config_descriptor *cdesc; 1962 struct usb2_device_stats *stat; 1963 struct usb2_fs_init *pinit; 1964 struct usb2_fs_uninit *puninit; 1965 uint32_t *ptime; 1966 void *addr; 1967 int *pint; 1968 } u; 1969 struct usb2_device_descriptor *dtemp; 1970 struct usb2_config_descriptor *ctemp; 1971 struct usb2_interface *iface; 1972 int error = 0; 1973 uint8_t n; 1974 1975 u.addr = addr; 1976 1977 DPRINTFN(6, "cmd=0x%08lx\n", cmd); 1978 1979 switch (cmd) { 1980 case USB_DISCOVER: 1981 usb2_needs_explore_all(); 1982 break; 1983 1984 case USB_SETDEBUG: 1985 if (!(fflags & FWRITE)) { 1986 error = EPERM; 1987 break; 1988 } 1989 usb2_debug = *(int *)addr; 1990 break; 1991 1992 case USB_GET_CONFIG: 1993 *(int *)addr = f->udev->curr_config_index; 1994 break; 1995 1996 case USB_SET_CONFIG: 1997 if (!(fflags & FWRITE)) { 1998 error = EPERM; 1999 break; 2000 } 2001 error = ugen_set_config(f, *(int *)addr); 2002 break; 2003 2004 case USB_GET_ALTINTERFACE: 2005 iface = usb2_get_iface(f->udev, 2006 u.ai->uai_interface_index); 2007 if (iface && iface->idesc) { 2008 u.ai->uai_alt_index = iface->alt_index; 2009 } else { 2010 error = EINVAL; 2011 } 2012 break; 2013 2014 case USB_SET_ALTINTERFACE: 2015 if (!(fflags & FWRITE)) { 2016 error = EPERM; 2017 break; 2018 } 2019 error = ugen_set_interface(f, 2020 u.ai->uai_interface_index, u.ai->uai_alt_index); 2021 break; 2022 2023 case USB_GET_DEVICE_DESC: 2024 dtemp = usb2_get_device_descriptor(f->udev); 2025 if (!dtemp) { 2026 error = EIO; 2027 break; 2028 } 2029 *u.ddesc = *dtemp; 2030 break; 2031 2032 case USB_GET_CONFIG_DESC: 2033 ctemp = usb2_get_config_descriptor(f->udev); 2034 if (!ctemp) { 2035 error = EIO; 2036 break; 2037 } 2038 *u.cdesc = *ctemp; 2039 break; 2040 2041 case USB_GET_FULL_DESC: 2042 error = ugen_get_cdesc(f, addr); 2043 break; 2044 2045 case USB_GET_STRING_DESC: 2046 error = ugen_get_sdesc(f, addr); 2047 break; 2048 2049 case USB_REQUEST: 2050 case USB_DO_REQUEST: 2051 if (!(fflags & FWRITE)) { 2052 error = EPERM; 2053 break; 2054 } 2055 error = ugen_do_request(f, addr); 2056 break; 2057 2058 case USB_DEVICEINFO: 2059 case USB_GET_DEVICEINFO: 2060 error = usb2_gen_fill_deviceinfo(f, addr); 2061 break; 2062 2063 case USB_GET_DEVICENAMES: 2064 error = usb2_gen_fill_devicenames(f, addr); 2065 break; 2066 2067 case USB_DEVICESTATS: 2068 for (n = 0; n != 4; n++) { 2069 2070 u.stat->uds_requests_fail[n] = 2071 f->udev->bus->stats_err.uds_requests[n]; 2072 2073 u.stat->uds_requests_ok[n] = 2074 f->udev->bus->stats_ok.uds_requests[n]; 2075 } 2076 break; 2077 2078 case USB_DEVICEENUMERATE: 2079 error = ugen_re_enumerate(f); 2080 break; 2081 2082 case USB_GET_PLUGTIME: 2083 *u.ptime = f->udev->plugtime; 2084 break; 2085 2086 case USB_CLAIM_INTERFACE: 2087 case USB_RELEASE_INTERFACE: 2088 /* TODO */ 2089 break; 2090 2091 case USB_IFACE_DRIVER_ACTIVE: 2092 /* TODO */ 2093 *u.pint = 0; 2094 break; 2095 2096 case USB_IFACE_DRIVER_DETACH: 2097 /* TODO */ 2098 error = priv_check(curthread, PRIV_DRIVER); 2099 if (error) { 2100 break; 2101 } 2102 error = EINVAL; 2103 break; 2104 2105 case USB_SET_POWER_MODE: 2106 error = ugen_set_power_mode(f, *u.pint); 2107 break; 2108 2109 case USB_GET_POWER_MODE: 2110 *u.pint = ugen_get_power_mode(f); 2111 break; 2112 2113 case USB_SET_PORT_ENABLE: 2114 error = ugen_do_port_feature(f, 2115 *u.pint, 1, UHF_PORT_ENABLE); 2116 break; 2117 2118 case USB_SET_PORT_DISABLE: 2119 error = ugen_do_port_feature(f, 2120 *u.pint, 0, UHF_PORT_ENABLE); 2121 break; 2122 2123 case USB_FS_INIT: 2124 /* verify input parameters */ 2125 if (u.pinit->pEndpoints == NULL) { 2126 error = EINVAL; 2127 break; 2128 } 2129 if (u.pinit->ep_index_max > 127) { 2130 error = EINVAL; 2131 break; 2132 } 2133 if (u.pinit->ep_index_max == 0) { 2134 error = EINVAL; 2135 break; 2136 } 2137 if (f->fs_xfer != NULL) { 2138 error = EBUSY; 2139 break; 2140 } 2141 if (f->dev_ep_index != 0) { 2142 error = EINVAL; 2143 break; 2144 } 2145 if (ugen_fifo_in_use(f, fflags)) { 2146 error = EBUSY; 2147 break; 2148 } 2149 error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max); 2150 if (error) { 2151 break; 2152 } 2153 f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) * 2154 u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO); 2155 if (f->fs_xfer == NULL) { 2156 usb2_fifo_free_buffer(f); 2157 error = ENOMEM; 2158 break; 2159 } 2160 f->fs_ep_max = u.pinit->ep_index_max; 2161 f->fs_ep_ptr = u.pinit->pEndpoints; 2162 break; 2163 2164 case USB_FS_UNINIT: 2165 if (u.puninit->dummy != 0) { 2166 error = EINVAL; 2167 break; 2168 } 2169 error = ugen_fs_uninit(f); 2170 break; 2171 2172 default: 2173 mtx_lock(f->priv_mtx); 2174 error = ugen_iface_ioctl(f, cmd, addr, fflags); 2175 mtx_unlock(f->priv_mtx); 2176 break; 2177 } 2178 DPRINTFN(6, "error=%d\n", error); 2179 return (error); 2180} 2181 2182static void 2183ugen_default_fs_callback(struct usb2_xfer *xfer) 2184{ 2185 ; /* workaround for a bug in "indent" */ 2186 2187 DPRINTF("st=%u alen=%u aframes=%u\n", 2188 USB_GET_STATE(xfer), xfer->actlen, xfer->aframes); 2189 2190 switch (USB_GET_STATE(xfer)) { 2191 case USB_ST_SETUP: 2192 usb2_start_hardware(xfer); 2193 break; 2194 default: 2195 ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo)); 2196 break; 2197 } 2198} 2199