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