1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2008-2023 Hans Petter Selasky 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #ifdef USB_GLOBAL_INCLUDE_FILE 29 #include USB_GLOBAL_INCLUDE_FILE 30 #else 31 #ifdef COMPAT_FREEBSD32 32 #include <sys/abi_compat.h> 33 #endif 34 #include <sys/stdint.h> 35 #include <sys/stddef.h> 36 #include <sys/param.h> 37 #include <sys/queue.h> 38 #include <sys/types.h> 39 #include <sys/systm.h> 40 #include <sys/kernel.h> 41 #include <sys/bus.h> 42 #include <sys/module.h> 43 #include <sys/lock.h> 44 #include <sys/mutex.h> 45 #include <sys/condvar.h> 46 #include <sys/sysctl.h> 47 #include <sys/sx.h> 48 #include <sys/unistd.h> 49 #include <sys/callout.h> 50 #include <sys/malloc.h> 51 #include <sys/priv.h> 52 #include <sys/conf.h> 53 #include <sys/fcntl.h> 54 55 #include <dev/usb/usb.h> 56 #include <dev/usb/usb_ioctl.h> 57 #include <dev/usb/usbdi.h> 58 #include <dev/usb/usbdi_util.h> 59 60 #define USB_DEBUG_VAR ugen_debug 61 62 #include <dev/usb/usb_core.h> 63 #include <dev/usb/usb_dev.h> 64 #include <dev/usb/usb_mbuf.h> 65 #include <dev/usb/usb_process.h> 66 #include <dev/usb/usb_device.h> 67 #include <dev/usb/usb_debug.h> 68 #include <dev/usb/usb_request.h> 69 #include <dev/usb/usb_busdma.h> 70 #include <dev/usb/usb_util.h> 71 #include <dev/usb/usb_hub.h> 72 #include <dev/usb/usb_generic.h> 73 #include <dev/usb/usb_transfer.h> 74 75 #include <dev/usb/usb_controller.h> 76 #include <dev/usb/usb_bus.h> 77 #endif /* USB_GLOBAL_INCLUDE_FILE */ 78 79 #if USB_HAVE_UGEN 80 81 /* defines */ 82 83 #define UGEN_BULK_FS_BUFFER_SIZE (64*32) /* bytes */ 84 #define UGEN_BULK_HS_BUFFER_SIZE (1024*32) /* bytes */ 85 #define UGEN_HW_FRAMES 50 /* number of milliseconds per transfer */ 86 87 /* function prototypes */ 88 89 static usb_callback_t ugen_read_clear_stall_callback; 90 static usb_callback_t ugen_write_clear_stall_callback; 91 static usb_callback_t ugen_ctrl_read_callback; 92 static usb_callback_t ugen_ctrl_write_callback; 93 static usb_callback_t ugen_isoc_read_callback; 94 static usb_callback_t ugen_isoc_write_callback; 95 static usb_callback_t ugen_ctrl_fs_callback; 96 97 static usb_fifo_open_t ugen_open; 98 static usb_fifo_close_t ugen_close; 99 static usb_fifo_ioctl_t ugen_ioctl; 100 static usb_fifo_ioctl_t ugen_ioctl_post; 101 static usb_fifo_cmd_t ugen_start_read; 102 static usb_fifo_cmd_t ugen_start_write; 103 static usb_fifo_cmd_t ugen_stop_io; 104 105 static int ugen_transfer_setup(struct usb_fifo *, 106 const struct usb_config *, uint8_t); 107 static int ugen_open_pipe_write(struct usb_fifo *); 108 static int ugen_open_pipe_read(struct usb_fifo *); 109 static int ugen_set_config(struct usb_fifo *, uint8_t); 110 static int ugen_set_interface(struct usb_fifo *, uint8_t, uint8_t); 111 static int ugen_get_cdesc(struct usb_fifo *, struct usb_gen_descriptor *); 112 static int ugen_get_sdesc(struct usb_fifo *, struct usb_gen_descriptor *); 113 static int ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd); 114 #ifdef COMPAT_FREEBSD32 115 static int ugen_get32(u_long cmd, struct usb_fifo *f, struct usb_gen_descriptor32 *ugd32); 116 #endif 117 static int ugen_re_enumerate(struct usb_fifo *); 118 static int ugen_iface_ioctl(struct usb_fifo *, u_long, void *, int); 119 static uint8_t ugen_fs_get_complete(struct usb_fifo *, uint8_t *); 120 static int ugen_fs_uninit(struct usb_fifo *f); 121 static int ugen_fs_copyin(struct usb_fifo *, uint8_t, struct usb_fs_endpoint*); 122 static uint8_t ugen_fifo_in_use(struct usb_fifo *, int fflags); 123 124 /* structures */ 125 126 struct usb_fifo_methods usb_ugen_methods = { 127 .f_open = &ugen_open, 128 .f_close = &ugen_close, 129 .f_ioctl = &ugen_ioctl, 130 .f_ioctl_post = &ugen_ioctl_post, 131 .f_start_read = &ugen_start_read, 132 .f_stop_read = &ugen_stop_io, 133 .f_start_write = &ugen_start_write, 134 .f_stop_write = &ugen_stop_io, 135 }; 136 137 #ifdef USB_DEBUG 138 static int ugen_debug = 0; 139 140 static SYSCTL_NODE(_hw_usb, OID_AUTO, ugen, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 141 "USB generic"); 142 SYSCTL_INT(_hw_usb_ugen, OID_AUTO, debug, CTLFLAG_RWTUN, &ugen_debug, 143 0, "Debug level"); 144 #endif 145 146 /* prototypes */ 147 148 static int 149 ugen_transfer_setup(struct usb_fifo *f, 150 const struct usb_config *setup, uint8_t n_setup) 151 { 152 struct usb_endpoint *ep = usb_fifo_softc(f); 153 struct usb_device *udev = f->udev; 154 uint8_t iface_index = ep->iface_index; 155 int error; 156 157 mtx_unlock(f->priv_mtx); 158 159 /* 160 * "usbd_transfer_setup()" can sleep so one needs to make a wrapper, 161 * exiting the mutex and checking things 162 */ 163 error = usbd_transfer_setup(udev, &iface_index, f->xfer, 164 setup, n_setup, f, f->priv_mtx); 165 if (error == 0) { 166 if (f->xfer[0]->nframes == 1) { 167 error = usb_fifo_alloc_buffer(f, 168 f->xfer[0]->max_data_length, 2); 169 } else { 170 error = usb_fifo_alloc_buffer(f, 171 f->xfer[0]->max_frame_size, 172 2 * f->xfer[0]->nframes); 173 } 174 if (error) { 175 usbd_transfer_unsetup(f->xfer, n_setup); 176 } 177 } 178 mtx_lock(f->priv_mtx); 179 180 return (error); 181 } 182 183 static int 184 ugen_open(struct usb_fifo *f, int fflags) 185 { 186 struct usb_endpoint *ep = usb_fifo_softc(f); 187 struct usb_endpoint_descriptor *ed = ep->edesc; 188 uint8_t type; 189 190 DPRINTFN(1, "flag=0x%x pid=%d name=%s\n", fflags, 191 curthread->td_proc->p_pid, curthread->td_proc->p_comm); 192 193 mtx_lock(f->priv_mtx); 194 switch (usbd_get_speed(f->udev)) { 195 case USB_SPEED_LOW: 196 case USB_SPEED_FULL: 197 f->nframes = UGEN_HW_FRAMES; 198 f->bufsize = UGEN_BULK_FS_BUFFER_SIZE; 199 break; 200 default: 201 f->nframes = UGEN_HW_FRAMES * 8; 202 f->bufsize = UGEN_BULK_HS_BUFFER_SIZE; 203 break; 204 } 205 206 type = ed->bmAttributes & UE_XFERTYPE; 207 if (type == UE_INTERRUPT) { 208 f->bufsize = 0; /* use "wMaxPacketSize" */ 209 } 210 f->timeout = USB_NO_TIMEOUT; 211 f->flag_short = 0; 212 f->fifo_zlp = 0; 213 mtx_unlock(f->priv_mtx); 214 215 return (0); 216 } 217 218 static void 219 ugen_close(struct usb_fifo *f, int fflags) 220 { 221 222 DPRINTFN(1, "flag=0x%x pid=%d name=%s\n", fflags, 223 curthread->td_proc->p_pid, curthread->td_proc->p_comm); 224 225 /* cleanup */ 226 227 mtx_lock(f->priv_mtx); 228 usbd_transfer_stop(f->xfer[0]); 229 usbd_transfer_stop(f->xfer[1]); 230 mtx_unlock(f->priv_mtx); 231 232 usbd_transfer_unsetup(f->xfer, 2); 233 usb_fifo_free_buffer(f); 234 235 if (ugen_fs_uninit(f)) { 236 /* ignore any errors - we are closing */ 237 DPRINTFN(6, "no FIFOs\n"); 238 } 239 } 240 241 static int 242 ugen_open_pipe_write(struct usb_fifo *f) 243 { 244 struct usb_config usb_config[2]; 245 struct usb_endpoint *ep = usb_fifo_softc(f); 246 struct usb_endpoint_descriptor *ed = ep->edesc; 247 248 USB_MTX_ASSERT(f->priv_mtx, MA_OWNED); 249 250 if (f->xfer[0] || f->xfer[1]) { 251 /* transfers are already opened */ 252 return (0); 253 } 254 memset(usb_config, 0, sizeof(usb_config)); 255 256 usb_config[1].type = UE_CONTROL; 257 usb_config[1].endpoint = 0; 258 usb_config[1].direction = UE_DIR_ANY; 259 usb_config[1].timeout = 1000; /* 1 second */ 260 usb_config[1].interval = 50;/* 50 milliseconds */ 261 usb_config[1].bufsize = sizeof(struct usb_device_request); 262 usb_config[1].callback = &ugen_write_clear_stall_callback; 263 usb_config[1].usb_mode = USB_MODE_HOST; 264 265 usb_config[0].type = ed->bmAttributes & UE_XFERTYPE; 266 usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 267 usb_config[0].stream_id = 0; /* XXX support more stream ID's */ 268 usb_config[0].direction = UE_DIR_TX; 269 usb_config[0].interval = USB_DEFAULT_INTERVAL; 270 usb_config[0].flags.proxy_buffer = 1; 271 usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */ 272 273 switch (ed->bmAttributes & UE_XFERTYPE) { 274 case UE_INTERRUPT: 275 case UE_BULK: 276 if (f->flag_short) { 277 usb_config[0].flags.force_short_xfer = 1; 278 } 279 usb_config[0].callback = &ugen_ctrl_write_callback; 280 usb_config[0].timeout = f->timeout; 281 usb_config[0].frames = 1; 282 usb_config[0].bufsize = f->bufsize; 283 if (ugen_transfer_setup(f, usb_config, 2)) { 284 return (EIO); 285 } 286 /* first transfer does not clear stall */ 287 f->flag_stall = 0; 288 break; 289 290 case UE_ISOCHRONOUS: 291 usb_config[0].flags.short_xfer_ok = 1; 292 usb_config[0].bufsize = 0; /* use default */ 293 usb_config[0].frames = f->nframes; 294 usb_config[0].callback = &ugen_isoc_write_callback; 295 usb_config[0].timeout = 0; 296 297 /* clone configuration */ 298 usb_config[1] = usb_config[0]; 299 300 if (ugen_transfer_setup(f, usb_config, 2)) { 301 return (EIO); 302 } 303 break; 304 default: 305 return (EINVAL); 306 } 307 return (0); 308 } 309 310 static int 311 ugen_open_pipe_read(struct usb_fifo *f) 312 { 313 struct usb_config usb_config[2]; 314 struct usb_endpoint *ep = usb_fifo_softc(f); 315 struct usb_endpoint_descriptor *ed = ep->edesc; 316 317 USB_MTX_ASSERT(f->priv_mtx, MA_OWNED); 318 319 if (f->xfer[0] || f->xfer[1]) { 320 /* transfers are already opened */ 321 return (0); 322 } 323 memset(usb_config, 0, sizeof(usb_config)); 324 325 usb_config[1].type = UE_CONTROL; 326 usb_config[1].endpoint = 0; 327 usb_config[1].direction = UE_DIR_ANY; 328 usb_config[1].timeout = 1000; /* 1 second */ 329 usb_config[1].interval = 50;/* 50 milliseconds */ 330 usb_config[1].bufsize = sizeof(struct usb_device_request); 331 usb_config[1].callback = &ugen_read_clear_stall_callback; 332 usb_config[1].usb_mode = USB_MODE_HOST; 333 334 usb_config[0].type = ed->bmAttributes & UE_XFERTYPE; 335 usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 336 usb_config[0].stream_id = 0; /* XXX support more stream ID's */ 337 usb_config[0].direction = UE_DIR_RX; 338 usb_config[0].interval = USB_DEFAULT_INTERVAL; 339 usb_config[0].flags.proxy_buffer = 1; 340 usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */ 341 342 switch (ed->bmAttributes & UE_XFERTYPE) { 343 case UE_INTERRUPT: 344 case UE_BULK: 345 if (f->flag_short) { 346 usb_config[0].flags.short_xfer_ok = 1; 347 } 348 usb_config[0].timeout = f->timeout; 349 usb_config[0].frames = 1; 350 usb_config[0].callback = &ugen_ctrl_read_callback; 351 usb_config[0].bufsize = f->bufsize; 352 353 if (ugen_transfer_setup(f, usb_config, 2)) { 354 return (EIO); 355 } 356 /* first transfer does not clear stall */ 357 f->flag_stall = 0; 358 break; 359 360 case UE_ISOCHRONOUS: 361 usb_config[0].flags.short_xfer_ok = 1; 362 usb_config[0].bufsize = 0; /* use default */ 363 usb_config[0].frames = f->nframes; 364 usb_config[0].callback = &ugen_isoc_read_callback; 365 usb_config[0].timeout = 0; 366 367 /* clone configuration */ 368 usb_config[1] = usb_config[0]; 369 370 if (ugen_transfer_setup(f, usb_config, 2)) { 371 return (EIO); 372 } 373 break; 374 375 default: 376 return (EINVAL); 377 } 378 return (0); 379 } 380 381 static void 382 ugen_start_read(struct usb_fifo *f) 383 { 384 /* check that pipes are open */ 385 if (ugen_open_pipe_read(f)) { 386 /* signal error */ 387 usb_fifo_put_data_error(f); 388 } 389 /* start transfers */ 390 usbd_transfer_start(f->xfer[0]); 391 usbd_transfer_start(f->xfer[1]); 392 } 393 394 static void 395 ugen_start_write(struct usb_fifo *f) 396 { 397 /* check that pipes are open */ 398 if (ugen_open_pipe_write(f)) { 399 /* signal error */ 400 usb_fifo_get_data_error(f); 401 } 402 /* start transfers */ 403 usbd_transfer_start(f->xfer[0]); 404 usbd_transfer_start(f->xfer[1]); 405 } 406 407 static void 408 ugen_stop_io(struct usb_fifo *f) 409 { 410 /* stop transfers */ 411 usbd_transfer_stop(f->xfer[0]); 412 usbd_transfer_stop(f->xfer[1]); 413 } 414 415 static void 416 ugen_ctrl_read_callback(struct usb_xfer *xfer, usb_error_t error) 417 { 418 struct usb_fifo *f = usbd_xfer_softc(xfer); 419 struct usb_mbuf *m; 420 421 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 422 423 switch (USB_GET_STATE(xfer)) { 424 case USB_ST_TRANSFERRED: 425 if (xfer->actlen == 0) { 426 if (f->fifo_zlp != 4) { 427 f->fifo_zlp++; 428 } else { 429 /* 430 * Throttle a little bit we have multiple ZLPs 431 * in a row! 432 */ 433 xfer->interval = 64; /* ms */ 434 } 435 } else { 436 /* clear throttle */ 437 xfer->interval = 0; 438 f->fifo_zlp = 0; 439 } 440 usb_fifo_put_data(f, xfer->frbuffers, 0, 441 xfer->actlen, 1); 442 443 case USB_ST_SETUP: 444 if (f->flag_stall) { 445 usbd_transfer_start(f->xfer[1]); 446 break; 447 } 448 USB_IF_POLL(&f->free_q, m); 449 if (m) { 450 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 451 usbd_transfer_submit(xfer); 452 } 453 break; 454 455 default: /* Error */ 456 if (xfer->error != USB_ERR_CANCELLED) { 457 /* send a zero length packet to userland */ 458 usb_fifo_put_data(f, xfer->frbuffers, 0, 0, 1); 459 f->flag_stall = 1; 460 f->fifo_zlp = 0; 461 usbd_transfer_start(f->xfer[1]); 462 } 463 break; 464 } 465 } 466 467 static void 468 ugen_ctrl_write_callback(struct usb_xfer *xfer, usb_error_t error) 469 { 470 struct usb_fifo *f = usbd_xfer_softc(xfer); 471 usb_frlength_t actlen; 472 473 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 474 475 switch (USB_GET_STATE(xfer)) { 476 case USB_ST_SETUP: 477 case USB_ST_TRANSFERRED: 478 /* 479 * If writing is in stall, just jump to clear stall 480 * callback and solve the situation. 481 */ 482 if (f->flag_stall) { 483 usbd_transfer_start(f->xfer[1]); 484 break; 485 } 486 /* 487 * Write data, setup and perform hardware transfer. 488 */ 489 if (usb_fifo_get_data(f, xfer->frbuffers, 0, 490 xfer->max_data_length, &actlen, 0)) { 491 usbd_xfer_set_frame_len(xfer, 0, actlen); 492 usbd_transfer_submit(xfer); 493 } 494 break; 495 496 default: /* Error */ 497 if (xfer->error != USB_ERR_CANCELLED) { 498 f->flag_stall = 1; 499 usbd_transfer_start(f->xfer[1]); 500 } 501 break; 502 } 503 } 504 505 static void 506 ugen_read_clear_stall_callback(struct usb_xfer *xfer, usb_error_t error) 507 { 508 struct usb_fifo *f = usbd_xfer_softc(xfer); 509 struct usb_xfer *xfer_other = f->xfer[0]; 510 511 if (f->flag_stall == 0) { 512 /* nothing to do */ 513 return; 514 } 515 if (usbd_clear_stall_callback(xfer, xfer_other)) { 516 DPRINTFN(5, "f=%p: stall cleared\n", f); 517 f->flag_stall = 0; 518 usbd_transfer_start(xfer_other); 519 } 520 } 521 522 static void 523 ugen_write_clear_stall_callback(struct usb_xfer *xfer, usb_error_t error) 524 { 525 struct usb_fifo *f = usbd_xfer_softc(xfer); 526 struct usb_xfer *xfer_other = f->xfer[0]; 527 528 if (f->flag_stall == 0) { 529 /* nothing to do */ 530 return; 531 } 532 if (usbd_clear_stall_callback(xfer, xfer_other)) { 533 DPRINTFN(5, "f=%p: stall cleared\n", f); 534 f->flag_stall = 0; 535 usbd_transfer_start(xfer_other); 536 } 537 } 538 539 static void 540 ugen_isoc_read_callback(struct usb_xfer *xfer, usb_error_t error) 541 { 542 struct usb_fifo *f = usbd_xfer_softc(xfer); 543 usb_frlength_t offset; 544 usb_frcount_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 551 DPRINTFN(6, "actlen=%d\n", xfer->actlen); 552 553 offset = 0; 554 555 for (n = 0; n != xfer->aframes; n++) { 556 usb_fifo_put_data(f, xfer->frbuffers, offset, 557 xfer->frlengths[n], 1); 558 offset += xfer->max_frame_size; 559 } 560 561 case USB_ST_SETUP: 562 tr_setup: 563 for (n = 0; n != xfer->nframes; n++) { 564 /* setup size for next transfer */ 565 usbd_xfer_set_frame_len(xfer, n, xfer->max_frame_size); 566 } 567 usbd_transfer_submit(xfer); 568 break; 569 570 default: /* Error */ 571 if (xfer->error == USB_ERR_CANCELLED) { 572 break; 573 } 574 goto tr_setup; 575 } 576 } 577 578 static void 579 ugen_isoc_write_callback(struct usb_xfer *xfer, usb_error_t error) 580 { 581 struct usb_fifo *f = usbd_xfer_softc(xfer); 582 usb_frlength_t actlen; 583 usb_frlength_t offset; 584 usb_frcount_t n; 585 586 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 587 588 switch (USB_GET_STATE(xfer)) { 589 case USB_ST_TRANSFERRED: 590 case USB_ST_SETUP: 591 tr_setup: 592 offset = 0; 593 for (n = 0; n != xfer->nframes; n++) { 594 if (usb_fifo_get_data(f, xfer->frbuffers, offset, 595 xfer->max_frame_size, &actlen, 1)) { 596 usbd_xfer_set_frame_len(xfer, n, actlen); 597 offset += actlen; 598 } else { 599 break; 600 } 601 } 602 603 for (; n != xfer->nframes; n++) { 604 /* fill in zero frames */ 605 usbd_xfer_set_frame_len(xfer, n, 0); 606 } 607 usbd_transfer_submit(xfer); 608 break; 609 610 default: /* Error */ 611 if (xfer->error == USB_ERR_CANCELLED) { 612 break; 613 } 614 goto tr_setup; 615 } 616 } 617 618 static int 619 ugen_set_config(struct usb_fifo *f, uint8_t index) 620 { 621 DPRINTFN(2, "index %u\n", index); 622 623 if (f->udev->flags.usb_mode != USB_MODE_HOST) { 624 /* not possible in device side mode */ 625 return (ENOTTY); 626 } 627 628 /* make sure all FIFO's are gone */ 629 /* else there can be a deadlock */ 630 if (ugen_fs_uninit(f)) { 631 /* ignore any errors */ 632 DPRINTFN(6, "no FIFOs\n"); 633 } 634 635 if (usbd_start_set_config(f->udev, index) != 0) 636 return (EIO); 637 638 return (0); 639 } 640 641 static int 642 ugen_set_interface(struct usb_fifo *f, 643 uint8_t iface_index, uint8_t alt_index) 644 { 645 DPRINTFN(2, "%u, %u\n", iface_index, alt_index); 646 647 if (f->udev->flags.usb_mode != USB_MODE_HOST) { 648 /* not possible in device side mode */ 649 return (ENOTTY); 650 } 651 /* make sure all FIFO's are gone */ 652 /* else there can be a deadlock */ 653 if (ugen_fs_uninit(f)) { 654 /* ignore any errors */ 655 DPRINTFN(6, "no FIFOs\n"); 656 } 657 /* change setting - will free generic FIFOs, if any */ 658 if (usbd_set_alt_interface_index(f->udev, iface_index, alt_index)) { 659 return (EIO); 660 } 661 /* probe and attach */ 662 if (usb_probe_and_attach(f->udev, iface_index)) { 663 return (EIO); 664 } 665 return (0); 666 } 667 668 /*------------------------------------------------------------------------* 669 * ugen_get_cdesc 670 * 671 * This function will retrieve the complete configuration descriptor 672 * at the given index. 673 *------------------------------------------------------------------------*/ 674 static int 675 ugen_get_cdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd) 676 { 677 struct usb_config_descriptor *cdesc; 678 struct usb_device *udev = f->udev; 679 int error; 680 uint16_t len; 681 uint8_t free_data; 682 683 DPRINTFN(6, "\n"); 684 685 if (ugd->ugd_data == NULL) { 686 /* userland pointer should not be zero */ 687 return (EINVAL); 688 } 689 if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) || 690 (ugd->ugd_config_index == udev->curr_config_index)) { 691 cdesc = usbd_get_config_descriptor(udev); 692 if (cdesc == NULL) 693 return (ENXIO); 694 free_data = 0; 695 696 } else { 697 #if (USB_HAVE_FIXED_CONFIG == 0) 698 if (usbd_req_get_config_desc_full(udev, 699 NULL, &cdesc, ugd->ugd_config_index)) { 700 return (ENXIO); 701 } 702 free_data = 1; 703 #else 704 /* configuration descriptor data is shared */ 705 return (EINVAL); 706 #endif 707 } 708 709 len = UGETW(cdesc->wTotalLength); 710 if (len > ugd->ugd_maxlen) { 711 len = ugd->ugd_maxlen; 712 } 713 DPRINTFN(6, "len=%u\n", len); 714 715 ugd->ugd_actlen = len; 716 ugd->ugd_offset = 0; 717 718 error = copyout(cdesc, ugd->ugd_data, len); 719 720 if (free_data) 721 usbd_free_config_desc(udev, cdesc); 722 723 return (error); 724 } 725 726 static int 727 ugen_get_sdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd) 728 { 729 void *ptr; 730 uint16_t size; 731 int error; 732 uint8_t do_unlock; 733 734 /* Protect scratch area */ 735 do_unlock = usbd_ctrl_lock(f->udev); 736 737 ptr = f->udev->scratch.data; 738 size = sizeof(f->udev->scratch.data); 739 740 if (usbd_req_get_string_desc(f->udev, NULL, ptr, 741 size, ugd->ugd_lang_id, ugd->ugd_string_index)) { 742 error = EINVAL; 743 } else { 744 if (size > ((uint8_t *)ptr)[0]) { 745 size = ((uint8_t *)ptr)[0]; 746 } 747 if (size > ugd->ugd_maxlen) { 748 size = ugd->ugd_maxlen; 749 } 750 ugd->ugd_actlen = size; 751 ugd->ugd_offset = 0; 752 753 error = copyout(ptr, ugd->ugd_data, size); 754 } 755 if (do_unlock) 756 usbd_ctrl_unlock(f->udev); 757 758 return (error); 759 } 760 761 /*------------------------------------------------------------------------* 762 * ugen_get_iface_driver 763 * 764 * This function generates an USB interface description for userland. 765 * 766 * Returns: 767 * 0: Success 768 * Else: Failure 769 *------------------------------------------------------------------------*/ 770 static int 771 ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd) 772 { 773 struct usb_device *udev = f->udev; 774 struct usb_interface *iface; 775 const char *ptr; 776 const char *desc; 777 unsigned len; 778 unsigned maxlen; 779 char buf[128]; 780 int error; 781 782 DPRINTFN(6, "\n"); 783 784 if ((ugd->ugd_data == NULL) || (ugd->ugd_maxlen == 0)) { 785 /* userland pointer should not be zero */ 786 return (EINVAL); 787 } 788 789 iface = usbd_get_iface(udev, ugd->ugd_iface_index); 790 if ((iface == NULL) || (iface->idesc == NULL)) { 791 /* invalid interface index */ 792 return (EINVAL); 793 } 794 795 /* read out device nameunit string, if any */ 796 if ((iface->subdev != NULL) && 797 device_is_attached(iface->subdev) && 798 (ptr = device_get_nameunit(iface->subdev)) && 799 (desc = device_get_desc(iface->subdev))) { 800 /* print description */ 801 snprintf(buf, sizeof(buf), "%s: <%s>", ptr, desc); 802 803 /* range checks */ 804 maxlen = ugd->ugd_maxlen - 1; 805 len = strlen(buf); 806 if (len > maxlen) 807 len = maxlen; 808 809 /* update actual length, including terminating zero */ 810 ugd->ugd_actlen = len + 1; 811 812 /* copy out interface description */ 813 error = copyout(buf, ugd->ugd_data, ugd->ugd_actlen); 814 } else { 815 /* zero length string is default */ 816 error = copyout("", ugd->ugd_data, 1); 817 } 818 return (error); 819 } 820 821 /*------------------------------------------------------------------------* 822 * ugen_fill_deviceinfo 823 * 824 * This function dumps information about an USB device to the 825 * structure pointed to by the "di" argument. 826 * 827 * Returns: 828 * 0: Success 829 * Else: Failure 830 *------------------------------------------------------------------------*/ 831 int 832 ugen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di) 833 { 834 return (usbd_fill_deviceinfo(f->udev, di)); 835 } 836 837 int 838 ugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur) 839 { 840 int error; 841 uint16_t len; 842 uint16_t actlen; 843 844 if (usb_check_request(f->udev, &ur->ucr_request)) { 845 return (EPERM); 846 } 847 len = UGETW(ur->ucr_request.wLength); 848 849 /* check if "ucr_data" is valid */ 850 if (len != 0) { 851 if (ur->ucr_data == NULL) { 852 return (EFAULT); 853 } 854 } 855 /* do the USB request */ 856 error = usbd_do_request_flags 857 (f->udev, NULL, &ur->ucr_request, ur->ucr_data, 858 (ur->ucr_flags & USB_SHORT_XFER_OK) | 859 USB_USER_DATA_PTR, &actlen, 860 USB_DEFAULT_TIMEOUT); 861 862 ur->ucr_actlen = actlen; 863 864 if (error) { 865 error = EIO; 866 } 867 return (error); 868 } 869 870 #ifdef COMPAT_FREEBSD32 871 static int 872 ugen_do_request32(struct usb_fifo *f, struct usb_ctl_request32 *ur32) 873 { 874 struct usb_ctl_request ur; 875 int error; 876 877 PTRIN_CP(*ur32, ur, ucr_data); 878 CP(*ur32, ur, ucr_flags); 879 CP(*ur32, ur, ucr_actlen); 880 CP(*ur32, ur, ucr_addr); 881 CP(*ur32, ur, ucr_request); 882 883 error = ugen_do_request(f, &ur); 884 885 /* Don't update ucr_data pointer */ 886 CP(ur, *ur32, ucr_flags); 887 CP(ur, *ur32, ucr_actlen); 888 CP(ur, *ur32, ucr_addr); 889 CP(ur, *ur32, ucr_request); 890 891 return (error); 892 } 893 #endif 894 895 /*------------------------------------------------------------------------ 896 * ugen_re_enumerate 897 *------------------------------------------------------------------------*/ 898 static int 899 ugen_re_enumerate(struct usb_fifo *f) 900 { 901 struct usb_device *udev = f->udev; 902 int error; 903 904 /* 905 * This request can be useful for testing USB drivers: 906 */ 907 error = priv_check(curthread, PRIV_DRIVER); 908 if (error) { 909 return (error); 910 } 911 if (udev->flags.usb_mode != USB_MODE_HOST) { 912 /* not possible in device side mode */ 913 DPRINTFN(6, "device mode\n"); 914 return (ENOTTY); 915 } 916 /* make sure all FIFO's are gone */ 917 /* else there can be a deadlock */ 918 if (ugen_fs_uninit(f)) { 919 /* ignore any errors */ 920 DPRINTFN(6, "no FIFOs\n"); 921 } 922 /* start re-enumeration of device */ 923 usbd_start_re_enumerate(udev); 924 return (0); 925 } 926 927 static int 928 ugen_fs_init(struct usb_fifo *f, 929 struct usb_fs_endpoint *fs_ep_ptr, usb_size_t fs_ep_sz, 930 int fflags, uint8_t ep_index_max) 931 { 932 int error; 933 934 /* verify input parameters */ 935 if (fs_ep_ptr == NULL || ep_index_max > USB_FS_XFER_MAX) 936 return (EINVAL); 937 938 if (f->fs_ep_max != 0) 939 return (EBUSY); 940 941 if (f->dev_ep_index != 0 || ep_index_max == 0) 942 return (EINVAL); 943 944 if (ugen_fifo_in_use(f, fflags)) 945 return (EBUSY); 946 947 error = usb_fifo_alloc_buffer(f, 1, ep_index_max); 948 if (error == 0) { 949 mtx_lock(f->priv_mtx); 950 f->fs_ep_max = ep_index_max; 951 f->fs_ep_ptr = fs_ep_ptr; 952 f->fs_ep_sz = fs_ep_sz; 953 mtx_unlock(f->priv_mtx); 954 } 955 return (error); 956 } 957 958 int 959 ugen_fs_uninit(struct usb_fifo *f) 960 { 961 if (f->fs_ep_max == 0) 962 return (EINVAL); 963 964 /* 965 * Prevent calls into the fast-path code, by setting fs_ep_max 966 * to zero: 967 */ 968 sx_xlock(&f->fs_fastpath_lock); 969 mtx_lock(f->priv_mtx); 970 f->fs_ep_max = 0; 971 mtx_unlock(f->priv_mtx); 972 sx_xunlock(&f->fs_fastpath_lock); 973 974 usbd_transfer_unsetup(f->fs_xfer, USB_FS_XFER_MAX); 975 976 mtx_lock(f->priv_mtx); 977 f->fs_ep_ptr = NULL; 978 f->flag_iscomplete = 0; 979 mtx_unlock(f->priv_mtx); 980 981 usb_fifo_free_buffer(f); 982 return (0); 983 } 984 985 static int 986 usb_fs_open(struct usb_fifo *f, struct usb_fs_open *popen, 987 int fflags, usb_stream_t stream_id) 988 { 989 struct usb_config usb_config[1] = {}; 990 struct usb_endpoint *ep; 991 struct usb_endpoint_descriptor *ed; 992 uint8_t iface_index; 993 uint8_t pre_scale; 994 uint8_t isread; 995 int error; 996 997 if (popen->ep_index >= f->fs_ep_max) 998 return (EINVAL); 999 1000 if (f->fs_xfer[popen->ep_index] != NULL) 1001 return (EBUSY); 1002 1003 if (popen->max_bufsize > USB_FS_MAX_BUFSIZE) 1004 popen->max_bufsize = USB_FS_MAX_BUFSIZE; 1005 1006 if (popen->max_frames & USB_FS_MAX_FRAMES_PRE_SCALE) { 1007 pre_scale = 1; 1008 popen->max_frames &= ~USB_FS_MAX_FRAMES_PRE_SCALE; 1009 } else { 1010 pre_scale = 0; 1011 } 1012 1013 if (popen->max_frames > USB_FS_MAX_FRAMES) 1014 popen->max_frames = USB_FS_MAX_FRAMES; 1015 1016 if (popen->max_frames == 0) 1017 return (EINVAL); 1018 1019 ep = usbd_get_ep_by_addr(f->udev, popen->ep_no); 1020 if (ep == NULL) 1021 return (EINVAL); 1022 1023 ed = ep->edesc; 1024 if (ed == NULL) 1025 return (ENXIO); 1026 1027 iface_index = ep->iface_index; 1028 1029 usb_config[0].type = ed->bmAttributes & UE_XFERTYPE; 1030 usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 1031 usb_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN); 1032 usb_config[0].interval = USB_DEFAULT_INTERVAL; 1033 usb_config[0].flags.proxy_buffer = 1; 1034 if (pre_scale != 0) 1035 usb_config[0].flags.pre_scale_frames = 1; 1036 1037 usb_config[0].callback = &ugen_ctrl_fs_callback; 1038 usb_config[0].timeout = 0; /* no timeout */ 1039 usb_config[0].frames = popen->max_frames; 1040 usb_config[0].bufsize = popen->max_bufsize; 1041 usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */ 1042 usb_config[0].stream_id = stream_id; 1043 1044 if (usb_config[0].type == UE_CONTROL) { 1045 if (f->udev->flags.usb_mode != USB_MODE_HOST) 1046 return (EINVAL); 1047 } else { 1048 isread = ((usb_config[0].endpoint & 1049 (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN); 1050 1051 if (f->udev->flags.usb_mode != USB_MODE_HOST) 1052 isread = !isread; 1053 1054 /* check permissions */ 1055 if (isread) { 1056 if (!(fflags & FREAD)) 1057 return (EPERM); 1058 } else { 1059 if (!(fflags & FWRITE)) 1060 return (EPERM); 1061 } 1062 } 1063 error = usbd_transfer_setup(f->udev, &iface_index, 1064 f->fs_xfer + popen->ep_index, usb_config, 1, 1065 f, f->priv_mtx); 1066 if (error == 0) { 1067 /* update maximums */ 1068 popen->max_packet_length = 1069 f->fs_xfer[popen->ep_index]->max_frame_size; 1070 popen->max_bufsize = 1071 f->fs_xfer[popen->ep_index]->max_data_length; 1072 /* update number of frames */ 1073 popen->max_frames = 1074 f->fs_xfer[popen->ep_index]->nframes; 1075 /* store index of endpoint */ 1076 f->fs_xfer[popen->ep_index]->priv_fifo = 1077 ((uint8_t *)0) + popen->ep_index; 1078 } else { 1079 error = ENOMEM; 1080 } 1081 return (error); 1082 } 1083 1084 static int 1085 usb_fs_close(struct usb_fifo *f, struct usb_fs_close *pclose) 1086 { 1087 struct usb_xfer *xfer; 1088 1089 if (pclose->ep_index >= f->fs_ep_max) 1090 return (EINVAL); 1091 1092 /* 1093 * Prevent calls into the fast-path code, by setting the 1094 * fs_xfer[] in question to NULL: 1095 */ 1096 sx_xlock(&f->fs_fastpath_lock); 1097 mtx_lock(f->priv_mtx); 1098 xfer = f->fs_xfer[pclose->ep_index]; 1099 f->fs_xfer[pclose->ep_index] = NULL; 1100 mtx_unlock(f->priv_mtx); 1101 sx_xunlock(&f->fs_fastpath_lock); 1102 1103 if (xfer == NULL) 1104 return (EINVAL); 1105 1106 usbd_transfer_unsetup(&xfer, 1); 1107 return (0); 1108 } 1109 1110 static int 1111 usb_fs_clear_stall_sync(struct usb_fifo *f, struct usb_fs_clear_stall_sync *pstall) 1112 { 1113 struct usb_device_request req; 1114 struct usb_endpoint *ep; 1115 int error; 1116 1117 if (pstall->ep_index >= f->fs_ep_max) 1118 return (EINVAL); 1119 1120 if (f->fs_xfer[pstall->ep_index] == NULL) 1121 return (EINVAL); 1122 1123 if (f->udev->flags.usb_mode != USB_MODE_HOST) 1124 return (EINVAL); 1125 1126 mtx_lock(f->priv_mtx); 1127 error = usbd_transfer_pending(f->fs_xfer[pstall->ep_index]); 1128 mtx_unlock(f->priv_mtx); 1129 1130 if (error) 1131 return (EBUSY); 1132 1133 ep = f->fs_xfer[pstall->ep_index]->endpoint; 1134 1135 /* setup a clear-stall packet */ 1136 req.bmRequestType = UT_WRITE_ENDPOINT; 1137 req.bRequest = UR_CLEAR_FEATURE; 1138 USETW(req.wValue, UF_ENDPOINT_HALT); 1139 req.wIndex[0] = ep->edesc->bEndpointAddress; 1140 req.wIndex[1] = 0; 1141 USETW(req.wLength, 0); 1142 1143 error = usbd_do_request(f->udev, NULL, &req, NULL); 1144 if (error == 0) { 1145 usbd_clear_data_toggle(f->udev, ep); 1146 } else { 1147 error = ENXIO; 1148 } 1149 return (error); 1150 } 1151 1152 static uint8_t 1153 ugen_fs_get_complete(struct usb_fifo *f, uint8_t *pindex) 1154 { 1155 struct usb_mbuf *m; 1156 1157 USB_IF_DEQUEUE(&f->used_q, m); 1158 1159 if (m) { 1160 *pindex = *((uint8_t *)(m->cur_data_ptr)); 1161 1162 USB_IF_ENQUEUE(&f->free_q, m); 1163 1164 return (0); /* success */ 1165 } else { 1166 *pindex = 0; /* fix compiler warning */ 1167 1168 f->flag_iscomplete = 0; 1169 } 1170 return (1); /* failure */ 1171 } 1172 1173 static void 1174 ugen_fs_set_complete(struct usb_fifo *f, uint8_t index) 1175 { 1176 struct usb_mbuf *m; 1177 1178 USB_IF_DEQUEUE(&f->free_q, m); 1179 1180 if (m == NULL) { 1181 /* can happen during close */ 1182 DPRINTF("out of buffers\n"); 1183 return; 1184 } 1185 USB_MBUF_RESET(m); 1186 1187 *((uint8_t *)(m->cur_data_ptr)) = index; 1188 1189 USB_IF_ENQUEUE(&f->used_q, m); 1190 1191 f->flag_iscomplete = 1; 1192 1193 usb_fifo_wakeup(f); 1194 } 1195 1196 static int 1197 ugen_fs_getbuffer(void **uptrp, struct usb_fifo *f, void *buffer, 1198 usb_frcount_t n) 1199 { 1200 union { 1201 void **ppBuffer; 1202 #ifdef COMPAT_FREEBSD32 1203 uint32_t *ppBuffer32; 1204 #endif 1205 } u; 1206 #ifdef COMPAT_FREEBSD32 1207 uint32_t uptr32; 1208 #endif 1209 1210 u.ppBuffer = buffer; 1211 switch (f->fs_ep_sz) { 1212 case sizeof(struct usb_fs_endpoint): 1213 if (fueword(u.ppBuffer + n, (long *)uptrp) != 0) 1214 return (EFAULT); 1215 return (0); 1216 #ifdef COMPAT_FREEBSD32 1217 case sizeof(struct usb_fs_endpoint32): 1218 if (fueword32(u.ppBuffer32 + n, &uptr32) != 0) 1219 return (EFAULT); 1220 *uptrp = PTRIN(uptr32); 1221 return (0); 1222 #endif 1223 default: 1224 panic("%s: unhandled fs_ep_sz %#x", __func__, f->fs_ep_sz); 1225 } 1226 } 1227 1228 static int 1229 ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index) 1230 { 1231 struct usb_device_request *req; 1232 struct usb_xfer *xfer; 1233 struct usb_fs_endpoint fs_ep; 1234 void *uaddr; /* userland pointer */ 1235 void *kaddr; 1236 usb_frlength_t offset; 1237 usb_frlength_t rem; 1238 usb_frcount_t n; 1239 uint32_t length; 1240 int error; 1241 uint8_t isread; 1242 1243 mtx_lock(f->priv_mtx); 1244 if (ep_index >= f->fs_ep_max) { 1245 mtx_unlock(f->priv_mtx); 1246 return (EINVAL); 1247 } 1248 xfer = f->fs_xfer[ep_index]; 1249 if (xfer == NULL) { 1250 mtx_unlock(f->priv_mtx); 1251 return (EINVAL); 1252 } 1253 if (usbd_transfer_pending(xfer)) { 1254 mtx_unlock(f->priv_mtx); 1255 return (EBUSY); /* should not happen */ 1256 } 1257 mtx_unlock(f->priv_mtx); 1258 1259 error = ugen_fs_copyin(f, ep_index, &fs_ep); 1260 if (error) { 1261 return (error); 1262 } 1263 /* security checks */ 1264 1265 if (fs_ep.nFrames > xfer->max_frame_count) { 1266 xfer->error = USB_ERR_INVAL; 1267 goto complete; 1268 } 1269 if (fs_ep.nFrames == 0) { 1270 xfer->error = USB_ERR_INVAL; 1271 goto complete; 1272 } 1273 error = ugen_fs_getbuffer(&uaddr, f, fs_ep.ppBuffer, 0); 1274 if (error) { 1275 return (error); 1276 } 1277 /* reset first frame */ 1278 usbd_xfer_set_frame_offset(xfer, 0, 0); 1279 1280 if (xfer->flags_int.control_xfr) { 1281 req = xfer->frbuffers[0].buffer; 1282 1283 if (fueword32(fs_ep.pLength, &length) != 0) { 1284 return (EFAULT); 1285 } 1286 if (length != sizeof(*req)) { 1287 xfer->error = USB_ERR_INVAL; 1288 goto complete; 1289 } 1290 if (length != 0) { 1291 error = copyin(uaddr, req, length); 1292 if (error) { 1293 return (error); 1294 } 1295 } 1296 if (usb_check_request(f->udev, req)) { 1297 xfer->error = USB_ERR_INVAL; 1298 goto complete; 1299 } 1300 usbd_xfer_set_frame_len(xfer, 0, length); 1301 1302 /* Host mode only ! */ 1303 if ((req->bmRequestType & 1304 (UT_READ | UT_WRITE)) == UT_READ) { 1305 isread = 1; 1306 } else { 1307 isread = 0; 1308 } 1309 n = 1; 1310 offset = sizeof(*req); 1311 1312 } else { 1313 /* Device and Host mode */ 1314 if (USB_GET_DATA_ISREAD(xfer)) { 1315 isread = 1; 1316 } else { 1317 isread = 0; 1318 } 1319 n = 0; 1320 offset = 0; 1321 } 1322 1323 rem = usbd_xfer_max_len(xfer); 1324 xfer->nframes = fs_ep.nFrames; 1325 xfer->timeout = fs_ep.timeout; 1326 if (xfer->timeout > 65535) { 1327 xfer->timeout = 65535; 1328 } 1329 if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK) 1330 xfer->flags.short_xfer_ok = 1; 1331 else 1332 xfer->flags.short_xfer_ok = 0; 1333 1334 if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK) 1335 xfer->flags.short_frames_ok = 1; 1336 else 1337 xfer->flags.short_frames_ok = 0; 1338 1339 if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT) 1340 xfer->flags.force_short_xfer = 1; 1341 else 1342 xfer->flags.force_short_xfer = 0; 1343 1344 if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL) 1345 usbd_xfer_set_stall(xfer); 1346 else 1347 xfer->flags.stall_pipe = 0; 1348 1349 for (; n != xfer->nframes; n++) { 1350 if (fueword32(fs_ep.pLength + n, &length) != 0) { 1351 break; 1352 } 1353 usbd_xfer_set_frame_len(xfer, n, length); 1354 1355 if (length > rem) { 1356 xfer->error = USB_ERR_INVAL; 1357 goto complete; 1358 } 1359 rem -= length; 1360 1361 if (!isread) { 1362 /* we need to know the source buffer */ 1363 error = ugen_fs_getbuffer(&uaddr, f, fs_ep.ppBuffer, n); 1364 if (error) { 1365 break; 1366 } 1367 if (xfer->flags_int.isochronous_xfr) { 1368 /* get kernel buffer address */ 1369 kaddr = xfer->frbuffers[0].buffer; 1370 kaddr = USB_ADD_BYTES(kaddr, offset); 1371 } else { 1372 /* set current frame offset */ 1373 usbd_xfer_set_frame_offset(xfer, offset, n); 1374 1375 /* get kernel buffer address */ 1376 kaddr = xfer->frbuffers[n].buffer; 1377 } 1378 1379 /* move data */ 1380 error = copyin(uaddr, kaddr, length); 1381 if (error) { 1382 break; 1383 } 1384 } 1385 offset += length; 1386 } 1387 return (error); 1388 1389 complete: 1390 mtx_lock(f->priv_mtx); 1391 ugen_fs_set_complete(f, ep_index); 1392 mtx_unlock(f->priv_mtx); 1393 return (0); 1394 } 1395 1396 static struct usb_fs_endpoint * 1397 ugen_fs_ep_uptr(struct usb_fifo *f, uint8_t ep_index) 1398 { 1399 return ((struct usb_fs_endpoint *) 1400 ((char *)f->fs_ep_ptr + (ep_index * f->fs_ep_sz))); 1401 } 1402 1403 static int 1404 ugen_fs_copyin(struct usb_fifo *f, uint8_t ep_index, 1405 struct usb_fs_endpoint* fs_ep) 1406 { 1407 #ifdef COMPAT_FREEBSD32 1408 struct usb_fs_endpoint32 fs_ep32; 1409 #endif 1410 int error; 1411 1412 switch (f->fs_ep_sz) { 1413 case sizeof(struct usb_fs_endpoint): 1414 error = copyin(ugen_fs_ep_uptr(f, ep_index), fs_ep, 1415 f->fs_ep_sz); 1416 if (error != 0) 1417 return (error); 1418 break; 1419 1420 #ifdef COMPAT_FREEBSD32 1421 case sizeof(struct usb_fs_endpoint32): 1422 error = copyin(ugen_fs_ep_uptr(f, ep_index), &fs_ep32, 1423 f->fs_ep_sz); 1424 if (error != 0) 1425 return (error); 1426 PTRIN_CP(fs_ep32, *fs_ep, ppBuffer); 1427 PTRIN_CP(fs_ep32, *fs_ep, pLength); 1428 CP(fs_ep32, *fs_ep, nFrames); 1429 CP(fs_ep32, *fs_ep, aFrames); 1430 CP(fs_ep32, *fs_ep, flags); 1431 CP(fs_ep32, *fs_ep, timeout); 1432 CP(fs_ep32, *fs_ep, isoc_time_complete); 1433 CP(fs_ep32, *fs_ep, status); 1434 break; 1435 #endif 1436 default: 1437 panic("%s: unhandled fs_ep_sz %#x", __func__, f->fs_ep_sz); 1438 } 1439 1440 return (0); 1441 } 1442 1443 static int 1444 ugen_fs_update(const struct usb_fs_endpoint *fs_ep, 1445 struct usb_fifo *f, uint8_t ep_index) 1446 { 1447 union { 1448 struct usb_fs_endpoint *fs_ep_uptr; 1449 #ifdef COMPAT_FREEBSD32 1450 struct usb_fs_endpoint32 *fs_ep_uptr32; 1451 #endif 1452 } u; 1453 uint32_t *aFrames_uptr; 1454 uint16_t *isoc_time_complete_uptr; 1455 int *status_uptr; 1456 1457 switch (f->fs_ep_sz) { 1458 case sizeof(struct usb_fs_endpoint): 1459 u.fs_ep_uptr = ugen_fs_ep_uptr(f, ep_index); 1460 aFrames_uptr = &u.fs_ep_uptr->aFrames; 1461 isoc_time_complete_uptr = &u.fs_ep_uptr->isoc_time_complete; 1462 status_uptr = &u.fs_ep_uptr->status; 1463 break; 1464 #ifdef COMPAT_FREEBSD32 1465 case sizeof(struct usb_fs_endpoint32): 1466 u.fs_ep_uptr32 = (struct usb_fs_endpoint32 *) 1467 ugen_fs_ep_uptr(f, ep_index); 1468 aFrames_uptr = &u.fs_ep_uptr32->aFrames; 1469 isoc_time_complete_uptr = &u.fs_ep_uptr32->isoc_time_complete; 1470 status_uptr = &u.fs_ep_uptr32->status; 1471 break; 1472 #endif 1473 default: 1474 panic("%s: unhandled fs_ep_sz %#x", __func__, f->fs_ep_sz); 1475 } 1476 1477 /* update "aFrames" */ 1478 if (suword32(aFrames_uptr, fs_ep->aFrames) != 0) 1479 return (EFAULT); 1480 1481 /* update "isoc_time_complete" */ 1482 if (suword16(isoc_time_complete_uptr, fs_ep->isoc_time_complete) != 0) 1483 return (EFAULT); 1484 1485 /* update "status" */ 1486 if (suword32(status_uptr, fs_ep->status) != 0) 1487 return (EFAULT); 1488 1489 return (0); 1490 } 1491 1492 static int 1493 ugen_fs_copy_out_cancelled(struct usb_fifo *f, uint8_t ep_index) 1494 { 1495 struct usb_fs_endpoint fs_ep; 1496 int error; 1497 1498 error = ugen_fs_copyin(f, ep_index, &fs_ep); 1499 if (error) 1500 return (error); 1501 1502 fs_ep.status = USB_ERR_CANCELLED; 1503 fs_ep.aFrames = 0; 1504 fs_ep.isoc_time_complete = 0; 1505 1506 return (ugen_fs_update(&fs_ep, f, ep_index)); 1507 } 1508 1509 static int 1510 ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index) 1511 { 1512 struct usb_device_request *req; 1513 struct usb_xfer *xfer; 1514 struct usb_fs_endpoint fs_ep; 1515 void *uaddr; /* userland ptr */ 1516 void *kaddr; 1517 usb_frlength_t offset; 1518 usb_frlength_t rem; 1519 usb_frcount_t n; 1520 uint32_t length; 1521 uint32_t temp; 1522 int error; 1523 uint8_t isread; 1524 1525 mtx_lock(f->priv_mtx); 1526 if (ep_index >= f->fs_ep_max) { 1527 mtx_unlock(f->priv_mtx); 1528 return (EINVAL); 1529 } 1530 xfer = f->fs_xfer[ep_index]; 1531 if (xfer == NULL) { 1532 mtx_unlock(f->priv_mtx); 1533 return (EINVAL); 1534 } 1535 if (!xfer->flags_int.transferring && 1536 !xfer->flags_int.started) { 1537 mtx_unlock(f->priv_mtx); 1538 DPRINTF("Returning fake cancel event\n"); 1539 return (ugen_fs_copy_out_cancelled(f, ep_index)); 1540 } else if (usbd_transfer_pending(xfer)) { 1541 mtx_unlock(f->priv_mtx); 1542 return (EBUSY); /* should not happen */ 1543 } 1544 mtx_unlock(f->priv_mtx); 1545 1546 error = ugen_fs_copyin(f, ep_index, &fs_ep); 1547 if (error) { 1548 return (error); 1549 } 1550 1551 fs_ep.status = xfer->error; 1552 fs_ep.aFrames = xfer->aframes; 1553 fs_ep.isoc_time_complete = xfer->isoc_time_complete; 1554 if (xfer->error) { 1555 goto complete; 1556 } 1557 if (xfer->flags_int.control_xfr) { 1558 req = xfer->frbuffers[0].buffer; 1559 1560 /* Host mode only ! */ 1561 if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) { 1562 isread = 1; 1563 } else { 1564 isread = 0; 1565 } 1566 if (xfer->nframes == 0) 1567 n = 0; /* should never happen */ 1568 else 1569 n = 1; 1570 } else { 1571 /* Device and Host mode */ 1572 if (USB_GET_DATA_ISREAD(xfer)) { 1573 isread = 1; 1574 } else { 1575 isread = 0; 1576 } 1577 n = 0; 1578 } 1579 1580 /* Update lengths and copy out data */ 1581 1582 rem = usbd_xfer_max_len(xfer); 1583 offset = 0; 1584 1585 for (; n != xfer->nframes; n++) { 1586 /* get initial length into "temp" */ 1587 if (fueword32(fs_ep.pLength + n, &temp) != 0) { 1588 return (EFAULT); 1589 } 1590 if (temp > rem) { 1591 /* the userland length has been corrupted */ 1592 DPRINTF("corrupt userland length " 1593 "%u > %u\n", temp, rem); 1594 fs_ep.status = USB_ERR_INVAL; 1595 goto complete; 1596 } 1597 rem -= temp; 1598 1599 /* get actual transfer length */ 1600 length = xfer->frlengths[n]; 1601 if (length > temp) { 1602 /* data overflow */ 1603 fs_ep.status = USB_ERR_INVAL; 1604 DPRINTF("data overflow %u > %u\n", 1605 length, temp); 1606 goto complete; 1607 } 1608 if (isread) { 1609 /* we need to know the destination buffer */ 1610 error = ugen_fs_getbuffer(&uaddr, f, fs_ep.ppBuffer, n); 1611 if (error) { 1612 return (error); 1613 } 1614 if (xfer->flags_int.isochronous_xfr) { 1615 /* only one frame buffer */ 1616 kaddr = USB_ADD_BYTES( 1617 xfer->frbuffers[0].buffer, offset); 1618 } else { 1619 /* multiple frame buffers */ 1620 kaddr = xfer->frbuffers[n].buffer; 1621 } 1622 1623 /* move data */ 1624 error = copyout(kaddr, uaddr, length); 1625 if (error) { 1626 goto complete; 1627 } 1628 } 1629 /* 1630 * Update offset according to initial length, which is 1631 * needed by isochronous transfers! 1632 */ 1633 offset += temp; 1634 1635 /* update length */ 1636 if (suword32(fs_ep.pLength + n, length) != 0) 1637 goto complete; 1638 } 1639 1640 complete: 1641 if (error == 0) 1642 error = ugen_fs_update(&fs_ep, f, ep_index); 1643 return (error); 1644 } 1645 1646 static uint8_t 1647 ugen_fifo_in_use(struct usb_fifo *f, int fflags) 1648 { 1649 struct usb_fifo *f_rx; 1650 struct usb_fifo *f_tx; 1651 1652 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX]; 1653 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX]; 1654 1655 if ((fflags & FREAD) && f_rx && 1656 (f_rx->xfer[0] || f_rx->xfer[1])) { 1657 return (1); /* RX FIFO in use */ 1658 } 1659 if ((fflags & FWRITE) && f_tx && 1660 (f_tx->xfer[0] || f_tx->xfer[1])) { 1661 return (1); /* TX FIFO in use */ 1662 } 1663 return (0); /* not in use */ 1664 } 1665 1666 static int 1667 ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) 1668 { 1669 union { 1670 struct usb_fs_complete *pcomp; 1671 struct usb_fs_start *pstart; 1672 struct usb_fs_stop *pstop; 1673 void *addr; 1674 } u; 1675 struct usb_xfer *xfer; 1676 int error; 1677 uint8_t ep_index; 1678 1679 u.addr = addr; 1680 1681 DPRINTFN(6, "cmd=0x%08lx\n", cmd); 1682 1683 switch (cmd) { 1684 case USB_FS_COMPLETE: 1685 sx_slock(&f->fs_fastpath_lock); 1686 mtx_lock(f->priv_mtx); 1687 error = ugen_fs_get_complete(f, &ep_index); 1688 mtx_unlock(f->priv_mtx); 1689 1690 if (error != 0) { 1691 error = EBUSY; 1692 } else { 1693 u.pcomp->ep_index = ep_index; 1694 error = ugen_fs_copy_out(f, u.pcomp->ep_index); 1695 } 1696 sx_sunlock(&f->fs_fastpath_lock); 1697 break; 1698 1699 case USB_FS_START: 1700 sx_slock(&f->fs_fastpath_lock); 1701 error = ugen_fs_copy_in(f, u.pstart->ep_index); 1702 if (error == 0) { 1703 mtx_lock(f->priv_mtx); 1704 xfer = f->fs_xfer[u.pstart->ep_index]; 1705 usbd_transfer_start(xfer); 1706 mtx_unlock(f->priv_mtx); 1707 } 1708 sx_sunlock(&f->fs_fastpath_lock); 1709 break; 1710 1711 case USB_FS_STOP: 1712 mtx_lock(f->priv_mtx); 1713 if (u.pstop->ep_index >= f->fs_ep_max) { 1714 error = EINVAL; 1715 } else { 1716 error = 0; 1717 xfer = f->fs_xfer[u.pstart->ep_index]; 1718 if (usbd_transfer_pending(xfer)) { 1719 usbd_transfer_stop(xfer); 1720 1721 /* 1722 * Check if the USB transfer was 1723 * stopped before it was even started 1724 * and fake a cancel event. 1725 */ 1726 if (!xfer->flags_int.transferring && 1727 !xfer->flags_int.started) { 1728 DPRINTF("Issuing fake completion event\n"); 1729 ugen_fs_set_complete(xfer->priv_sc, 1730 USB_P2U(xfer->priv_fifo)); 1731 } 1732 } 1733 } 1734 mtx_unlock(f->priv_mtx); 1735 break; 1736 1737 default: 1738 error = ENOIOCTL; 1739 break; 1740 } 1741 1742 DPRINTFN(6, "error=%d\n", error); 1743 1744 return (error); 1745 } 1746 1747 static int 1748 ugen_set_short_xfer(struct usb_fifo *f, void *addr) 1749 { 1750 uint8_t t; 1751 1752 if (*(int *)addr) 1753 t = 1; 1754 else 1755 t = 0; 1756 1757 if (f->flag_short == t) { 1758 /* same value like before - accept */ 1759 return (0); 1760 } 1761 if (f->xfer[0] || f->xfer[1]) { 1762 /* cannot change this during transfer */ 1763 return (EBUSY); 1764 } 1765 f->flag_short = t; 1766 return (0); 1767 } 1768 1769 static int 1770 ugen_set_timeout(struct usb_fifo *f, void *addr) 1771 { 1772 f->timeout = *(int *)addr; 1773 if (f->timeout > 65535) { 1774 /* limit user input */ 1775 f->timeout = 65535; 1776 } 1777 return (0); 1778 } 1779 1780 static int 1781 ugen_get_frame_size(struct usb_fifo *f, void *addr) 1782 { 1783 if (f->xfer[0]) { 1784 *(int *)addr = f->xfer[0]->max_frame_size; 1785 } else { 1786 return (EINVAL); 1787 } 1788 return (0); 1789 } 1790 1791 static int 1792 ugen_set_buffer_size(struct usb_fifo *f, void *addr) 1793 { 1794 usb_frlength_t t; 1795 1796 if (*(int *)addr < 0) 1797 t = 0; /* use "wMaxPacketSize" */ 1798 else if (*(int *)addr < (256 * 1024)) 1799 t = *(int *)addr; 1800 else 1801 t = 256 * 1024; 1802 1803 if (f->bufsize == t) { 1804 /* same value like before - accept */ 1805 return (0); 1806 } 1807 if (f->xfer[0] || f->xfer[1]) { 1808 /* cannot change this during transfer */ 1809 return (EBUSY); 1810 } 1811 f->bufsize = t; 1812 return (0); 1813 } 1814 1815 static int 1816 ugen_get_buffer_size(struct usb_fifo *f, void *addr) 1817 { 1818 *(int *)addr = f->bufsize; 1819 return (0); 1820 } 1821 1822 static int 1823 ugen_get_iface_desc(struct usb_fifo *f, 1824 struct usb_interface_descriptor *idesc) 1825 { 1826 struct usb_interface *iface; 1827 1828 iface = usbd_get_iface(f->udev, f->iface_index); 1829 if (iface && iface->idesc) { 1830 *idesc = *(iface->idesc); 1831 } else { 1832 return (EIO); 1833 } 1834 return (0); 1835 } 1836 1837 static int 1838 ugen_get_endpoint_desc(struct usb_fifo *f, 1839 struct usb_endpoint_descriptor *ed) 1840 { 1841 struct usb_endpoint *ep; 1842 1843 ep = usb_fifo_softc(f); 1844 1845 if (ep && ep->edesc) { 1846 *ed = *ep->edesc; 1847 } else { 1848 return (EINVAL); 1849 } 1850 return (0); 1851 } 1852 1853 static int 1854 ugen_set_power_mode(struct usb_fifo *f, int mode) 1855 { 1856 struct usb_device *udev = f->udev; 1857 int err; 1858 uint8_t old_mode; 1859 1860 if ((udev == NULL) || 1861 (udev->parent_hub == NULL)) { 1862 return (EINVAL); 1863 } 1864 err = priv_check(curthread, PRIV_DRIVER); 1865 if (err) 1866 return (err); 1867 1868 /* get old power mode */ 1869 old_mode = udev->power_mode; 1870 1871 /* if no change, then just return */ 1872 if (old_mode == mode) 1873 return (0); 1874 1875 switch (mode) { 1876 case USB_POWER_MODE_OFF: 1877 if (udev->flags.usb_mode == USB_MODE_HOST && 1878 udev->re_enumerate_wait == USB_RE_ENUM_DONE) { 1879 udev->re_enumerate_wait = USB_RE_ENUM_PWR_OFF; 1880 } 1881 /* set power mode will wake up the explore thread */ 1882 break; 1883 1884 case USB_POWER_MODE_ON: 1885 case USB_POWER_MODE_SAVE: 1886 break; 1887 1888 case USB_POWER_MODE_RESUME: 1889 #if USB_HAVE_POWERD 1890 /* let USB-powerd handle resume */ 1891 USB_BUS_LOCK(udev->bus); 1892 udev->pwr_save.write_refs++; 1893 udev->pwr_save.last_xfer_time = ticks; 1894 USB_BUS_UNLOCK(udev->bus); 1895 1896 /* set new power mode */ 1897 usbd_set_power_mode(udev, USB_POWER_MODE_SAVE); 1898 1899 /* wait for resume to complete */ 1900 usb_pause_mtx(NULL, hz / 4); 1901 1902 /* clear write reference */ 1903 USB_BUS_LOCK(udev->bus); 1904 udev->pwr_save.write_refs--; 1905 USB_BUS_UNLOCK(udev->bus); 1906 #endif 1907 mode = USB_POWER_MODE_SAVE; 1908 break; 1909 1910 case USB_POWER_MODE_SUSPEND: 1911 #if USB_HAVE_POWERD 1912 /* let USB-powerd handle suspend */ 1913 USB_BUS_LOCK(udev->bus); 1914 udev->pwr_save.last_xfer_time = ticks - (256 * hz); 1915 USB_BUS_UNLOCK(udev->bus); 1916 #endif 1917 mode = USB_POWER_MODE_SAVE; 1918 break; 1919 1920 default: 1921 return (EINVAL); 1922 } 1923 1924 if (err) 1925 return (ENXIO); /* I/O failure */ 1926 1927 /* if we are powered off we need to re-enumerate first */ 1928 if (old_mode == USB_POWER_MODE_OFF) { 1929 if (udev->flags.usb_mode == USB_MODE_HOST && 1930 udev->re_enumerate_wait == USB_RE_ENUM_DONE) { 1931 udev->re_enumerate_wait = USB_RE_ENUM_START; 1932 } 1933 /* set power mode will wake up the explore thread */ 1934 } 1935 1936 /* set new power mode */ 1937 usbd_set_power_mode(udev, mode); 1938 1939 return (0); /* success */ 1940 } 1941 1942 static int 1943 ugen_get_power_mode(struct usb_fifo *f) 1944 { 1945 struct usb_device *udev = f->udev; 1946 1947 if (udev == NULL) 1948 return (USB_POWER_MODE_ON); 1949 1950 return (udev->power_mode); 1951 } 1952 1953 static int 1954 ugen_get_port_path(struct usb_fifo *f, struct usb_device_port_path *dpp) 1955 { 1956 struct usb_device *udev = f->udev; 1957 struct usb_device *next; 1958 unsigned nlevel = 0; 1959 1960 if (udev == NULL) 1961 goto error; 1962 1963 dpp->udp_bus = device_get_unit(udev->bus->bdev); 1964 dpp->udp_index = udev->device_index; 1965 1966 /* count port levels */ 1967 next = udev; 1968 while (next->parent_hub != NULL) { 1969 nlevel++; 1970 next = next->parent_hub; 1971 } 1972 1973 /* check if too many levels */ 1974 if (nlevel > USB_DEVICE_PORT_PATH_MAX) 1975 goto error; 1976 1977 /* store total level of ports */ 1978 dpp->udp_port_level = nlevel; 1979 1980 /* store port index array */ 1981 next = udev; 1982 while (next->parent_hub != NULL) { 1983 dpp->udp_port_no[--nlevel] = next->port_no; 1984 next = next->parent_hub; 1985 } 1986 return (0); /* success */ 1987 1988 error: 1989 return (EINVAL); /* failure */ 1990 } 1991 1992 static int 1993 ugen_get_power_usage(struct usb_fifo *f) 1994 { 1995 struct usb_device *udev = f->udev; 1996 1997 if (udev == NULL) 1998 return (0); 1999 2000 return (udev->power); 2001 } 2002 2003 static int 2004 ugen_do_port_feature(struct usb_fifo *f, uint8_t port_no, 2005 uint8_t set, uint16_t feature) 2006 { 2007 struct usb_device *udev = f->udev; 2008 struct usb_hub *hub; 2009 int err; 2010 2011 err = priv_check(curthread, PRIV_DRIVER); 2012 if (err) { 2013 return (err); 2014 } 2015 if (port_no == 0) { 2016 return (EINVAL); 2017 } 2018 if ((udev == NULL) || 2019 (udev->hub == NULL)) { 2020 return (EINVAL); 2021 } 2022 hub = udev->hub; 2023 2024 if (port_no > hub->nports) { 2025 return (EINVAL); 2026 } 2027 if (set) 2028 err = usbd_req_set_port_feature(udev, 2029 NULL, port_no, feature); 2030 else 2031 err = usbd_req_clear_port_feature(udev, 2032 NULL, port_no, feature); 2033 2034 if (err) 2035 return (ENXIO); /* failure */ 2036 2037 return (0); /* success */ 2038 } 2039 2040 static int 2041 ugen_iface_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) 2042 { 2043 struct usb_fifo *f_rx; 2044 struct usb_fifo *f_tx; 2045 int error = 0; 2046 2047 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX]; 2048 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX]; 2049 2050 switch (cmd) { 2051 case USB_SET_RX_SHORT_XFER: 2052 if (fflags & FREAD) { 2053 error = ugen_set_short_xfer(f_rx, addr); 2054 } else { 2055 error = EINVAL; 2056 } 2057 break; 2058 2059 case USB_SET_TX_FORCE_SHORT: 2060 if (fflags & FWRITE) { 2061 error = ugen_set_short_xfer(f_tx, addr); 2062 } else { 2063 error = EINVAL; 2064 } 2065 break; 2066 2067 case USB_SET_RX_TIMEOUT: 2068 if (fflags & FREAD) { 2069 error = ugen_set_timeout(f_rx, addr); 2070 } else { 2071 error = EINVAL; 2072 } 2073 break; 2074 2075 case USB_SET_TX_TIMEOUT: 2076 if (fflags & FWRITE) { 2077 error = ugen_set_timeout(f_tx, addr); 2078 } else { 2079 error = EINVAL; 2080 } 2081 break; 2082 2083 case USB_GET_RX_FRAME_SIZE: 2084 if (fflags & FREAD) { 2085 error = ugen_get_frame_size(f_rx, addr); 2086 } else { 2087 error = EINVAL; 2088 } 2089 break; 2090 2091 case USB_GET_TX_FRAME_SIZE: 2092 if (fflags & FWRITE) { 2093 error = ugen_get_frame_size(f_tx, addr); 2094 } else { 2095 error = EINVAL; 2096 } 2097 break; 2098 2099 case USB_SET_RX_BUFFER_SIZE: 2100 if (fflags & FREAD) { 2101 error = ugen_set_buffer_size(f_rx, addr); 2102 } else { 2103 error = EINVAL; 2104 } 2105 break; 2106 2107 case USB_SET_TX_BUFFER_SIZE: 2108 if (fflags & FWRITE) { 2109 error = ugen_set_buffer_size(f_tx, addr); 2110 } else { 2111 error = EINVAL; 2112 } 2113 break; 2114 2115 case USB_GET_RX_BUFFER_SIZE: 2116 if (fflags & FREAD) { 2117 error = ugen_get_buffer_size(f_rx, addr); 2118 } else { 2119 error = EINVAL; 2120 } 2121 break; 2122 2123 case USB_GET_TX_BUFFER_SIZE: 2124 if (fflags & FWRITE) { 2125 error = ugen_get_buffer_size(f_tx, addr); 2126 } else { 2127 error = EINVAL; 2128 } 2129 break; 2130 2131 case USB_GET_RX_INTERFACE_DESC: 2132 if (fflags & FREAD) { 2133 error = ugen_get_iface_desc(f_rx, addr); 2134 } else { 2135 error = EINVAL; 2136 } 2137 break; 2138 2139 case USB_GET_TX_INTERFACE_DESC: 2140 if (fflags & FWRITE) { 2141 error = ugen_get_iface_desc(f_tx, addr); 2142 } else { 2143 error = EINVAL; 2144 } 2145 break; 2146 2147 case USB_GET_RX_ENDPOINT_DESC: 2148 if (fflags & FREAD) { 2149 error = ugen_get_endpoint_desc(f_rx, addr); 2150 } else { 2151 error = EINVAL; 2152 } 2153 break; 2154 2155 case USB_GET_TX_ENDPOINT_DESC: 2156 if (fflags & FWRITE) { 2157 error = ugen_get_endpoint_desc(f_tx, addr); 2158 } else { 2159 error = EINVAL; 2160 } 2161 break; 2162 2163 case USB_SET_RX_STALL_FLAG: 2164 if ((fflags & FREAD) && (*(int *)addr)) { 2165 f_rx->flag_stall = 1; 2166 } 2167 break; 2168 2169 case USB_SET_TX_STALL_FLAG: 2170 if ((fflags & FWRITE) && (*(int *)addr)) { 2171 f_tx->flag_stall = 1; 2172 } 2173 break; 2174 2175 default: 2176 error = ENOIOCTL; 2177 break; 2178 } 2179 return (error); 2180 } 2181 2182 static int 2183 ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) 2184 { 2185 union { 2186 struct usb_interface_descriptor *idesc; 2187 struct usb_alt_interface *ai; 2188 struct usb_device_descriptor *ddesc; 2189 struct usb_config_descriptor *cdesc; 2190 struct usb_device_stats *stat; 2191 struct usb_fs_init *pinit; 2192 #ifdef COMPAT_FREEBSD32 2193 struct usb_fs_init32 *pinit32; 2194 #endif 2195 struct usb_fs_uninit *puninit; 2196 struct usb_fs_open *popen; 2197 struct usb_fs_open_stream *popen_stream; 2198 struct usb_fs_close *pclose; 2199 struct usb_fs_clear_stall_sync *pstall; 2200 struct usb_device_port_path *dpp; 2201 uint32_t *ptime; 2202 void *addr; 2203 int *pint; 2204 } u; 2205 struct usb_device_descriptor *dtemp; 2206 struct usb_config_descriptor *ctemp; 2207 struct usb_interface *iface; 2208 int error = 0; 2209 uint8_t n; 2210 2211 u.addr = addr; 2212 2213 DPRINTFN(6, "cmd=0x%08lx\n", cmd); 2214 2215 switch (cmd) { 2216 case USB_DISCOVER: 2217 usb_needs_explore_all(); 2218 break; 2219 2220 case USB_SETDEBUG: 2221 if (!(fflags & FWRITE)) { 2222 error = EPERM; 2223 break; 2224 } 2225 usb_debug = *(int *)addr; 2226 break; 2227 2228 case USB_GET_CONFIG: 2229 *(int *)addr = f->udev->curr_config_index; 2230 break; 2231 2232 case USB_SET_CONFIG: 2233 if (!(fflags & FWRITE)) { 2234 error = EPERM; 2235 break; 2236 } 2237 error = ugen_set_config(f, *(int *)addr); 2238 break; 2239 2240 case USB_GET_ALTINTERFACE: 2241 iface = usbd_get_iface(f->udev, 2242 u.ai->uai_interface_index); 2243 if (iface && iface->idesc) { 2244 u.ai->uai_alt_index = iface->alt_index; 2245 } else { 2246 error = EINVAL; 2247 } 2248 break; 2249 2250 case USB_SET_ALTINTERFACE: 2251 if (!(fflags & FWRITE)) { 2252 error = EPERM; 2253 break; 2254 } 2255 error = ugen_set_interface(f, 2256 u.ai->uai_interface_index, u.ai->uai_alt_index); 2257 break; 2258 2259 case USB_GET_DEVICE_DESC: 2260 dtemp = usbd_get_device_descriptor(f->udev); 2261 if (!dtemp) { 2262 error = EIO; 2263 break; 2264 } 2265 *u.ddesc = *dtemp; 2266 break; 2267 2268 case USB_GET_CONFIG_DESC: 2269 ctemp = usbd_get_config_descriptor(f->udev); 2270 if (!ctemp) { 2271 error = EIO; 2272 break; 2273 } 2274 *u.cdesc = *ctemp; 2275 break; 2276 2277 case USB_GET_FULL_DESC: 2278 error = ugen_get_cdesc(f, addr); 2279 break; 2280 2281 case USB_GET_STRING_DESC: 2282 error = ugen_get_sdesc(f, addr); 2283 break; 2284 2285 case USB_GET_IFACE_DRIVER: 2286 error = ugen_get_iface_driver(f, addr); 2287 break; 2288 2289 #ifdef COMPAT_FREEBSD32 2290 case USB_GET_FULL_DESC32: 2291 case USB_GET_STRING_DESC32: 2292 case USB_GET_IFACE_DRIVER32: 2293 error = ugen_get32(cmd, f, addr); 2294 break; 2295 #endif 2296 2297 case USB_REQUEST: 2298 case USB_DO_REQUEST: 2299 if (!(fflags & FWRITE)) { 2300 error = EPERM; 2301 break; 2302 } 2303 error = ugen_do_request(f, addr); 2304 break; 2305 2306 #ifdef COMPAT_FREEBSD32 2307 case USB_REQUEST32: 2308 case USB_DO_REQUEST32: 2309 if (!(fflags & FWRITE)) { 2310 error = EPERM; 2311 break; 2312 } 2313 error = ugen_do_request32(f, addr); 2314 break; 2315 #endif 2316 2317 case USB_DEVICEINFO: 2318 case USB_GET_DEVICEINFO: 2319 error = ugen_fill_deviceinfo(f, addr); 2320 break; 2321 2322 case USB_DEVICESTATS: 2323 for (n = 0; n != 4; n++) { 2324 u.stat->uds_requests_fail[n] = 2325 f->udev->stats_err.uds_requests[n]; 2326 u.stat->uds_requests_ok[n] = 2327 f->udev->stats_ok.uds_requests[n]; 2328 } 2329 break; 2330 2331 case USB_DEVICEENUMERATE: 2332 error = ugen_re_enumerate(f); 2333 break; 2334 2335 case USB_GET_PLUGTIME: 2336 *u.ptime = f->udev->plugtime; 2337 break; 2338 2339 case USB_CLAIM_INTERFACE: 2340 case USB_RELEASE_INTERFACE: 2341 /* TODO */ 2342 break; 2343 2344 case USB_IFACE_DRIVER_ACTIVE: 2345 n = *u.pint & 0xFF; 2346 iface = usbd_get_iface(f->udev, n); 2347 if (iface != NULL && iface->subdev != NULL && 2348 device_is_alive(iface->subdev)) 2349 error = 0; 2350 else 2351 error = ENXIO; 2352 break; 2353 2354 case USB_IFACE_DRIVER_DETACH: 2355 2356 error = priv_check(curthread, PRIV_DRIVER); 2357 2358 if (error) 2359 break; 2360 2361 n = *u.pint & 0xFF; 2362 2363 if (n == USB_IFACE_INDEX_ANY) { 2364 error = EINVAL; 2365 break; 2366 } 2367 2368 /* 2369 * Detach the currently attached driver. 2370 */ 2371 usb_detach_device(f->udev, n, 0); 2372 2373 /* 2374 * Set parent to self, this should keep attach away 2375 * until the next set configuration event. 2376 */ 2377 usbd_set_parent_iface(f->udev, n, n); 2378 break; 2379 2380 case USB_SET_POWER_MODE: 2381 error = ugen_set_power_mode(f, *u.pint); 2382 break; 2383 2384 case USB_GET_POWER_MODE: 2385 *u.pint = ugen_get_power_mode(f); 2386 break; 2387 2388 case USB_GET_DEV_PORT_PATH: 2389 error = ugen_get_port_path(f, u.dpp); 2390 break; 2391 2392 case USB_GET_POWER_USAGE: 2393 *u.pint = ugen_get_power_usage(f); 2394 break; 2395 2396 case USB_SET_PORT_ENABLE: 2397 error = ugen_do_port_feature(f, 2398 *u.pint, 1, UHF_PORT_ENABLE); 2399 break; 2400 2401 case USB_SET_PORT_DISABLE: 2402 error = ugen_do_port_feature(f, 2403 *u.pint, 0, UHF_PORT_ENABLE); 2404 break; 2405 2406 case USB_FS_INIT: 2407 error = ugen_fs_init(f, u.pinit->pEndpoints, 2408 sizeof(struct usb_fs_endpoint), fflags, 2409 u.pinit->ep_index_max); 2410 break; 2411 #ifdef COMPAT_FREEBSD32 2412 case USB_FS_INIT32: 2413 error = ugen_fs_init(f, PTRIN(u.pinit32->pEndpoints), 2414 sizeof(struct usb_fs_endpoint32), fflags, 2415 u.pinit32->ep_index_max); 2416 break; 2417 #endif 2418 case USB_FS_UNINIT: 2419 if (u.puninit->dummy != 0) { 2420 error = EINVAL; 2421 break; 2422 } 2423 error = ugen_fs_uninit(f); 2424 break; 2425 2426 case USB_FS_OPEN: 2427 case USB_FS_OPEN_STREAM: 2428 error = usb_fs_open(f, u.popen, fflags, 2429 (cmd == USB_FS_OPEN_STREAM) ? u.popen_stream->stream_id : 0); 2430 break; 2431 2432 case USB_FS_CLOSE: 2433 error = usb_fs_close(f, u.pclose); 2434 break; 2435 2436 case USB_FS_CLEAR_STALL_SYNC: 2437 error = usb_fs_clear_stall_sync(f, u.pstall); 2438 break; 2439 2440 default: 2441 mtx_lock(f->priv_mtx); 2442 error = ugen_iface_ioctl(f, cmd, addr, fflags); 2443 mtx_unlock(f->priv_mtx); 2444 break; 2445 } 2446 DPRINTFN(6, "error=%d\n", error); 2447 return (error); 2448 } 2449 2450 static void 2451 ugen_ctrl_fs_callback(struct usb_xfer *xfer, usb_error_t error) 2452 { 2453 ; /* workaround for a bug in "indent" */ 2454 2455 DPRINTF("st=%u alen=%u aframes=%u\n", 2456 USB_GET_STATE(xfer), xfer->actlen, xfer->aframes); 2457 2458 switch (USB_GET_STATE(xfer)) { 2459 case USB_ST_SETUP: 2460 usbd_transfer_submit(xfer); 2461 break; 2462 default: 2463 ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo)); 2464 break; 2465 } 2466 } 2467 2468 #ifdef COMPAT_FREEBSD32 2469 void 2470 usb_gen_descriptor_from32(struct usb_gen_descriptor *ugd, 2471 const struct usb_gen_descriptor32 *ugd32) 2472 { 2473 PTRIN_CP(*ugd32, *ugd, ugd_data); 2474 CP(*ugd32, *ugd, ugd_lang_id); 2475 CP(*ugd32, *ugd, ugd_maxlen); 2476 CP(*ugd32, *ugd, ugd_actlen); 2477 CP(*ugd32, *ugd, ugd_offset); 2478 CP(*ugd32, *ugd, ugd_config_index); 2479 CP(*ugd32, *ugd, ugd_string_index); 2480 CP(*ugd32, *ugd, ugd_iface_index); 2481 CP(*ugd32, *ugd, ugd_altif_index); 2482 CP(*ugd32, *ugd, ugd_endpt_index); 2483 CP(*ugd32, *ugd, ugd_report_type); 2484 /* Don't copy reserved */ 2485 } 2486 2487 void 2488 update_usb_gen_descriptor32(struct usb_gen_descriptor32 *ugd32, 2489 struct usb_gen_descriptor *ugd) 2490 { 2491 /* Don't update ugd_data pointer */ 2492 CP(*ugd32, *ugd, ugd_lang_id); 2493 CP(*ugd32, *ugd, ugd_maxlen); 2494 CP(*ugd32, *ugd, ugd_actlen); 2495 CP(*ugd32, *ugd, ugd_offset); 2496 CP(*ugd32, *ugd, ugd_config_index); 2497 CP(*ugd32, *ugd, ugd_string_index); 2498 CP(*ugd32, *ugd, ugd_iface_index); 2499 CP(*ugd32, *ugd, ugd_altif_index); 2500 CP(*ugd32, *ugd, ugd_endpt_index); 2501 CP(*ugd32, *ugd, ugd_report_type); 2502 /* Don't update reserved */ 2503 } 2504 2505 static int 2506 ugen_get32(u_long cmd, struct usb_fifo *f, struct usb_gen_descriptor32 *ugd32) 2507 { 2508 struct usb_gen_descriptor ugd; 2509 int error; 2510 2511 usb_gen_descriptor_from32(&ugd, ugd32); 2512 switch (cmd) { 2513 case USB_GET_FULL_DESC32: 2514 error = ugen_get_cdesc(f, &ugd); 2515 break; 2516 2517 case USB_GET_STRING_DESC32: 2518 error = ugen_get_sdesc(f, &ugd); 2519 break; 2520 2521 case USB_GET_IFACE_DRIVER32: 2522 error = ugen_get_iface_driver(f, &ugd); 2523 break; 2524 default: 2525 /* Can't happen except by programmer error */ 2526 panic("%s: called with invalid cmd %lx", __func__, cmd); 2527 } 2528 update_usb_gen_descriptor32(ugd32, &ugd); 2529 2530 return (error); 2531 } 2532 2533 #endif /* COMPAT_FREEBSD32 */ 2534 2535 #endif /* USB_HAVE_UGEN */ 2536