sys/dev/usb/controller/usb_controller.c

   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 "opt_ddb.h"
  33
  34 #include <sys/stdint.h>
  35 #include <sys/stddef.h>
  36 #include <sys/param.h>
  37 #include <sys/queue.h>
  38 #include <sys/types.h>
  39 #include <sys/systm.h>
  40 #include <sys/kernel.h>
  41 #include <sys/bus.h>
  42 #include <sys/module.h>
  43 #include <sys/lock.h>
  44 #include <sys/mutex.h>
  45 #include <sys/condvar.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/sx.h>
  48 #include <sys/unistd.h>
  49 #include <sys/callout.h>
  50 #include <sys/malloc.h>
  51 #include <sys/priv.h>
  52
  53 #include <dev/usb/usb.h>
  54 #include <dev/usb/usbdi.h>
  55
  56 #define USB_DEBUG_VAR usb_ctrl_debug
  57
  58 #include <dev/usb/usb_core.h>
  59 #include <dev/usb/usb_debug.h>
  60 #include <dev/usb/usb_process.h>
  61 #include <dev/usb/usb_busdma.h>
  62 #include <dev/usb/usb_dynamic.h>
  63 #include <dev/usb/usb_device.h>
  64 #include <dev/usb/usb_dev.h>
  65 #include <dev/usb/usb_hub.h>
  66
  67 #include <dev/usb/usb_controller.h>
  68 #include <dev/usb/usb_bus.h>
  69 #include <dev/usb/usb_pf.h>
  70 #include "usb_if.h"
  71 #endif                  /* USB_GLOBAL_INCLUDE_FILE */
  72
  73 /* function prototypes  */
  74
  75 static device_probe_t usb_probe;
  76 static device_attach_t usb_attach;
  77 static device_detach_t usb_detach;
  78 static device_suspend_t usb_suspend;
  79 static device_resume_t usb_resume;
  80 static device_shutdown_t usb_shutdown;
  81
  82 static void     usb_attach_sub(device_t, struct usb_bus *);
  83
  84 /* static variables */
  85
  86 #ifdef USB_DEBUG
  87 static int usb_ctrl_debug = 0;
  88
  89 static SYSCTL_NODE(_hw_usb, OID_AUTO, ctrl, CTLFLAG_RW, 0, "USB controller");
  90 SYSCTL_INT(_hw_usb_ctrl, OID_AUTO, debug, CTLFLAG_RWTUN, &usb_ctrl_debug, 0,
  91     "Debug level");
  92 #endif
  93
  94 #if USB_HAVE_ROOT_MOUNT_HOLD
  95 static int usb_no_boot_wait = 0;
  96 SYSCTL_INT(_hw_usb, OID_AUTO, no_boot_wait, CTLFLAG_RDTUN, &usb_no_boot_wait, 0,
  97     "No USB device enumerate waiting at boot.");
  98 #endif
  99
 100 static int usb_no_suspend_wait = 0;
 101 SYSCTL_INT(_hw_usb, OID_AUTO, no_suspend_wait, CTLFLAG_RWTUN,
 102     &usb_no_suspend_wait, 0, "No USB device waiting at system suspend.");
 103
 104 static int usb_no_shutdown_wait = 0;
 105 SYSCTL_INT(_hw_usb, OID_AUTO, no_shutdown_wait, CTLFLAG_RWTUN,
 106     &usb_no_shutdown_wait, 0, "No USB device waiting at system shutdown.");
 107
 108 static devclass_t usb_devclass;
 109
 110 static device_method_t usb_methods[] = {
 111         DEVMETHOD(device_probe, usb_probe),
 112         DEVMETHOD(device_attach, usb_attach),
 113         DEVMETHOD(device_detach, usb_detach),
 114         DEVMETHOD(device_suspend, usb_suspend),
 115         DEVMETHOD(device_resume, usb_resume),
 116         DEVMETHOD(device_shutdown, usb_shutdown),
 117
 118         DEVMETHOD_END
 119 };
 120
 121 static driver_t usb_driver = {
 122         .name = "usbus",
 123         .methods = usb_methods,
 124         .size = 0,
 125 };
 126
 127 /* Host Only Drivers */
 128 DRIVER_MODULE(usbus, ohci, usb_driver, usb_devclass, 0, 0);
 129 DRIVER_MODULE(usbus, uhci, usb_driver, usb_devclass, 0, 0);
 130 DRIVER_MODULE(usbus, ehci, usb_driver, usb_devclass, 0, 0);
 131 DRIVER_MODULE(usbus, xhci, usb_driver, usb_devclass, 0, 0);
 132
 133 /* Device Only Drivers */
 134 DRIVER_MODULE(usbus, musbotg, usb_driver, usb_devclass, 0, 0);
 135 DRIVER_MODULE(usbus, uss820dci, usb_driver, usb_devclass, 0, 0);
 136 DRIVER_MODULE(usbus, octusb, usb_driver, usb_devclass, 0, 0);
 137
 138 /* Dual Mode Drivers */
 139 DRIVER_MODULE(usbus, dwcotg, usb_driver, usb_devclass, 0, 0);
 140 DRIVER_MODULE(usbus, saf1761otg, usb_driver, usb_devclass, 0, 0);
 141
 142 /*------------------------------------------------------------------------*
 143  *      usb_probe
 144  *
 145  * This function is called from "{ehci,ohci,uhci}_pci_attach()".
 146  *------------------------------------------------------------------------*/
 147 static int
 148 usb_probe(device_t dev)
 149 {
 150         DPRINTF("\n");
 151         return (0);
 152 }
 153
 154 #if USB_HAVE_ROOT_MOUNT_HOLD
 155 static void
 156 usb_root_mount_rel(struct usb_bus *bus)
 157 {
 158         if (bus->bus_roothold != NULL) {
 159                 DPRINTF("Releasing root mount hold %p\n", bus->bus_roothold);
 160                 root_mount_rel(bus->bus_roothold);
 161                 bus->bus_roothold = NULL;
 162         }
 163 }
 164 #endif
 165
 166 /*------------------------------------------------------------------------*
 167  *      usb_attach
 168  *------------------------------------------------------------------------*/
 169 static int
 170 usb_attach(device_t dev)
 171 {
 172         struct usb_bus *bus = device_get_ivars(dev);
 173
 174         DPRINTF("\n");
 175
 176         if (bus == NULL) {
 177                 device_printf(dev, "USB device has no ivars\n");
 178                 return (ENXIO);
 179         }
 180
 181 #if USB_HAVE_ROOT_MOUNT_HOLD
 182         if (usb_no_boot_wait == 0) {
 183                 /* delay vfs_mountroot until the bus is explored */
 184                 bus->bus_roothold = root_mount_hold(device_get_nameunit(dev));
 185         }
 186 #endif
 187         usb_attach_sub(dev, bus);
 188
 189         return (0);                     /* return success */
 190 }
 191
 192 /*------------------------------------------------------------------------*
 193  *      usb_detach
 194  *------------------------------------------------------------------------*/
 195 static int
 196 usb_detach(device_t dev)
 197 {
 198         struct usb_bus *bus = device_get_softc(dev);
 199
 200         DPRINTF("\n");
 201
 202         if (bus == NULL) {
 203                 /* was never setup properly */
 204                 return (0);
 205         }
 206         /* Stop power watchdog */
 207         usb_callout_drain(&bus->power_wdog);
 208
 209 #if USB_HAVE_ROOT_MOUNT_HOLD
 210         /* Let the USB explore process detach all devices. */
 211         usb_root_mount_rel(bus);
 212 #endif
 213
 214         USB_BUS_LOCK(bus);
 215
 216         /* Queue detach job */
 217         usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
 218             &bus->detach_msg[0], &bus->detach_msg[1]);
 219
 220         /* Wait for detach to complete */
 221         usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
 222             &bus->detach_msg[0], &bus->detach_msg[1]);
 223
 224 #if USB_HAVE_UGEN
 225         /* Wait for cleanup to complete */
 226         usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
 227             &bus->cleanup_msg[0], &bus->cleanup_msg[1]);
 228 #endif
 229         USB_BUS_UNLOCK(bus);
 230
 231 #if USB_HAVE_PER_BUS_PROCESS
 232         /* Get rid of USB callback processes */
 233
 234         usb_proc_free(USB_BUS_GIANT_PROC(bus));
 235         usb_proc_free(USB_BUS_NON_GIANT_ISOC_PROC(bus));
 236         usb_proc_free(USB_BUS_NON_GIANT_BULK_PROC(bus));
 237
 238         /* Get rid of USB explore process */
 239
 240         usb_proc_free(USB_BUS_EXPLORE_PROC(bus));
 241
 242         /* Get rid of control transfer process */
 243
 244         usb_proc_free(USB_BUS_CONTROL_XFER_PROC(bus));
 245 #endif
 246
 247 #if USB_HAVE_PF
 248         usbpf_detach(bus);
 249 #endif
 250         return (0);
 251 }
 252
 253 /*------------------------------------------------------------------------*
 254  *      usb_suspend
 255  *------------------------------------------------------------------------*/
 256 static int
 257 usb_suspend(device_t dev)
 258 {
 259         struct usb_bus *bus = device_get_softc(dev);
 260
 261         DPRINTF("\n");
 262
 263         if (bus == NULL) {
 264                 /* was never setup properly */
 265                 return (0);
 266         }
 267
 268         USB_BUS_LOCK(bus);
 269         usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
 270             &bus->suspend_msg[0], &bus->suspend_msg[1]);
 271         if (usb_no_suspend_wait == 0) {
 272                 /* wait for suspend callback to be executed */
 273                 usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
 274                     &bus->suspend_msg[0], &bus->suspend_msg[1]);
 275         }
 276         USB_BUS_UNLOCK(bus);
 277
 278         return (0);
 279 }
 280
 281 /*------------------------------------------------------------------------*
 282  *      usb_resume
 283  *------------------------------------------------------------------------*/
 284 static int
 285 usb_resume(device_t dev)
 286 {
 287         struct usb_bus *bus = device_get_softc(dev);
 288
 289         DPRINTF("\n");
 290
 291         if (bus == NULL) {
 292                 /* was never setup properly */
 293                 return (0);
 294         }
 295
 296         USB_BUS_LOCK(bus);
 297         usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
 298             &bus->resume_msg[0], &bus->resume_msg[1]);
 299         USB_BUS_UNLOCK(bus);
 300
 301         return (0);
 302 }
 303
 304 /*------------------------------------------------------------------------*
 305  *      usb_bus_reset_async_locked
 306  *------------------------------------------------------------------------*/
 307 void
 308 usb_bus_reset_async_locked(struct usb_bus *bus)
 309 {
 310         USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
 311
 312         DPRINTF("\n");
 313
 314         if (bus->reset_msg[0].hdr.pm_qentry.tqe_prev != NULL ||
 315             bus->reset_msg[1].hdr.pm_qentry.tqe_prev != NULL) {
 316                 DPRINTF("Reset already pending\n");
 317                 return;
 318         }
 319
 320         device_printf(bus->parent, "Resetting controller\n");
 321
 322         usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
 323             &bus->reset_msg[0], &bus->reset_msg[1]);
 324 }
 325
 326 /*------------------------------------------------------------------------*
 327  *      usb_shutdown
 328  *------------------------------------------------------------------------*/
 329 static int
 330 usb_shutdown(device_t dev)
 331 {
 332         struct usb_bus *bus = device_get_softc(dev);
 333
 334         DPRINTF("\n");
 335
 336         if (bus == NULL) {
 337                 /* was never setup properly */
 338                 return (0);
 339         }
 340
 341         DPRINTF("%s: Controller shutdown\n", device_get_nameunit(bus->bdev));
 342
 343         USB_BUS_LOCK(bus);
 344         usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
 345             &bus->shutdown_msg[0], &bus->shutdown_msg[1]);
 346         if (usb_no_shutdown_wait == 0) {
 347                 /* wait for shutdown callback to be executed */
 348                 usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
 349                     &bus->shutdown_msg[0], &bus->shutdown_msg[1]);
 350         }
 351         USB_BUS_UNLOCK(bus);
 352
 353         DPRINTF("%s: Controller shutdown complete\n",
 354             device_get_nameunit(bus->bdev));
 355
 356         return (0);
 357 }
 358
 359 /*------------------------------------------------------------------------*
 360  *      usb_bus_explore
 361  *
 362  * This function is used to explore the device tree from the root.
 363  *------------------------------------------------------------------------*/
 364 static void
 365 usb_bus_explore(struct usb_proc_msg *pm)
 366 {
 367         struct usb_bus *bus;
 368         struct usb_device *udev;
 369
 370         bus = ((struct usb_bus_msg *)pm)->bus;
 371         udev = bus->devices[USB_ROOT_HUB_ADDR];
 372
 373         if (bus->no_explore != 0)
 374                 return;
 375
 376         if (udev != NULL) {
 377                 USB_BUS_UNLOCK(bus);
 378                 uhub_explore_handle_re_enumerate(udev);
 379                 USB_BUS_LOCK(bus);
 380         }
 381
 382         if (udev != NULL && udev->hub != NULL) {
 383
 384                 if (bus->do_probe) {
 385                         bus->do_probe = 0;
 386                         bus->driver_added_refcount++;
 387                 }
 388                 if (bus->driver_added_refcount == 0) {
 389                         /* avoid zero, hence that is memory default */
 390                         bus->driver_added_refcount = 1;
 391                 }
 392
 393 #ifdef DDB
 394                 /*
 395                  * The following three lines of code are only here to
 396                  * recover from DDB:
 397                  */
 398                 usb_proc_rewakeup(USB_BUS_CONTROL_XFER_PROC(bus));
 399                 usb_proc_rewakeup(USB_BUS_GIANT_PROC(bus));
 400                 usb_proc_rewakeup(USB_BUS_NON_GIANT_ISOC_PROC(bus));
 401                 usb_proc_rewakeup(USB_BUS_NON_GIANT_BULK_PROC(bus));
 402 #endif
 403
 404                 USB_BUS_UNLOCK(bus);
 405
 406 #if USB_HAVE_POWERD
 407                 /*
 408                  * First update the USB power state!
 409                  */
 410                 usb_bus_powerd(bus);
 411 #endif
 412                  /* Explore the Root USB HUB. */
 413                 (udev->hub->explore) (udev);
 414                 USB_BUS_LOCK(bus);
 415         }
 416 #if USB_HAVE_ROOT_MOUNT_HOLD
 417         usb_root_mount_rel(bus);
 418 #endif
 419 }
 420
 421 /*------------------------------------------------------------------------*
 422  *      usb_bus_detach
 423  *
 424  * This function is used to detach the device tree from the root.
 425  *------------------------------------------------------------------------*/
 426 static void
 427 usb_bus_detach(struct usb_proc_msg *pm)
 428 {
 429         struct usb_bus *bus;
 430         struct usb_device *udev;
 431         device_t dev;
 432
 433         bus = ((struct usb_bus_msg *)pm)->bus;
 434         udev = bus->devices[USB_ROOT_HUB_ADDR];
 435         dev = bus->bdev;
 436         /* clear the softc */
 437         device_set_softc(dev, NULL);
 438         USB_BUS_UNLOCK(bus);
 439
 440         /* detach children first */
 441         mtx_lock(&Giant);
 442         bus_generic_detach(dev);
 443         mtx_unlock(&Giant);
 444
 445         /*
 446          * Free USB device and all subdevices, if any.
 447          */
 448         usb_free_device(udev, 0);
 449
 450         USB_BUS_LOCK(bus);
 451         /* clear bdev variable last */
 452         bus->bdev = NULL;
 453 }
 454
 455 /*------------------------------------------------------------------------*
 456  *      usb_bus_suspend
 457  *
 458  * This function is used to suspend the USB controller.
 459  *------------------------------------------------------------------------*/
 460 static void
 461 usb_bus_suspend(struct usb_proc_msg *pm)
 462 {
 463         struct usb_bus *bus;
 464         struct usb_device *udev;
 465         usb_error_t err;
 466         uint8_t do_unlock;
 467
 468         DPRINTF("\n");
 469
 470         bus = ((struct usb_bus_msg *)pm)->bus;
 471         udev = bus->devices[USB_ROOT_HUB_ADDR];
 472
 473         if (udev == NULL || bus->bdev == NULL)
 474                 return;
 475
 476         USB_BUS_UNLOCK(bus);
 477
 478         /*
 479          * We use the shutdown event here because the suspend and
 480          * resume events are reserved for the USB port suspend and
 481          * resume. The USB system suspend is implemented like full
 482          * shutdown and all connected USB devices will be disconnected
 483          * subsequently. At resume all USB devices will be
 484          * re-connected again.
 485          */
 486
 487         bus_generic_shutdown(bus->bdev);
 488
 489         do_unlock = usbd_enum_lock(udev);
 490
 491         err = usbd_set_config_index(udev, USB_UNCONFIG_INDEX);
 492         if (err)
 493                 device_printf(bus->bdev, "Could not unconfigure root HUB\n");
 494
 495         USB_BUS_LOCK(bus);
 496         bus->hw_power_state = 0;
 497         bus->no_explore = 1;
 498         USB_BUS_UNLOCK(bus);
 499
 500         if (bus->methods->set_hw_power != NULL)
 501                 (bus->methods->set_hw_power) (bus);
 502
 503         if (bus->methods->set_hw_power_sleep != NULL)
 504                 (bus->methods->set_hw_power_sleep) (bus, USB_HW_POWER_SUSPEND);
 505
 506         if (do_unlock)
 507                 usbd_enum_unlock(udev);
 508
 509         USB_BUS_LOCK(bus);
 510 }
 511
 512 /*------------------------------------------------------------------------*
 513  *      usb_bus_resume
 514  *
 515  * This function is used to resume the USB controller.
 516  *------------------------------------------------------------------------*/
 517 static void
 518 usb_bus_resume(struct usb_proc_msg *pm)
 519 {
 520         struct usb_bus *bus;
 521         struct usb_device *udev;
 522         usb_error_t err;
 523         uint8_t do_unlock;
 524
 525         DPRINTF("\n");
 526
 527         bus = ((struct usb_bus_msg *)pm)->bus;
 528         udev = bus->devices[USB_ROOT_HUB_ADDR];
 529
 530         if (udev == NULL || bus->bdev == NULL)
 531                 return;
 532
 533         USB_BUS_UNLOCK(bus);
 534
 535         do_unlock = usbd_enum_lock(udev);
 536 #if 0
 537         DEVMETHOD(usb_take_controller, NULL);   /* dummy */
 538 #endif
 539         USB_TAKE_CONTROLLER(device_get_parent(bus->bdev));
 540
 541         USB_BUS_LOCK(bus);
 542         bus->hw_power_state =
 543           USB_HW_POWER_CONTROL |
 544           USB_HW_POWER_BULK |
 545           USB_HW_POWER_INTERRUPT |
 546           USB_HW_POWER_ISOC |
 547           USB_HW_POWER_NON_ROOT_HUB;
 548         bus->no_explore = 0;
 549         USB_BUS_UNLOCK(bus);
 550
 551         if (bus->methods->set_hw_power_sleep != NULL)
 552                 (bus->methods->set_hw_power_sleep) (bus, USB_HW_POWER_RESUME);
 553
 554         if (bus->methods->set_hw_power != NULL)
 555                 (bus->methods->set_hw_power) (bus);
 556
 557         /* restore USB configuration to index 0 */
 558         err = usbd_set_config_index(udev, 0);
 559         if (err)
 560                 device_printf(bus->bdev, "Could not configure root HUB\n");
 561
 562         /* probe and attach */
 563         err = usb_probe_and_attach(udev, USB_IFACE_INDEX_ANY);
 564         if (err) {
 565                 device_printf(bus->bdev, "Could not probe and "
 566                     "attach root HUB\n");
 567         }
 568
 569         if (do_unlock)
 570                 usbd_enum_unlock(udev);
 571
 572         USB_BUS_LOCK(bus);
 573 }
 574
 575 /*------------------------------------------------------------------------*
 576  *      usb_bus_reset
 577  *
 578  * This function is used to reset the USB controller.
 579  *------------------------------------------------------------------------*/
 580 static void
 581 usb_bus_reset(struct usb_proc_msg *pm)
 582 {
 583         struct usb_bus *bus;
 584
 585         DPRINTF("\n");
 586
 587         bus = ((struct usb_bus_msg *)pm)->bus;
 588
 589         if (bus->bdev == NULL || bus->no_explore != 0)
 590                 return;
 591
 592         /* a suspend and resume will reset the USB controller */
 593         usb_bus_suspend(pm);
 594         usb_bus_resume(pm);
 595 }
 596
 597 /*------------------------------------------------------------------------*
 598  *      usb_bus_shutdown
 599  *
 600  * This function is used to shutdown the USB controller.
 601  *------------------------------------------------------------------------*/
 602 static void
 603 usb_bus_shutdown(struct usb_proc_msg *pm)
 604 {
 605         struct usb_bus *bus;
 606         struct usb_device *udev;
 607         usb_error_t err;
 608         uint8_t do_unlock;
 609
 610         bus = ((struct usb_bus_msg *)pm)->bus;
 611         udev = bus->devices[USB_ROOT_HUB_ADDR];
 612
 613         if (udev == NULL || bus->bdev == NULL)
 614                 return;
 615
 616         USB_BUS_UNLOCK(bus);
 617
 618         bus_generic_shutdown(bus->bdev);
 619
 620         do_unlock = usbd_enum_lock(udev);
 621
 622         err = usbd_set_config_index(udev, USB_UNCONFIG_INDEX);
 623         if (err)
 624                 device_printf(bus->bdev, "Could not unconfigure root HUB\n");
 625
 626         USB_BUS_LOCK(bus);
 627         bus->hw_power_state = 0;
 628         bus->no_explore = 1;
 629         USB_BUS_UNLOCK(bus);
 630
 631         if (bus->methods->set_hw_power != NULL)
 632                 (bus->methods->set_hw_power) (bus);
 633
 634         if (bus->methods->set_hw_power_sleep != NULL)
 635                 (bus->methods->set_hw_power_sleep) (bus, USB_HW_POWER_SHUTDOWN);
 636
 637         if (do_unlock)
 638                 usbd_enum_unlock(udev);
 639
 640         USB_BUS_LOCK(bus);
 641 }
 642
 643 /*------------------------------------------------------------------------*
 644  *      usb_bus_cleanup
 645  *
 646  * This function is used to cleanup leftover USB character devices.
 647  *------------------------------------------------------------------------*/
 648 #if USB_HAVE_UGEN
 649 static void
 650 usb_bus_cleanup(struct usb_proc_msg *pm)
 651 {
 652         struct usb_bus *bus;
 653         struct usb_fs_privdata *pd;
 654
 655         bus = ((struct usb_bus_msg *)pm)->bus;
 656
 657         while ((pd = LIST_FIRST(&bus->pd_cleanup_list)) != NULL) {
 658
 659                 LIST_REMOVE(pd, pd_next);
 660                 USB_BUS_UNLOCK(bus);
 661
 662                 usb_destroy_dev_sync(pd);
 663
 664                 USB_BUS_LOCK(bus);
 665         }
 666 }
 667 #endif
 668
 669 static void
 670 usb_power_wdog(void *arg)
 671 {
 672         struct usb_bus *bus = arg;
 673
 674         USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
 675
 676         usb_callout_reset(&bus->power_wdog,
 677             4 * hz, usb_power_wdog, arg);
 678
 679 #ifdef DDB
 680         /*
 681          * The following line of code is only here to recover from
 682          * DDB:
 683          */
 684         usb_proc_rewakeup(USB_BUS_EXPLORE_PROC(bus));   /* recover from DDB */
 685 #endif
 686
 687 #if USB_HAVE_POWERD
 688         USB_BUS_UNLOCK(bus);
 689
 690         usb_bus_power_update(bus);
 691
 692         USB_BUS_LOCK(bus);
 693 #endif
 694 }
 695
 696 /*------------------------------------------------------------------------*
 697  *      usb_bus_attach
 698  *
 699  * This function attaches USB in context of the explore thread.
 700  *------------------------------------------------------------------------*/
 701 static void
 702 usb_bus_attach(struct usb_proc_msg *pm)
 703 {
 704         struct usb_bus *bus;
 705         struct usb_device *child;
 706         device_t dev;
 707         usb_error_t err;
 708         enum usb_dev_speed speed;
 709
 710         bus = ((struct usb_bus_msg *)pm)->bus;
 711         dev = bus->bdev;
 712
 713         DPRINTF("\n");
 714
 715         switch (bus->usbrev) {
 716         case USB_REV_1_0:
 717                 speed = USB_SPEED_FULL;
 718                 device_printf(bus->bdev, "12Mbps Full Speed USB v1.0\n");
 719                 break;
 720
 721         case USB_REV_1_1:
 722                 speed = USB_SPEED_FULL;
 723                 device_printf(bus->bdev, "12Mbps Full Speed USB v1.1\n");
 724                 break;
 725
 726         case USB_REV_2_0:
 727                 speed = USB_SPEED_HIGH;
 728                 device_printf(bus->bdev, "480Mbps High Speed USB v2.0\n");
 729                 break;
 730
 731         case USB_REV_2_5:
 732                 speed = USB_SPEED_VARIABLE;
 733                 device_printf(bus->bdev, "480Mbps Wireless USB v2.5\n");
 734                 break;
 735
 736         case USB_REV_3_0:
 737                 speed = USB_SPEED_SUPER;
 738                 device_printf(bus->bdev, "5.0Gbps Super Speed USB v3.0\n");
 739                 break;
 740
 741         default:
 742                 device_printf(bus->bdev, "Unsupported USB revision\n");
 743 #if USB_HAVE_ROOT_MOUNT_HOLD
 744                 usb_root_mount_rel(bus);
 745 #endif
 746                 return;
 747         }
 748
 749         /* default power_mask value */
 750         bus->hw_power_state =
 751           USB_HW_POWER_CONTROL |
 752           USB_HW_POWER_BULK |
 753           USB_HW_POWER_INTERRUPT |
 754           USB_HW_POWER_ISOC |
 755           USB_HW_POWER_NON_ROOT_HUB;
 756
 757         USB_BUS_UNLOCK(bus);
 758
 759         /* make sure power is set at least once */
 760
 761         if (bus->methods->set_hw_power != NULL) {
 762                 (bus->methods->set_hw_power) (bus);
 763         }
 764
 765         /* allocate the Root USB device */
 766
 767         child = usb_alloc_device(bus->bdev, bus, NULL, 0, 0, 1,
 768             speed, USB_MODE_HOST);
 769         if (child) {
 770                 err = usb_probe_and_attach(child,
 771                     USB_IFACE_INDEX_ANY);
 772                 if (!err) {
 773                         if ((bus->devices[USB_ROOT_HUB_ADDR] == NULL) ||
 774                             (bus->devices[USB_ROOT_HUB_ADDR]->hub == NULL)) {
 775                                 err = USB_ERR_NO_ROOT_HUB;
 776                         }
 777                 }
 778         } else {
 779                 err = USB_ERR_NOMEM;
 780         }
 781
 782         USB_BUS_LOCK(bus);
 783
 784         if (err) {
 785                 device_printf(bus->bdev, "Root HUB problem, error=%s\n",
 786                     usbd_errstr(err));
 787 #if USB_HAVE_ROOT_MOUNT_HOLD
 788                 usb_root_mount_rel(bus);
 789 #endif
 790         }
 791
 792         /* set softc - we are ready */
 793         device_set_softc(dev, bus);
 794
 795         /* start watchdog */
 796         usb_power_wdog(bus);
 797 }
 798
 799 /*------------------------------------------------------------------------*
 800  *      usb_attach_sub
 801  *
 802  * This function creates a thread which runs the USB attach code.
 803  *------------------------------------------------------------------------*/
 804 static void
 805 usb_attach_sub(device_t dev, struct usb_bus *bus)
 806 {
 807         mtx_lock(&Giant);
 808         if (usb_devclass_ptr == NULL)
 809                 usb_devclass_ptr = devclass_find("usbus");
 810         mtx_unlock(&Giant);
 811
 812 #if USB_HAVE_PF
 813         usbpf_attach(bus);
 814 #endif
 815         /* Initialise USB process messages */
 816         bus->explore_msg[0].hdr.pm_callback = &usb_bus_explore;
 817         bus->explore_msg[0].bus = bus;
 818         bus->explore_msg[1].hdr.pm_callback = &usb_bus_explore;
 819         bus->explore_msg[1].bus = bus;
 820
 821         bus->detach_msg[0].hdr.pm_callback = &usb_bus_detach;
 822         bus->detach_msg[0].bus = bus;
 823         bus->detach_msg[1].hdr.pm_callback = &usb_bus_detach;
 824         bus->detach_msg[1].bus = bus;
 825
 826         bus->attach_msg[0].hdr.pm_callback = &usb_bus_attach;
 827         bus->attach_msg[0].bus = bus;
 828         bus->attach_msg[1].hdr.pm_callback = &usb_bus_attach;
 829         bus->attach_msg[1].bus = bus;
 830
 831         bus->suspend_msg[0].hdr.pm_callback = &usb_bus_suspend;
 832         bus->suspend_msg[0].bus = bus;
 833         bus->suspend_msg[1].hdr.pm_callback = &usb_bus_suspend;
 834         bus->suspend_msg[1].bus = bus;
 835
 836         bus->resume_msg[0].hdr.pm_callback = &usb_bus_resume;
 837         bus->resume_msg[0].bus = bus;
 838         bus->resume_msg[1].hdr.pm_callback = &usb_bus_resume;
 839         bus->resume_msg[1].bus = bus;
 840
 841         bus->reset_msg[0].hdr.pm_callback = &usb_bus_reset;
 842         bus->reset_msg[0].bus = bus;
 843         bus->reset_msg[1].hdr.pm_callback = &usb_bus_reset;
 844         bus->reset_msg[1].bus = bus;
 845
 846         bus->shutdown_msg[0].hdr.pm_callback = &usb_bus_shutdown;
 847         bus->shutdown_msg[0].bus = bus;
 848         bus->shutdown_msg[1].hdr.pm_callback = &usb_bus_shutdown;
 849         bus->shutdown_msg[1].bus = bus;
 850
 851 #if USB_HAVE_UGEN
 852         LIST_INIT(&bus->pd_cleanup_list);
 853         bus->cleanup_msg[0].hdr.pm_callback = &usb_bus_cleanup;
 854         bus->cleanup_msg[0].bus = bus;
 855         bus->cleanup_msg[1].hdr.pm_callback = &usb_bus_cleanup;
 856         bus->cleanup_msg[1].bus = bus;
 857 #endif
 858
 859 #if USB_HAVE_PER_BUS_PROCESS
 860         /* Create USB explore and callback processes */
 861
 862         if (usb_proc_create(USB_BUS_GIANT_PROC(bus),
 863             &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_MED)) {
 864                 device_printf(dev, "WARNING: Creation of USB Giant "
 865                     "callback process failed.\n");
 866         } else if (usb_proc_create(USB_BUS_NON_GIANT_ISOC_PROC(bus),
 867             &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_HIGHEST)) {
 868                 device_printf(dev, "WARNING: Creation of USB non-Giant ISOC "
 869                     "callback process failed.\n");
 870         } else if (usb_proc_create(USB_BUS_NON_GIANT_BULK_PROC(bus),
 871             &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_HIGH)) {
 872                 device_printf(dev, "WARNING: Creation of USB non-Giant BULK "
 873                     "callback process failed.\n");
 874         } else if (usb_proc_create(USB_BUS_EXPLORE_PROC(bus),
 875             &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_MED)) {
 876                 device_printf(dev, "WARNING: Creation of USB explore "
 877                     "process failed.\n");
 878         } else if (usb_proc_create(USB_BUS_CONTROL_XFER_PROC(bus),
 879             &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_MED)) {
 880                 device_printf(dev, "WARNING: Creation of USB control transfer "
 881                     "process failed.\n");
 882         } else
 883 #endif
 884         {
 885                 /* Get final attach going */
 886                 USB_BUS_LOCK(bus);
 887                 usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
 888                     &bus->attach_msg[0], &bus->attach_msg[1]);
 889                 USB_BUS_UNLOCK(bus);
 890
 891                 /* Do initial explore */
 892                 usb_needs_explore(bus, 1);
 893         }
 894 }
 895 SYSUNINIT(usb_bus_unload, SI_SUB_KLD, SI_ORDER_ANY, usb_bus_unload, NULL);
 896
 897 /*------------------------------------------------------------------------*
 898  *      usb_bus_mem_flush_all_cb
 899  *------------------------------------------------------------------------*/
 900 #if USB_HAVE_BUSDMA
 901 static void
 902 usb_bus_mem_flush_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
 903     struct usb_page *pg, usb_size_t size, usb_size_t align)
 904 {
 905         usb_pc_cpu_flush(pc);
 906 }
 907 #endif
 908
 909 /*------------------------------------------------------------------------*
 910  *      usb_bus_mem_flush_all - factored out code
 911  *------------------------------------------------------------------------*/
 912 #if USB_HAVE_BUSDMA
 913 void
 914 usb_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb)
 915 {
 916         if (cb) {
 917                 cb(bus, &usb_bus_mem_flush_all_cb);
 918         }
 919 }
 920 #endif
 921
 922 /*------------------------------------------------------------------------*
 923  *      usb_bus_mem_alloc_all_cb
 924  *------------------------------------------------------------------------*/
 925 #if USB_HAVE_BUSDMA
 926 static void
 927 usb_bus_mem_alloc_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
 928     struct usb_page *pg, usb_size_t size, usb_size_t align)
 929 {
 930         /* need to initialize the page cache */
 931         pc->tag_parent = bus->dma_parent_tag;
 932
 933         if (usb_pc_alloc_mem(pc, pg, size, align)) {
 934                 bus->alloc_failed = 1;
 935         }
 936 }
 937 #endif
 938
 939 /*------------------------------------------------------------------------*
 940  *      usb_bus_mem_alloc_all - factored out code
 941  *
 942  * Returns:
 943  *    0: Success
 944  * Else: Failure
 945  *------------------------------------------------------------------------*/
 946 uint8_t
 947 usb_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat,
 948     usb_bus_mem_cb_t *cb)
 949 {
 950         bus->alloc_failed = 0;
 951
 952         mtx_init(&bus->bus_mtx, device_get_nameunit(bus->parent),
 953             "usb_def_mtx", MTX_DEF | MTX_RECURSE);
 954
 955         mtx_init(&bus->bus_spin_lock, device_get_nameunit(bus->parent),
 956             "usb_spin_mtx", MTX_SPIN | MTX_RECURSE);
 957
 958         usb_callout_init_mtx(&bus->power_wdog,
 959             &bus->bus_mtx, 0);
 960
 961         TAILQ_INIT(&bus->intr_q.head);
 962
 963 #if USB_HAVE_BUSDMA
 964         usb_dma_tag_setup(bus->dma_parent_tag, bus->dma_tags,
 965             dmat, &bus->bus_mtx, NULL, bus->dma_bits, USB_BUS_DMA_TAG_MAX);
 966 #endif
 967         if ((bus->devices_max > USB_MAX_DEVICES) ||
 968             (bus->devices_max < USB_MIN_DEVICES) ||
 969             (bus->devices == NULL)) {
 970                 DPRINTFN(0, "Devices field has not been "
 971                     "initialised properly\n");
 972                 bus->alloc_failed = 1;          /* failure */
 973         }
 974 #if USB_HAVE_BUSDMA
 975         if (cb) {
 976                 cb(bus, &usb_bus_mem_alloc_all_cb);
 977         }
 978 #endif
 979         if (bus->alloc_failed) {
 980                 usb_bus_mem_free_all(bus, cb);
 981         }
 982         return (bus->alloc_failed);
 983 }
 984
 985 /*------------------------------------------------------------------------*
 986  *      usb_bus_mem_free_all_cb
 987  *------------------------------------------------------------------------*/
 988 #if USB_HAVE_BUSDMA
 989 static void
 990 usb_bus_mem_free_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
 991     struct usb_page *pg, usb_size_t size, usb_size_t align)
 992 {
 993         usb_pc_free_mem(pc);
 994 }
 995 #endif
 996
 997 /*------------------------------------------------------------------------*
 998  *      usb_bus_mem_free_all - factored out code
 999  *------------------------------------------------------------------------*/
