1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved. 4 * Copyright (c) 1998 Lennart Augustsson. All rights reserved. 5 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/stdint.h> 30 #include <sys/param.h> 31 #include <sys/queue.h> 32 #include <sys/types.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/bus.h> 36 #include <sys/module.h> 37 #include <sys/lock.h> 38 #include <sys/mutex.h> 39 #include <sys/condvar.h> 40 #include <sys/sysctl.h> 41 #include <sys/unistd.h> 42 #include <sys/callout.h> 43 #include <sys/malloc.h> 44 #include <sys/priv.h> 45 46 #include <bus/u4b/usb.h> 47 #include <bus/u4b/usbdi.h> 48 #include <bus/u4b/usbdi_util.h> 49 #include <bus/u4b/usb_ioctl.h> 50 #include <bus/u4b/usbhid.h> 51 52 #define USB_DEBUG_VAR usb_debug 53 54 #include <bus/u4b/usb_core.h> 55 #include <bus/u4b/usb_busdma.h> 56 #include <bus/u4b/usb_request.h> 57 #include <bus/u4b/usb_process.h> 58 #include <bus/u4b/usb_transfer.h> 59 #include <bus/u4b/usb_debug.h> 60 #include <bus/u4b/usb_device.h> 61 #include <bus/u4b/usb_util.h> 62 #include <bus/u4b/usb_dynamic.h> 63 64 #include <bus/u4b/usb_controller.h> 65 #include <bus/u4b/usb_bus.h> 66 #include <sys/ctype.h> 67 68 static int usb_no_cs_fail; 69 70 SYSCTL_INT(_hw_usb, OID_AUTO, no_cs_fail, CTLFLAG_RW, 71 &usb_no_cs_fail, 0, "USB clear stall failures are ignored, if set"); 72 73 #ifdef USB_DEBUG 74 static int usb_pr_poll_delay = USB_PORT_RESET_DELAY; 75 static int usb_pr_recovery_delay = USB_PORT_RESET_RECOVERY; 76 77 SYSCTL_INT(_hw_usb, OID_AUTO, pr_poll_delay, CTLFLAG_RW, 78 &usb_pr_poll_delay, 0, "USB port reset poll delay in ms"); 79 SYSCTL_INT(_hw_usb, OID_AUTO, pr_recovery_delay, CTLFLAG_RW, 80 &usb_pr_recovery_delay, 0, "USB port reset recovery delay in ms"); 81 82 #ifdef USB_REQ_DEBUG 83 /* The following structures are used in connection to fault injection. */ 84 struct usb_ctrl_debug { 85 int bus_index; /* target bus */ 86 int dev_index; /* target address */ 87 int ds_fail; /* fail data stage */ 88 int ss_fail; /* fail data stage */ 89 int ds_delay; /* data stage delay in ms */ 90 int ss_delay; /* status stage delay in ms */ 91 int bmRequestType_value; 92 int bRequest_value; 93 }; 94 95 struct usb_ctrl_debug_bits { 96 uint16_t ds_delay; 97 uint16_t ss_delay; 98 uint8_t ds_fail:1; 99 uint8_t ss_fail:1; 100 uint8_t enabled:1; 101 }; 102 103 /* The default is to disable fault injection. */ 104 105 static struct usb_ctrl_debug usb_ctrl_debug = { 106 .bus_index = -1, 107 .dev_index = -1, 108 .bmRequestType_value = -1, 109 .bRequest_value = -1, 110 }; 111 112 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_bus_fail, CTLFLAG_RW, 113 &usb_ctrl_debug.bus_index, 0, "USB controller index to fail"); 114 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_dev_fail, CTLFLAG_RW, 115 &usb_ctrl_debug.dev_index, 0, "USB device address to fail"); 116 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ds_fail, CTLFLAG_RW, 117 &usb_ctrl_debug.ds_fail, 0, "USB fail data stage"); 118 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ss_fail, CTLFLAG_RW, 119 &usb_ctrl_debug.ss_fail, 0, "USB fail status stage"); 120 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ds_delay, CTLFLAG_RW, 121 &usb_ctrl_debug.ds_delay, 0, "USB data stage delay in ms"); 122 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ss_delay, CTLFLAG_RW, 123 &usb_ctrl_debug.ss_delay, 0, "USB status stage delay in ms"); 124 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_rt_fail, CTLFLAG_RW, 125 &usb_ctrl_debug.bmRequestType_value, 0, "USB bmRequestType to fail"); 126 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_rv_fail, CTLFLAG_RW, 127 &usb_ctrl_debug.bRequest_value, 0, "USB bRequest to fail"); 128 129 /*------------------------------------------------------------------------* 130 * usbd_get_debug_bits 131 * 132 * This function is only useful in USB host mode. 133 *------------------------------------------------------------------------*/ 134 static void 135 usbd_get_debug_bits(struct usb_device *udev, struct usb_device_request *req, 136 struct usb_ctrl_debug_bits *dbg) 137 { 138 int temp; 139 140 memset(dbg, 0, sizeof(*dbg)); 141 142 /* Compute data stage delay */ 143 144 temp = usb_ctrl_debug.ds_delay; 145 if (temp < 0) 146 temp = 0; 147 else if (temp > (16*1024)) 148 temp = (16*1024); 149 150 dbg->ds_delay = temp; 151 152 /* Compute status stage delay */ 153 154 temp = usb_ctrl_debug.ss_delay; 155 if (temp < 0) 156 temp = 0; 157 else if (temp > (16*1024)) 158 temp = (16*1024); 159 160 dbg->ss_delay = temp; 161 162 /* Check if this control request should be failed */ 163 164 if (usbd_get_bus_index(udev) != usb_ctrl_debug.bus_index) 165 return; 166 167 if (usbd_get_device_index(udev) != usb_ctrl_debug.dev_index) 168 return; 169 170 temp = usb_ctrl_debug.bmRequestType_value; 171 172 if ((temp != req->bmRequestType) && (temp >= 0) && (temp <= 255)) 173 return; 174 175 temp = usb_ctrl_debug.bRequest_value; 176 177 if ((temp != req->bRequest) && (temp >= 0) && (temp <= 255)) 178 return; 179 180 temp = usb_ctrl_debug.ds_fail; 181 if (temp) 182 dbg->ds_fail = 1; 183 184 temp = usb_ctrl_debug.ss_fail; 185 if (temp) 186 dbg->ss_fail = 1; 187 188 dbg->enabled = 1; 189 } 190 #endif /* USB_REQ_DEBUG */ 191 #endif /* USB_DEBUG */ 192 193 /*------------------------------------------------------------------------* 194 * usbd_do_request_callback 195 * 196 * This function is the USB callback for generic USB Host control 197 * transfers. 198 *------------------------------------------------------------------------*/ 199 void 200 usbd_do_request_callback(struct usb_xfer *xfer, usb_error_t error) 201 { 202 ; /* workaround for a bug in "indent" */ 203 204 DPRINTF("st=%u\n", USB_GET_STATE(xfer)); 205 206 switch (USB_GET_STATE(xfer)) { 207 case USB_ST_SETUP: 208 usbd_transfer_submit(xfer); 209 break; 210 default: 211 cv_signal(&xfer->xroot->udev->ctrlreq_cv); 212 break; 213 } 214 } 215 216 /*------------------------------------------------------------------------* 217 * usb_do_clear_stall_callback 218 * 219 * This function is the USB callback for generic clear stall requests. 220 *------------------------------------------------------------------------*/ 221 void 222 usb_do_clear_stall_callback(struct usb_xfer *xfer, usb_error_t error) 223 { 224 struct usb_device_request req; 225 struct usb_device *udev; 226 struct usb_endpoint *ep; 227 struct usb_endpoint *ep_end; 228 struct usb_endpoint *ep_first; 229 uint8_t to; 230 231 udev = xfer->xroot->udev; 232 233 USB_BUS_LOCK(udev->bus); 234 235 /* round robin endpoint clear stall */ 236 237 ep = udev->ep_curr; 238 ep_end = udev->endpoints + udev->endpoints_max; 239 ep_first = udev->endpoints; 240 to = udev->endpoints_max; 241 242 switch (USB_GET_STATE(xfer)) { 243 case USB_ST_TRANSFERRED: 244 tr_transferred: 245 /* reset error counter */ 246 udev->clear_stall_errors = 0; 247 248 if (ep == NULL) 249 goto tr_setup; /* device was unconfigured */ 250 if (ep->edesc && 251 ep->is_stalled) { 252 ep->toggle_next = 0; 253 ep->is_stalled = 0; 254 /* some hardware needs a callback to clear the data toggle */ 255 usbd_clear_stall_locked(udev, ep); 256 /* start up the current or next transfer, if any */ 257 usb_command_wrapper(&ep->endpoint_q, 258 ep->endpoint_q.curr); 259 } 260 ep++; 261 262 case USB_ST_SETUP: 263 tr_setup: 264 if (to == 0) 265 break; /* no endpoints - nothing to do */ 266 if ((ep < ep_first) || (ep >= ep_end)) 267 ep = ep_first; /* endpoint wrapped around */ 268 if (ep->edesc && 269 ep->is_stalled) { 270 271 /* setup a clear-stall packet */ 272 273 req.bmRequestType = UT_WRITE_ENDPOINT; 274 req.bRequest = UR_CLEAR_FEATURE; 275 USETW(req.wValue, UF_ENDPOINT_HALT); 276 req.wIndex[0] = ep->edesc->bEndpointAddress; 277 req.wIndex[1] = 0; 278 USETW(req.wLength, 0); 279 280 /* copy in the transfer */ 281 282 usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); 283 284 /* set length */ 285 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 286 xfer->nframes = 1; 287 USB_BUS_UNLOCK(udev->bus); 288 289 usbd_transfer_submit(xfer); 290 291 USB_BUS_LOCK(udev->bus); 292 break; 293 } 294 ep++; 295 to--; 296 goto tr_setup; 297 298 default: 299 if (error == USB_ERR_CANCELLED) 300 break; 301 302 DPRINTF("Clear stall failed.\n"); 303 304 /* 305 * Some VMs like VirtualBox always return failure on 306 * clear-stall which we sometimes should just ignore. 307 */ 308 if (usb_no_cs_fail) 309 goto tr_transferred; 310 if (udev->clear_stall_errors == USB_CS_RESET_LIMIT) 311 goto tr_setup; 312 313 if (error == USB_ERR_TIMEOUT) { 314 udev->clear_stall_errors = USB_CS_RESET_LIMIT; 315 DPRINTF("Trying to re-enumerate.\n"); 316 usbd_start_re_enumerate(udev); 317 } else { 318 udev->clear_stall_errors++; 319 if (udev->clear_stall_errors == USB_CS_RESET_LIMIT) { 320 DPRINTF("Trying to re-enumerate.\n"); 321 usbd_start_re_enumerate(udev); 322 } 323 } 324 goto tr_setup; 325 } 326 327 /* store current endpoint */ 328 udev->ep_curr = ep; 329 USB_BUS_UNLOCK(udev->bus); 330 } 331 332 static usb_handle_req_t * 333 usbd_get_hr_func(struct usb_device *udev) 334 { 335 /* figure out if there is a Handle Request function */ 336 if (udev->flags.usb_mode == USB_MODE_DEVICE) 337 return (usb_temp_get_desc_p); 338 else if (udev->parent_hub == NULL) 339 return (udev->bus->methods->roothub_exec); 340 else 341 return (NULL); 342 } 343 344 /*------------------------------------------------------------------------* 345 * usbd_do_request_flags and usbd_do_request 346 * 347 * Description of arguments passed to these functions: 348 * 349 * "udev" - this is the "usb_device" structure pointer on which the 350 * request should be performed. It is possible to call this function 351 * in both Host Side mode and Device Side mode. 352 * 353 * "mtx" - if this argument is non-NULL the mutex pointed to by it 354 * will get dropped and picked up during the execution of this 355 * function, hence this function sometimes needs to sleep. If this 356 * argument is NULL it has no effect. 357 * 358 * "req" - this argument must always be non-NULL and points to an 359 * 8-byte structure holding the USB request to be done. The USB 360 * request structure has a bit telling the direction of the USB 361 * request, if it is a read or a write. 362 * 363 * "data" - if the "wLength" part of the structure pointed to by "req" 364 * is non-zero this argument must point to a valid kernel buffer which 365 * can hold at least "wLength" bytes. If "wLength" is zero "data" can 366 * be NULL. 367 * 368 * "flags" - here is a list of valid flags: 369 * 370 * o USB_SHORT_XFER_OK: allows the data transfer to be shorter than 371 * specified 372 * 373 * o USB_DELAY_STATUS_STAGE: allows the status stage to be performed 374 * at a later point in time. This is tunable by the "hw.usb.ss_delay" 375 * sysctl. This flag is mostly useful for debugging. 376 * 377 * o USB_USER_DATA_PTR: treat the "data" pointer like a userland 378 * pointer. 379 * 380 * "actlen" - if non-NULL the actual transfer length will be stored in 381 * the 16-bit unsigned integer pointed to by "actlen". This 382 * information is mostly useful when the "USB_SHORT_XFER_OK" flag is 383 * used. 384 * 385 * "timeout" - gives the timeout for the control transfer in 386 * milliseconds. A "timeout" value less than 50 milliseconds is 387 * treated like a 50 millisecond timeout. A "timeout" value greater 388 * than 30 seconds is treated like a 30 second timeout. This USB stack 389 * does not allow control requests without a timeout. 390 * 391 * NOTE: This function is thread safe. All calls to 392 * "usbd_do_request_flags" will be serialised by the use of an 393 * internal "sx_lock". 394 * 395 * Returns: 396 * 0: Success 397 * Else: Failure 398 *------------------------------------------------------------------------*/ 399 usb_error_t 400 usbd_do_request_flags(struct usb_device *udev, struct lock *lock, 401 struct usb_device_request *req, void *data, uint16_t flags, 402 uint16_t *actlen, usb_timeout_t timeout) 403 { 404 #ifdef USB_REQ_DEBUG 405 struct usb_ctrl_debug_bits dbg; 406 #endif 407 usb_handle_req_t *hr_func; 408 struct usb_xfer *xfer; 409 const void *desc; 410 int err = 0; 411 usb_ticks_t start_ticks; 412 usb_ticks_t delta_ticks; 413 usb_ticks_t max_ticks; 414 uint16_t length; 415 uint16_t temp; 416 uint16_t acttemp; 417 uint8_t enum_locked; 418 419 if (timeout < 50) { 420 /* timeout is too small */ 421 timeout = 50; 422 } 423 if (timeout > 30000) { 424 /* timeout is too big */ 425 timeout = 30000; 426 } 427 length = UGETW(req->wLength); 428 429 enum_locked = usbd_enum_is_locked(udev); 430 431 DPRINTFN(5, "udev=%p bmRequestType=0x%02x bRequest=0x%02x " 432 "wValue=0x%02x%02x wIndex=0x%02x%02x wLength=0x%02x%02x\n", 433 udev, req->bmRequestType, req->bRequest, 434 req->wValue[1], req->wValue[0], 435 req->wIndex[1], req->wIndex[0], 436 req->wLength[1], req->wLength[0]); 437 438 /* Check if the device is still alive */ 439 if (udev->state < USB_STATE_POWERED) { 440 DPRINTF("usb device has gone\n"); 441 return (USB_ERR_NOT_CONFIGURED); 442 } 443 444 /* 445 * Set "actlen" to a known value in case the caller does not 446 * check the return value: 447 */ 448 if (actlen) 449 *actlen = 0; 450 451 #if (USB_HAVE_USER_IO == 0) 452 if (flags & USB_USER_DATA_PTR) 453 return (USB_ERR_INVAL); 454 #endif 455 #if 0 456 if ((mtx != NULL) && (mtx != &Giant)) { 457 #endif 458 if (lock != NULL) { 459 lockmgr(lock, LK_RELEASE); 460 KKASSERT(!lockowned(lock)); 461 } 462 463 /* 464 * We need to allow suspend and resume at this point, else the 465 * control transfer will timeout if the device is suspended! 466 */ 467 if (enum_locked) 468 usbd_sr_unlock(udev); 469 470 /* 471 * Grab the default sx-lock so that serialisation 472 * is achieved when multiple threads are involved: 473 */ 474 lockmgr(&udev->ctrl_lock, LK_EXCLUSIVE); 475 476 hr_func = usbd_get_hr_func(udev); 477 478 if (hr_func != NULL) { 479 DPRINTF("Handle Request function is set\n"); 480 481 desc = NULL; 482 temp = 0; 483 484 if (!(req->bmRequestType & UT_READ)) { 485 if (length != 0) { 486 DPRINTFN(1, "The handle request function " 487 "does not support writing data!\n"); 488 err = USB_ERR_INVAL; 489 goto done; 490 } 491 } 492 493 /* The root HUB code needs the BUS lock locked */ 494 495 USB_BUS_LOCK(udev->bus); 496 err = (hr_func) (udev, req, &desc, &temp); 497 USB_BUS_UNLOCK(udev->bus); 498 499 if (err) 500 goto done; 501 502 if (length > temp) { 503 if (!(flags & USB_SHORT_XFER_OK)) { 504 err = USB_ERR_SHORT_XFER; 505 goto done; 506 } 507 length = temp; 508 } 509 if (actlen) 510 *actlen = length; 511 512 if (length > 0) { 513 #if USB_HAVE_USER_IO 514 if (flags & USB_USER_DATA_PTR) { 515 if (copyout(desc, data, length)) { 516 err = USB_ERR_INVAL; 517 goto done; 518 } 519 } else 520 #endif 521 memcpy(data, desc, length); 522 } 523 goto done; /* success */ 524 } 525 526 /* 527 * Setup a new USB transfer or use the existing one, if any: 528 */ 529 usbd_ctrl_transfer_setup(udev); 530 531 xfer = udev->ctrl_xfer[0]; 532 if (xfer == NULL) { 533 /* most likely out of memory */ 534 err = USB_ERR_NOMEM; 535 goto done; 536 } 537 538 #ifdef USB_REQ_DEBUG 539 /* Get debug bits */ 540 usbd_get_debug_bits(udev, req, &dbg); 541 542 /* Check for fault injection */ 543 if (dbg.enabled) 544 flags |= USB_DELAY_STATUS_STAGE; 545 #endif 546 USB_XFER_LOCK(xfer); 547 548 if (flags & USB_DELAY_STATUS_STAGE) 549 xfer->flags.manual_status = 1; 550 else 551 xfer->flags.manual_status = 0; 552 553 if (flags & USB_SHORT_XFER_OK) 554 xfer->flags.short_xfer_ok = 1; 555 else 556 xfer->flags.short_xfer_ok = 0; 557 558 xfer->timeout = timeout; 559 560 start_ticks = ticks; 561 562 max_ticks = USB_MS_TO_TICKS(timeout); 563 564 usbd_copy_in(xfer->frbuffers, 0, req, sizeof(*req)); 565 566 usbd_xfer_set_frame_len(xfer, 0, sizeof(*req)); 567 568 while (1) { 569 temp = length; 570 if (temp > usbd_xfer_max_len(xfer)) { 571 temp = usbd_xfer_max_len(xfer); 572 } 573 #ifdef USB_REQ_DEBUG 574 if (xfer->flags.manual_status) { 575 if (usbd_xfer_frame_len(xfer, 0) != 0) { 576 /* Execute data stage separately */ 577 temp = 0; 578 } else if (temp > 0) { 579 if (dbg.ds_fail) { 580 err = USB_ERR_INVAL; 581 break; 582 } 583 if (dbg.ds_delay > 0) { 584 usb_pause_mtx( 585 xfer->xroot->xfer_lock, 586 USB_MS_TO_TICKS(dbg.ds_delay)); 587 /* make sure we don't time out */ 588 start_ticks = ticks; 589 } 590 } 591 } 592 #endif 593 usbd_xfer_set_frame_len(xfer, 1, temp); 594 595 if (temp > 0) { 596 if (!(req->bmRequestType & UT_READ)) { 597 #if USB_HAVE_USER_IO 598 if (flags & USB_USER_DATA_PTR) { 599 USB_XFER_UNLOCK(xfer); 600 err = usbd_copy_in_user(xfer->frbuffers + 1, 601 0, data, temp); 602 USB_XFER_LOCK(xfer); 603 if (err) { 604 err = USB_ERR_INVAL; 605 break; 606 } 607 } else 608 #endif 609 usbd_copy_in(xfer->frbuffers + 1, 610 0, data, temp); 611 } 612 usbd_xfer_set_frames(xfer, 2); 613 } else { 614 if (usbd_xfer_frame_len(xfer, 0) == 0) { 615 if (xfer->flags.manual_status) { 616 #ifdef USB_REQ_DEBUG 617 if (dbg.ss_fail) { 618 err = USB_ERR_INVAL; 619 break; 620 } 621 if (dbg.ss_delay > 0) { 622 usb_pause_mtx( 623 xfer->xroot->xfer_lock, 624 USB_MS_TO_TICKS(dbg.ss_delay)); 625 /* make sure we don't time out */ 626 start_ticks = ticks; 627 } 628 #endif 629 xfer->flags.manual_status = 0; 630 } else { 631 break; 632 } 633 } 634 usbd_xfer_set_frames(xfer, 1); 635 } 636 637 usbd_transfer_start(xfer); 638 639 while (usbd_transfer_pending(xfer)) { 640 cv_wait(&udev->ctrlreq_cv, 641 xfer->xroot->xfer_lock); 642 } 643 644 err = xfer->error; 645 646 if (err) { 647 break; 648 } 649 650 /* get actual length of DATA stage */ 651 652 if (xfer->aframes < 2) { 653 acttemp = 0; 654 } else { 655 acttemp = usbd_xfer_frame_len(xfer, 1); 656 } 657 658 /* check for short packet */ 659 660 if (temp > acttemp) { 661 temp = acttemp; 662 length = temp; 663 } 664 if (temp > 0) { 665 if (req->bmRequestType & UT_READ) { 666 #if USB_HAVE_USER_IO 667 if (flags & USB_USER_DATA_PTR) { 668 USB_XFER_UNLOCK(xfer); 669 err = usbd_copy_out_user(xfer->frbuffers + 1, 670 0, data, temp); 671 USB_XFER_LOCK(xfer); 672 if (err) { 673 err = USB_ERR_INVAL; 674 break; 675 } 676 } else 677 #endif 678 usbd_copy_out(xfer->frbuffers + 1, 679 0, data, temp); 680 } 681 } 682 /* 683 * Clear "frlengths[0]" so that we don't send the setup 684 * packet again: 685 */ 686 usbd_xfer_set_frame_len(xfer, 0, 0); 687 688 /* update length and data pointer */ 689 length -= temp; 690 data = USB_ADD_BYTES(data, temp); 691 692 if (actlen) { 693 (*actlen) += temp; 694 } 695 /* check for timeout */ 696 697 delta_ticks = ticks - start_ticks; 698 if (delta_ticks > max_ticks) { 699 if (!err) { 700 err = USB_ERR_TIMEOUT; 701 } 702 } 703 if (err) { 704 break; 705 } 706 } 707 708 if (err) { 709 /* 710 * Make sure that the control endpoint is no longer 711 * blocked in case of a non-transfer related error: 712 */ 713 usbd_transfer_stop(xfer); 714 } 715 USB_XFER_UNLOCK(xfer); 716 717 done: 718 lockmgr(&udev->ctrl_lock, LK_RELEASE); 719 720 if (enum_locked) 721 usbd_sr_lock(udev); 722 723 #if 0 724 if ((mtx != NULL) && (mtx != &Giant)) 725 #endif 726 if (lock != NULL) 727 lockmgr(lock, LK_EXCLUSIVE); 728 729 return ((usb_error_t)err); 730 } 731 732 /*------------------------------------------------------------------------* 733 * usbd_do_request_proc - factored out code 734 * 735 * This function is factored out code. It does basically the same like 736 * usbd_do_request_flags, except it will check the status of the 737 * passed process argument before doing the USB request. If the 738 * process is draining the USB_ERR_IOERROR code will be returned. It 739 * is assumed that the mutex associated with the process is locked 740 * when calling this function. 741 *------------------------------------------------------------------------*/ 742 usb_error_t 743 usbd_do_request_proc(struct usb_device *udev, struct usb_process *pproc, 744 struct usb_device_request *req, void *data, uint16_t flags, 745 uint16_t *actlen, usb_timeout_t timeout) 746 { 747 usb_error_t err; 748 uint16_t len; 749 750 /* get request data length */ 751 len = UGETW(req->wLength); 752 753 /* check if the device is being detached */ 754 if (usb_proc_is_gone(pproc)) { 755 err = USB_ERR_IOERROR; 756 goto done; 757 } 758 759 /* forward the USB request */ 760 err = usbd_do_request_flags(udev, pproc->up_lock, 761 req, data, flags, actlen, timeout); 762 763 done: 764 /* on failure we zero the data */ 765 /* on short packet we zero the unused data */ 766 if ((len != 0) && (req->bmRequestType & UE_DIR_IN)) { 767 if (err) 768 memset(data, 0, len); 769 else if (actlen && *actlen != len) 770 memset(((uint8_t *)data) + *actlen, 0, len - *actlen); 771 } 772 return (err); 773 } 774 775 /*------------------------------------------------------------------------* 776 * usbd_req_reset_port 777 * 778 * This function will instruct a USB HUB to perform a reset sequence 779 * on the specified port number. 780 * 781 * Returns: 782 * 0: Success. The USB device should now be at address zero. 783 * Else: Failure. No USB device is present and the USB port should be 784 * disabled. 785 *------------------------------------------------------------------------*/ 786 usb_error_t 787 usbd_req_reset_port(struct usb_device *udev, struct lock *lock, uint8_t port) 788 { 789 struct usb_port_status ps; 790 usb_error_t err; 791 uint16_t n; 792 uint16_t status; 793 uint16_t change; 794 795 #ifdef USB_DEBUG 796 uint16_t pr_poll_delay; 797 uint16_t pr_recovery_delay; 798 799 #endif 800 801 DPRINTF("\n"); 802 803 /* clear any leftover port reset changes first */ 804 usbd_req_clear_port_feature( 805 udev, lock, port, UHF_C_PORT_RESET); 806 807 /* assert port reset on the given port */ 808 err = usbd_req_set_port_feature( 809 udev, lock, port, UHF_PORT_RESET); 810 811 /* check for errors */ 812 if (err) 813 goto done; 814 #ifdef USB_DEBUG 815 /* range check input parameters */ 816 pr_poll_delay = usb_pr_poll_delay; 817 if (pr_poll_delay < 1) { 818 pr_poll_delay = 1; 819 } else if (pr_poll_delay > 1000) { 820 pr_poll_delay = 1000; 821 } 822 pr_recovery_delay = usb_pr_recovery_delay; 823 if (pr_recovery_delay > 1000) { 824 pr_recovery_delay = 1000; 825 } 826 #endif 827 n = 0; 828 while (1) { 829 #ifdef USB_DEBUG 830 /* wait for the device to recover from reset */ 831 usb_pause_mtx(lock, USB_MS_TO_TICKS(pr_poll_delay)); 832 n += pr_poll_delay; 833 #else 834 /* wait for the device to recover from reset */ 835 usb_pause_mtx(lock, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY)); 836 n += USB_PORT_RESET_DELAY; 837 #endif 838 err = usbd_req_get_port_status(udev, lock, &ps, port); 839 if (err) 840 goto done; 841 842 status = UGETW(ps.wPortStatus); 843 change = UGETW(ps.wPortChange); 844 845 /* if the device disappeared, just give up */ 846 if (!(status & UPS_CURRENT_CONNECT_STATUS)) 847 goto done; 848 849 /* check if reset is complete */ 850 if (change & UPS_C_PORT_RESET) 851 break; 852 853 /* 854 * Some Virtual Machines like VirtualBox 4.x fail to 855 * generate a port reset change event. Check if reset 856 * is no longer asserted. 857 */ 858 if (!(status & UPS_RESET)) 859 break; 860 861 /* check for timeout */ 862 if (n > 1000) { 863 n = 0; 864 break; 865 } 866 } 867 868 /* clear port reset first */ 869 err = usbd_req_clear_port_feature( 870 udev, lock, port, UHF_C_PORT_RESET); 871 if (err) 872 goto done; 873 874 /* check for timeout */ 875 if (n == 0) { 876 err = USB_ERR_TIMEOUT; 877 goto done; 878 } 879 #ifdef USB_DEBUG 880 /* wait for the device to recover from reset */ 881 usb_pause_mtx(lock, USB_MS_TO_TICKS(pr_recovery_delay)); 882 #else 883 /* wait for the device to recover from reset */ 884 usb_pause_mtx(lock, USB_MS_TO_TICKS(USB_PORT_RESET_RECOVERY)); 885 #endif 886 887 done: 888 DPRINTFN(2, "port %d reset returning error=%s\n", 889 port, usbd_errstr(err)); 890 return (err); 891 } 892 893 /*------------------------------------------------------------------------* 894 * usbd_req_warm_reset_port 895 * 896 * This function will instruct an USB HUB to perform a warm reset 897 * sequence on the specified port number. This kind of reset is not 898 * mandatory for LOW-, FULL- and HIGH-speed USB HUBs and is targeted 899 * for SUPER-speed USB HUBs. 900 * 901 * Returns: 902 * 0: Success. The USB device should now be available again. 903 * Else: Failure. No USB device is present and the USB port should be 904 * disabled. 905 *------------------------------------------------------------------------*/ 906 usb_error_t 907 usbd_req_warm_reset_port(struct usb_device *udev, struct lock *lock, 908 uint8_t port) 909 { 910 struct usb_port_status ps; 911 usb_error_t err; 912 uint16_t n; 913 uint16_t status; 914 uint16_t change; 915 916 #ifdef USB_DEBUG 917 uint16_t pr_poll_delay; 918 uint16_t pr_recovery_delay; 919 920 #endif 921 922 DPRINTF("\n"); 923 924 err = usbd_req_get_port_status(udev, lock, &ps, port); 925 if (err) 926 goto done; 927 928 status = UGETW(ps.wPortStatus); 929 930 switch (UPS_PORT_LINK_STATE_GET(status)) { 931 case UPS_PORT_LS_U3: 932 case UPS_PORT_LS_COMP_MODE: 933 case UPS_PORT_LS_LOOPBACK: 934 case UPS_PORT_LS_SS_INA: 935 break; 936 default: 937 DPRINTF("Wrong state for warm reset\n"); 938 return (0); 939 } 940 941 /* clear any leftover warm port reset changes first */ 942 usbd_req_clear_port_feature(udev, lock, 943 port, UHF_C_BH_PORT_RESET); 944 945 /* set warm port reset */ 946 err = usbd_req_set_port_feature(udev, lock, 947 port, UHF_BH_PORT_RESET); 948 if (err) 949 goto done; 950 951 #ifdef USB_DEBUG 952 /* range check input parameters */ 953 pr_poll_delay = usb_pr_poll_delay; 954 if (pr_poll_delay < 1) { 955 pr_poll_delay = 1; 956 } else if (pr_poll_delay > 1000) { 957 pr_poll_delay = 1000; 958 } 959 pr_recovery_delay = usb_pr_recovery_delay; 960 if (pr_recovery_delay > 1000) { 961 pr_recovery_delay = 1000; 962 } 963 #endif 964 n = 0; 965 while (1) { 966 #ifdef USB_DEBUG 967 /* wait for the device to recover from reset */ 968 usb_pause_mtx(lock, USB_MS_TO_TICKS(pr_poll_delay)); 969 n += pr_poll_delay; 970 #else 971 /* wait for the device to recover from reset */ 972 usb_pause_mtx(lock, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY)); 973 n += USB_PORT_RESET_DELAY; 974 #endif 975 err = usbd_req_get_port_status(udev, lock, &ps, port); 976 if (err) 977 goto done; 978 979 status = UGETW(ps.wPortStatus); 980 change = UGETW(ps.wPortChange); 981 982 /* if the device disappeared, just give up */ 983 if (!(status & UPS_CURRENT_CONNECT_STATUS)) 984 goto done; 985 986 /* check if reset is complete */ 987 if (change & UPS_C_BH_PORT_RESET) 988 break; 989 990 /* check for timeout */ 991 if (n > 1000) { 992 n = 0; 993 break; 994 } 995 } 996 997 /* clear port reset first */ 998 err = usbd_req_clear_port_feature( 999 udev, lock, port, UHF_C_BH_PORT_RESET); 1000 if (err) 1001 goto done; 1002 1003 /* check for timeout */ 1004 if (n == 0) { 1005 err = USB_ERR_TIMEOUT; 1006 goto done; 1007 } 1008 #ifdef USB_DEBUG 1009 /* wait for the device to recover from reset */ 1010 usb_pause_mtx(lock, USB_MS_TO_TICKS(pr_recovery_delay)); 1011 #else 1012 /* wait for the device to recover from reset */ 1013 usb_pause_mtx(lock, USB_MS_TO_TICKS(USB_PORT_RESET_RECOVERY)); 1014 #endif 1015 1016 done: 1017 DPRINTFN(2, "port %d warm reset returning error=%s\n", 1018 port, usbd_errstr(err)); 1019 return (err); 1020 } 1021 1022 /*------------------------------------------------------------------------* 1023 * usbd_req_get_desc 1024 * 1025 * This function can be used to retrieve USB descriptors. It contains 1026 * some additional logic like zeroing of missing descriptor bytes and 1027 * retrying an USB descriptor in case of failure. The "min_len" 1028 * argument specifies the minimum descriptor length. The "max_len" 1029 * argument specifies the maximum descriptor length. If the real 1030 * descriptor length is less than the minimum length the missing 1031 * byte(s) will be zeroed. The type field, the second byte of the USB 1032 * descriptor, will get forced to the correct type. If the "actlen" 1033 * pointer is non-NULL, the actual length of the transfer will get 1034 * stored in the 16-bit unsigned integer which it is pointing to. The 1035 * first byte of the descriptor will not get updated. If the "actlen" 1036 * pointer is NULL the first byte of the descriptor will get updated 1037 * to reflect the actual length instead. If "min_len" is not equal to 1038 * "max_len" then this function will try to retrive the beginning of 1039 * the descriptor and base the maximum length on the first byte of the 1040 * descriptor. 1041 * 1042 * Returns: 1043 * 0: Success 1044 * Else: Failure 1045 *------------------------------------------------------------------------*/ 1046 usb_error_t 1047 usbd_req_get_desc(struct usb_device *udev, 1048 struct lock *lock, uint16_t *actlen, void *desc, 1049 uint16_t min_len, uint16_t max_len, 1050 uint16_t id, uint8_t type, uint8_t index, 1051 uint8_t retries) 1052 { 1053 struct usb_device_request req; 1054 uint8_t *buf; 1055 usb_error_t err; 1056 1057 DPRINTFN(4, "id=%d, type=%d, index=%d, max_len=%d\n", 1058 id, type, index, max_len); 1059 1060 req.bmRequestType = UT_READ_DEVICE; 1061 req.bRequest = UR_GET_DESCRIPTOR; 1062 USETW2(req.wValue, type, index); 1063 USETW(req.wIndex, id); 1064 1065 while (1) { 1066 1067 if ((min_len < 2) || (max_len < 2)) { 1068 err = USB_ERR_INVAL; 1069 goto done; 1070 } 1071 USETW(req.wLength, min_len); 1072 1073 err = usbd_do_request_flags(udev, lock, &req, 1074 desc, 0, NULL, 1000); 1075 1076 if (err) { 1077 if (!retries) { 1078 goto done; 1079 } 1080 retries--; 1081 1082 usb_pause_mtx(lock, hz / 5); 1083 1084 continue; 1085 } 1086 buf = desc; 1087 1088 if (min_len == max_len) { 1089 1090 /* enforce correct length */ 1091 if ((buf[0] > min_len) && (actlen == NULL)) 1092 buf[0] = min_len; 1093 1094 /* enforce correct type */ 1095 buf[1] = type; 1096 1097 goto done; 1098 } 1099 /* range check */ 1100 1101 if (max_len > buf[0]) { 1102 max_len = buf[0]; 1103 } 1104 /* zero minimum data */ 1105 1106 while (min_len > max_len) { 1107 min_len--; 1108 buf[min_len] = 0; 1109 } 1110 1111 /* set new minimum length */ 1112 1113 min_len = max_len; 1114 } 1115 done: 1116 if (actlen != NULL) { 1117 if (err) 1118 *actlen = 0; 1119 else 1120 *actlen = min_len; 1121 } 1122 return (err); 1123 } 1124 1125 /*------------------------------------------------------------------------* 1126 * usbd_req_get_string_any 1127 * 1128 * This function will return the string given by "string_index" 1129 * using the first language ID. The maximum length "len" includes 1130 * the terminating zero. The "len" argument should be twice as 1131 * big pluss 2 bytes, compared with the actual maximum string length ! 1132 * 1133 * Returns: 1134 * 0: Success 1135 * Else: Failure 1136 *------------------------------------------------------------------------*/ 1137 usb_error_t 1138 usbd_req_get_string_any(struct usb_device *udev, struct lock *lock, char *buf, 1139 uint16_t len, uint8_t string_index) 1140 { 1141 char *s; 1142 uint8_t *temp; 1143 uint16_t i; 1144 uint16_t n; 1145 uint16_t c; 1146 uint8_t swap; 1147 usb_error_t err; 1148 1149 if (len == 0) { 1150 /* should not happen */ 1151 return (USB_ERR_NORMAL_COMPLETION); 1152 } 1153 if (string_index == 0) { 1154 /* this is the language table */ 1155 buf[0] = 0; 1156 return (USB_ERR_INVAL); 1157 } 1158 if (udev->flags.no_strings) { 1159 buf[0] = 0; 1160 return (USB_ERR_STALLED); 1161 } 1162 err = usbd_req_get_string_desc 1163 (udev, lock, buf, len, udev->langid, string_index); 1164 if (err) { 1165 buf[0] = 0; 1166 return (err); 1167 } 1168 temp = (uint8_t *)buf; 1169 1170 if (temp[0] < 2) { 1171 /* string length is too short */ 1172 buf[0] = 0; 1173 return (USB_ERR_INVAL); 1174 } 1175 /* reserve one byte for terminating zero */ 1176 len--; 1177 1178 /* find maximum length */ 1179 s = buf; 1180 n = (temp[0] / 2) - 1; 1181 if (n > len) { 1182 n = len; 1183 } 1184 /* skip descriptor header */ 1185 temp += 2; 1186 1187 /* reset swap state */ 1188 swap = 3; 1189 1190 /* convert and filter */ 1191 for (i = 0; (i != n); i++) { 1192 c = UGETW(temp + (2 * i)); 1193 1194 /* convert from Unicode, handle buggy strings */ 1195 if (((c & 0xff00) == 0) && (swap & 1)) { 1196 /* Little Endian, default */ 1197 *s = c; 1198 swap = 1; 1199 } else if (((c & 0x00ff) == 0) && (swap & 2)) { 1200 /* Big Endian */ 1201 *s = c >> 8; 1202 swap = 2; 1203 } else { 1204 /* silently skip bad character */ 1205 continue; 1206 } 1207 1208 /* 1209 * Filter by default - We only allow alphanumerical 1210 * and a few more to avoid any problems with scripts 1211 * and daemons. 1212 */ 1213 if (isalpha(*s) || 1214 isdigit(*s) || 1215 *s == '-' || 1216 *s == '+' || 1217 *s == ' ' || 1218 *s == '.' || 1219 *s == ',') { 1220 /* allowed */ 1221 s++; 1222 } 1223 /* silently skip bad character */ 1224 } 1225 *s = 0; /* zero terminate resulting string */ 1226 return (USB_ERR_NORMAL_COMPLETION); 1227 } 1228 1229 /*------------------------------------------------------------------------* 1230 * usbd_req_get_string_desc 1231 * 1232 * If you don't know the language ID, consider using 1233 * "usbd_req_get_string_any()". 1234 * 1235 * Returns: 1236 * 0: Success 1237 * Else: Failure 1238 *------------------------------------------------------------------------*/ 1239 usb_error_t 1240 usbd_req_get_string_desc(struct usb_device *udev, struct lock *lock, void *sdesc, 1241 uint16_t max_len, uint16_t lang_id, 1242 uint8_t string_index) 1243 { 1244 return (usbd_req_get_desc(udev, lock, NULL, sdesc, 2, max_len, lang_id, 1245 UDESC_STRING, string_index, 0)); 1246 } 1247 1248 /*------------------------------------------------------------------------* 1249 * usbd_req_get_config_desc_ptr 1250 * 1251 * This function is used in device side mode to retrieve the pointer 1252 * to the generated config descriptor. This saves allocating space for 1253 * an additional config descriptor when setting the configuration. 1254 * 1255 * Returns: 1256 * 0: Success 1257 * Else: Failure 1258 *------------------------------------------------------------------------*/ 1259 usb_error_t 1260 usbd_req_get_descriptor_ptr(struct usb_device *udev, 1261 struct usb_config_descriptor **ppcd, uint16_t wValue) 1262 { 1263 struct usb_device_request req; 1264 usb_handle_req_t *hr_func; 1265 const void *ptr; 1266 uint16_t len; 1267 usb_error_t err; 1268 1269 req.bmRequestType = UT_READ_DEVICE; 1270 req.bRequest = UR_GET_DESCRIPTOR; 1271 USETW(req.wValue, wValue); 1272 USETW(req.wIndex, 0); 1273 USETW(req.wLength, 0); 1274 1275 ptr = NULL; 1276 len = 0; 1277 1278 hr_func = usbd_get_hr_func(udev); 1279 1280 if (hr_func == NULL) 1281 err = USB_ERR_INVAL; 1282 else { 1283 USB_BUS_LOCK(udev->bus); 1284 err = (hr_func) (udev, &req, &ptr, &len); 1285 USB_BUS_UNLOCK(udev->bus); 1286 } 1287 1288 if (err) 1289 ptr = NULL; 1290 else if (ptr == NULL) 1291 err = USB_ERR_INVAL; 1292 1293 *ppcd = __DECONST(struct usb_config_descriptor *, ptr); 1294 1295 return (err); 1296 } 1297 1298 /*------------------------------------------------------------------------* 1299 * usbd_req_get_config_desc 1300 * 1301 * Returns: 1302 * 0: Success 1303 * Else: Failure 1304 *------------------------------------------------------------------------*/ 1305 usb_error_t 1306 usbd_req_get_config_desc(struct usb_device *udev, struct lock *lock, 1307 struct usb_config_descriptor *d, uint8_t conf_index) 1308 { 1309 usb_error_t err; 1310 1311 DPRINTFN(4, "confidx=%d\n", conf_index); 1312 1313 err = usbd_req_get_desc(udev, lock, NULL, d, sizeof(*d), 1314 sizeof(*d), 0, UDESC_CONFIG, conf_index, 0); 1315 if (err) { 1316 goto done; 1317 } 1318 /* Extra sanity checking */ 1319 if (UGETW(d->wTotalLength) < sizeof(*d)) { 1320 err = USB_ERR_INVAL; 1321 } 1322 done: 1323 return (err); 1324 } 1325 1326 /*------------------------------------------------------------------------* 1327 * usbd_req_get_config_desc_full 1328 * 1329 * This function gets the complete USB configuration descriptor and 1330 * ensures that "wTotalLength" is correct. 1331 * 1332 * Returns: 1333 * 0: Success 1334 * Else: Failure 1335 *------------------------------------------------------------------------*/ 1336 usb_error_t 1337 usbd_req_get_config_desc_full(struct usb_device *udev, struct lock *lock, 1338 struct usb_config_descriptor **ppcd, struct malloc_type *mtype, 1339 uint8_t index) 1340 { 1341 struct usb_config_descriptor cd; 1342 struct usb_config_descriptor *cdesc; 1343 uint16_t len; 1344 usb_error_t err; 1345 1346 DPRINTFN(4, "index=%d\n", index); 1347 1348 *ppcd = NULL; 1349 1350 err = usbd_req_get_config_desc(udev, lock, &cd, index); 1351 if (err) { 1352 return (err); 1353 } 1354 /* get full descriptor */ 1355 len = UGETW(cd.wTotalLength); 1356 if (len < sizeof(*cdesc)) { 1357 /* corrupt descriptor */ 1358 return (USB_ERR_INVAL); 1359 } 1360 cdesc = kmalloc(len, mtype, M_WAITOK); 1361 if (cdesc == NULL) { 1362 return (USB_ERR_NOMEM); 1363 } 1364 err = usbd_req_get_desc(udev, lock, NULL, cdesc, len, len, 0, 1365 UDESC_CONFIG, index, 3); 1366 if (err) { 1367 kfree(cdesc, mtype); 1368 return (err); 1369 } 1370 /* make sure that the device is not fooling us: */ 1371 USETW(cdesc->wTotalLength, len); 1372 1373 *ppcd = cdesc; 1374 1375 return (0); /* success */ 1376 } 1377 1378 /*------------------------------------------------------------------------* 1379 * usbd_req_get_device_desc 1380 * 1381 * Returns: 1382 * 0: Success 1383 * Else: Failure 1384 *------------------------------------------------------------------------*/ 1385 usb_error_t 1386 usbd_req_get_device_desc(struct usb_device *udev, struct lock *lock, 1387 struct usb_device_descriptor *d) 1388 { 1389 DPRINTFN(4, "\n"); 1390 return (usbd_req_get_desc(udev, lock, NULL, d, sizeof(*d), 1391 sizeof(*d), 0, UDESC_DEVICE, 0, 3)); 1392 } 1393 1394 /*------------------------------------------------------------------------* 1395 * usbd_req_get_alt_interface_no 1396 * 1397 * Returns: 1398 * 0: Success 1399 * Else: Failure 1400 *------------------------------------------------------------------------*/ 1401 usb_error_t 1402 usbd_req_get_alt_interface_no(struct usb_device *udev, struct lock *lock, 1403 uint8_t *alt_iface_no, uint8_t iface_index) 1404 { 1405 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1406 struct usb_device_request req; 1407 1408 if ((iface == NULL) || (iface->idesc == NULL)) 1409 return (USB_ERR_INVAL); 1410 1411 req.bmRequestType = UT_READ_INTERFACE; 1412 req.bRequest = UR_GET_INTERFACE; 1413 USETW(req.wValue, 0); 1414 req.wIndex[0] = iface->idesc->bInterfaceNumber; 1415 req.wIndex[1] = 0; 1416 USETW(req.wLength, 1); 1417 return (usbd_do_request(udev, lock, &req, alt_iface_no)); 1418 } 1419 1420 /*------------------------------------------------------------------------* 1421 * usbd_req_set_alt_interface_no 1422 * 1423 * Returns: 1424 * 0: Success 1425 * Else: Failure 1426 *------------------------------------------------------------------------*/ 1427 usb_error_t 1428 usbd_req_set_alt_interface_no(struct usb_device *udev, struct lock *lock, 1429 uint8_t iface_index, uint8_t alt_no) 1430 { 1431 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1432 struct usb_device_request req; 1433 1434 if ((iface == NULL) || (iface->idesc == NULL)) 1435 return (USB_ERR_INVAL); 1436 1437 req.bmRequestType = UT_WRITE_INTERFACE; 1438 req.bRequest = UR_SET_INTERFACE; 1439 req.wValue[0] = alt_no; 1440 req.wValue[1] = 0; 1441 req.wIndex[0] = iface->idesc->bInterfaceNumber; 1442 req.wIndex[1] = 0; 1443 USETW(req.wLength, 0); 1444 return (usbd_do_request(udev, lock, &req, 0)); 1445 } 1446 1447 /*------------------------------------------------------------------------* 1448 * usbd_req_get_device_status 1449 * 1450 * Returns: 1451 * 0: Success 1452 * Else: Failure 1453 *------------------------------------------------------------------------*/ 1454 usb_error_t 1455 usbd_req_get_device_status(struct usb_device *udev, struct lock *lock, 1456 struct usb_status *st) 1457 { 1458 struct usb_device_request req; 1459 1460 req.bmRequestType = UT_READ_DEVICE; 1461 req.bRequest = UR_GET_STATUS; 1462 USETW(req.wValue, 0); 1463 USETW(req.wIndex, 0); 1464 USETW(req.wLength, sizeof(*st)); 1465 return (usbd_do_request(udev, lock, &req, st)); 1466 } 1467 1468 /*------------------------------------------------------------------------* 1469 * usbd_req_get_hub_descriptor 1470 * 1471 * Returns: 1472 * 0: Success 1473 * Else: Failure 1474 *------------------------------------------------------------------------*/ 1475 usb_error_t 1476 usbd_req_get_hub_descriptor(struct usb_device *udev, struct lock *lock, 1477 struct usb_hub_descriptor *hd, uint8_t nports) 1478 { 1479 struct usb_device_request req; 1480 uint16_t len = (nports + 7 + (8 * 8)) / 8; 1481 1482 req.bmRequestType = UT_READ_CLASS_DEVICE; 1483 req.bRequest = UR_GET_DESCRIPTOR; 1484 USETW2(req.wValue, UDESC_HUB, 0); 1485 USETW(req.wIndex, 0); 1486 USETW(req.wLength, len); 1487 return (usbd_do_request(udev, lock, &req, hd)); 1488 } 1489 1490 /*------------------------------------------------------------------------* 1491 * usbd_req_get_ss_hub_descriptor 1492 * 1493 * Returns: 1494 * 0: Success 1495 * Else: Failure 1496 *------------------------------------------------------------------------*/ 1497 usb_error_t 1498 usbd_req_get_ss_hub_descriptor(struct usb_device *udev, struct lock *lock, 1499 struct usb_hub_ss_descriptor *hd, uint8_t nports) 1500 { 1501 struct usb_device_request req; 1502 uint16_t len = sizeof(*hd) - 32 + 1 + ((nports + 7) / 8); 1503 1504 req.bmRequestType = UT_READ_CLASS_DEVICE; 1505 req.bRequest = UR_GET_DESCRIPTOR; 1506 USETW2(req.wValue, UDESC_SS_HUB, 0); 1507 USETW(req.wIndex, 0); 1508 USETW(req.wLength, len); 1509 return (usbd_do_request(udev, lock, &req, hd)); 1510 } 1511 1512 /*------------------------------------------------------------------------* 1513 * usbd_req_get_hub_status 1514 * 1515 * Returns: 1516 * 0: Success 1517 * Else: Failure 1518 *------------------------------------------------------------------------*/ 1519 usb_error_t 1520 usbd_req_get_hub_status(struct usb_device *udev, struct lock *lock, 1521 struct usb_hub_status *st) 1522 { 1523 struct usb_device_request req; 1524 1525 req.bmRequestType = UT_READ_CLASS_DEVICE; 1526 req.bRequest = UR_GET_STATUS; 1527 USETW(req.wValue, 0); 1528 USETW(req.wIndex, 0); 1529 USETW(req.wLength, sizeof(struct usb_hub_status)); 1530 return (usbd_do_request(udev, lock, &req, st)); 1531 } 1532 1533 /*------------------------------------------------------------------------* 1534 * usbd_req_set_address 1535 * 1536 * This function is used to set the address for an USB device. After 1537 * port reset the USB device will respond at address zero. 1538 * 1539 * Returns: 1540 * 0: Success 1541 * Else: Failure 1542 *------------------------------------------------------------------------*/ 1543 usb_error_t 1544 usbd_req_set_address(struct usb_device *udev, struct lock *lock, uint16_t addr) 1545 { 1546 struct usb_device_request req; 1547 usb_error_t err; 1548 1549 DPRINTFN(6, "setting device address=%d\n", addr); 1550 1551 req.bmRequestType = UT_WRITE_DEVICE; 1552 req.bRequest = UR_SET_ADDRESS; 1553 USETW(req.wValue, addr); 1554 USETW(req.wIndex, 0); 1555 USETW(req.wLength, 0); 1556 1557 err = USB_ERR_INVAL; 1558 1559 /* check if USB controller handles set address */ 1560 if (udev->bus->methods->set_address != NULL) 1561 err = (udev->bus->methods->set_address) (udev, lock, addr); 1562 1563 if (err != USB_ERR_INVAL) 1564 goto done; 1565 1566 /* Setting the address should not take more than 1 second ! */ 1567 err = usbd_do_request_flags(udev, lock, &req, NULL, 1568 USB_DELAY_STATUS_STAGE, NULL, 1000); 1569 1570 done: 1571 /* allow device time to set new address */ 1572 usb_pause_mtx(lock, 1573 USB_MS_TO_TICKS(USB_SET_ADDRESS_SETTLE)); 1574 1575 return (err); 1576 } 1577 1578 /*------------------------------------------------------------------------* 1579 * usbd_req_get_port_status 1580 * 1581 * Returns: 1582 * 0: Success 1583 * Else: Failure 1584 *------------------------------------------------------------------------*/ 1585 usb_error_t 1586 usbd_req_get_port_status(struct usb_device *udev, struct lock *lock, 1587 struct usb_port_status *ps, uint8_t port) 1588 { 1589 struct usb_device_request req; 1590 1591 req.bmRequestType = UT_READ_CLASS_OTHER; 1592 req.bRequest = UR_GET_STATUS; 1593 USETW(req.wValue, 0); 1594 req.wIndex[0] = port; 1595 req.wIndex[1] = 0; 1596 USETW(req.wLength, sizeof *ps); 1597 return (usbd_do_request(udev, lock, &req, ps)); 1598 } 1599 1600 /*------------------------------------------------------------------------* 1601 * usbd_req_clear_hub_feature 1602 * 1603 * Returns: 1604 * 0: Success 1605 * Else: Failure 1606 *------------------------------------------------------------------------*/ 1607 usb_error_t 1608 usbd_req_clear_hub_feature(struct usb_device *udev, struct lock *lock, 1609 uint16_t sel) 1610 { 1611 struct usb_device_request req; 1612 1613 req.bmRequestType = UT_WRITE_CLASS_DEVICE; 1614 req.bRequest = UR_CLEAR_FEATURE; 1615 USETW(req.wValue, sel); 1616 USETW(req.wIndex, 0); 1617 USETW(req.wLength, 0); 1618 return (usbd_do_request(udev, lock, &req, 0)); 1619 } 1620 1621 /*------------------------------------------------------------------------* 1622 * usbd_req_set_hub_feature 1623 * 1624 * Returns: 1625 * 0: Success 1626 * Else: Failure 1627 *------------------------------------------------------------------------*/ 1628 usb_error_t 1629 usbd_req_set_hub_feature(struct usb_device *udev, struct lock *lock, 1630 uint16_t sel) 1631 { 1632 struct usb_device_request req; 1633 1634 req.bmRequestType = UT_WRITE_CLASS_DEVICE; 1635 req.bRequest = UR_SET_FEATURE; 1636 USETW(req.wValue, sel); 1637 USETW(req.wIndex, 0); 1638 USETW(req.wLength, 0); 1639 return (usbd_do_request(udev, lock, &req, 0)); 1640 } 1641 1642 /*------------------------------------------------------------------------* 1643 * usbd_req_set_hub_u1_timeout 1644 * 1645 * Returns: 1646 * 0: Success 1647 * Else: Failure 1648 *------------------------------------------------------------------------*/ 1649 usb_error_t 1650 usbd_req_set_hub_u1_timeout(struct usb_device *udev, struct lock *lock, 1651 uint8_t port, uint8_t timeout) 1652 { 1653 struct usb_device_request req; 1654 1655 req.bmRequestType = UT_WRITE_CLASS_OTHER; 1656 req.bRequest = UR_SET_FEATURE; 1657 USETW(req.wValue, UHF_PORT_U1_TIMEOUT); 1658 req.wIndex[0] = port; 1659 req.wIndex[1] = timeout; 1660 USETW(req.wLength, 0); 1661 return (usbd_do_request(udev, lock, &req, 0)); 1662 } 1663 1664 /*------------------------------------------------------------------------* 1665 * usbd_req_set_hub_u2_timeout 1666 * 1667 * Returns: 1668 * 0: Success 1669 * Else: Failure 1670 *------------------------------------------------------------------------*/ 1671 usb_error_t 1672 usbd_req_set_hub_u2_timeout(struct usb_device *udev, struct lock *lock, 1673 uint8_t port, uint8_t timeout) 1674 { 1675 struct usb_device_request req; 1676 1677 req.bmRequestType = UT_WRITE_CLASS_OTHER; 1678 req.bRequest = UR_SET_FEATURE; 1679 USETW(req.wValue, UHF_PORT_U2_TIMEOUT); 1680 req.wIndex[0] = port; 1681 req.wIndex[1] = timeout; 1682 USETW(req.wLength, 0); 1683 return (usbd_do_request(udev, lock, &req, 0)); 1684 } 1685 1686 /*------------------------------------------------------------------------* 1687 * usbd_req_set_hub_depth 1688 * 1689 * Returns: 1690 * 0: Success 1691 * Else: Failure 1692 *------------------------------------------------------------------------*/ 1693 usb_error_t 1694 usbd_req_set_hub_depth(struct usb_device *udev, struct lock *lock, 1695 uint16_t depth) 1696 { 1697 struct usb_device_request req; 1698 1699 req.bmRequestType = UT_WRITE_CLASS_DEVICE; 1700 req.bRequest = UR_SET_HUB_DEPTH; 1701 USETW(req.wValue, depth); 1702 USETW(req.wIndex, 0); 1703 USETW(req.wLength, 0); 1704 return (usbd_do_request(udev, lock, &req, 0)); 1705 } 1706 1707 /*------------------------------------------------------------------------* 1708 * usbd_req_clear_port_feature 1709 * 1710 * Returns: 1711 * 0: Success 1712 * Else: Failure 1713 *------------------------------------------------------------------------*/ 1714 usb_error_t 1715 usbd_req_clear_port_feature(struct usb_device *udev, struct lock *lock, 1716 uint8_t port, uint16_t sel) 1717 { 1718 struct usb_device_request req; 1719 1720 req.bmRequestType = UT_WRITE_CLASS_OTHER; 1721 req.bRequest = UR_CLEAR_FEATURE; 1722 USETW(req.wValue, sel); 1723 req.wIndex[0] = port; 1724 req.wIndex[1] = 0; 1725 USETW(req.wLength, 0); 1726 return (usbd_do_request(udev, lock, &req, 0)); 1727 } 1728 1729 /*------------------------------------------------------------------------* 1730 * usbd_req_set_port_feature 1731 * 1732 * Returns: 1733 * 0: Success 1734 * Else: Failure 1735 *------------------------------------------------------------------------*/ 1736 usb_error_t 1737 usbd_req_set_port_feature(struct usb_device *udev, struct lock *lock, 1738 uint8_t port, uint16_t sel) 1739 { 1740 struct usb_device_request req; 1741 1742 req.bmRequestType = UT_WRITE_CLASS_OTHER; 1743 req.bRequest = UR_SET_FEATURE; 1744 USETW(req.wValue, sel); 1745 req.wIndex[0] = port; 1746 req.wIndex[1] = 0; 1747 USETW(req.wLength, 0); 1748 return (usbd_do_request(udev, lock, &req, 0)); 1749 } 1750 1751 /*------------------------------------------------------------------------* 1752 * usbd_req_set_protocol 1753 * 1754 * Returns: 1755 * 0: Success 1756 * Else: Failure 1757 *------------------------------------------------------------------------*/ 1758 usb_error_t 1759 usbd_req_set_protocol(struct usb_device *udev, struct lock *lock, 1760 uint8_t iface_index, uint16_t report) 1761 { 1762 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1763 struct usb_device_request req; 1764 1765 if ((iface == NULL) || (iface->idesc == NULL)) { 1766 return (USB_ERR_INVAL); 1767 } 1768 DPRINTFN(5, "iface=%p, report=%d, endpt=%d\n", 1769 iface, report, iface->idesc->bInterfaceNumber); 1770 1771 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 1772 req.bRequest = UR_SET_PROTOCOL; 1773 USETW(req.wValue, report); 1774 req.wIndex[0] = iface->idesc->bInterfaceNumber; 1775 req.wIndex[1] = 0; 1776 USETW(req.wLength, 0); 1777 return (usbd_do_request(udev, lock, &req, 0)); 1778 } 1779 1780 /*------------------------------------------------------------------------* 1781 * usbd_req_set_report 1782 * 1783 * Returns: 1784 * 0: Success 1785 * Else: Failure 1786 *------------------------------------------------------------------------*/ 1787 usb_error_t 1788 usbd_req_set_report(struct usb_device *udev, struct lock *lock, void *data, uint16_t len, 1789 uint8_t iface_index, uint8_t type, uint8_t id) 1790 { 1791 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1792 struct usb_device_request req; 1793 1794 if ((iface == NULL) || (iface->idesc == NULL)) { 1795 return (USB_ERR_INVAL); 1796 } 1797 DPRINTFN(5, "len=%d\n", len); 1798 1799 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 1800 req.bRequest = UR_SET_REPORT; 1801 USETW2(req.wValue, type, id); 1802 req.wIndex[0] = iface->idesc->bInterfaceNumber; 1803 req.wIndex[1] = 0; 1804 USETW(req.wLength, len); 1805 return (usbd_do_request(udev, lock, &req, data)); 1806 } 1807 1808 /*------------------------------------------------------------------------* 1809 * usbd_req_get_report 1810 * 1811 * Returns: 1812 * 0: Success 1813 * Else: Failure 1814 *------------------------------------------------------------------------*/ 1815 usb_error_t 1816 usbd_req_get_report(struct usb_device *udev, struct lock *lock, void *data, 1817 uint16_t len, uint8_t iface_index, uint8_t type, uint8_t id) 1818 { 1819 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1820 struct usb_device_request req; 1821 1822 if ((iface == NULL) || (iface->idesc == NULL)) { 1823 return (USB_ERR_INVAL); 1824 } 1825 DPRINTFN(5, "len=%d\n", len); 1826 1827 req.bmRequestType = UT_READ_CLASS_INTERFACE; 1828 req.bRequest = UR_GET_REPORT; 1829 USETW2(req.wValue, type, id); 1830 req.wIndex[0] = iface->idesc->bInterfaceNumber; 1831 req.wIndex[1] = 0; 1832 USETW(req.wLength, len); 1833 return (usbd_do_request(udev, lock, &req, data)); 1834 } 1835 1836 /*------------------------------------------------------------------------* 1837 * usbd_req_set_idle 1838 * 1839 * Returns: 1840 * 0: Success 1841 * Else: Failure 1842 *------------------------------------------------------------------------*/ 1843 usb_error_t 1844 usbd_req_set_idle(struct usb_device *udev, struct lock *lock, 1845 uint8_t iface_index, uint8_t duration, uint8_t id) 1846 { 1847 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1848 struct usb_device_request req; 1849 1850 if ((iface == NULL) || (iface->idesc == NULL)) { 1851 return (USB_ERR_INVAL); 1852 } 1853 DPRINTFN(5, "%d %d\n", duration, id); 1854 1855 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 1856 req.bRequest = UR_SET_IDLE; 1857 USETW2(req.wValue, duration, id); 1858 req.wIndex[0] = iface->idesc->bInterfaceNumber; 1859 req.wIndex[1] = 0; 1860 USETW(req.wLength, 0); 1861 return (usbd_do_request(udev, lock, &req, 0)); 1862 } 1863 1864 /*------------------------------------------------------------------------* 1865 * usbd_req_get_report_descriptor 1866 * 1867 * Returns: 1868 * 0: Success 1869 * Else: Failure 1870 *------------------------------------------------------------------------*/ 1871 usb_error_t 1872 usbd_req_get_report_descriptor(struct usb_device *udev, struct lock *lock, 1873 void *d, uint16_t size, uint8_t iface_index) 1874 { 1875 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1876 struct usb_device_request req; 1877 1878 if ((iface == NULL) || (iface->idesc == NULL)) { 1879 return (USB_ERR_INVAL); 1880 } 1881 req.bmRequestType = UT_READ_INTERFACE; 1882 req.bRequest = UR_GET_DESCRIPTOR; 1883 USETW2(req.wValue, UDESC_REPORT, 0); /* report id should be 0 */ 1884 req.wIndex[0] = iface->idesc->bInterfaceNumber; 1885 req.wIndex[1] = 0; 1886 USETW(req.wLength, size); 1887 return (usbd_do_request(udev, lock, &req, d)); 1888 } 1889 1890 /*------------------------------------------------------------------------* 1891 * usbd_req_set_config 1892 * 1893 * This function is used to select the current configuration number in 1894 * both USB device side mode and USB host side mode. When setting the 1895 * configuration the function of the interfaces can change. 1896 * 1897 * Returns: 1898 * 0: Success 1899 * Else: Failure 1900 *------------------------------------------------------------------------*/ 1901 usb_error_t 1902 usbd_req_set_config(struct usb_device *udev, struct lock *lock, uint8_t conf) 1903 { 1904 struct usb_device_request req; 1905 1906 DPRINTF("setting config %d\n", conf); 1907 1908 /* do "set configuration" request */ 1909 1910 req.bmRequestType = UT_WRITE_DEVICE; 1911 req.bRequest = UR_SET_CONFIG; 1912 req.wValue[0] = conf; 1913 req.wValue[1] = 0; 1914 USETW(req.wIndex, 0); 1915 USETW(req.wLength, 0); 1916 return (usbd_do_request(udev, lock, &req, 0)); 1917 } 1918 1919 /*------------------------------------------------------------------------* 1920 * usbd_req_get_config 1921 * 1922 * Returns: 1923 * 0: Success 1924 * Else: Failure 1925 *------------------------------------------------------------------------*/ 1926 usb_error_t 1927 usbd_req_get_config(struct usb_device *udev, struct lock *lock, uint8_t *pconf) 1928 { 1929 struct usb_device_request req; 1930 1931 req.bmRequestType = UT_READ_DEVICE; 1932 req.bRequest = UR_GET_CONFIG; 1933 USETW(req.wValue, 0); 1934 USETW(req.wIndex, 0); 1935 USETW(req.wLength, 1); 1936 return (usbd_do_request(udev, lock, &req, pconf)); 1937 } 1938 1939 /*------------------------------------------------------------------------* 1940 * usbd_setup_device_desc 1941 *------------------------------------------------------------------------*/ 1942 usb_error_t 1943 usbd_setup_device_desc(struct usb_device *udev, struct lock *lock) 1944 { 1945 usb_error_t err; 1946 1947 /* 1948 * Get the first 8 bytes of the device descriptor ! 1949 * 1950 * NOTE: "usbd_do_request()" will check the device descriptor 1951 * next time we do a request to see if the maximum packet size 1952 * changed! The 8 first bytes of the device descriptor 1953 * contains the maximum packet size to use on control endpoint 1954 * 0. If this value is different from "USB_MAX_IPACKET" a new 1955 * USB control request will be setup! 1956 */ 1957 switch (udev->speed) { 1958 case USB_SPEED_FULL: 1959 case USB_SPEED_LOW: 1960 err = usbd_req_get_desc(udev, lock, NULL, &udev->ddesc, 1961 USB_MAX_IPACKET, USB_MAX_IPACKET, 0, UDESC_DEVICE, 0, 0); 1962 if (err != 0) { 1963 DPRINTFN(0, "getting device descriptor " 1964 "at addr %d failed, %s\n", udev->address, 1965 usbd_errstr(err)); 1966 return (err); 1967 } 1968 break; 1969 default: 1970 DPRINTF("Minimum MaxPacketSize is large enough " 1971 "to hold the complete device descriptor\n"); 1972 break; 1973 } 1974 1975 /* get the full device descriptor */ 1976 err = usbd_req_get_device_desc(udev, lock, &udev->ddesc); 1977 1978 /* try one more time, if error */ 1979 if (err) 1980 err = usbd_req_get_device_desc(udev, lock, &udev->ddesc); 1981 1982 if (err) { 1983 DPRINTF("addr=%d, getting full desc failed\n", 1984 udev->address); 1985 return (err); 1986 } 1987 1988 DPRINTF("adding unit addr=%d, rev=%02x, class=%d, " 1989 "subclass=%d, protocol=%d, maxpacket=%d, len=%d, speed=%d\n", 1990 udev->address, UGETW(udev->ddesc.bcdUSB), 1991 udev->ddesc.bDeviceClass, 1992 udev->ddesc.bDeviceSubClass, 1993 udev->ddesc.bDeviceProtocol, 1994 udev->ddesc.bMaxPacketSize, 1995 udev->ddesc.bLength, 1996 udev->speed); 1997 1998 return (err); 1999 } 2000 2001 /*------------------------------------------------------------------------* 2002 * usbd_req_re_enumerate 2003 * 2004 * NOTE: After this function returns the hardware is in the 2005 * unconfigured state! The application is responsible for setting a 2006 * new configuration. 2007 * 2008 * Returns: 2009 * 0: Success 2010 * Else: Failure 2011 *------------------------------------------------------------------------*/ 2012 usb_error_t 2013 usbd_req_re_enumerate(struct usb_device *udev, struct lock *lock) 2014 { 2015 struct usb_device *parent_hub; 2016 usb_error_t err; 2017 uint8_t old_addr; 2018 uint8_t do_retry = 1; 2019 2020 if (udev->flags.usb_mode != USB_MODE_HOST) { 2021 return (USB_ERR_INVAL); 2022 } 2023 old_addr = udev->address; 2024 parent_hub = udev->parent_hub; 2025 if (parent_hub == NULL) { 2026 return (USB_ERR_INVAL); 2027 } 2028 retry: 2029 /* 2030 * Try to reset the High Speed parent HUB of a LOW- or FULL- 2031 * speed device, if any. 2032 */ 2033 if (udev->parent_hs_hub != NULL && 2034 udev->speed != USB_SPEED_HIGH) { 2035 DPRINTF("Trying to reset parent High Speed TT.\n"); 2036 err = usbd_req_reset_tt(udev->parent_hs_hub, NULL, 2037 udev->hs_port_no); 2038 if (err) { 2039 DPRINTF("Resetting parent High " 2040 "Speed TT failed (%s).\n", 2041 usbd_errstr(err)); 2042 } 2043 } 2044 2045 /* Try to warm reset first */ 2046 if (parent_hub->speed == USB_SPEED_SUPER) 2047 usbd_req_warm_reset_port(parent_hub, lock, udev->port_no); 2048 2049 /* Try to reset the parent HUB port. */ 2050 err = usbd_req_reset_port(parent_hub, lock, udev->port_no); 2051 if (err) { 2052 DPRINTFN(0, "addr=%d, port reset failed, %s\n", 2053 old_addr, usbd_errstr(err)); 2054 goto done; 2055 } 2056 2057 /* 2058 * After that the port has been reset our device should be at 2059 * address zero: 2060 */ 2061 udev->address = USB_START_ADDR; 2062 2063 /* reset "bMaxPacketSize" */ 2064 udev->ddesc.bMaxPacketSize = USB_MAX_IPACKET; 2065 2066 /* reset USB state */ 2067 usb_set_device_state(udev, USB_STATE_POWERED); 2068 2069 /* 2070 * Restore device address: 2071 */ 2072 err = usbd_req_set_address(udev, lock, old_addr); 2073 if (err) { 2074 /* XXX ignore any errors! */ 2075 DPRINTFN(0, "addr=%d, set address failed! (%s, ignored)\n", 2076 old_addr, usbd_errstr(err)); 2077 } 2078 /* 2079 * Restore device address, if the controller driver did not 2080 * set a new one: 2081 */ 2082 if (udev->address == USB_START_ADDR) 2083 udev->address = old_addr; 2084 2085 /* setup the device descriptor and the initial "wMaxPacketSize" */ 2086 err = usbd_setup_device_desc(udev, lock); 2087 2088 done: 2089 if (err && do_retry) { 2090 /* give the USB firmware some time to load */ 2091 usb_pause_mtx(lock, hz / 2); 2092 /* no more retries after this retry */ 2093 do_retry = 0; 2094 /* try again */ 2095 goto retry; 2096 } 2097 /* restore address */ 2098 if (udev->address == USB_START_ADDR) 2099 udev->address = old_addr; 2100 /* update state, if successful */ 2101 if (err == 0) 2102 usb_set_device_state(udev, USB_STATE_ADDRESSED); 2103 return (err); 2104 } 2105 2106 /*------------------------------------------------------------------------* 2107 * usbd_req_clear_device_feature 2108 * 2109 * Returns: 2110 * 0: Success 2111 * Else: Failure 2112 *------------------------------------------------------------------------*/ 2113 usb_error_t 2114 usbd_req_clear_device_feature(struct usb_device *udev, struct lock *lock, 2115 uint16_t sel) 2116 { 2117 struct usb_device_request req; 2118 2119 req.bmRequestType = UT_WRITE_DEVICE; 2120 req.bRequest = UR_CLEAR_FEATURE; 2121 USETW(req.wValue, sel); 2122 USETW(req.wIndex, 0); 2123 USETW(req.wLength, 0); 2124 return (usbd_do_request(udev, lock, &req, 0)); 2125 } 2126 2127 /*------------------------------------------------------------------------* 2128 * usbd_req_set_device_feature 2129 * 2130 * Returns: 2131 * 0: Success 2132 * Else: Failure 2133 *------------------------------------------------------------------------*/ 2134 usb_error_t 2135 usbd_req_set_device_feature(struct usb_device *udev, struct lock *lock, 2136 uint16_t sel) 2137 { 2138 struct usb_device_request req; 2139 2140 req.bmRequestType = UT_WRITE_DEVICE; 2141 req.bRequest = UR_SET_FEATURE; 2142 USETW(req.wValue, sel); 2143 USETW(req.wIndex, 0); 2144 USETW(req.wLength, 0); 2145 return (usbd_do_request(udev, lock, &req, 0)); 2146 } 2147 2148 /*------------------------------------------------------------------------* 2149 * usbd_req_reset_tt 2150 * 2151 * Returns: 2152 * 0: Success 2153 * Else: Failure 2154 *------------------------------------------------------------------------*/ 2155 usb_error_t 2156 usbd_req_reset_tt(struct usb_device *udev, struct lock *lock, 2157 uint8_t port) 2158 { 2159 struct usb_device_request req; 2160 2161 /* For single TT HUBs the port should be 1 */ 2162 2163 if (udev->ddesc.bDeviceClass == UDCLASS_HUB && 2164 udev->ddesc.bDeviceProtocol == UDPROTO_HSHUBSTT) 2165 port = 1; 2166 2167 req.bmRequestType = UT_WRITE_CLASS_OTHER; 2168 req.bRequest = UR_RESET_TT; 2169 USETW(req.wValue, 0); 2170 req.wIndex[0] = port; 2171 req.wIndex[1] = 0; 2172 USETW(req.wLength, 0); 2173 return (usbd_do_request(udev, lock, &req, 0)); 2174 } 2175 2176 /*------------------------------------------------------------------------* 2177 * usbd_req_clear_tt_buffer 2178 * 2179 * For single TT HUBs the port should be 1. 2180 * 2181 * Returns: 2182 * 0: Success 2183 * Else: Failure 2184 *------------------------------------------------------------------------*/ 2185 usb_error_t 2186 usbd_req_clear_tt_buffer(struct usb_device *udev, struct lock *lock, 2187 uint8_t port, uint8_t addr, uint8_t type, uint8_t endpoint) 2188 { 2189 struct usb_device_request req; 2190 uint16_t wValue; 2191 2192 /* For single TT HUBs the port should be 1 */ 2193 2194 if (udev->ddesc.bDeviceClass == UDCLASS_HUB && 2195 udev->ddesc.bDeviceProtocol == UDPROTO_HSHUBSTT) 2196 port = 1; 2197 2198 wValue = (endpoint & 0xF) | ((addr & 0x7F) << 4) | 2199 ((endpoint & 0x80) << 8) | ((type & 3) << 12); 2200 2201 req.bmRequestType = UT_WRITE_CLASS_OTHER; 2202 req.bRequest = UR_CLEAR_TT_BUFFER; 2203 USETW(req.wValue, wValue); 2204 req.wIndex[0] = port; 2205 req.wIndex[1] = 0; 2206 USETW(req.wLength, 0); 2207 return (usbd_do_request(udev, lock, &req, 0)); 2208 } 2209 2210 /*------------------------------------------------------------------------* 2211 * usbd_req_set_port_link_state 2212 * 2213 * USB 3.0 specific request 2214 * 2215 * Returns: 2216 * 0: Success 2217 * Else: Failure 2218 *------------------------------------------------------------------------*/ 2219 usb_error_t 2220 usbd_req_set_port_link_state(struct usb_device *udev, struct lock *lock, 2221 uint8_t port, uint8_t link_state) 2222 { 2223 struct usb_device_request req; 2224 2225 req.bmRequestType = UT_WRITE_CLASS_OTHER; 2226 req.bRequest = UR_SET_FEATURE; 2227 USETW(req.wValue, UHF_PORT_LINK_STATE); 2228 req.wIndex[0] = port; 2229 req.wIndex[1] = link_state; 2230 USETW(req.wLength, 0); 2231 return (usbd_do_request(udev, lock, &req, 0)); 2232 } 2233