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