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