1 /* $FreeBSD$ */ 2 /*- 3 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 4 * 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 #ifdef USB_GLOBAL_INCLUDE_FILE 30 #include USB_GLOBAL_INCLUDE_FILE 31 #else 32 #include <sys/stdint.h> 33 #include <sys/stddef.h> 34 #include <sys/param.h> 35 #include <sys/eventhandler.h> 36 #include <sys/queue.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/bus.h> 40 #include <sys/module.h> 41 #include <sys/lock.h> 42 #include <sys/mutex.h> 43 #include <sys/condvar.h> 44 #include <sys/sysctl.h> 45 #include <sys/sx.h> 46 #include <sys/unistd.h> 47 #include <sys/callout.h> 48 #include <sys/malloc.h> 49 #include <sys/priv.h> 50 #include <sys/conf.h> 51 #include <sys/fcntl.h> 52 53 #include <dev/usb/usb.h> 54 #include <dev/usb/usbdi.h> 55 #include <dev/usb/usbdi_util.h> 56 #include <dev/usb/usb_ioctl.h> 57 58 #if USB_HAVE_UGEN 59 #include <sys/sbuf.h> 60 #endif 61 62 #include "usbdevs.h" 63 64 #define USB_DEBUG_VAR usb_debug 65 66 #include <dev/usb/usb_core.h> 67 #include <dev/usb/usb_debug.h> 68 #include <dev/usb/usb_process.h> 69 #include <dev/usb/usb_device.h> 70 #include <dev/usb/usb_busdma.h> 71 #include <dev/usb/usb_transfer.h> 72 #include <dev/usb/usb_request.h> 73 #include <dev/usb/usb_dynamic.h> 74 #include <dev/usb/usb_hub.h> 75 #include <dev/usb/usb_util.h> 76 #include <dev/usb/usb_msctest.h> 77 #if USB_HAVE_UGEN 78 #include <dev/usb/usb_dev.h> 79 #include <dev/usb/usb_generic.h> 80 #endif 81 82 #include <dev/usb/quirk/usb_quirk.h> 83 84 #include <dev/usb/usb_controller.h> 85 #include <dev/usb/usb_bus.h> 86 #endif /* USB_GLOBAL_INCLUDE_FILE */ 87 88 /* function prototypes */ 89 90 static int sysctl_hw_usb_template(SYSCTL_HANDLER_ARGS); 91 static void usb_init_endpoint(struct usb_device *, uint8_t, 92 struct usb_endpoint_descriptor *, 93 struct usb_endpoint_ss_comp_descriptor *, 94 struct usb_endpoint *); 95 static void usb_unconfigure(struct usb_device *, uint8_t); 96 static void usb_detach_device_sub(struct usb_device *, device_t *, 97 char **, uint8_t); 98 static uint8_t usb_probe_and_attach_sub(struct usb_device *, 99 struct usb_attach_arg *); 100 static void usb_init_attach_arg(struct usb_device *, 101 struct usb_attach_arg *); 102 static void usb_suspend_resume_sub(struct usb_device *, device_t, 103 uint8_t); 104 static usb_proc_callback_t usbd_clear_stall_proc; 105 static usb_error_t usb_config_parse(struct usb_device *, uint8_t, uint8_t); 106 static void usbd_set_device_strings(struct usb_device *); 107 #if USB_HAVE_DEVCTL 108 static void usb_notify_addq(const char *type, struct usb_device *); 109 #endif 110 #if USB_HAVE_UGEN 111 static void usb_fifo_free_wrap(struct usb_device *, uint8_t, uint8_t); 112 static void usb_cdev_create(struct usb_device *); 113 static void usb_cdev_free(struct usb_device *); 114 #endif 115 116 /* This variable is global to allow easy access to it: */ 117 118 #ifdef USB_TEMPLATE 119 int usb_template = USB_TEMPLATE; 120 #else 121 int usb_template = -1; 122 #endif 123 124 SYSCTL_PROC(_hw_usb, OID_AUTO, template, 125 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 126 NULL, 0, sysctl_hw_usb_template, 127 "I", "Selected USB device side template"); 128 129 /*------------------------------------------------------------------------* 130 * usb_trigger_reprobe_on_off 131 * 132 * This function sets the pull up resistors for all ports currently 133 * operating in device mode either on (when on_not_off is 1), or off 134 * (when it's 0). 135 *------------------------------------------------------------------------*/ 136 static void 137 usb_trigger_reprobe_on_off(int on_not_off) 138 { 139 struct usb_port_status ps; 140 struct usb_bus *bus; 141 struct usb_device *udev; 142 usb_error_t err; 143 int do_unlock, max; 144 145 max = devclass_get_maxunit(usb_devclass_ptr); 146 while (max >= 0) { 147 mtx_lock(&usb_ref_lock); 148 bus = devclass_get_softc(usb_devclass_ptr, max); 149 max--; 150 151 if (bus == NULL || bus->devices == NULL || 152 bus->devices[USB_ROOT_HUB_ADDR] == NULL) { 153 mtx_unlock(&usb_ref_lock); 154 continue; 155 } 156 157 udev = bus->devices[USB_ROOT_HUB_ADDR]; 158 159 if (udev->refcount == USB_DEV_REF_MAX) { 160 mtx_unlock(&usb_ref_lock); 161 continue; 162 } 163 164 udev->refcount++; 165 mtx_unlock(&usb_ref_lock); 166 167 do_unlock = usbd_enum_lock(udev); 168 if (do_unlock > 1) { 169 do_unlock = 0; 170 goto next; 171 } 172 173 err = usbd_req_get_port_status(udev, NULL, &ps, 1); 174 if (err != 0) { 175 DPRINTF("usbd_req_get_port_status() " 176 "failed: %s\n", usbd_errstr(err)); 177 goto next; 178 } 179 180 if ((UGETW(ps.wPortStatus) & UPS_PORT_MODE_DEVICE) == 0) 181 goto next; 182 183 if (on_not_off) { 184 err = usbd_req_set_port_feature(udev, NULL, 1, 185 UHF_PORT_POWER); 186 if (err != 0) { 187 DPRINTF("usbd_req_set_port_feature() " 188 "failed: %s\n", usbd_errstr(err)); 189 } 190 } else { 191 err = usbd_req_clear_port_feature(udev, NULL, 1, 192 UHF_PORT_POWER); 193 if (err != 0) { 194 DPRINTF("usbd_req_clear_port_feature() " 195 "failed: %s\n", usbd_errstr(err)); 196 } 197 } 198 199 next: 200 mtx_lock(&usb_ref_lock); 201 if (do_unlock) 202 usbd_enum_unlock(udev); 203 if (--(udev->refcount) == 0) 204 cv_broadcast(&udev->ref_cv); 205 mtx_unlock(&usb_ref_lock); 206 } 207 } 208 209 /*------------------------------------------------------------------------* 210 * usb_trigger_reprobe_all 211 * 212 * This function toggles the pull up resistors for all ports currently 213 * operating in device mode, causing the host machine to reenumerate them. 214 *------------------------------------------------------------------------*/ 215 static void 216 usb_trigger_reprobe_all(void) 217 { 218 219 /* 220 * Set the pull up resistors off for all ports in device mode. 221 */ 222 usb_trigger_reprobe_on_off(0); 223 224 /* 225 * According to the DWC OTG spec this must be at least 3ms. 226 */ 227 usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_POWER_DOWN_TIME)); 228 229 /* 230 * Set the pull up resistors back on. 231 */ 232 usb_trigger_reprobe_on_off(1); 233 } 234 235 static int 236 sysctl_hw_usb_template(SYSCTL_HANDLER_ARGS) 237 { 238 int error, val; 239 240 val = usb_template; 241 error = sysctl_handle_int(oidp, &val, 0, req); 242 if (error != 0 || req->newptr == NULL || usb_template == val) 243 return (error); 244 245 usb_template = val; 246 247 if (usb_template < 0) { 248 usb_trigger_reprobe_on_off(0); 249 } else { 250 usb_trigger_reprobe_all(); 251 } 252 253 return (0); 254 } 255 256 /* English is default language */ 257 258 static int usb_lang_id = 0x0009; 259 static int usb_lang_mask = 0x00FF; 260 261 SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_id, CTLFLAG_RWTUN, 262 &usb_lang_id, 0, "Preferred USB language ID"); 263 264 SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_mask, CTLFLAG_RWTUN, 265 &usb_lang_mask, 0, "Preferred USB language mask"); 266 267 static const char* statestr[USB_STATE_MAX] = { 268 [USB_STATE_DETACHED] = "DETACHED", 269 [USB_STATE_ATTACHED] = "ATTACHED", 270 [USB_STATE_POWERED] = "POWERED", 271 [USB_STATE_ADDRESSED] = "ADDRESSED", 272 [USB_STATE_CONFIGURED] = "CONFIGURED", 273 }; 274 275 const char * 276 usb_statestr(enum usb_dev_state state) 277 { 278 return ((state < USB_STATE_MAX) ? statestr[state] : "UNKNOWN"); 279 } 280 281 const char * 282 usb_get_manufacturer(struct usb_device *udev) 283 { 284 return (udev->manufacturer ? udev->manufacturer : "Unknown"); 285 } 286 287 const char * 288 usb_get_product(struct usb_device *udev) 289 { 290 return (udev->product ? udev->product : ""); 291 } 292 293 const char * 294 usb_get_serial(struct usb_device *udev) 295 { 296 return (udev->serial ? udev->serial : ""); 297 } 298 299 /*------------------------------------------------------------------------* 300 * usbd_get_ep_by_addr 301 * 302 * This function searches for an USB ep by endpoint address and 303 * direction. 304 * 305 * Returns: 306 * NULL: Failure 307 * Else: Success 308 *------------------------------------------------------------------------*/ 309 struct usb_endpoint * 310 usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val) 311 { 312 struct usb_endpoint *ep = udev->endpoints; 313 struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max; 314 enum { 315 EA_MASK = (UE_DIR_IN | UE_DIR_OUT | UE_ADDR), 316 }; 317 318 /* 319 * According to the USB specification not all bits are used 320 * for the endpoint address. Keep defined bits only: 321 */ 322 ea_val &= EA_MASK; 323 324 /* 325 * Iterate across all the USB endpoints searching for a match 326 * based on the endpoint address: 327 */ 328 for (; ep != ep_end; ep++) { 329 330 if (ep->edesc == NULL) { 331 continue; 332 } 333 /* do the mask and check the value */ 334 if ((ep->edesc->bEndpointAddress & EA_MASK) == ea_val) { 335 goto found; 336 } 337 } 338 339 /* 340 * The default endpoint is always present and is checked separately: 341 */ 342 if ((udev->ctrl_ep.edesc != NULL) && 343 ((udev->ctrl_ep.edesc->bEndpointAddress & EA_MASK) == ea_val)) { 344 ep = &udev->ctrl_ep; 345 goto found; 346 } 347 return (NULL); 348 349 found: 350 return (ep); 351 } 352 353 /*------------------------------------------------------------------------* 354 * usbd_get_endpoint 355 * 356 * This function searches for an USB endpoint based on the information 357 * given by the passed "struct usb_config" pointer. 358 * 359 * Return values: 360 * NULL: No match. 361 * Else: Pointer to "struct usb_endpoint". 362 *------------------------------------------------------------------------*/ 363 struct usb_endpoint * 364 usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index, 365 const struct usb_config *setup) 366 { 367 struct usb_endpoint *ep = udev->endpoints; 368 struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max; 369 uint8_t index = setup->ep_index; 370 uint8_t ea_mask; 371 uint8_t ea_val; 372 uint8_t type_mask; 373 uint8_t type_val; 374 375 DPRINTFN(10, "udev=%p iface_index=%d address=0x%x " 376 "type=0x%x dir=0x%x index=%d\n", 377 udev, iface_index, setup->endpoint, 378 setup->type, setup->direction, setup->ep_index); 379 380 /* check USB mode */ 381 382 if (setup->usb_mode != USB_MODE_DUAL && 383 udev->flags.usb_mode != setup->usb_mode) { 384 /* wrong mode - no endpoint */ 385 return (NULL); 386 } 387 388 /* setup expected endpoint direction mask and value */ 389 390 if (setup->direction == UE_DIR_RX) { 391 ea_mask = (UE_DIR_IN | UE_DIR_OUT); 392 ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ? 393 UE_DIR_OUT : UE_DIR_IN; 394 } else if (setup->direction == UE_DIR_TX) { 395 ea_mask = (UE_DIR_IN | UE_DIR_OUT); 396 ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ? 397 UE_DIR_IN : UE_DIR_OUT; 398 } else if (setup->direction == UE_DIR_ANY) { 399 /* match any endpoint direction */ 400 ea_mask = 0; 401 ea_val = 0; 402 } else { 403 /* match the given endpoint direction */ 404 ea_mask = (UE_DIR_IN | UE_DIR_OUT); 405 ea_val = (setup->direction & (UE_DIR_IN | UE_DIR_OUT)); 406 } 407 408 /* setup expected endpoint address */ 409 410 if (setup->endpoint == UE_ADDR_ANY) { 411 /* match any endpoint address */ 412 } else { 413 /* match the given endpoint address */ 414 ea_mask |= UE_ADDR; 415 ea_val |= (setup->endpoint & UE_ADDR); 416 } 417 418 /* setup expected endpoint type */ 419 420 if (setup->type == UE_BULK_INTR) { 421 /* this will match BULK and INTERRUPT endpoints */ 422 type_mask = 2; 423 type_val = 2; 424 } else if (setup->type == UE_TYPE_ANY) { 425 /* match any endpoint type */ 426 type_mask = 0; 427 type_val = 0; 428 } else { 429 /* match the given endpoint type */ 430 type_mask = UE_XFERTYPE; 431 type_val = (setup->type & UE_XFERTYPE); 432 } 433 434 /* 435 * Iterate across all the USB endpoints searching for a match 436 * based on the endpoint address. Note that we are searching 437 * the endpoints from the beginning of the "udev->endpoints" array. 438 */ 439 for (; ep != ep_end; ep++) { 440 441 if ((ep->edesc == NULL) || 442 (ep->iface_index != iface_index)) { 443 continue; 444 } 445 /* do the masks and check the values */ 446 447 if (((ep->edesc->bEndpointAddress & ea_mask) == ea_val) && 448 ((ep->edesc->bmAttributes & type_mask) == type_val)) { 449 if (!index--) { 450 goto found; 451 } 452 } 453 } 454 455 /* 456 * Match against default endpoint last, so that "any endpoint", "any 457 * address" and "any direction" returns the first endpoint of the 458 * interface. "iface_index" and "direction" is ignored: 459 */ 460 if ((udev->ctrl_ep.edesc != NULL) && 461 ((udev->ctrl_ep.edesc->bEndpointAddress & ea_mask) == ea_val) && 462 ((udev->ctrl_ep.edesc->bmAttributes & type_mask) == type_val) && 463 (!index)) { 464 ep = &udev->ctrl_ep; 465 goto found; 466 } 467 return (NULL); 468 469 found: 470 return (ep); 471 } 472 473 /*------------------------------------------------------------------------* 474 * usbd_interface_count 475 * 476 * This function stores the number of USB interfaces excluding 477 * alternate settings, which the USB config descriptor reports into 478 * the unsigned 8-bit integer pointed to by "count". 479 * 480 * Returns: 481 * 0: Success 482 * Else: Failure 483 *------------------------------------------------------------------------*/ 484 usb_error_t 485 usbd_interface_count(struct usb_device *udev, uint8_t *count) 486 { 487 if (udev->cdesc == NULL) { 488 *count = 0; 489 return (USB_ERR_NOT_CONFIGURED); 490 } 491 *count = udev->ifaces_max; 492 return (USB_ERR_NORMAL_COMPLETION); 493 } 494 495 /*------------------------------------------------------------------------* 496 * usb_init_endpoint 497 * 498 * This function will initialise the USB endpoint structure pointed to by 499 * the "endpoint" argument. The structure pointed to by "endpoint" must be 500 * zeroed before calling this function. 501 *------------------------------------------------------------------------*/ 502 static void 503 usb_init_endpoint(struct usb_device *udev, uint8_t iface_index, 504 struct usb_endpoint_descriptor *edesc, 505 struct usb_endpoint_ss_comp_descriptor *ecomp, 506 struct usb_endpoint *ep) 507 { 508 const struct usb_bus_methods *methods; 509 usb_stream_t x; 510 511 methods = udev->bus->methods; 512 513 (methods->endpoint_init) (udev, edesc, ep); 514 515 /* initialise USB endpoint structure */ 516 ep->edesc = edesc; 517 ep->ecomp = ecomp; 518 ep->iface_index = iface_index; 519 520 /* setup USB stream queues */ 521 for (x = 0; x != USB_MAX_EP_STREAMS; x++) { 522 TAILQ_INIT(&ep->endpoint_q[x].head); 523 ep->endpoint_q[x].command = &usbd_pipe_start; 524 } 525 526 /* the pipe is not supported by the hardware */ 527 if (ep->methods == NULL) 528 return; 529 530 /* check for SUPER-speed streams mode endpoint */ 531 if (udev->speed == USB_SPEED_SUPER && ecomp != NULL && 532 (edesc->bmAttributes & UE_XFERTYPE) == UE_BULK && 533 (UE_GET_BULK_STREAMS(ecomp->bmAttributes) != 0)) { 534 usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_STREAMS); 535 } else { 536 usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_DEFAULT); 537 } 538 539 /* clear stall, if any */ 540 if (methods->clear_stall != NULL) { 541 USB_BUS_LOCK(udev->bus); 542 (methods->clear_stall) (udev, ep); 543 USB_BUS_UNLOCK(udev->bus); 544 } 545 } 546 547 /*-----------------------------------------------------------------------* 548 * usb_endpoint_foreach 549 * 550 * This function will iterate all the USB endpoints except the control 551 * endpoint. This function is NULL safe. 552 * 553 * Return values: 554 * NULL: End of USB endpoints 555 * Else: Pointer to next USB endpoint 556 *------------------------------------------------------------------------*/ 557 struct usb_endpoint * 558 usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep) 559 { 560 struct usb_endpoint *ep_end; 561 562 /* be NULL safe */ 563 if (udev == NULL) 564 return (NULL); 565 566 ep_end = udev->endpoints + udev->endpoints_max; 567 568 /* get next endpoint */ 569 if (ep == NULL) 570 ep = udev->endpoints; 571 else 572 ep++; 573 574 /* find next allocated ep */ 575 while (ep != ep_end) { 576 if (ep->edesc != NULL) 577 return (ep); 578 ep++; 579 } 580 return (NULL); 581 } 582 583 /*------------------------------------------------------------------------* 584 * usb_wait_pending_refs 585 * 586 * This function will wait for any USB references to go away before 587 * returning. This function is used before freeing a USB device. 588 *------------------------------------------------------------------------*/ 589 static void 590 usb_wait_pending_refs(struct usb_device *udev) 591 { 592 #if USB_HAVE_UGEN 593 DPRINTF("Refcount = %d\n", (int)udev->refcount); 594 595 mtx_lock(&usb_ref_lock); 596 udev->refcount--; 597 while (1) { 598 /* wait for any pending references to go away */ 599 if (udev->refcount == 0) { 600 /* prevent further refs being taken, if any */ 601 udev->refcount = USB_DEV_REF_MAX; 602 break; 603 } 604 cv_wait(&udev->ref_cv, &usb_ref_lock); 605 } 606 mtx_unlock(&usb_ref_lock); 607 #endif 608 } 609 610 /*------------------------------------------------------------------------* 611 * usb_unconfigure 612 * 613 * This function will free all USB interfaces and USB endpoints belonging 614 * to an USB device. 615 * 616 * Flag values, see "USB_UNCFG_FLAG_XXX". 617 *------------------------------------------------------------------------*/ 618 static void 619 usb_unconfigure(struct usb_device *udev, uint8_t flag) 620 { 621 uint8_t do_unlock; 622 623 /* Prevent re-enumeration */ 624 do_unlock = usbd_enum_lock(udev); 625 626 /* detach all interface drivers */ 627 usb_detach_device(udev, USB_IFACE_INDEX_ANY, flag); 628 629 #if USB_HAVE_UGEN 630 /* free all FIFOs except control endpoint FIFOs */ 631 usb_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag); 632 633 /* 634 * Free all cdev's, if any. 635 */ 636 usb_cdev_free(udev); 637 #endif 638 639 #if USB_HAVE_COMPAT_LINUX 640 /* free Linux compat device, if any */ 641 if (udev->linux_endpoint_start != NULL) { 642 usb_linux_free_device_p(udev); 643 udev->linux_endpoint_start = NULL; 644 } 645 #endif 646 647 usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE); 648 649 /* free "cdesc" after "ifaces" and "endpoints", if any */ 650 if (udev->cdesc != NULL) { 651 if (udev->flags.usb_mode != USB_MODE_DEVICE) 652 usbd_free_config_desc(udev, udev->cdesc); 653 udev->cdesc = NULL; 654 } 655 /* set unconfigured state */ 656 udev->curr_config_no = USB_UNCONFIG_NO; 657 udev->curr_config_index = USB_UNCONFIG_INDEX; 658 659 if (do_unlock) 660 usbd_enum_unlock(udev); 661 } 662 663 /*------------------------------------------------------------------------* 664 * usbd_set_config_index 665 * 666 * This function selects configuration by index, independent of the 667 * actual configuration number. This function should not be used by 668 * USB drivers. 669 * 670 * Returns: 671 * 0: Success 672 * Else: Failure 673 *------------------------------------------------------------------------*/ 674 usb_error_t 675 usbd_set_config_index(struct usb_device *udev, uint8_t index) 676 { 677 struct usb_status ds; 678 struct usb_config_descriptor *cdp; 679 uint16_t power; 680 uint16_t max_power; 681 uint8_t selfpowered; 682 uint8_t do_unlock; 683 usb_error_t err; 684 685 DPRINTFN(6, "udev=%p index=%d\n", udev, index); 686 687 /* Prevent re-enumeration */ 688 do_unlock = usbd_enum_lock(udev); 689 690 usb_unconfigure(udev, 0); 691 692 if (index == USB_UNCONFIG_INDEX) { 693 /* 694 * Leave unallocated when unconfiguring the 695 * device. "usb_unconfigure()" will also reset 696 * the current config number and index. 697 */ 698 err = usbd_req_set_config(udev, NULL, USB_UNCONFIG_NO); 699 if (udev->state == USB_STATE_CONFIGURED) 700 usb_set_device_state(udev, USB_STATE_ADDRESSED); 701 goto done; 702 } 703 /* get the full config descriptor */ 704 if (udev->flags.usb_mode == USB_MODE_DEVICE) { 705 /* save some memory */ 706 err = usbd_req_get_descriptor_ptr(udev, &cdp, 707 (UDESC_CONFIG << 8) | index); 708 } else { 709 /* normal request */ 710 err = usbd_req_get_config_desc_full(udev, 711 NULL, &cdp, index); 712 } 713 if (err) { 714 goto done; 715 } 716 /* set the new config descriptor */ 717 718 udev->cdesc = cdp; 719 720 /* Figure out if the device is self or bus powered. */ 721 selfpowered = 0; 722 if ((!udev->flags.uq_bus_powered) && 723 (cdp->bmAttributes & UC_SELF_POWERED) && 724 (udev->flags.usb_mode == USB_MODE_HOST)) { 725 /* May be self powered. */ 726 if (cdp->bmAttributes & UC_BUS_POWERED) { 727 /* Must ask device. */ 728 err = usbd_req_get_device_status(udev, NULL, &ds); 729 if (err) { 730 DPRINTFN(0, "could not read " 731 "device status: %s\n", 732 usbd_errstr(err)); 733 } else if (UGETW(ds.wStatus) & UDS_SELF_POWERED) { 734 selfpowered = 1; 735 } 736 DPRINTF("status=0x%04x \n", 737 UGETW(ds.wStatus)); 738 } else 739 selfpowered = 1; 740 } 741 DPRINTF("udev=%p cdesc=%p (addr %d) cno=%d attr=0x%02x, " 742 "selfpowered=%d, power=%d\n", 743 udev, cdp, 744 udev->address, cdp->bConfigurationValue, cdp->bmAttributes, 745 selfpowered, cdp->bMaxPower * 2); 746 747 /* Check if we have enough power. */ 748 power = cdp->bMaxPower * 2; 749 750 if (udev->parent_hub) { 751 max_power = udev->parent_hub->hub->portpower; 752 } else { 753 max_power = USB_MAX_POWER; 754 } 755 756 if (power > max_power) { 757 DPRINTFN(0, "power exceeded %d > %d\n", power, max_power); 758 err = USB_ERR_NO_POWER; 759 goto done; 760 } 761 /* Only update "self_powered" in USB Host Mode */ 762 if (udev->flags.usb_mode == USB_MODE_HOST) { 763 udev->flags.self_powered = selfpowered; 764 } 765 udev->power = power; 766 udev->curr_config_no = cdp->bConfigurationValue; 767 udev->curr_config_index = index; 768 usb_set_device_state(udev, USB_STATE_CONFIGURED); 769 770 /* Set the actual configuration value. */ 771 err = usbd_req_set_config(udev, NULL, cdp->bConfigurationValue); 772 if (err) { 773 goto done; 774 } 775 776 err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC); 777 if (err) { 778 goto done; 779 } 780 781 err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT); 782 if (err) { 783 goto done; 784 } 785 786 #if USB_HAVE_UGEN 787 /* create device nodes for each endpoint */ 788 usb_cdev_create(udev); 789 #endif 790 791 done: 792 DPRINTF("error=%s\n", usbd_errstr(err)); 793 if (err) { 794 usb_unconfigure(udev, 0); 795 } 796 if (do_unlock) 797 usbd_enum_unlock(udev); 798 return (err); 799 } 800 801 /*------------------------------------------------------------------------* 802 * usb_config_parse 803 * 804 * This function will allocate and free USB interfaces and USB endpoints, 805 * parse the USB configuration structure and initialise the USB endpoints 806 * and interfaces. If "iface_index" is not equal to 807 * "USB_IFACE_INDEX_ANY" then the "cmd" parameter is the 808 * alternate_setting to be selected for the given interface. Else the 809 * "cmd" parameter is defined by "USB_CFG_XXX". "iface_index" can be 810 * "USB_IFACE_INDEX_ANY" or a valid USB interface index. This function 811 * is typically called when setting the configuration or when setting 812 * an alternate interface. 813 * 814 * Returns: 815 * 0: Success 816 * Else: Failure 817 *------------------------------------------------------------------------*/ 818 static usb_error_t 819 usb_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd) 820 { 821 struct usb_idesc_parse_state ips; 822 struct usb_interface_descriptor *id; 823 struct usb_endpoint_descriptor *ed; 824 struct usb_interface *iface; 825 struct usb_endpoint *ep; 826 usb_error_t err; 827 uint8_t ep_curr; 828 uint8_t ep_max; 829 uint8_t temp; 830 uint8_t do_init; 831 uint8_t alt_index; 832 833 if (iface_index != USB_IFACE_INDEX_ANY) { 834 /* parameter overload */ 835 alt_index = cmd; 836 cmd = USB_CFG_INIT; 837 } else { 838 /* not used */ 839 alt_index = 0; 840 } 841 842 err = 0; 843 844 DPRINTFN(5, "iface_index=%d cmd=%d\n", 845 iface_index, cmd); 846 847 if (cmd == USB_CFG_FREE) 848 goto cleanup; 849 850 if (cmd == USB_CFG_INIT) { 851 sx_assert(&udev->enum_sx, SA_LOCKED); 852 853 /* check for in-use endpoints */ 854 855 ep = udev->endpoints; 856 ep_max = udev->endpoints_max; 857 while (ep_max--) { 858 /* look for matching endpoints */ 859 if ((iface_index == USB_IFACE_INDEX_ANY) || 860 (iface_index == ep->iface_index)) { 861 if (ep->refcount_alloc != 0) { 862 /* 863 * This typically indicates a 864 * more serious error. 865 */ 866 err = USB_ERR_IN_USE; 867 } else { 868 /* reset endpoint */ 869 memset(ep, 0, sizeof(*ep)); 870 /* make sure we don't zero the endpoint again */ 871 ep->iface_index = USB_IFACE_INDEX_ANY; 872 } 873 } 874 ep++; 875 } 876 877 if (err) 878 return (err); 879 } 880 881 memset(&ips, 0, sizeof(ips)); 882 883 ep_curr = 0; 884 ep_max = 0; 885 886 while ((id = usb_idesc_foreach(udev->cdesc, &ips))) { 887 888 iface = udev->ifaces + ips.iface_index; 889 890 /* check for specific interface match */ 891 892 if (cmd == USB_CFG_INIT) { 893 if ((iface_index != USB_IFACE_INDEX_ANY) && 894 (iface_index != ips.iface_index)) { 895 /* wrong interface */ 896 do_init = 0; 897 } else if (alt_index != ips.iface_index_alt) { 898 /* wrong alternate setting */ 899 do_init = 0; 900 } else { 901 /* initialise interface */ 902 do_init = 1; 903 } 904 } else 905 do_init = 0; 906 907 /* check for new interface */ 908 if (ips.iface_index_alt == 0) { 909 /* update current number of endpoints */ 910 ep_curr = ep_max; 911 } 912 /* check for init */ 913 if (do_init) { 914 /* setup the USB interface structure */ 915 iface->idesc = id; 916 /* set alternate index */ 917 iface->alt_index = alt_index; 918 /* set default interface parent */ 919 if (iface_index == USB_IFACE_INDEX_ANY) { 920 iface->parent_iface_index = 921 USB_IFACE_INDEX_ANY; 922 } 923 } 924 925 DPRINTFN(5, "found idesc nendpt=%d\n", id->bNumEndpoints); 926 927 ed = (struct usb_endpoint_descriptor *)id; 928 929 temp = ep_curr; 930 931 /* iterate all the endpoint descriptors */ 932 while ((ed = usb_edesc_foreach(udev->cdesc, ed))) { 933 934 /* check if endpoint limit has been reached */ 935 if (temp >= USB_MAX_EP_UNITS) { 936 DPRINTF("Endpoint limit reached\n"); 937 break; 938 } 939 940 ep = udev->endpoints + temp; 941 942 if (do_init) { 943 void *ecomp; 944 945 ecomp = usb_ed_comp_foreach(udev->cdesc, (void *)ed); 946 if (ecomp != NULL) 947 DPRINTFN(5, "Found endpoint companion descriptor\n"); 948 949 usb_init_endpoint(udev, 950 ips.iface_index, ed, ecomp, ep); 951 } 952 953 temp ++; 954 955 /* find maximum number of endpoints */ 956 if (ep_max < temp) 957 ep_max = temp; 958 } 959 } 960 961 /* NOTE: It is valid to have no interfaces and no endpoints! */ 962 963 if (cmd == USB_CFG_ALLOC) { 964 udev->ifaces_max = ips.iface_index; 965 #if (USB_HAVE_FIXED_IFACE == 0) 966 udev->ifaces = NULL; 967 if (udev->ifaces_max != 0) { 968 udev->ifaces = malloc(sizeof(*iface) * udev->ifaces_max, 969 M_USB, M_WAITOK | M_ZERO); 970 if (udev->ifaces == NULL) { 971 err = USB_ERR_NOMEM; 972 goto done; 973 } 974 } 975 #endif 976 #if (USB_HAVE_FIXED_ENDPOINT == 0) 977 if (ep_max != 0) { 978 udev->endpoints = malloc(sizeof(*ep) * ep_max, 979 M_USB, M_WAITOK | M_ZERO); 980 if (udev->endpoints == NULL) { 981 err = USB_ERR_NOMEM; 982 goto done; 983 } 984 } else { 985 udev->endpoints = NULL; 986 } 987 #endif 988 USB_BUS_LOCK(udev->bus); 989 udev->endpoints_max = ep_max; 990 /* reset any ongoing clear-stall */ 991 udev->ep_curr = NULL; 992 USB_BUS_UNLOCK(udev->bus); 993 } 994 #if (USB_HAVE_FIXED_IFACE == 0) || (USB_HAVE_FIXED_ENDPOINT == 0) 995 done: 996 #endif 997 if (err) { 998 if (cmd == USB_CFG_ALLOC) { 999 cleanup: 1000 USB_BUS_LOCK(udev->bus); 1001 udev->endpoints_max = 0; 1002 /* reset any ongoing clear-stall */ 1003 udev->ep_curr = NULL; 1004 USB_BUS_UNLOCK(udev->bus); 1005 1006 #if (USB_HAVE_FIXED_IFACE == 0) 1007 free(udev->ifaces, M_USB); 1008 udev->ifaces = NULL; 1009 #endif 1010 #if (USB_HAVE_FIXED_ENDPOINT == 0) 1011 free(udev->endpoints, M_USB); 1012 udev->endpoints = NULL; 1013 #endif 1014 udev->ifaces_max = 0; 1015 } 1016 } 1017 return (err); 1018 } 1019 1020 /*------------------------------------------------------------------------* 1021 * usbd_set_alt_interface_index 1022 * 1023 * This function will select an alternate interface index for the 1024 * given interface index. The interface should not be in use when this 1025 * function is called. That means there should not be any open USB 1026 * transfers. Else an error is returned. If the alternate setting is 1027 * already set this function will simply return success. This function 1028 * is called in Host mode and Device mode! 1029 * 1030 * Returns: 1031 * 0: Success 1032 * Else: Failure 1033 *------------------------------------------------------------------------*/ 1034 usb_error_t 1035 usbd_set_alt_interface_index(struct usb_device *udev, 1036 uint8_t iface_index, uint8_t alt_index) 1037 { 1038 struct usb_interface *iface = usbd_get_iface(udev, iface_index); 1039 usb_error_t err; 1040 uint8_t do_unlock; 1041 1042 /* Prevent re-enumeration */ 1043 do_unlock = usbd_enum_lock(udev); 1044 1045 if (iface == NULL) { 1046 err = USB_ERR_INVAL; 1047 goto done; 1048 } 1049 if (iface->alt_index == alt_index) { 1050 /* 1051 * Optimise away duplicate setting of 1052 * alternate setting in USB Host Mode! 1053 */ 1054 err = 0; 1055 goto done; 1056 } 1057 #if USB_HAVE_UGEN 1058 /* 1059 * Free all generic FIFOs for this interface, except control 1060 * endpoint FIFOs: 1061 */ 1062 usb_fifo_free_wrap(udev, iface_index, 0); 1063 #endif 1064 1065 err = usb_config_parse(udev, iface_index, alt_index); 1066 if (err) { 1067 goto done; 1068 } 1069 if (iface->alt_index != alt_index) { 1070 /* the alternate setting does not exist */ 1071 err = USB_ERR_INVAL; 1072 goto done; 1073 } 1074 1075 err = usbd_req_set_alt_interface_no(udev, NULL, iface_index, 1076 iface->idesc->bAlternateSetting); 1077 1078 done: 1079 if (do_unlock) 1080 usbd_enum_unlock(udev); 1081 return (err); 1082 } 1083 1084 /*------------------------------------------------------------------------* 1085 * usbd_set_endpoint_stall 1086 * 1087 * This function is used to make a BULK or INTERRUPT endpoint send 1088 * STALL tokens in USB device mode. 1089 * 1090 * Returns: 1091 * 0: Success 1092 * Else: Failure 1093 *------------------------------------------------------------------------*/ 1094 usb_error_t 1095 usbd_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep, 1096 uint8_t do_stall) 1097 { 1098 struct usb_xfer *xfer; 1099 usb_stream_t x; 1100 uint8_t et; 1101 uint8_t was_stalled; 1102 1103 if (ep == NULL) { 1104 /* nothing to do */ 1105 DPRINTF("Cannot find endpoint\n"); 1106 /* 1107 * Pretend that the clear or set stall request is 1108 * successful else some USB host stacks can do 1109 * strange things, especially when a control endpoint 1110 * stalls. 1111 */ 1112 return (0); 1113 } 1114 et = (ep->edesc->bmAttributes & UE_XFERTYPE); 1115 1116 if ((et != UE_BULK) && 1117 (et != UE_INTERRUPT)) { 1118 /* 1119 * Should not stall control 1120 * nor isochronous endpoints. 1121 */ 1122 DPRINTF("Invalid endpoint\n"); 1123 return (0); 1124 } 1125 USB_BUS_LOCK(udev->bus); 1126 1127 /* store current stall state */ 1128 was_stalled = ep->is_stalled; 1129 1130 /* check for no change */ 1131 if (was_stalled && do_stall) { 1132 /* if the endpoint is already stalled do nothing */ 1133 USB_BUS_UNLOCK(udev->bus); 1134 DPRINTF("No change\n"); 1135 return (0); 1136 } 1137 /* set stalled state */ 1138 ep->is_stalled = 1; 1139 1140 if (do_stall || (!was_stalled)) { 1141 if (!was_stalled) { 1142 for (x = 0; x != USB_MAX_EP_STREAMS; x++) { 1143 /* lookup the current USB transfer, if any */ 1144 xfer = ep->endpoint_q[x].curr; 1145 if (xfer != NULL) { 1146 /* 1147 * The "xfer_stall" method 1148 * will complete the USB 1149 * transfer like in case of a 1150 * timeout setting the error 1151 * code "USB_ERR_STALLED". 1152 */ 1153 (udev->bus->methods->xfer_stall) (xfer); 1154 } 1155 } 1156 } 1157 (udev->bus->methods->set_stall) (udev, ep, &do_stall); 1158 } 1159 if (!do_stall) { 1160 ep->toggle_next = 0; /* reset data toggle */ 1161 ep->is_stalled = 0; /* clear stalled state */ 1162 1163 (udev->bus->methods->clear_stall) (udev, ep); 1164 1165 /* start the current or next transfer, if any */ 1166 for (x = 0; x != USB_MAX_EP_STREAMS; x++) { 1167 usb_command_wrapper(&ep->endpoint_q[x], 1168 ep->endpoint_q[x].curr); 1169 } 1170 } 1171 USB_BUS_UNLOCK(udev->bus); 1172 return (0); 1173 } 1174 1175 /*------------------------------------------------------------------------* 1176 * usb_reset_iface_endpoints - used in USB device side mode 1177 *------------------------------------------------------------------------*/ 1178 usb_error_t 1179 usb_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index) 1180 { 1181 struct usb_endpoint *ep; 1182 struct usb_endpoint *ep_end; 1183 1184 ep = udev->endpoints; 1185 ep_end = udev->endpoints + udev->endpoints_max; 1186 1187 for (; ep != ep_end; ep++) { 1188 1189 if ((ep->edesc == NULL) || 1190 (ep->iface_index != iface_index)) { 1191 continue; 1192 } 1193 /* simulate a clear stall from the peer */ 1194 usbd_set_endpoint_stall(udev, ep, 0); 1195 } 1196 return (0); 1197 } 1198 1199 /*------------------------------------------------------------------------* 1200 * usb_detach_device_sub 1201 * 1202 * This function will try to detach an USB device. If it fails a panic 1203 * will result. 1204 * 1205 * Flag values, see "USB_UNCFG_FLAG_XXX". 1206 *------------------------------------------------------------------------*/ 1207 static void 1208 usb_detach_device_sub(struct usb_device *udev, device_t *ppdev, 1209 char **ppnpinfo, uint8_t flag) 1210 { 1211 device_t dev; 1212 char *pnpinfo; 1213 int err; 1214 1215 dev = *ppdev; 1216 if (dev) { 1217 /* 1218 * NOTE: It is important to clear "*ppdev" before deleting 1219 * the child due to some device methods being called late 1220 * during the delete process ! 1221 */ 1222 *ppdev = NULL; 1223 1224 if (!rebooting) { 1225 device_printf(dev, "at %s, port %d, addr %d " 1226 "(disconnected)\n", 1227 device_get_nameunit(udev->parent_dev), 1228 udev->port_no, udev->address); 1229 } 1230 1231 if (device_is_attached(dev)) { 1232 if (udev->flags.peer_suspended) { 1233 err = DEVICE_RESUME(dev); 1234 if (err) { 1235 device_printf(dev, "Resume failed\n"); 1236 } 1237 } 1238 } 1239 /* detach and delete child */ 1240 if (device_delete_child(udev->parent_dev, dev)) { 1241 goto error; 1242 } 1243 } 1244 1245 pnpinfo = *ppnpinfo; 1246 if (pnpinfo != NULL) { 1247 *ppnpinfo = NULL; 1248 free(pnpinfo, M_USBDEV); 1249 } 1250 return; 1251 1252 error: 1253 /* Detach is not allowed to fail in the USB world */ 1254 panic("usb_detach_device_sub: A USB driver would not detach\n"); 1255 } 1256 1257 /*------------------------------------------------------------------------* 1258 * usb_detach_device 1259 * 1260 * The following function will detach the matching interfaces. 1261 * This function is NULL safe. 1262 * 1263 * Flag values, see "USB_UNCFG_FLAG_XXX". 1264 *------------------------------------------------------------------------*/ 1265 void 1266 usb_detach_device(struct usb_device *udev, uint8_t iface_index, 1267 uint8_t flag) 1268 { 1269 struct usb_interface *iface; 1270 uint8_t i; 1271 1272 if (udev == NULL) { 1273 /* nothing to do */ 1274 return; 1275 } 1276 DPRINTFN(4, "udev=%p\n", udev); 1277 1278 sx_assert(&udev->enum_sx, SA_LOCKED); 1279 1280 /* 1281 * First detach the child to give the child's detach routine a 1282 * chance to detach the sub-devices in the correct order. 1283 * Then delete the child using "device_delete_child()" which 1284 * will detach all sub-devices from the bottom and upwards! 1285 */ 1286 if (iface_index != USB_IFACE_INDEX_ANY) { 1287 i = iface_index; 1288 iface_index = i + 1; 1289 } else { 1290 i = 0; 1291 iface_index = USB_IFACE_MAX; 1292 } 1293 1294 /* do the detach */ 1295 1296 for (; i != iface_index; i++) { 1297 1298 iface = usbd_get_iface(udev, i); 1299 if (iface == NULL) { 1300 /* looks like the end of the USB interfaces */ 1301 break; 1302 } 1303 usb_detach_device_sub(udev, &iface->subdev, 1304 &iface->pnpinfo, flag); 1305 } 1306 } 1307 1308 /*------------------------------------------------------------------------* 1309 * usb_probe_and_attach_sub 1310 * 1311 * Returns: 1312 * 0: Success 1313 * Else: Failure 1314 *------------------------------------------------------------------------*/ 1315 static uint8_t 1316 usb_probe_and_attach_sub(struct usb_device *udev, 1317 struct usb_attach_arg *uaa) 1318 { 1319 struct usb_interface *iface; 1320 device_t dev; 1321 int err; 1322 1323 iface = uaa->iface; 1324 if (iface->parent_iface_index != USB_IFACE_INDEX_ANY) { 1325 /* leave interface alone */ 1326 return (0); 1327 } 1328 dev = iface->subdev; 1329 if (dev) { 1330 1331 /* clean up after module unload */ 1332 1333 if (device_is_attached(dev)) { 1334 /* already a device there */ 1335 return (0); 1336 } 1337 /* clear "iface->subdev" as early as possible */ 1338 1339 iface->subdev = NULL; 1340 1341 if (device_delete_child(udev->parent_dev, dev)) { 1342 1343 /* 1344 * Panic here, else one can get a double call 1345 * to device_detach(). USB devices should 1346 * never fail on detach! 1347 */ 1348 panic("device_delete_child() failed\n"); 1349 } 1350 } 1351 if (uaa->temp_dev == NULL) { 1352 1353 /* create a new child */ 1354 uaa->temp_dev = device_add_child(udev->parent_dev, NULL, -1); 1355 if (uaa->temp_dev == NULL) { 1356 device_printf(udev->parent_dev, 1357 "Device creation failed\n"); 1358 return (1); /* failure */ 1359 } 1360 device_set_ivars(uaa->temp_dev, uaa); 1361 device_quiet(uaa->temp_dev); 1362 } 1363 /* 1364 * Set "subdev" before probe and attach so that "devd" gets 1365 * the information it needs. 1366 */ 1367 iface->subdev = uaa->temp_dev; 1368 1369 if (device_probe_and_attach(iface->subdev) == 0) { 1370 /* 1371 * The USB attach arguments are only available during probe 1372 * and attach ! 1373 */ 1374 uaa->temp_dev = NULL; 1375 device_set_ivars(iface->subdev, NULL); 1376 1377 if (udev->flags.peer_suspended) { 1378 err = DEVICE_SUSPEND(iface->subdev); 1379 if (err) 1380 device_printf(iface->subdev, "Suspend failed\n"); 1381 } 1382 return (0); /* success */ 1383 } else { 1384 /* No USB driver found */ 1385 iface->subdev = NULL; 1386 } 1387 return (1); /* failure */ 1388 } 1389 1390 /*------------------------------------------------------------------------* 1391 * usbd_set_parent_iface 1392 * 1393 * Using this function will lock the alternate interface setting on an 1394 * interface. It is typically used for multi interface drivers. In USB 1395 * device side mode it is assumed that the alternate interfaces all 1396 * have the same endpoint descriptors. The default parent index value 1397 * is "USB_IFACE_INDEX_ANY". Then the alternate setting value is not 1398 * locked. 1399 *------------------------------------------------------------------------*/ 1400 void 1401 usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index, 1402 uint8_t parent_index) 1403 { 1404 struct usb_interface *iface; 1405 1406 if (udev == NULL) { 1407 /* nothing to do */ 1408 return; 1409 } 1410 iface = usbd_get_iface(udev, iface_index); 1411 if (iface != NULL) 1412 iface->parent_iface_index = parent_index; 1413 } 1414 1415 static void 1416 usb_init_attach_arg(struct usb_device *udev, 1417 struct usb_attach_arg *uaa) 1418 { 1419 memset(uaa, 0, sizeof(*uaa)); 1420 1421 uaa->device = udev; 1422 uaa->usb_mode = udev->flags.usb_mode; 1423 uaa->port = udev->port_no; 1424 uaa->dev_state = UAA_DEV_READY; 1425 1426 uaa->info.idVendor = UGETW(udev->ddesc.idVendor); 1427 uaa->info.idProduct = UGETW(udev->ddesc.idProduct); 1428 uaa->info.bcdDevice = UGETW(udev->ddesc.bcdDevice); 1429 uaa->info.bDeviceClass = udev->ddesc.bDeviceClass; 1430 uaa->info.bDeviceSubClass = udev->ddesc.bDeviceSubClass; 1431 uaa->info.bDeviceProtocol = udev->ddesc.bDeviceProtocol; 1432 uaa->info.bConfigIndex = udev->curr_config_index; 1433 uaa->info.bConfigNum = udev->curr_config_no; 1434 } 1435 1436 /*------------------------------------------------------------------------* 1437 * usb_probe_and_attach 1438 * 1439 * This function is called from "uhub_explore_sub()", 1440 * "usb_handle_set_config()" and "usb_handle_request()". 1441 * 1442 * Returns: 1443 * 0: Success 1444 * Else: A control transfer failed 1445 *------------------------------------------------------------------------*/ 1446 usb_error_t 1447 usb_probe_and_attach(struct usb_device *udev, uint8_t iface_index) 1448 { 1449 struct usb_attach_arg uaa; 1450 struct usb_interface *iface; 1451 uint8_t i; 1452 uint8_t j; 1453 uint8_t do_unlock; 1454 1455 if (udev == NULL) { 1456 DPRINTF("udev == NULL\n"); 1457 return (USB_ERR_INVAL); 1458 } 1459 /* Prevent re-enumeration */ 1460 do_unlock = usbd_enum_lock(udev); 1461 1462 if (udev->curr_config_index == USB_UNCONFIG_INDEX) { 1463 /* do nothing - no configuration has been set */ 1464 goto done; 1465 } 1466 /* setup USB attach arguments */ 1467 1468 usb_init_attach_arg(udev, &uaa); 1469 1470 /* 1471 * If the whole USB device is targeted, invoke the USB event 1472 * handler(s): 1473 */ 1474 if (iface_index == USB_IFACE_INDEX_ANY) { 1475 1476 if (usb_test_quirk(&uaa, UQ_MSC_DYMO_EJECT) != 0 && 1477 usb_dymo_eject(udev, 0) == 0) { 1478 /* success, mark the udev as disappearing */ 1479 uaa.dev_state = UAA_DEV_EJECTING; 1480 } 1481 1482 EVENTHANDLER_INVOKE(usb_dev_configured, udev, &uaa); 1483 1484 if (uaa.dev_state != UAA_DEV_READY) { 1485 /* leave device unconfigured */ 1486 usb_unconfigure(udev, 0); 1487 goto done; 1488 } 1489 } 1490 1491 /* Check if only one interface should be probed: */ 1492 if (iface_index != USB_IFACE_INDEX_ANY) { 1493 i = iface_index; 1494 j = i + 1; 1495 } else { 1496 i = 0; 1497 j = USB_IFACE_MAX; 1498 } 1499 1500 /* Do the probe and attach */ 1501 for (; i != j; i++) { 1502 1503 iface = usbd_get_iface(udev, i); 1504 if (iface == NULL) { 1505 /* 1506 * Looks like the end of the USB 1507 * interfaces ! 1508 */ 1509 DPRINTFN(2, "end of interfaces " 1510 "at %u\n", i); 1511 break; 1512 } 1513 if (iface->idesc == NULL) { 1514 /* no interface descriptor */ 1515 continue; 1516 } 1517 uaa.iface = iface; 1518 1519 uaa.info.bInterfaceClass = 1520 iface->idesc->bInterfaceClass; 1521 uaa.info.bInterfaceSubClass = 1522 iface->idesc->bInterfaceSubClass; 1523 uaa.info.bInterfaceProtocol = 1524 iface->idesc->bInterfaceProtocol; 1525 uaa.info.bIfaceIndex = i; 1526 uaa.info.bIfaceNum = 1527 iface->idesc->bInterfaceNumber; 1528 uaa.driver_info = 0; /* reset driver_info */ 1529 1530 DPRINTFN(2, "iclass=%u/%u/%u iindex=%u/%u\n", 1531 uaa.info.bInterfaceClass, 1532 uaa.info.bInterfaceSubClass, 1533 uaa.info.bInterfaceProtocol, 1534 uaa.info.bIfaceIndex, 1535 uaa.info.bIfaceNum); 1536 1537 usb_probe_and_attach_sub(udev, &uaa); 1538 1539 /* 1540 * Remove the leftover child, if any, to enforce that 1541 * a new nomatch devd event is generated for the next 1542 * interface if no driver is found: 1543 */ 1544 if (uaa.temp_dev == NULL) 1545 continue; 1546 if (device_delete_child(udev->parent_dev, uaa.temp_dev)) 1547 DPRINTFN(0, "device delete child failed\n"); 1548 uaa.temp_dev = NULL; 1549 } 1550 done: 1551 if (do_unlock) 1552 usbd_enum_unlock(udev); 1553 return (0); 1554 } 1555 1556 /*------------------------------------------------------------------------* 1557 * usb_suspend_resume_sub 1558 * 1559 * This function is called when the suspend or resume methods should 1560 * be executed on an USB device. 1561 *------------------------------------------------------------------------*/ 1562 static void 1563 usb_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend) 1564 { 1565 int err; 1566 1567 if (dev == NULL) { 1568 return; 1569 } 1570 if (!device_is_attached(dev)) { 1571 return; 1572 } 1573 if (do_suspend) { 1574 err = DEVICE_SUSPEND(dev); 1575 } else { 1576 err = DEVICE_RESUME(dev); 1577 } 1578 if (err) { 1579 device_printf(dev, "%s failed\n", 1580 do_suspend ? "Suspend" : "Resume"); 1581 } 1582 } 1583 1584 /*------------------------------------------------------------------------* 1585 * usb_suspend_resume 1586 * 1587 * The following function will suspend or resume the USB device. 1588 * 1589 * Returns: 1590 * 0: Success 1591 * Else: Failure 1592 *------------------------------------------------------------------------*/ 1593 usb_error_t 1594 usb_suspend_resume(struct usb_device *udev, uint8_t do_suspend) 1595 { 1596 struct usb_interface *iface; 1597 uint8_t i; 1598 1599 if (udev == NULL) { 1600 /* nothing to do */ 1601 return (0); 1602 } 1603 DPRINTFN(4, "udev=%p do_suspend=%d\n", udev, do_suspend); 1604 1605 sx_assert(&udev->sr_sx, SA_LOCKED); 1606 1607 USB_BUS_LOCK(udev->bus); 1608 /* filter the suspend events */ 1609 if (udev->flags.peer_suspended == do_suspend) { 1610 USB_BUS_UNLOCK(udev->bus); 1611 /* nothing to do */ 1612 return (0); 1613 } 1614 udev->flags.peer_suspended = do_suspend; 1615 USB_BUS_UNLOCK(udev->bus); 1616 1617 /* do the suspend or resume */ 1618 1619 for (i = 0; i != USB_IFACE_MAX; i++) { 1620 1621 iface = usbd_get_iface(udev, i); 1622 if (iface == NULL) { 1623 /* looks like the end of the USB interfaces */ 1624 break; 1625 } 1626 usb_suspend_resume_sub(udev, iface->subdev, do_suspend); 1627 } 1628 return (0); 1629 } 1630 1631 /*------------------------------------------------------------------------* 1632 * usbd_clear_stall_proc 1633 * 1634 * This function performs generic USB clear stall operations. 1635 *------------------------------------------------------------------------*/ 1636 static void 1637 usbd_clear_stall_proc(struct usb_proc_msg *_pm) 1638 { 1639 struct usb_udev_msg *pm = (void *)_pm; 1640 struct usb_device *udev = pm->udev; 1641 1642 /* Change lock */ 1643 USB_BUS_UNLOCK(udev->bus); 1644 USB_MTX_LOCK(&udev->device_mtx); 1645 1646 /* Start clear stall callback */ 1647 usbd_transfer_start(udev->ctrl_xfer[1]); 1648 1649 /* Change lock */ 1650 USB_MTX_UNLOCK(&udev->device_mtx); 1651 USB_BUS_LOCK(udev->bus); 1652 } 1653 1654 /*------------------------------------------------------------------------* 1655 * usb_alloc_device 1656 * 1657 * This function allocates a new USB device. This function is called 1658 * when a new device has been put in the powered state, but not yet in 1659 * the addressed state. Get initial descriptor, set the address, get 1660 * full descriptor and get strings. 1661 * 1662 * Return values: 1663 * 0: Failure 1664 * Else: Success 1665 *------------------------------------------------------------------------*/ 1666 struct usb_device * 1667 usb_alloc_device(device_t parent_dev, struct usb_bus *bus, 1668 struct usb_device *parent_hub, uint8_t depth, uint8_t port_index, 1669 uint8_t port_no, enum usb_dev_speed speed, enum usb_hc_mode mode) 1670 { 1671 struct usb_attach_arg uaa; 1672 struct usb_device *udev; 1673 struct usb_device *adev; 1674 struct usb_device *hub; 1675 uint8_t *scratch_ptr; 1676 usb_error_t err; 1677 uint8_t device_index; 1678 uint8_t config_index; 1679 uint8_t config_quirk; 1680 uint8_t set_config_failed; 1681 uint8_t do_unlock; 1682 1683 DPRINTF("parent_dev=%p, bus=%p, parent_hub=%p, depth=%u, " 1684 "port_index=%u, port_no=%u, speed=%u, usb_mode=%u\n", 1685 parent_dev, bus, parent_hub, depth, port_index, port_no, 1686 speed, mode); 1687 1688 /* 1689 * Find an unused device index. In USB Host mode this is the 1690 * same as the device address. 1691 * 1692 * Device index zero is not used and device index 1 should 1693 * always be the root hub. 1694 */ 1695 for (device_index = USB_ROOT_HUB_ADDR; 1696 (device_index != bus->devices_max) && 1697 (bus->devices[device_index] != NULL); 1698 device_index++) /* nop */; 1699 1700 if (device_index == bus->devices_max) { 1701 device_printf(bus->bdev, 1702 "No free USB device index for new device\n"); 1703 return (NULL); 1704 } 1705 1706 if (depth > 0x10) { 1707 device_printf(bus->bdev, 1708 "Invalid device depth\n"); 1709 return (NULL); 1710 } 1711 udev = malloc(sizeof(*udev), M_USB, M_WAITOK | M_ZERO); 1712 if (udev == NULL) { 1713 return (NULL); 1714 } 1715 /* initialise our SX-lock */ 1716 sx_init_flags(&udev->enum_sx, "USB config SX lock", SX_DUPOK); 1717 sx_init_flags(&udev->sr_sx, "USB suspend and resume SX lock", SX_NOWITNESS); 1718 sx_init_flags(&udev->ctrl_sx, "USB control transfer SX lock", SX_DUPOK); 1719 1720 cv_init(&udev->ctrlreq_cv, "WCTRL"); 1721 cv_init(&udev->ref_cv, "UGONE"); 1722 1723 /* initialise our mutex */ 1724 mtx_init(&udev->device_mtx, "USB device mutex", NULL, MTX_DEF); 1725 1726 /* initialise generic clear stall */ 1727 udev->cs_msg[0].hdr.pm_callback = &usbd_clear_stall_proc; 1728 udev->cs_msg[0].udev = udev; 1729 udev->cs_msg[1].hdr.pm_callback = &usbd_clear_stall_proc; 1730 udev->cs_msg[1].udev = udev; 1731 1732 /* initialise some USB device fields */ 1733 udev->parent_hub = parent_hub; 1734 udev->parent_dev = parent_dev; 1735 udev->port_index = port_index; 1736 udev->port_no = port_no; 1737 udev->depth = depth; 1738 udev->bus = bus; 1739 udev->address = USB_START_ADDR; /* default value */ 1740 udev->plugtime = (usb_ticks_t)ticks; 1741 /* 1742 * We need to force the power mode to "on" because there are plenty 1743 * of USB devices out there that do not work very well with 1744 * automatic suspend and resume! 1745 */ 1746 udev->power_mode = usbd_filter_power_mode(udev, USB_POWER_MODE_ON); 1747 udev->pwr_save.last_xfer_time = ticks; 1748 /* we are not ready yet */ 1749 udev->refcount = 1; 1750 1751 /* set up default endpoint descriptor */ 1752 udev->ctrl_ep_desc.bLength = sizeof(udev->ctrl_ep_desc); 1753 udev->ctrl_ep_desc.bDescriptorType = UDESC_ENDPOINT; 1754 udev->ctrl_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT; 1755 udev->ctrl_ep_desc.bmAttributes = UE_CONTROL; 1756 udev->ctrl_ep_desc.wMaxPacketSize[0] = USB_MAX_IPACKET; 1757 udev->ctrl_ep_desc.wMaxPacketSize[1] = 0; 1758 udev->ctrl_ep_desc.bInterval = 0; 1759 1760 /* set up default endpoint companion descriptor */ 1761 udev->ctrl_ep_comp_desc.bLength = sizeof(udev->ctrl_ep_comp_desc); 1762 udev->ctrl_ep_comp_desc.bDescriptorType = UDESC_ENDPOINT_SS_COMP; 1763 1764 udev->ddesc.bMaxPacketSize = USB_MAX_IPACKET; 1765 1766 udev->speed = speed; 1767 udev->flags.usb_mode = mode; 1768 1769 /* search for our High Speed USB HUB, if any */ 1770 1771 adev = udev; 1772 hub = udev->parent_hub; 1773 1774 while (hub) { 1775 if (hub->speed == USB_SPEED_HIGH) { 1776 udev->hs_hub_addr = hub->address; 1777 udev->parent_hs_hub = hub; 1778 udev->hs_port_no = adev->port_no; 1779 break; 1780 } 1781 adev = hub; 1782 hub = hub->parent_hub; 1783 } 1784 1785 /* init the default endpoint */ 1786 usb_init_endpoint(udev, 0, 1787 &udev->ctrl_ep_desc, 1788 &udev->ctrl_ep_comp_desc, 1789 &udev->ctrl_ep); 1790 1791 /* set device index */ 1792 udev->device_index = device_index; 1793 1794 #if USB_HAVE_UGEN 1795 /* Create ugen name */ 1796 snprintf(udev->ugen_name, sizeof(udev->ugen_name), 1797 USB_GENERIC_NAME "%u.%u", device_get_unit(bus->bdev), 1798 device_index); 1799 LIST_INIT(&udev->pd_list); 1800 1801 /* Create the control endpoint device */ 1802 udev->ctrl_dev = usb_make_dev(udev, NULL, 0, 0, 1803 FREAD|FWRITE, UID_ROOT, GID_OPERATOR, 0600); 1804 1805 /* Create a link from /dev/ugenX.X to the default endpoint */ 1806 if (udev->ctrl_dev != NULL) 1807 make_dev_alias(udev->ctrl_dev->cdev, "%s", udev->ugen_name); 1808 #endif 1809 /* Initialise device */ 1810 if (bus->methods->device_init != NULL) { 1811 err = (bus->methods->device_init) (udev); 1812 if (err != 0) { 1813 DPRINTFN(0, "device init %d failed " 1814 "(%s, ignored)\n", device_index, 1815 usbd_errstr(err)); 1816 goto done; 1817 } 1818 } 1819 /* set powered device state after device init is complete */ 1820 usb_set_device_state(udev, USB_STATE_POWERED); 1821 1822 if (udev->flags.usb_mode == USB_MODE_HOST) { 1823 1824 err = usbd_req_set_address(udev, NULL, device_index); 1825 1826 /* 1827 * This is the new USB device address from now on, if 1828 * the set address request didn't set it already. 1829 */ 1830 if (udev->address == USB_START_ADDR) 1831 udev->address = device_index; 1832 1833 /* 1834 * We ignore any set-address errors, hence there are 1835 * buggy USB devices out there that actually receive 1836 * the SETUP PID, but manage to set the address before 1837 * the STATUS stage is ACK'ed. If the device responds 1838 * to the subsequent get-descriptor at the new 1839 * address, then we know that the set-address command 1840 * was successful. 1841 */ 1842 if (err) { 1843 DPRINTFN(0, "set address %d failed " 1844 "(%s, ignored)\n", udev->address, 1845 usbd_errstr(err)); 1846 } 1847 } else { 1848 /* We are not self powered */ 1849 udev->flags.self_powered = 0; 1850 1851 /* Set unconfigured state */ 1852 udev->curr_config_no = USB_UNCONFIG_NO; 1853 udev->curr_config_index = USB_UNCONFIG_INDEX; 1854 1855 /* Setup USB descriptors */ 1856 err = (usb_temp_setup_by_index_p) (udev, usb_template); 1857 if (err) { 1858 DPRINTFN(0, "setting up USB template failed - " 1859 "usb_template(4) not loaded?\n"); 1860 goto done; 1861 } 1862 } 1863 usb_set_device_state(udev, USB_STATE_ADDRESSED); 1864 1865 /* setup the device descriptor and the initial "wMaxPacketSize" */ 1866 err = usbd_setup_device_desc(udev, NULL); 1867 1868 if (err != 0) { 1869 /* try to enumerate two more times */ 1870 err = usbd_req_re_enumerate(udev, NULL); 1871 if (err != 0) { 1872 err = usbd_req_re_enumerate(udev, NULL); 1873 if (err != 0) { 1874 goto done; 1875 } 1876 } 1877 } 1878 1879 /* 1880 * Setup temporary USB attach args so that we can figure out some 1881 * basic quirks for this device. 1882 */ 1883 usb_init_attach_arg(udev, &uaa); 1884 1885 if (usb_test_quirk(&uaa, UQ_BUS_POWERED)) { 1886 udev->flags.uq_bus_powered = 1; 1887 } 1888 if (usb_test_quirk(&uaa, UQ_NO_STRINGS)) { 1889 udev->flags.no_strings = 1; 1890 } 1891 /* 1892 * Workaround for buggy USB devices. 1893 * 1894 * It appears that some string-less USB chips will crash and 1895 * disappear if any attempts are made to read any string 1896 * descriptors. 1897 * 1898 * Try to detect such chips by checking the strings in the USB 1899 * device descriptor. If no strings are present there we 1900 * simply disable all USB strings. 1901 */ 1902 1903 /* Protect scratch area */ 1904 do_unlock = usbd_ctrl_lock(udev); 1905 1906 scratch_ptr = udev->scratch.data; 1907 1908 if (udev->flags.no_strings) { 1909 err = USB_ERR_INVAL; 1910 } else if (udev->ddesc.iManufacturer || 1911 udev->ddesc.iProduct || 1912 udev->ddesc.iSerialNumber) { 1913 /* read out the language ID string */ 1914 err = usbd_req_get_string_desc(udev, NULL, 1915 (char *)scratch_ptr, 4, 0, USB_LANGUAGE_TABLE); 1916 } else { 1917 err = USB_ERR_INVAL; 1918 } 1919 1920 if (err || (scratch_ptr[0] < 4)) { 1921 udev->flags.no_strings = 1; 1922 } else { 1923 uint16_t langid; 1924 uint16_t pref; 1925 uint16_t mask; 1926 uint8_t x; 1927 1928 /* load preferred value and mask */ 1929 pref = usb_lang_id; 1930 mask = usb_lang_mask; 1931 1932 /* align length correctly */ 1933 scratch_ptr[0] &= ~1U; 1934 1935 /* fix compiler warning */ 1936 langid = 0; 1937 1938 /* search for preferred language */ 1939 for (x = 2; (x < scratch_ptr[0]); x += 2) { 1940 langid = UGETW(scratch_ptr + x); 1941 if ((langid & mask) == pref) 1942 break; 1943 } 1944 if (x >= scratch_ptr[0]) { 1945 /* pick the first language as the default */ 1946 DPRINTFN(1, "Using first language\n"); 1947 langid = UGETW(scratch_ptr + 2); 1948 } 1949 1950 DPRINTFN(1, "Language selected: 0x%04x\n", langid); 1951 udev->langid = langid; 1952 } 1953 1954 if (do_unlock) 1955 usbd_ctrl_unlock(udev); 1956 1957 /* assume 100mA bus powered for now. Changed when configured. */ 1958 udev->power = USB_MIN_POWER; 1959 /* fetch the vendor and product strings from the device */ 1960 usbd_set_device_strings(udev); 1961 1962 if (udev->flags.usb_mode == USB_MODE_DEVICE) { 1963 /* USB device mode setup is complete */ 1964 err = 0; 1965 goto config_done; 1966 } 1967 1968 /* 1969 * Most USB devices should attach to config index 0 by 1970 * default 1971 */ 1972 if (usb_test_quirk(&uaa, UQ_CFG_INDEX_0)) { 1973 config_index = 0; 1974 config_quirk = 1; 1975 } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_1)) { 1976 config_index = 1; 1977 config_quirk = 1; 1978 } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_2)) { 1979 config_index = 2; 1980 config_quirk = 1; 1981 } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_3)) { 1982 config_index = 3; 1983 config_quirk = 1; 1984 } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_4)) { 1985 config_index = 4; 1986 config_quirk = 1; 1987 } else { 1988 config_index = 0; 1989 config_quirk = 0; 1990 } 1991 1992 set_config_failed = 0; 1993 repeat_set_config: 1994 1995 DPRINTF("setting config %u\n", config_index); 1996 1997 /* get the USB device configured */ 1998 err = usbd_set_config_index(udev, config_index); 1999 if (err) { 2000 if (udev->ddesc.bNumConfigurations != 0) { 2001 if (!set_config_failed) { 2002 set_config_failed = 1; 2003 /* XXX try to re-enumerate the device */ 2004 err = usbd_req_re_enumerate(udev, NULL); 2005 if (err == 0) 2006 goto repeat_set_config; 2007 } 2008 DPRINTFN(0, "Failure selecting configuration index %u:" 2009 "%s, port %u, addr %u (ignored)\n", 2010 config_index, usbd_errstr(err), udev->port_no, 2011 udev->address); 2012 } 2013 /* 2014 * Some USB devices do not have any configurations. Ignore any 2015 * set config failures! 2016 */ 2017 err = 0; 2018 goto config_done; 2019 } 2020 if (!config_quirk && config_index + 1 < udev->ddesc.bNumConfigurations) { 2021 if ((udev->cdesc->bNumInterface < 2) && 2022 usbd_get_no_descriptors(udev->cdesc, UDESC_ENDPOINT) == 0) { 2023 DPRINTFN(0, "Found no endpoints, trying next config\n"); 2024 config_index++; 2025 goto repeat_set_config; 2026 } 2027 #if USB_HAVE_MSCTEST 2028 if (config_index == 0) { 2029 /* 2030 * Try to figure out if we have an 2031 * auto-install disk there: 2032 */ 2033 if (usb_iface_is_cdrom(udev, 0)) { 2034 DPRINTFN(0, "Found possible auto-install " 2035 "disk (trying next config)\n"); 2036 config_index++; 2037 goto repeat_set_config; 2038 } 2039 } 2040 #endif 2041 } 2042 #if USB_HAVE_MSCTEST 2043 if (set_config_failed == 0 && config_index == 0 && 2044 usb_test_quirk(&uaa, UQ_MSC_NO_SYNC_CACHE) == 0 && 2045 usb_test_quirk(&uaa, UQ_MSC_NO_GETMAXLUN) == 0) { 2046 2047 /* 2048 * Try to figure out if there are any MSC quirks we 2049 * should apply automatically: 2050 */ 2051 err = usb_msc_auto_quirk(udev, 0); 2052 2053 if (err != 0) { 2054 set_config_failed = 1; 2055 goto repeat_set_config; 2056 } 2057 } 2058 #endif 2059 2060 config_done: 2061 DPRINTF("new dev (addr %d), udev=%p, parent_hub=%p\n", 2062 udev->address, udev, udev->parent_hub); 2063 2064 /* register our device - we are ready */ 2065 usb_bus_port_set_device(bus, parent_hub ? 2066 parent_hub->hub->ports + port_index : NULL, udev, device_index); 2067 2068 #if USB_HAVE_UGEN 2069 /* Symlink the ugen device name */ 2070 udev->ugen_symlink = usb_alloc_symlink(udev->ugen_name); 2071 2072 /* Announce device */ 2073 printf("%s: <%s %s> at %s\n", udev->ugen_name, 2074 usb_get_manufacturer(udev), usb_get_product(udev), 2075 device_get_nameunit(udev->bus->bdev)); 2076 #endif 2077 2078 #if USB_HAVE_DEVCTL 2079 usb_notify_addq("ATTACH", udev); 2080 #endif 2081 done: 2082 if (err) { 2083 /* 2084 * Free USB device and all subdevices, if any. 2085 */ 2086 usb_free_device(udev, 0); 2087 udev = NULL; 2088 } 2089 return (udev); 2090 } 2091 2092 #if USB_HAVE_UGEN 2093 struct usb_fs_privdata * 2094 usb_make_dev(struct usb_device *udev, const char *devname, int ep, 2095 int fi, int rwmode, uid_t uid, gid_t gid, int mode) 2096 { 2097 struct usb_fs_privdata* pd; 2098 struct make_dev_args args; 2099 char buffer[32]; 2100 2101 /* Store information to locate ourselves again later */ 2102 pd = malloc(sizeof(struct usb_fs_privdata), M_USBDEV, 2103 M_WAITOK | M_ZERO); 2104 pd->bus_index = device_get_unit(udev->bus->bdev); 2105 pd->dev_index = udev->device_index; 2106 pd->ep_addr = ep; 2107 pd->fifo_index = fi; 2108 pd->mode = rwmode; 2109 2110 /* Now, create the device itself */ 2111 if (devname == NULL) { 2112 devname = buffer; 2113 snprintf(buffer, sizeof(buffer), USB_DEVICE_DIR "/%u.%u.%u", 2114 pd->bus_index, pd->dev_index, pd->ep_addr); 2115 } 2116 2117 /* Setup arguments for make_dev_s() */ 2118 make_dev_args_init(&args); 2119 args.mda_devsw = &usb_devsw; 2120 args.mda_uid = uid; 2121 args.mda_gid = gid; 2122 args.mda_mode = mode; 2123 args.mda_si_drv1 = pd; 2124 2125 if (make_dev_s(&args, &pd->cdev, "%s", devname) != 0) { 2126 DPRINTFN(0, "Failed to create device %s\n", devname); 2127 free(pd, M_USBDEV); 2128 return (NULL); 2129 } 2130 return (pd); 2131 } 2132 2133 void 2134 usb_destroy_dev_sync(struct usb_fs_privdata *pd) 2135 { 2136 DPRINTFN(1, "Destroying device at ugen%d.%d\n", 2137 pd->bus_index, pd->dev_index); 2138 2139 /* 2140 * Destroy character device synchronously. After this 2141 * all system calls are returned. Can block. 2142 */ 2143 destroy_dev(pd->cdev); 2144 2145 free(pd, M_USBDEV); 2146 } 2147 2148 void 2149 usb_destroy_dev(struct usb_fs_privdata *pd) 2150 { 2151 struct usb_bus *bus; 2152 2153 if (pd == NULL) 2154 return; 2155 2156 mtx_lock(&usb_ref_lock); 2157 bus = devclass_get_softc(usb_devclass_ptr, pd->bus_index); 2158 mtx_unlock(&usb_ref_lock); 2159 2160 if (bus == NULL) { 2161 usb_destroy_dev_sync(pd); 2162 return; 2163 } 2164 2165 /* make sure we can re-use the device name */ 2166 delist_dev(pd->cdev); 2167 2168 USB_BUS_LOCK(bus); 2169 LIST_INSERT_HEAD(&bus->pd_cleanup_list, pd, pd_next); 2170 /* get cleanup going */ 2171 usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus), 2172 &bus->cleanup_msg[0], &bus->cleanup_msg[1]); 2173 USB_BUS_UNLOCK(bus); 2174 } 2175 2176 static void 2177 usb_cdev_create(struct usb_device *udev) 2178 { 2179 struct usb_config_descriptor *cd; 2180 struct usb_endpoint_descriptor *ed; 2181 struct usb_descriptor *desc; 2182 struct usb_fs_privdata* pd; 2183 int inmode, outmode, inmask, outmask, mode; 2184 uint8_t ep; 2185 2186 KASSERT(LIST_FIRST(&udev->pd_list) == NULL, ("stale cdev entries")); 2187 2188 DPRINTFN(2, "Creating device nodes\n"); 2189 2190 if (usbd_get_mode(udev) == USB_MODE_DEVICE) { 2191 inmode = FWRITE; 2192 outmode = FREAD; 2193 } else { /* USB_MODE_HOST */ 2194 inmode = FREAD; 2195 outmode = FWRITE; 2196 } 2197 2198 inmask = 0; 2199 outmask = 0; 2200 desc = NULL; 2201 2202 /* 2203 * Collect all used endpoint numbers instead of just 2204 * generating 16 static endpoints. 2205 */ 2206 cd = usbd_get_config_descriptor(udev); 2207 while ((desc = usb_desc_foreach(cd, desc))) { 2208 /* filter out all endpoint descriptors */ 2209 if ((desc->bDescriptorType == UDESC_ENDPOINT) && 2210 (desc->bLength >= sizeof(*ed))) { 2211 ed = (struct usb_endpoint_descriptor *)desc; 2212 2213 /* update masks */ 2214 ep = ed->bEndpointAddress; 2215 if (UE_GET_DIR(ep) == UE_DIR_OUT) 2216 outmask |= 1 << UE_GET_ADDR(ep); 2217 else 2218 inmask |= 1 << UE_GET_ADDR(ep); 2219 } 2220 } 2221 2222 /* Create all available endpoints except EP0 */ 2223 for (ep = 1; ep < 16; ep++) { 2224 mode = (inmask & (1 << ep)) ? inmode : 0; 2225 mode |= (outmask & (1 << ep)) ? outmode : 0; 2226 if (mode == 0) 2227 continue; /* no IN or OUT endpoint */ 2228 2229 pd = usb_make_dev(udev, NULL, ep, 0, 2230 mode, UID_ROOT, GID_OPERATOR, 0600); 2231 2232 if (pd != NULL) 2233 LIST_INSERT_HEAD(&udev->pd_list, pd, pd_next); 2234 } 2235 } 2236 2237 static void 2238 usb_cdev_free(struct usb_device *udev) 2239 { 2240 struct usb_fs_privdata* pd; 2241 2242 DPRINTFN(2, "Freeing device nodes\n"); 2243 2244 while ((pd = LIST_FIRST(&udev->pd_list)) != NULL) { 2245 KASSERT(pd->cdev->si_drv1 == pd, ("privdata corrupt")); 2246 2247 LIST_REMOVE(pd, pd_next); 2248 2249 usb_destroy_dev(pd); 2250 } 2251 } 2252 #endif 2253 2254 /*------------------------------------------------------------------------* 2255 * usb_free_device 2256 * 2257 * This function is NULL safe and will free an USB device and its 2258 * children devices, if any. 2259 * 2260 * Flag values: Reserved, set to zero. 2261 *------------------------------------------------------------------------*/ 2262 void 2263 usb_free_device(struct usb_device *udev, uint8_t flag) 2264 { 2265 struct usb_bus *bus; 2266 2267 if (udev == NULL) 2268 return; /* already freed */ 2269 2270 DPRINTFN(4, "udev=%p port=%d\n", udev, udev->port_no); 2271 2272 bus = udev->bus; 2273 2274 /* set DETACHED state to prevent any further references */ 2275 usb_set_device_state(udev, USB_STATE_DETACHED); 2276 2277 #if USB_HAVE_DEVCTL 2278 usb_notify_addq("DETACH", udev); 2279 #endif 2280 2281 #if USB_HAVE_UGEN 2282 if (!rebooting) { 2283 printf("%s: <%s %s> at %s (disconnected)\n", udev->ugen_name, 2284 usb_get_manufacturer(udev), usb_get_product(udev), 2285 device_get_nameunit(bus->bdev)); 2286 } 2287 2288 /* Destroy UGEN symlink, if any */ 2289 if (udev->ugen_symlink) { 2290 usb_free_symlink(udev->ugen_symlink); 2291 udev->ugen_symlink = NULL; 2292 } 2293 2294 usb_destroy_dev(udev->ctrl_dev); 2295 #endif 2296 2297 if (udev->flags.usb_mode == USB_MODE_DEVICE) { 2298 /* stop receiving any control transfers (Device Side Mode) */ 2299 usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX); 2300 } 2301 2302 /* the following will get the device unconfigured in software */ 2303 usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_EP0); 2304 2305 /* final device unregister after all character devices are closed */ 2306 usb_bus_port_set_device(bus, udev->parent_hub ? 2307 udev->parent_hub->hub->ports + udev->port_index : NULL, 2308 NULL, USB_ROOT_HUB_ADDR); 2309 2310 /* unsetup any leftover default USB transfers */ 2311 usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX); 2312 2313 /* template unsetup, if any */ 2314 (usb_temp_unsetup_p) (udev); 2315 2316 /* 2317 * Make sure that our clear-stall messages are not queued 2318 * anywhere: 2319 */ 2320 USB_BUS_LOCK(udev->bus); 2321 usb_proc_mwait(USB_BUS_CS_PROC(udev->bus), 2322 &udev->cs_msg[0], &udev->cs_msg[1]); 2323 USB_BUS_UNLOCK(udev->bus); 2324 2325 /* wait for all references to go away */ 2326 usb_wait_pending_refs(udev); 2327 2328 sx_destroy(&udev->enum_sx); 2329 sx_destroy(&udev->sr_sx); 2330 sx_destroy(&udev->ctrl_sx); 2331 2332 cv_destroy(&udev->ctrlreq_cv); 2333 cv_destroy(&udev->ref_cv); 2334 2335 mtx_destroy(&udev->device_mtx); 2336 #if USB_HAVE_UGEN 2337 KASSERT(LIST_FIRST(&udev->pd_list) == NULL, ("leaked cdev entries")); 2338 #endif 2339 2340 /* Uninitialise device */ 2341 if (bus->methods->device_uninit != NULL) 2342 (bus->methods->device_uninit) (udev); 2343 2344 /* free device */ 2345 free(udev->serial, M_USB); 2346 free(udev->manufacturer, M_USB); 2347 free(udev->product, M_USB); 2348 free(udev, M_USB); 2349 } 2350 2351 /*------------------------------------------------------------------------* 2352 * usbd_get_iface 2353 * 2354 * This function is the safe way to get the USB interface structure 2355 * pointer by interface index. 2356 * 2357 * Return values: 2358 * NULL: Interface not present. 2359 * Else: Pointer to USB interface structure. 2360 *------------------------------------------------------------------------*/ 2361 struct usb_interface * 2362 usbd_get_iface(struct usb_device *udev, uint8_t iface_index) 2363 { 2364 struct usb_interface *iface = udev->ifaces + iface_index; 2365 2366 if (iface_index >= udev->ifaces_max) 2367 return (NULL); 2368 return (iface); 2369 } 2370 2371 /*------------------------------------------------------------------------* 2372 * usbd_find_descriptor 2373 * 2374 * This function will lookup the first descriptor that matches the 2375 * criteria given by the arguments "type" and "subtype". Descriptors 2376 * will only be searched within the interface having the index 2377 * "iface_index". If the "id" argument points to an USB descriptor, 2378 * it will be skipped before the search is started. This allows 2379 * searching for multiple descriptors using the same criteria. Else 2380 * the search is started after the interface descriptor. 2381 * 2382 * Return values: 2383 * NULL: End of descriptors 2384 * Else: A descriptor matching the criteria 2385 *------------------------------------------------------------------------*/ 2386 void * 2387 usbd_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index, 2388 uint8_t type, uint8_t type_mask, 2389 uint8_t subtype, uint8_t subtype_mask) 2390 { 2391 struct usb_descriptor *desc; 2392 struct usb_config_descriptor *cd; 2393 struct usb_interface *iface; 2394 2395 cd = usbd_get_config_descriptor(udev); 2396 if (cd == NULL) { 2397 return (NULL); 2398 } 2399 if (id == NULL) { 2400 iface = usbd_get_iface(udev, iface_index); 2401 if (iface == NULL) { 2402 return (NULL); 2403 } 2404 id = usbd_get_interface_descriptor(iface); 2405 if (id == NULL) { 2406 return (NULL); 2407 } 2408 } 2409 desc = (void *)id; 2410 2411 while ((desc = usb_desc_foreach(cd, desc))) { 2412 2413 if (desc->bDescriptorType == UDESC_INTERFACE) { 2414 break; 2415 } 2416 if (((desc->bDescriptorType & type_mask) == type) && 2417 ((desc->bDescriptorSubtype & subtype_mask) == subtype)) { 2418 return (desc); 2419 } 2420 } 2421 return (NULL); 2422 } 2423 2424 /*------------------------------------------------------------------------* 2425 * usb_devinfo 2426 * 2427 * This function will dump information from the device descriptor 2428 * belonging to the USB device pointed to by "udev", to the string 2429 * pointed to by "dst_ptr" having a maximum length of "dst_len" bytes 2430 * including the terminating zero. 2431 *------------------------------------------------------------------------*/ 2432 void 2433 usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len) 2434 { 2435 struct usb_device_descriptor *udd = &udev->ddesc; 2436 uint16_t bcdDevice; 2437 uint16_t bcdUSB; 2438 2439 bcdUSB = UGETW(udd->bcdUSB); 2440 bcdDevice = UGETW(udd->bcdDevice); 2441 2442 if (udd->bDeviceClass != 0xFF) { 2443 snprintf(dst_ptr, dst_len, "%s %s, class %d/%d, rev %x.%02x/" 2444 "%x.%02x, addr %d", 2445 usb_get_manufacturer(udev), 2446 usb_get_product(udev), 2447 udd->bDeviceClass, udd->bDeviceSubClass, 2448 (bcdUSB >> 8), bcdUSB & 0xFF, 2449 (bcdDevice >> 8), bcdDevice & 0xFF, 2450 udev->address); 2451 } else { 2452 snprintf(dst_ptr, dst_len, "%s %s, rev %x.%02x/" 2453 "%x.%02x, addr %d", 2454 usb_get_manufacturer(udev), 2455 usb_get_product(udev), 2456 (bcdUSB >> 8), bcdUSB & 0xFF, 2457 (bcdDevice >> 8), bcdDevice & 0xFF, 2458 udev->address); 2459 } 2460 } 2461 2462 #ifdef USB_VERBOSE 2463 /* 2464 * Descriptions of of known vendors and devices ("products"). 2465 */ 2466 struct usb_knowndev { 2467 uint16_t vendor; 2468 uint16_t product; 2469 uint32_t flags; 2470 const char *vendorname; 2471 const char *productname; 2472 }; 2473 2474 #define USB_KNOWNDEV_NOPROD 0x01 /* match on vendor only */ 2475 2476 #include "usbdevs.h" 2477 #include "usbdevs_data.h" 2478 #endif /* USB_VERBOSE */ 2479 2480 static void 2481 usbd_set_device_strings(struct usb_device *udev) 2482 { 2483 struct usb_device_descriptor *udd = &udev->ddesc; 2484 #ifdef USB_VERBOSE 2485 const struct usb_knowndev *kdp; 2486 #endif 2487 char *temp_ptr; 2488 size_t temp_size; 2489 uint16_t vendor_id; 2490 uint16_t product_id; 2491 uint8_t do_unlock; 2492 2493 /* Protect scratch area */ 2494 do_unlock = usbd_ctrl_lock(udev); 2495 2496 temp_ptr = (char *)udev->scratch.data; 2497 temp_size = sizeof(udev->scratch.data); 2498 2499 vendor_id = UGETW(udd->idVendor); 2500 product_id = UGETW(udd->idProduct); 2501 2502 /* get serial number string */ 2503 usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size, 2504 udev->ddesc.iSerialNumber); 2505 udev->serial = strdup(temp_ptr, M_USB); 2506 2507 /* get manufacturer string */ 2508 usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size, 2509 udev->ddesc.iManufacturer); 2510 usb_trim_spaces(temp_ptr); 2511 if (temp_ptr[0] != '\0') 2512 udev->manufacturer = strdup(temp_ptr, M_USB); 2513 2514 /* get product string */ 2515 usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size, 2516 udev->ddesc.iProduct); 2517 usb_trim_spaces(temp_ptr); 2518 if (temp_ptr[0] != '\0') 2519 udev->product = strdup(temp_ptr, M_USB); 2520 2521 #ifdef USB_VERBOSE 2522 if (udev->manufacturer == NULL || udev->product == NULL) { 2523 for (kdp = usb_knowndevs; kdp->vendorname != NULL; kdp++) { 2524 if (kdp->vendor == vendor_id && 2525 (kdp->product == product_id || 2526 (kdp->flags & USB_KNOWNDEV_NOPROD) != 0)) 2527 break; 2528 } 2529 if (kdp->vendorname != NULL) { 2530 /* XXX should use pointer to knowndevs string */ 2531 if (udev->manufacturer == NULL) { 2532 udev->manufacturer = strdup(kdp->vendorname, 2533 M_USB); 2534 } 2535 if (udev->product == NULL && 2536 (kdp->flags & USB_KNOWNDEV_NOPROD) == 0) { 2537 udev->product = strdup(kdp->productname, 2538 M_USB); 2539 } 2540 } 2541 } 2542 #endif 2543 /* Provide default strings if none were found */ 2544 if (udev->manufacturer == NULL) { 2545 snprintf(temp_ptr, temp_size, "vendor 0x%04x", vendor_id); 2546 udev->manufacturer = strdup(temp_ptr, M_USB); 2547 } 2548 if (udev->product == NULL) { 2549 snprintf(temp_ptr, temp_size, "product 0x%04x", product_id); 2550 udev->product = strdup(temp_ptr, M_USB); 2551 } 2552 2553 if (do_unlock) 2554 usbd_ctrl_unlock(udev); 2555 } 2556 2557 /* 2558 * Returns: 2559 * See: USB_MODE_XXX 2560 */ 2561 enum usb_hc_mode 2562 usbd_get_mode(struct usb_device *udev) 2563 { 2564 return (udev->flags.usb_mode); 2565 } 2566 2567 /* 2568 * Returns: 2569 * See: USB_SPEED_XXX 2570 */ 2571 enum usb_dev_speed 2572 usbd_get_speed(struct usb_device *udev) 2573 { 2574 return (udev->speed); 2575 } 2576 2577 uint32_t 2578 usbd_get_isoc_fps(struct usb_device *udev) 2579 { 2580 ; /* indent fix */ 2581 switch (udev->speed) { 2582 case USB_SPEED_LOW: 2583 case USB_SPEED_FULL: 2584 return (1000); 2585 default: 2586 return (8000); 2587 } 2588 } 2589 2590 struct usb_device_descriptor * 2591 usbd_get_device_descriptor(struct usb_device *udev) 2592 { 2593 if (udev == NULL) 2594 return (NULL); /* be NULL safe */ 2595 return (&udev->ddesc); 2596 } 2597 2598 struct usb_config_descriptor * 2599 usbd_get_config_descriptor(struct usb_device *udev) 2600 { 2601 if (udev == NULL) 2602 return (NULL); /* be NULL safe */ 2603 return (udev->cdesc); 2604 } 2605 2606 /*------------------------------------------------------------------------* 2607 * usb_test_quirk - test a device for a given quirk 2608 * 2609 * Return values: 2610 * 0: The USB device does not have the given quirk. 2611 * Else: The USB device has the given quirk. 2612 *------------------------------------------------------------------------*/ 2613 uint8_t 2614 usb_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk) 2615 { 2616 uint8_t found; 2617 uint8_t x; 2618 2619 if (quirk == UQ_NONE) 2620 return (0); 2621 2622 /* search the automatic per device quirks first */ 2623 2624 for (x = 0; x != USB_MAX_AUTO_QUIRK; x++) { 2625 if (uaa->device->autoQuirk[x] == quirk) 2626 return (1); 2627 } 2628 2629 /* search global quirk table, if any */ 2630 2631 found = (usb_test_quirk_p) (&uaa->info, quirk); 2632 2633 return (found); 2634 } 2635 2636 struct usb_interface_descriptor * 2637 usbd_get_interface_descriptor(struct usb_interface *iface) 2638 { 2639 if (iface == NULL) 2640 return (NULL); /* be NULL safe */ 2641 return (iface->idesc); 2642 } 2643 2644 uint8_t 2645 usbd_get_interface_altindex(struct usb_interface *iface) 2646 { 2647 return (iface->alt_index); 2648 } 2649 2650 uint8_t 2651 usbd_get_bus_index(struct usb_device *udev) 2652 { 2653 return ((uint8_t)device_get_unit(udev->bus->bdev)); 2654 } 2655 2656 uint8_t 2657 usbd_get_device_index(struct usb_device *udev) 2658 { 2659 return (udev->device_index); 2660 } 2661 2662 #if USB_HAVE_DEVCTL 2663 static void 2664 usb_notify_addq(const char *type, struct usb_device *udev) 2665 { 2666 struct usb_interface *iface; 2667 struct sbuf *sb; 2668 int i; 2669 2670 /* announce the device */ 2671 sb = sbuf_new_auto(); 2672 sbuf_printf(sb, 2673 #if USB_HAVE_UGEN 2674 "ugen=%s " 2675 "cdev=%s " 2676 #endif 2677 "vendor=0x%04x " 2678 "product=0x%04x " 2679 "devclass=0x%02x " 2680 "devsubclass=0x%02x " 2681 "sernum=\"%s\" " 2682 "release=0x%04x " 2683 "mode=%s " 2684 "port=%u " 2685 #if USB_HAVE_UGEN 2686 "parent=%s" 2687 #endif 2688 "", 2689 #if USB_HAVE_UGEN 2690 udev->ugen_name, 2691 udev->ugen_name, 2692 #endif 2693 UGETW(udev->ddesc.idVendor), 2694 UGETW(udev->ddesc.idProduct), 2695 udev->ddesc.bDeviceClass, 2696 udev->ddesc.bDeviceSubClass, 2697 usb_get_serial(udev), 2698 UGETW(udev->ddesc.bcdDevice), 2699 (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device", 2700 udev->port_no 2701 #if USB_HAVE_UGEN 2702 , udev->parent_hub != NULL ? 2703 udev->parent_hub->ugen_name : 2704 device_get_nameunit(device_get_parent(udev->bus->bdev)) 2705 #endif 2706 ); 2707 sbuf_finish(sb); 2708 devctl_notify("USB", "DEVICE", type, sbuf_data(sb)); 2709 sbuf_delete(sb); 2710 2711 /* announce each interface */ 2712 for (i = 0; i < USB_IFACE_MAX; i++) { 2713 iface = usbd_get_iface(udev, i); 2714 if (iface == NULL) 2715 break; /* end of interfaces */ 2716 if (iface->idesc == NULL) 2717 continue; /* no interface descriptor */ 2718 2719 sb = sbuf_new_auto(); 2720 sbuf_printf(sb, 2721 #if USB_HAVE_UGEN 2722 "ugen=%s " 2723 "cdev=%s " 2724 #endif 2725 "vendor=0x%04x " 2726 "product=0x%04x " 2727 "devclass=0x%02x " 2728 "devsubclass=0x%02x " 2729 "sernum=\"%s\" " 2730 "release=0x%04x " 2731 "mode=%s " 2732 "interface=%d " 2733 "endpoints=%d " 2734 "intclass=0x%02x " 2735 "intsubclass=0x%02x " 2736 "intprotocol=0x%02x", 2737 #if USB_HAVE_UGEN 2738 udev->ugen_name, 2739 udev->ugen_name, 2740 #endif 2741 UGETW(udev->ddesc.idVendor), 2742 UGETW(udev->ddesc.idProduct), 2743 udev->ddesc.bDeviceClass, 2744 udev->ddesc.bDeviceSubClass, 2745 usb_get_serial(udev), 2746 UGETW(udev->ddesc.bcdDevice), 2747 (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device", 2748 iface->idesc->bInterfaceNumber, 2749 iface->idesc->bNumEndpoints, 2750 iface->idesc->bInterfaceClass, 2751 iface->idesc->bInterfaceSubClass, 2752 iface->idesc->bInterfaceProtocol); 2753 sbuf_finish(sb); 2754 devctl_notify("USB", "INTERFACE", type, sbuf_data(sb)); 2755 sbuf_delete(sb); 2756 } 2757 } 2758 #endif 2759 2760 #if USB_HAVE_UGEN 2761 /*------------------------------------------------------------------------* 2762 * usb_fifo_free_wrap 2763 * 2764 * This function will free the FIFOs. 2765 * 2766 * Description of "flag" argument: If the USB_UNCFG_FLAG_FREE_EP0 flag 2767 * is set and "iface_index" is set to "USB_IFACE_INDEX_ANY", we free 2768 * all FIFOs. If the USB_UNCFG_FLAG_FREE_EP0 flag is not set and 2769 * "iface_index" is set to "USB_IFACE_INDEX_ANY", we free all non 2770 * control endpoint FIFOs. If "iface_index" is not set to 2771 * "USB_IFACE_INDEX_ANY" the flag has no effect. 2772 *------------------------------------------------------------------------*/ 2773 static void 2774 usb_fifo_free_wrap(struct usb_device *udev, 2775 uint8_t iface_index, uint8_t flag) 2776 { 2777 struct usb_fifo *f; 2778 uint16_t i; 2779 2780 /* 2781 * Free any USB FIFOs on the given interface: 2782 */ 2783 for (i = 0; i != USB_FIFO_MAX; i++) { 2784 f = udev->fifo[i]; 2785 if (f == NULL) { 2786 continue; 2787 } 2788 /* Check if the interface index matches */ 2789 if (iface_index == f->iface_index) { 2790 if (f->methods != &usb_ugen_methods) { 2791 /* 2792 * Don't free any non-generic FIFOs in 2793 * this case. 2794 */ 2795 continue; 2796 } 2797 if ((f->dev_ep_index == 0) && 2798 (f->fs_xfer == NULL)) { 2799 /* no need to free this FIFO */ 2800 continue; 2801 } 2802 } else if (iface_index == USB_IFACE_INDEX_ANY) { 2803 if ((f->methods == &usb_ugen_methods) && 2804 (f->dev_ep_index == 0) && 2805 (!(flag & USB_UNCFG_FLAG_FREE_EP0)) && 2806 (f->fs_xfer == NULL)) { 2807 /* no need to free this FIFO */ 2808 continue; 2809 } 2810 } else { 2811 /* no need to free this FIFO */ 2812 continue; 2813 } 2814 /* free this FIFO */ 2815 usb_fifo_free(f); 2816 } 2817 } 2818 #endif 2819 2820 /*------------------------------------------------------------------------* 2821 * usb_peer_can_wakeup 2822 * 2823 * Return values: 2824 * 0: Peer cannot do resume signalling. 2825 * Else: Peer can do resume signalling. 2826 *------------------------------------------------------------------------*/ 2827 uint8_t 2828 usb_peer_can_wakeup(struct usb_device *udev) 2829 { 2830 const struct usb_config_descriptor *cdp; 2831 2832 cdp = udev->cdesc; 2833 if ((cdp != NULL) && (udev->flags.usb_mode == USB_MODE_HOST)) { 2834 return (cdp->bmAttributes & UC_REMOTE_WAKEUP); 2835 } 2836 return (0); /* not supported */ 2837 } 2838 2839 void 2840 usb_set_device_state(struct usb_device *udev, enum usb_dev_state state) 2841 { 2842 2843 KASSERT(state < USB_STATE_MAX, ("invalid udev state")); 2844 2845 DPRINTF("udev %p state %s -> %s\n", udev, 2846 usb_statestr(udev->state), usb_statestr(state)); 2847 2848 #if USB_HAVE_UGEN 2849 mtx_lock(&usb_ref_lock); 2850 #endif 2851 udev->state = state; 2852 #if USB_HAVE_UGEN 2853 mtx_unlock(&usb_ref_lock); 2854 #endif 2855 if (udev->bus->methods->device_state_change != NULL) 2856 (udev->bus->methods->device_state_change) (udev); 2857 } 2858 2859 enum usb_dev_state 2860 usb_get_device_state(struct usb_device *udev) 2861 { 2862 if (udev == NULL) 2863 return (USB_STATE_DETACHED); 2864 return (udev->state); 2865 } 2866 2867 uint8_t 2868 usbd_device_attached(struct usb_device *udev) 2869 { 2870 return (udev->state > USB_STATE_DETACHED); 2871 } 2872 2873 /* 2874 * The following function locks enumerating the given USB device. If 2875 * the lock is already grabbed this function returns zero. Else a 2876 * a value of one is returned. 2877 */ 2878 uint8_t 2879 usbd_enum_lock(struct usb_device *udev) 2880 { 2881 if (sx_xlocked(&udev->enum_sx)) 2882 return (0); 2883 2884 sx_xlock(&udev->enum_sx); 2885 sx_xlock(&udev->sr_sx); 2886 /* 2887 * NEWBUS LOCK NOTE: We should check if any parent SX locks 2888 * are locked before locking Giant. Else the lock can be 2889 * locked multiple times. 2890 */ 2891 mtx_lock(&Giant); 2892 return (1); 2893 } 2894 2895 #if USB_HAVE_UGEN 2896 /* 2897 * This function is the same like usbd_enum_lock() except a value of 2898 * 255 is returned when a signal is pending: 2899 */ 2900 uint8_t 2901 usbd_enum_lock_sig(struct usb_device *udev) 2902 { 2903 if (sx_xlocked(&udev->enum_sx)) 2904 return (0); 2905 if (sx_xlock_sig(&udev->enum_sx)) 2906 return (255); 2907 if (sx_xlock_sig(&udev->sr_sx)) { 2908 sx_xunlock(&udev->enum_sx); 2909 return (255); 2910 } 2911 mtx_lock(&Giant); 2912 return (1); 2913 } 2914 #endif 2915 2916 /* The following function unlocks enumerating the given USB device. */ 2917 2918 void 2919 usbd_enum_unlock(struct usb_device *udev) 2920 { 2921 mtx_unlock(&Giant); 2922 sx_xunlock(&udev->enum_sx); 2923 sx_xunlock(&udev->sr_sx); 2924 } 2925 2926 /* The following function locks suspend and resume. */ 2927 2928 void 2929 usbd_sr_lock(struct usb_device *udev) 2930 { 2931 sx_xlock(&udev->sr_sx); 2932 /* 2933 * NEWBUS LOCK NOTE: We should check if any parent SX locks 2934 * are locked before locking Giant. Else the lock can be 2935 * locked multiple times. 2936 */ 2937 mtx_lock(&Giant); 2938 } 2939 2940 /* The following function unlocks suspend and resume. */ 2941 2942 void 2943 usbd_sr_unlock(struct usb_device *udev) 2944 { 2945 mtx_unlock(&Giant); 2946 sx_xunlock(&udev->sr_sx); 2947 } 2948 2949 /* 2950 * The following function checks the enumerating lock for the given 2951 * USB device. 2952 */ 2953 2954 uint8_t 2955 usbd_enum_is_locked(struct usb_device *udev) 2956 { 2957 return (sx_xlocked(&udev->enum_sx)); 2958 } 2959 2960 /* 2961 * The following function is used to serialize access to USB control 2962 * transfers and the USB scratch area. If the lock is already grabbed 2963 * this function returns zero. Else a value of one is returned. 2964 */ 2965 uint8_t 2966 usbd_ctrl_lock(struct usb_device *udev) 2967 { 2968 if (sx_xlocked(&udev->ctrl_sx)) 2969 return (0); 2970 sx_xlock(&udev->ctrl_sx); 2971 2972 /* 2973 * We need to allow suspend and resume at this point, else the 2974 * control transfer will timeout if the device is suspended! 2975 */ 2976 if (usbd_enum_is_locked(udev)) 2977 usbd_sr_unlock(udev); 2978 return (1); 2979 } 2980 2981 void 2982 usbd_ctrl_unlock(struct usb_device *udev) 2983 { 2984 sx_xunlock(&udev->ctrl_sx); 2985 2986 /* 2987 * Restore the suspend and resume lock after we have unlocked 2988 * the USB control transfer lock to avoid LOR: 2989 */ 2990 if (usbd_enum_is_locked(udev)) 2991 usbd_sr_lock(udev); 2992 } 2993 2994 /* 2995 * The following function is used to set the per-interface specific 2996 * plug and play information. The string referred to by the pnpinfo 2997 * argument can safely be freed after calling this function. The 2998 * pnpinfo of an interface will be reset at device detach or when 2999 * passing a NULL argument to this function. This function 3000 * returns zero on success, else a USB_ERR_XXX failure code. 3001 */ 3002 3003 usb_error_t 3004 usbd_set_pnpinfo(struct usb_device *udev, uint8_t iface_index, const char *pnpinfo) 3005 { 3006 struct usb_interface *iface; 3007 3008 iface = usbd_get_iface(udev, iface_index); 3009 if (iface == NULL) 3010 return (USB_ERR_INVAL); 3011 3012 if (iface->pnpinfo != NULL) { 3013 free(iface->pnpinfo, M_USBDEV); 3014 iface->pnpinfo = NULL; 3015 } 3016 3017 if (pnpinfo == NULL || pnpinfo[0] == 0) 3018 return (0); /* success */ 3019 3020 iface->pnpinfo = strdup(pnpinfo, M_USBDEV); 3021 if (iface->pnpinfo == NULL) 3022 return (USB_ERR_NOMEM); 3023 3024 return (0); /* success */ 3025 } 3026 3027 usb_error_t 3028 usbd_add_dynamic_quirk(struct usb_device *udev, uint16_t quirk) 3029 { 3030 uint8_t x; 3031 3032 for (x = 0; x != USB_MAX_AUTO_QUIRK; x++) { 3033 if (udev->autoQuirk[x] == 0 || 3034 udev->autoQuirk[x] == quirk) { 3035 udev->autoQuirk[x] = quirk; 3036 return (0); /* success */ 3037 } 3038 } 3039 return (USB_ERR_NOMEM); 3040 } 3041 3042 /* 3043 * The following function is used to select the endpoint mode. It 3044 * should not be called outside enumeration context. 3045 */ 3046 3047 usb_error_t 3048 usbd_set_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep, 3049 uint8_t ep_mode) 3050 { 3051 usb_error_t error; 3052 uint8_t do_unlock; 3053 3054 /* Prevent re-enumeration */ 3055 do_unlock = usbd_enum_lock(udev); 3056 3057 if (udev->bus->methods->set_endpoint_mode != NULL) { 3058 error = (udev->bus->methods->set_endpoint_mode) ( 3059 udev, ep, ep_mode); 3060 } else if (ep_mode != USB_EP_MODE_DEFAULT) { 3061 error = USB_ERR_INVAL; 3062 } else { 3063 error = 0; 3064 } 3065 3066 /* only set new mode regardless of error */ 3067 ep->ep_mode = ep_mode; 3068 3069 if (do_unlock) 3070 usbd_enum_unlock(udev); 3071 return (error); 3072 } 3073 3074 uint8_t 3075 usbd_get_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep) 3076 { 3077 return (ep->ep_mode); 3078 } 3079