sys/bus/usb/usb.c

   1 /*
   2  * $NetBSD: usb.c,v 1.68 2002/02/20 20:30:12 christos Exp $
   3  * $FreeBSD: src/sys/dev/usb/usb.c,v 1.106 2005/03/27 15:31:23 iedowse Exp $
   4  */
   5
   6 /* Also already merged from NetBSD:
   7  *      $NetBSD: usb.c,v 1.70 2002/05/09 21:54:32 augustss Exp $
   8  *      $NetBSD: usb.c,v 1.71 2002/06/01 23:51:04 lukem Exp $
   9  *      $NetBSD: usb.c,v 1.73 2002/09/23 05:51:19 simonb Exp $
  10  *      $NetBSD: usb.c,v 1.80 2003/11/07 17:03:25 wiz Exp $
  11  */
  12
  13 /*
  14  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  15  * All rights reserved.
  16  *
  17  * This code is derived from software contributed to The NetBSD Foundation
  18  * by Lennart Augustsson (lennart@augustsson.net) at
  19  * Carlstedt Research & Technology.
  20  *
  21  * Redistribution and use in source and binary forms, with or without
  22  * modification, are permitted provided that the following conditions
  23  * are met:
  24  * 1. Redistributions of source code must retain the above copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  * 2. Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in the
  28  *    documentation and/or other materials provided with the distribution.
  29  * 3. All advertising materials mentioning features or use of this software
  30  *    must display the following acknowledgement:
  31  *        This product includes software developed by the NetBSD
  32  *        Foundation, Inc. and its contributors.
  33  * 4. Neither the name of The NetBSD Foundation nor the names of its
  34  *    contributors may be used to endorse or promote products derived
  35  *    from this software without specific prior written permission.
  36  *
  37  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  38  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  39  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  40  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  41  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  42  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  43  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  44  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  45  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  47  * POSSIBILITY OF SUCH DAMAGE.
  48  */
  49
  50 /*
  51  * USB specifications and other documentation can be found at
  52  * http://www.usb.org/developers/docs/ and
  53  * http://www.usb.org/developers/devclass_docs/
  54  */
  55
  56 #include <sys/param.h>
  57 #include <sys/systm.h>
  58 #include <sys/kernel.h>
  59 #include <sys/lock.h>
  60 #include <sys/malloc.h>
  61 #include <sys/unistd.h>
  62 #include <sys/module.h>
  63 #include <sys/bus.h>
  64 #include <sys/fcntl.h>
  65 #include <sys/filio.h>
  66 #include <sys/uio.h>
  67 #include <sys/kthread.h>
  68 #include <sys/proc.h>
  69 #include <sys/conf.h>
  70 #include <sys/device.h>
  71 #include <sys/event.h>
  72 #include <sys/vnode.h>
  73 #include <sys/signalvar.h>
  74 #include <sys/sysctl.h>
  75
  76 #include <sys/thread2.h>
  77 #include <sys/mplock2.h>
  78
  79 #include <bus/usb/usb.h>
  80 #include <bus/usb/usbdi.h>
  81 #include <bus/usb/usbdi_util.h>
  82
  83 #define USBUNIT(d)      (minor(d))      /* usb_discover device nodes, kthread */
  84 #define USB_DEV_MINOR   255             /* event queue device */
  85
  86 MALLOC_DEFINE(M_USB, "USB", "USB");
  87 MALLOC_DEFINE(M_USBDEV, "USBdev", "USB device");
  88 MALLOC_DEFINE(M_USBHC, "USBHC", "USB host controller");
  89
  90 #include "usb_if.h"
  91
  92 #include <bus/usb/usbdivar.h>
  93 #include <bus/usb/usb_quirks.h>
  94
  95 /* Define this unconditionally in case a kernel module is loaded that
  96  * has been compiled with debugging options.
  97  */
  98 SYSCTL_NODE(_hw, OID_AUTO, usb, CTLFLAG_RW, 0, "USB debugging");
  99
 100 /*
 101  * XXX: This is a hack! If your USB keyboard doesn't work
 102  * early at boot, try setting this tunable to 0 from
 103  * bootleader:
 104  *
 105  *      set hw.usb.hack_defer_exploration=0
 106  */
 107 static int      hack_defer_exploration = 1;
 108
 109 #ifdef USB_DEBUG
 110 #define DPRINTF(x)      if (usbdebug) kprintf x
 111 #define DPRINTFN(n,x)   if (usbdebug>(n)) kprintf x
 112 int     usbdebug = 0;
 113 SYSCTL_INT(_hw_usb, OID_AUTO, debug, CTLFLAG_RW,
 114            &usbdebug, 0, "usb debug level");
 115
 116 /*
 117  * 0  - do usual exploration
 118  * 1  - do not use timeout exploration
 119  * >1 - do no exploration
 120  */
 121 int     usb_noexplore = 0;
 122 #else
 123 #define DPRINTF(x)
 124 #define DPRINTFN(n,x)
 125 #endif
 126
 127 struct usb_softc {
 128         cdev_t          sc_usbdev;
 129         TAILQ_ENTRY(usb_softc) sc_coldexplist; /* cold needs-explore list */
 130         usbd_bus_handle sc_bus;         /* USB controller */
 131         struct usbd_port sc_port;       /* dummy port for root hub */
 132
 133         struct thread   *sc_event_thread;
 134
 135         char            sc_dying;
 136 };
 137
 138 struct usb_taskq {
 139         TAILQ_HEAD(, usb_task)  tasks;
 140         struct thread           *task_thread_proc;
 141         const char              *name;
 142         int                     taskcreated;    /* task thread exists. */
 143 };
 144 static struct usb_taskq usb_taskq[USB_NUM_TASKQS];
 145
 146 d_open_t  usbopen;
 147 d_close_t usbclose;
 148 d_read_t usbread;
 149 d_ioctl_t usbioctl;
 150 d_kqfilter_t usbkqfilter;
 151
 152 static void usbfilt_detach(struct knote *);
 153 static int usbfilt(struct knote *, long);
 154
 155 static struct dev_ops usb_ops = {
 156         { "usb", 0, 0 },
 157         .d_open =       usbopen,
 158         .d_close =      usbclose,
 159         .d_read =       usbread,
 160         .d_ioctl =      usbioctl,
 161         .d_kqfilter =   usbkqfilter
 162 };
 163
 164 static void     usb_discover(device_t);
 165 static bus_child_detached_t usb_child_detached;
 166 static void     usb_create_event_thread(device_t);
 167 static void     usb_event_thread(void *);
 168 static void     usb_task_thread(void *);
 169
 170 static cdev_t usb_dev;          /* The /dev/usb device. */
 171 static int usb_ndevs;           /* Number of /dev/usbN devices. */
 172 /* Busses to explore at the end of boot-time device configuration */
 173 static TAILQ_HEAD(, usb_softc) usb_coldexplist =
 174     TAILQ_HEAD_INITIALIZER(usb_coldexplist);
 175
 176 #define USB_MAX_EVENTS 100
 177 struct usb_event_q {
 178         struct usb_event ue;
 179         TAILQ_ENTRY(usb_event_q) next;
 180 };
 181 static TAILQ_HEAD(, usb_event_q) usb_events =
 182         TAILQ_HEAD_INITIALIZER(usb_events);
 183 static int usb_nevents = 0;
 184 static struct kqinfo usb_kqevent;
 185 static struct proc *usb_async_proc;  /* process that wants USB SIGIO */
 186 static int usb_dev_open = 0;
 187 static void usb_add_event(int, struct usb_event *);
 188
 189 static int usb_get_next_event(struct usb_event *);
 190
 191 static const char *usbrev_str[] = USBREV_STR;
 192
 193 static device_probe_t usb_match;
 194 static device_attach_t usb_attach;
 195 static device_detach_t usb_detach;
 196
 197 static devclass_t usb_devclass;
 198
 199 static kobj_method_t usb_methods[] = {
 200         DEVMETHOD(device_probe, usb_match),
 201         DEVMETHOD(device_attach, usb_attach),
 202         DEVMETHOD(device_detach, usb_detach),
 203         DEVMETHOD(bus_child_detached, usb_child_detached),
 204         DEVMETHOD(device_suspend, bus_generic_suspend),
 205         DEVMETHOD(device_resume, bus_generic_resume),
 206         DEVMETHOD(device_shutdown, bus_generic_shutdown),
 207         {0,0}
 208 };
 209
 210 static driver_t usb_driver = {
 211         "usb",
 212         usb_methods,
 213         sizeof(struct usb_softc)
 214 };
 215
 216 MODULE_DEPEND(usb, usb, 1, 1, 1);
 217 MODULE_VERSION(usb, 1);
 218
 219 static int
 220 usb_match(device_t self)
 221 {
 222         DPRINTF(("usb_match\n"));
 223         return (UMATCH_GENERIC);
 224 }
 225
 226 static int
 227 usb_attach(device_t self)
 228 {
 229         struct usb_softc *sc = device_get_softc(self);
 230         void *aux = device_get_ivars(self);
 231         cdev_t tmp_dev;
 232         usbd_device_handle dev;
 233         usbd_status err;
 234         int usbrev;
 235         int speed;
 236         struct usb_event ue;
 237
 238         TUNABLE_INT_FETCH("hw.usb.hack_defer_exploration",
 239             &hack_defer_exploration);
 240
 241         DPRINTF(("usb_attach\n"));
 242
 243         usbd_init();
 244         sc->sc_bus = aux;
 245         sc->sc_bus->usbctl = sc;
 246         sc->sc_port.power = USB_MAX_POWER;
 247
 248         usbrev = sc->sc_bus->usbrev;
 249         device_printf(self, "USB revision %s", usbrev_str[usbrev]);
 250         switch (usbrev) {
 251         case USBREV_1_0:
 252         case USBREV_1_1:
 253                 speed = USB_SPEED_FULL;
 254                 break;
 255         case USBREV_2_0:
 256                 speed = USB_SPEED_HIGH;
 257                 break;
 258         default:
 259                 kprintf(", not supported\n");
 260                 sc->sc_dying = 1;
 261                 return ENXIO;
 262         }
 263         kprintf("\n");
 264
 265         /* Make sure not to use tsleep() if we are cold booting. */
 266         if (hack_defer_exploration && cold)
 267                 sc->sc_bus->use_polling++;
 268
 269         ue.u.ue_ctrlr.ue_bus = device_get_unit(self);
 270         usb_add_event(USB_EVENT_CTRLR_ATTACH, &ue);
 271
 272 #ifdef USB_USE_SOFTINTR
 273         callout_init(&sc->sc_bus->softi);
 274 #endif
 275
 276         err = usbd_new_device(self, sc->sc_bus, 0, speed, 0, &sc->sc_port);
 277         if (!err) {
 278                 dev = sc->sc_port.device;
 279                 if (dev->hub == NULL) {
 280                         sc->sc_dying = 1;
 281                         device_printf(self,
 282                             "root device is not a hub\n");
 283                         return ENXIO;
 284                 }
 285                 sc->sc_bus->root_hub = dev;
 286 #if 1
 287                 /*
 288                  * Turning this code off will delay attachment of USB devices
 289                  * until the USB event thread is running, which means that
 290                  * the keyboard will not work until after cold boot.
 291                  */
 292                 if (cold) {
 293                         if (hack_defer_exploration) {
 294                                 /* Explore high-speed busses before others. */
 295                                 if (speed == USB_SPEED_HIGH)
 296                                         dev->hub->explore(sc->sc_bus->root_hub);
 297                                 else
 298                                         TAILQ_INSERT_TAIL(&usb_coldexplist, sc,
 299                                             sc_coldexplist);
 300                         } else {
 301                                 /*
 302                                  * XXX Exploring high speed devices here will
 303                                  * hang the system.
 304                                  */
 305                                 if (speed != USB_SPEED_HIGH)
 306                                         dev->hub->explore(sc->sc_bus->root_hub);
 307                         }
 308                 }
 309 #endif
 310         } else {
 311                 device_printf(self,
 312                     "root hub problem, error=%d\n", err);
 313                 sc->sc_dying = 1;
 314         }
 315         if (hack_defer_exploration && cold)
 316                 sc->sc_bus->use_polling--;
 317
 318         usb_create_event_thread(self);
 319
 320         /*
 321          * The per controller devices (used for usb_discover)
 322          * XXX This is redundant now, but old usbd's will want it
 323          */
 324         tmp_dev = make_dev(&usb_ops, device_get_unit(self),
 325                            UID_ROOT, GID_OPERATOR, 0660,
 326                            "usb%d", device_get_unit(self));
 327         sc->sc_usbdev = reference_dev(tmp_dev);
 328         if (usb_ndevs++ == 0) {
 329                 /* The device spitting out events */
 330                 tmp_dev = make_dev(&usb_ops, USB_DEV_MINOR,
 331                                    UID_ROOT, GID_OPERATOR, 0660, "usb");
 332                 usb_dev = reference_dev(tmp_dev);
 333         }
 334
 335         return 0;
 336 }
 337
 338 static const char *taskq_names[] = USB_TASKQ_NAMES;
 339
 340 void
 341 usb_create_event_thread(device_t self)
 342 {
 343         struct usb_softc *sc = device_get_softc(self);
 344         int i;
 345
 346         if (kthread_create(usb_event_thread, self, &sc->sc_event_thread,
 347                            "%s", device_get_nameunit(self))) {
 348                 device_printf(self,
 349                     "unable to create event thread for\n");
 350                 panic("usb_create_event_thread");
 351         }
 352
 353         for (i = 0; i < USB_NUM_TASKQS; i++) {
 354                 struct usb_taskq *taskq = &usb_taskq[i];
 355
 356                 if (taskq->taskcreated == 0) {
 357                         taskq->taskcreated = 1;
 358                         taskq->name = taskq_names[i];
 359                         TAILQ_INIT(&taskq->tasks);
 360                         if (kthread_create(usb_task_thread, taskq,
 361                             &taskq->task_thread_proc, taskq->name)) {
 362                                 kprintf("unable to create task thread\n");
 363                                 panic("usb_create_event_thread task");
 364                         }
 365                 }
 366         }
 367 }
 368
 369 /*
 370  * Add a task to be performed by the task thread.  This function can be
 371  * called from any context and the task will be executed in a process
 372  * context ASAP.
 373  */
 374 void
 375 usb_add_task(usbd_device_handle dev, struct usb_task *task, int queue)
 376 {
 377         struct usb_taskq *taskq;
 378
 379         crit_enter();
 380
 381         taskq = &usb_taskq[queue];
 382         if (task->queue == -1) {
 383                 DPRINTFN(2,("usb_add_task: task=%p\n", task));
 384                 TAILQ_INSERT_TAIL(&taskq->tasks, task, next);
 385                 task->queue = queue;
 386         } else {
 387                 DPRINTFN(3,("usb_add_task: task=%p on q\n", task));
 388         }
 389         wakeup(&taskq->tasks);
 390
 391         crit_exit();
 392 }
 393
 394 void
 395 usb_do_task(usbd_device_handle dev, struct usb_task *task, int queue,
 396             int time_out)
 397 {
 398         struct usb_taskq *taskq;
 399
 400         crit_enter();
 401
 402         taskq = &usb_taskq[queue];
 403         if (task->queue == -1) {
 404                 DPRINTFN(2,("usb_add_task: task=%p\n", task));
 405                 TAILQ_INSERT_TAIL(&taskq->tasks, task, next);
 406                 task->queue = queue;
 407         } else {
 408                 DPRINTFN(3,("usb_add_task: task=%p on q\n", task));
 409         }
 410         wakeup(&taskq->tasks);
 411
 412         /* Wait until task is finished */
 413         tsleep((&taskq->tasks + 1), 0, "usbdotsk", time_out);
 414
 415         crit_exit();
 416 }
 417
 418 void
 419 usb_rem_task(usbd_device_handle dev, struct usb_task *task)
 420 {
 421         crit_enter();
 422         if (task->queue != -1) {
 423                 TAILQ_REMOVE(&usb_taskq[task->queue].tasks, task, next);
 424                 task->queue = -1;
 425         }
 426         crit_exit();
 427 }
 428
 429 void
 430 usb_event_thread(void *arg)
 431 {
 432         device_t self = arg;
 433         struct usb_softc *sc = device_get_softc(self);
 434
 435         DPRINTF(("usb_event_thread: start\n"));
 436
 437         /*
 438          * In case this controller is a companion controller to an
 439          * EHCI controller we need to wait until the EHCI controller
 440          * has grabbed the port.
 441          * XXX It would be nicer to do this with a tsleep(), but I don't
 442          * know how to synchronize the creation of the threads so it
 443          * will work.
 444          */
 445         usb_delay_ms(sc->sc_bus, 500);
 446
 447         get_mplock();
 448         crit_enter();
 449
 450         /* Make sure first discover does something. */
 451         sc->sc_bus->needs_explore = 1;
 452         usb_discover(self);
 453
 454         while (!sc->sc_dying) {
 455 #ifdef USB_DEBUG
 456                 if (usb_noexplore < 2)
 457 #endif
 458                 usb_discover(self);
 459 #ifdef USB_DEBUG
 460                 tsleep(&sc->sc_bus->needs_explore, 0, "usbevt",
 461                        usb_noexplore ? 0 : hz * 60);
 462 #else
 463                 tsleep(&sc->sc_bus->needs_explore, 0, "usbevt", hz * 60);
 464 #endif
 465                 DPRINTFN(2,("usb_event_thread: woke up\n"));
 466         }
 467         sc->sc_event_thread = NULL;
 468
 469         crit_exit();
 470         rel_mplock();
 471
 472         /* In case parent is waiting for us to exit. */
 473         wakeup(sc);
 474
 475         DPRINTF(("usb_event_thread: exit\n"));
 476 }
 477
 478 void
 479 usb_task_thread(void *arg)
 480 {
 481         struct usb_task *task;
 482         struct usb_taskq *taskq;
 483
 484         get_mplock();
 485         crit_enter();
 486
 487         taskq = arg;
 488         DPRINTF(("usb_task_thread: start taskq %s\n", taskq->name));
 489
 490         while (usb_ndevs > 0) {
 491                 task = TAILQ_FIRST(&taskq->tasks);
 492                 if (task == NULL) {
 493                         tsleep(&taskq->tasks, 0, "usbtsk", 0);
 494                         task = TAILQ_FIRST(&taskq->tasks);
 495                 }
 496                 DPRINTFN(2,("usb_task_thread: woke up task=%p\n", task));
 497                 if (task != NULL) {
 498                         TAILQ_REMOVE(&taskq->tasks, task, next);
 499                         task->queue = -1;
 500                         crit_exit();
 501                         task->fun(task->arg);
 502                         crit_enter();
 503                         wakeup((&taskq->tasks + 1));
 504                 }
 505         }
 506
 507         crit_exit();
 508         rel_mplock();
 509
 510         taskq->taskcreated = 0;
 511         wakeup(&taskq->taskcreated);
 512
 513         DPRINTF(("usb_event_thread: exit\n"));
 514 }
 515
 516 int
 517 usbopen(struct dev_open_args *ap)
 518 {
 519         cdev_t dev = ap->a_head.a_dev;
 520         int unit = USBUNIT(dev);
 521         struct usb_softc *sc;
 522
 523         if (unit == USB_DEV_MINOR) {
 524                 if (usb_dev_open)
 525                         return (EBUSY);
 526                 usb_dev_open = 1;
 527                 usb_async_proc = NULL;
 528                 return (0);
 529         }
 530
 531         sc = devclass_get_softc(usb_devclass, unit);
 532         if (sc == NULL)
 533                 return (ENXIO);
 534
 535         if (sc->sc_dying)
 536                 return (EIO);
 537
 538         return (0);
 539 }
 540
 541 int
 542 usbread(struct dev_read_args *ap)
 543 {
 544         cdev_t dev = ap->a_head.a_dev;
 545         struct uio *uio = ap->a_uio;
 546         struct usb_event ue;
 547         int unit = USBUNIT(dev);
 548         int error, n;
 549
 550         if (unit != USB_DEV_MINOR)
 551                 return (ENODEV);
 552
 553         if (uio->uio_resid != sizeof(struct usb_event))
 554                 return (EINVAL);
 555
 556         error = 0;
 557         crit_enter();
 558         for (;;) {
 559                 n = usb_get_next_event(&ue);
 560                 if (n != 0)
 561                         break;
 562                 if (ap->a_ioflag & IO_NDELAY) {
 563                         error = EWOULDBLOCK;
 564                         break;
 565                 }
 566                 error = tsleep(&usb_events, PCATCH, "usbrea", 0);
 567                 if (error)
 568                         break;
 569         }
 570         crit_exit();
 571         if (!error)
 572                 error = uiomove((void *)&ue, uio->uio_resid, uio);
 573
 574         return (error);
 575 }
 576
 577 int
 578 usbclose(struct dev_close_args *ap)
 579 {
 580         cdev_t dev = ap->a_head.a_dev;
 581         int unit = USBUNIT(dev);
 582
 583         if (unit == USB_DEV_MINOR) {
 584                 usb_async_proc = NULL;
 585                 usb_dev_open = 0;
 586         }
 587
 588         return (0);
 589 }
 590
 591 int
 592 usbioctl(struct dev_ioctl_args *ap)
 593 {
 594         cdev_t devt = ap->a_head.a_dev;
 595         struct usb_softc *sc;
 596         int unit = USBUNIT(devt);
 597
 598         if (unit == USB_DEV_MINOR) {
 599                 switch (ap->a_cmd) {
 600                 case FIOASYNC:
 601                         if (*(int *)ap->a_data)
 602                                 usb_async_proc = curproc;
 603                         else
 604                                 usb_async_proc = NULL;
 605                         return (0);
 606
 607                 default:
 608                         return (EINVAL);
 609                 }
 610         }
 611
 612         sc = devclass_get_softc(usb_devclass, unit);
 613
 614         if (sc->sc_dying)
 615                 return (EIO);
 616
 617         switch (ap->a_cmd) {
 618         /* This part should be deleted */
 619         case USB_DISCOVER:
 620                 break;
 621         case USB_REQUEST:
 622         {
 623                 struct usb_ctl_request *ur = (void *)ap->a_data;
 624                 size_t len = UGETW(ur->ucr_request.wLength);
 625                 struct iovec iov;
 626                 struct uio uio;
 627                 void *ptr = NULL;
 628                 int addr = ur->ucr_addr;
 629                 usbd_status err;
 630                 int error = 0;
 631
 632                 DPRINTF(("usbioctl: USB_REQUEST addr=%d len=%zu\n", addr, len));
 633                 if (len > 32768)
 634                         return (EINVAL);
 635                 if (addr < 0 || addr >= USB_MAX_DEVICES ||
 636                     sc->sc_bus->devices[addr] == 0)
 637                         return (EINVAL);
 638                 if (len != 0) {
 639                         iov.iov_base = (caddr_t)ur->ucr_data;
 640                         iov.iov_len = len;
 641                         uio.uio_iov = &iov;
 642                         uio.uio_iovcnt = 1;
 643                         uio.uio_resid = len;
 644                         uio.uio_offset = 0;
 645                         uio.uio_segflg = UIO_USERSPACE;
 646                         uio.uio_rw =
 647                                 ur->ucr_request.bmRequestType & UT_READ ?
 648                                 UIO_READ : UIO_WRITE;
 649                         uio.uio_td = curthread;
 650                         ptr = kmalloc(len, M_TEMP, M_WAITOK);
 651                         if (uio.uio_rw == UIO_WRITE) {
 652                                 error = uiomove(ptr, len, &uio);
 653                                 if (error)
 654                                         goto ret;
 655                         }
 656                 }
 657                 err = usbd_do_request_flags(sc->sc_bus->devices[addr],
 658                           &ur->ucr_request, ptr, ur->ucr_flags, &ur->ucr_actlen,
 659                           USBD_DEFAULT_TIMEOUT);
 660                 if (err) {
 661                         error = EIO;
 662                         goto ret;
 663                 }
 664                 if (len != 0) {
 665                         if (uio.uio_rw == UIO_READ) {
 666                                 error = uiomove(ptr, len, &uio);
 667                                 if (error)
 668                                         goto ret;
 669                         }
 670                 }
 671         ret:
 672                 if (ptr)
 673                         kfree(ptr, M_TEMP);
 674                 return (error);
 675         }
 676
 677         case USB_DEVICEINFO:
 678         {
 679                 struct usb_device_info *di = (void *)ap->a_data;
 680                 int addr = di->udi_addr;
 681                 usbd_device_handle dev;
 682
 683                 if (addr < 1 || addr >= USB_MAX_DEVICES)
 684                         return (EINVAL);
 685                 dev = sc->sc_bus->devices[addr];
 686                 if (dev == NULL)
 687                         return (ENXIO);
 688                 usbd_fill_deviceinfo(dev, di, 1);
 689                 break;
 690         }
 691
 692         case USB_DEVICESTATS:
 693                 *(struct usb_device_stats *)ap->a_data = sc->sc_bus->stats;
 694                 break;
 695
 696         default:
 697                 return (EINVAL);
 698         }
 699         return (0);
 700 }
 701
 702 static struct filterops usbfiltops =
 703         { FILTEROP_ISFD, NULL, usbfilt_detach, usbfilt };
 704
 705 int
 706 usbkqfilter(struct dev_kqfilter_args *ap)
 707 {
 708         cdev_t dev = ap->a_head.a_dev;
 709         struct knote *kn = ap->a_kn;
 710         struct klist *klist;
 711
 712         ap->a_result = 0;
 713
 714         switch (kn->kn_filter) {
 715         case EVFILT_READ:
 716                 kn->kn_fop = &usbfiltops;
 717                 kn->kn_hook = (caddr_t)dev;
 718                 break;
 719         default:
 720                 ap->a_result = EOPNOTSUPP;
 721                 return (0);
 722         }
 723
 724         klist = &usb_kqevent.ki_note;
 725         knote_insert(klist, kn);
 726
 727         return (0);
 728 }
 729
 730 static void
 731 usbfilt_detach(struct knote *kn)
 732 {
 733         struct klist *klist;
 734
 735         klist = &usb_kqevent.ki_note;
 736         knote_remove(klist, kn);
 737 }
 738
 739 static int
 740 usbfilt(struct knote *kn, long hint)
 741 {
 742         cdev_t dev = (cdev_t)kn->kn_hook;
 743         int unit = USBUNIT(dev);
 744         int ready = 0;
 745
 746         if (unit == USB_DEV_MINOR) {
 747                 crit_enter();
 748                 if (usb_nevents > 0)
 749                         ready = 1;
 750                 crit_exit();
 751         }
 752
 753         return (ready);
 754 }
 755
 756 /* Explore device tree from the root. */
 757 static void
 758 usb_discover(device_t self)
 759 {
 760         struct usb_softc *sc = device_get_softc(self);
 761
 762         DPRINTFN(2,("usb_discover\n"));
 763 #ifdef USB_DEBUG
 764         if (usb_noexplore > 1)
 765                 return;
 766 #endif
 767
 768         /*
 769          * We need mutual exclusion while traversing the device tree,
 770          * but this is guaranteed since this function is only called
 771          * from the event thread for the controller.
 772          */
 773         crit_enter();
 774         while (sc->sc_bus->needs_explore && !sc->sc_dying) {
 775                 sc->sc_bus->needs_explore = 0;
 776
 777                 crit_exit();
 778                 sc->sc_bus->root_hub->hub->explore(sc->sc_bus->root_hub);
 779                 crit_enter();
 780
 781         }
 782         crit_exit();
 783 }
 784
 785 void
 786 usb_needs_explore(usbd_device_handle dev)
 787 {
 788         DPRINTFN(2,("usb_needs_explore\n"));
 789         dev->bus->needs_explore = 1;
 790         wakeup(&dev->bus->needs_explore);
 791 }
 792
 793 /* Called from a critical section */
 794 int
 795 usb_get_next_event(struct usb_event *ue)
 796 {
 797         struct usb_event_q *ueq;
 798
 799         if (usb_nevents <= 0)
 800                 return (0);
 801         ueq = TAILQ_FIRST(&usb_events);
 802 #ifdef DIAGNOSTIC
 803         if (ueq == NULL) {
 804                 kprintf("usb: usb_nevents got out of sync! %d\n", usb_nevents);
 805                 usb_nevents = 0;
 806                 return (0);
 807         }
 808 #endif
 809         if (ue)
 810                 *ue = ueq->ue;
 811         TAILQ_REMOVE(&usb_events, ueq, next);
 812         kfree(ueq, M_USBDEV);
 813         usb_nevents--;
 814         return (1);
 815 }
 816
 817 void
 818 usbd_add_dev_event(int type, usbd_device_handle udev)
 819 {
 820         struct usb_event ue;
 821
 822         usbd_fill_deviceinfo(udev, &ue.u.ue_device, USB_EVENT_IS_ATTACH(type));
 823         usb_add_event(type, &ue);
 824 }
 825
 826 void
 827 usbd_add_drv_event(int type, usbd_device_handle udev, device_t dev)
 828 {
 829         struct usb_event ue;
 830
 831         ue.u.ue_driver.ue_cookie = udev->cookie;
 832         strncpy(ue.u.ue_driver.ue_devname, device_get_nameunit(dev),
 833                 sizeof ue.u.ue_driver.ue_devname);
 834         usb_add_event(type, &ue);
 835 }
 836
 837 void
 838 usb_add_event(int type, struct usb_event *uep)
 839 {
 840         struct usb_event_q *ueq;
 841         struct timeval thetime;
 842
 843         ueq = kmalloc(sizeof *ueq, M_USBDEV, M_INTWAIT);
 844         ueq->ue = *uep;
 845         ueq->ue.ue_type = type;
 846         microtime(&thetime);
 847         TIMEVAL_TO_TIMESPEC(&thetime, &ueq->ue.ue_time);
 848
 849         crit_enter();
 850         if (USB_EVENT_IS_DETACH(type)) {
 851                 struct usb_event_q *ueqi, *ueqi_next;
 852
 853                 for (ueqi = TAILQ_FIRST(&usb_events); ueqi; ueqi = ueqi_next) {
 854                         ueqi_next = TAILQ_NEXT(ueqi, next);
 855                         if (ueqi->ue.u.ue_driver.ue_cookie.cookie ==
 856                             uep->u.ue_device.udi_cookie.cookie) {
 857                                 TAILQ_REMOVE(&usb_events, ueqi, next);
 858                                 kfree(ueqi, M_USBDEV);
 859                                 usb_nevents--;
 860                                 ueqi_next = TAILQ_FIRST(&usb_events);
 861                         }
 862                 }
 863         }
 864         if (usb_nevents >= USB_MAX_EVENTS) {
 865                 /* Too many queued events, drop an old one. */
 866                 DPRINTF(("usb: event dropped\n"));
 867                 usb_get_next_event(NULL);
 868         }
 869         TAILQ_INSERT_TAIL(&usb_events, ueq, next);
 870         usb_nevents++;
 871         wakeup(&usb_events);
 872         KNOTE(&usb_kqevent.ki_note, 0);
 873         if (usb_async_proc != NULL) {
 874                 ksignal(usb_async_proc, SIGIO);
 875         }
 876         crit_exit();
 877 }
 878
 879 void
 880 usb_schedsoftintr(usbd_bus_handle bus)
 881 {
 882         DPRINTFN(10,("usb_schedsoftintr: polling=%d\n", bus->use_polling));
 883 #ifdef USB_USE_SOFTINTR
 884         if (bus->use_polling) {
 885                 bus->methods->soft_intr(bus);
 886         } else {
 887                 if (!callout_pending(&bus->softi))
 888                         callout_reset(&bus->softi, 0, bus->methods->soft_intr,
 889                             bus);
 890         }
 891 #else
 892        bus->methods->soft_intr(bus);
 893 #endif /* USB_USE_SOFTINTR */
 894 }
 895
 896 static int
 897 usb_detach(device_t self)
 898 {
 899         struct usb_softc *sc = device_get_softc(self);
 900         struct usb_event ue;
 901
 902         DPRINTF(("usb_detach: start\n"));
 903
 904         sc->sc_dying = 1;
 905
 906         /* Make all devices disconnect. */
 907         if (sc->sc_port.device != NULL)
 908                 usb_disconnect_port(&sc->sc_port, self);
 909
 910         /* Kill off event thread. */
 911         if (sc->sc_event_thread != NULL) {
 912                 wakeup(&sc->sc_bus->needs_explore);
 913                 if (tsleep(sc, 0, "usbdet", hz * 60))
 914                         device_printf(self,
 915                             "event thread didn't die\n");
 916                 DPRINTF(("usb_detach: event thread dead\n"));
 917         }
 918
 919         release_dev(sc->sc_usbdev);
 920
 921         if (--usb_ndevs == 0) {
 922                 int i;
 923
 924                 release_dev(usb_dev);
 925                 dev_ops_remove_minor(&usb_ops, USB_DEV_MINOR);
 926                 usb_dev = NULL;
 927
 928                 for (i = 0; i < USB_NUM_TASKQS; i++) {
 929                         struct usb_taskq *taskq = &usb_taskq[i];
 930                         wakeup(&taskq->tasks);
 931                         if (tsleep(&taskq->taskcreated, 0, "usbtdt",
 932                             hz * 60)) {
 933                                 kprintf("usb task thread %s didn't die\n",
 934                                     taskq->name);
 935                         }
 936                 }
 937         }
 938
 939         usbd_finish();
 940
 941 #ifdef USB_USE_SOFTINTR
 942         callout_stop(&sc->sc_bus->softi);
 943 #endif
 944
 945         ue.u.ue_ctrlr.ue_bus = device_get_unit(self);
 946         usb_add_event(USB_EVENT_CTRLR_DETACH, &ue);
 947
 948         return (0);
 949 }
 950
 951 static void
 952 usb_child_detached(device_t self, device_t child)
 953 {
 954         struct usb_softc *sc = device_get_softc(self);
 955
 956         /* XXX, should check it is the right device. */
 957         sc->sc_port.device = NULL;
 958 }
 959
 960 /* Explore USB busses at the end of device configuration */
 961 static void
 962 usb_cold_explore(void *arg)
 963 {
 964         struct usb_softc *sc;
 965
 966         TUNABLE_INT_FETCH("hw.usb.hack_defer_exploration",
 967             &hack_defer_exploration);
 968
 969         if (!hack_defer_exploration)
 970                 return;
 971
 972         KASSERT(cold || TAILQ_EMPTY(&usb_coldexplist),
 973             ("usb_cold_explore: busses to explore when !cold"));
 974         while (!TAILQ_EMPTY(&usb_coldexplist)) {
 975                 sc = TAILQ_FIRST(&usb_coldexplist);
 976                 TAILQ_REMOVE(&usb_coldexplist, sc, sc_coldexplist);
 977
 978                 sc->sc_bus->use_polling++;
 979                 sc->sc_port.device->hub->explore(sc->sc_bus->root_hub);
 980                 sc->sc_bus->use_polling--;
 981         }
 982 }
 983
 984 struct usbd_bus *
 985 usb_getbushandle(struct usb_softc *sc)
 986 {
 987         return (sc->sc_bus);
 988 }
 989
 990
 991 SYSINIT(usb_cold_explore, SI_SUB_CONFIGURE, SI_ORDER_MIDDLE,
 992     usb_cold_explore, NULL);
 993
 994 DRIVER_MODULE(usb, ohci, usb_driver, usb_devclass, NULL, NULL);
 995 DRIVER_MODULE(usb, uhci, usb_driver, usb_devclass, NULL, NULL);
 996 DRIVER_MODULE(usb, ehci, usb_driver, usb_devclass, NULL, NULL);