1000 void
1001 usb_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb)
1002 {
1003 #if USB_HAVE_BUSDMA
1004         if (cb) {
1005                 cb(bus, &usb_bus_mem_free_all_cb);
1006         }
1007         usb_dma_tag_unsetup(bus->dma_parent_tag);
1008 #endif
1009
1010         mtx_destroy(&bus->bus_mtx);
1011         mtx_destroy(&bus->bus_spin_lock);
1012 }
1013
1014 /* convenience wrappers */
1015 void
1016 usb_proc_explore_mwait(struct usb_device *udev, void *pm1, void *pm2)
1017 {
1018         usb_proc_mwait(USB_BUS_EXPLORE_PROC(udev->bus), pm1, pm2);
1019 }
1020
1021 void    *
1022 usb_proc_explore_msignal(struct usb_device *udev, void *pm1, void *pm2)
1023 {
1024         return (usb_proc_msignal(USB_BUS_EXPLORE_PROC(udev->bus), pm1, pm2));
1025 }
1026
1027 void
1028 usb_proc_explore_lock(struct usb_device *udev)
1029 {
1030         USB_BUS_LOCK(udev->bus);
1031 }
1032
1033 void
1034 usb_proc_explore_unlock(struct usb_device *udev)
1035 {
1036         USB_BUS_UNLOCK(udev->bus);
1037 }