sys/dev/usb/controller/usb_controller.c

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