root/dev/usb/usb.c

DEFINITIONS

1. usb_match
2. usb_attach
3. usb_create_event_thread
4. usb_add_task
5. usb_rem_task
6. usb_event_thread
7. usb_task_thread
8. usbctlprint
9. usbopen
10. usbread
11. usbclose
12. usbioctl
13. usbpoll
14. filt_usbrdetach
15. filt_usbread
16. usbkqfilter
17. usb_discover
18. usb_needs_explore
19. usb_needs_reattach
20. usb_get_next_event
21. usbd_add_dev_event
22. usbd_add_drv_event
23. usb_add_event
24. usb_schedsoftintr
25. usb_activate
26. usb_detach

    1 /*      $OpenBSD: usb.c,v 1.56 2007/06/15 11:41:48 mbalmer Exp $        */
    2 /*      $NetBSD: usb.c,v 1.77 2003/01/01 00:10:26 thorpej Exp $ */
    4 /*
    5  * Copyright (c) 1998, 2002 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Lennart Augustsson (lennart@augustsson.net) at
   10  * Carlstedt Research & Technology.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. All advertising materials mentioning features or use of this software
   21  *    must display the following acknowledgement:
   22  *        This product includes software developed by the NetBSD
   23  *        Foundation, Inc. and its contributors.
   24  * 4. Neither the name of The NetBSD Foundation nor the names of its
   25  *    contributors may be used to endorse or promote products derived
   26  *    from this software without specific prior written permission.
   27  *
   28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   38  * POSSIBILITY OF SUCH DAMAGE.
   39  */
   41 /*
   42  * USB specifications and other documentation can be found at
   43  * http://www.usb.org/developers/docs/ and
   44  * http://www.usb.org/developers/devclass_docs/
   45  */
   47 #include "ohci.h"
   48 #include "uhci.h"
   50 #include <sys/param.h>
   51 #include <sys/systm.h>
   52 #include <sys/kernel.h>
   53 #include <sys/malloc.h>
   54 #include <sys/device.h>
   55 #include <sys/kthread.h>
   56 #include <sys/proc.h>
   57 #include <sys/conf.h>
   58 #include <sys/fcntl.h>
   59 #include <sys/poll.h>
   60 #include <sys/selinfo.h>
   61 #include <sys/vnode.h>
   62 #include <sys/signalvar.h>
   64 #include <dev/usb/usb.h>
   65 #include <dev/usb/usbdi.h>
   66 #include <dev/usb/usbdi_util.h>
   68 #define USB_DEV_MINOR 255
   70 #include <machine/bus.h>
   72 #include <dev/usb/usbdivar.h>
   73 #include <dev/usb/usb_quirks.h>
   75 #ifdef USB_DEBUG
   76 #define DPRINTF(x)      do { if (usbdebug) printf x; } while (0)
   77 #define DPRINTFN(n,x)   do { if (usbdebug>(n)) printf x; } while (0)
   78 int     usbdebug = 0;
   79 #if defined(UHCI_DEBUG) && NUHCI > 0
   80 extern int      uhcidebug;
   81 #endif
   82 #if defined(OHCI_DEBUG) && NOHCI > 0
   83 extern int      ohcidebug;
   84 #endif
   85 /*
   86  * 0  - do usual exploration
   87  * 1  - do not use timeout exploration
   88  * >1 - do no exploration
   89  */
   90 int     usb_noexplore = 0;
   91 #else
   92 #define DPRINTF(x)
   93 #define DPRINTFN(n,x)
   94 #endif
   96 struct usb_softc {
   97         struct device    sc_dev;        /* base device */
usbd_bus_handle  sc_bus;        /* USB controller */
   99         struct usbd_port sc_port;       /* dummy port for root hub */
  101         struct proc     *sc_event_thread;
  103         char             sc_dying;
  104 };
TAILQ_HEAD(, usb_task) usb_all_tasks;
  108 volatile int threads_pending = 0;
  110 void    usb_discover(void *);
  111 void    usb_create_event_thread(void *);
  112 void    usb_event_thread(void *);
  113 void    usb_task_thread(void *);
  114 struct proc *usb_task_thread_proc = NULL;
  116 #define USB_MAX_EVENTS 100
  117 struct usb_event_q {
  118         struct usb_event ue;
SIMPLEQ_ENTRY(usb_event_q) next;
  120 };
SIMPLEQ_HEAD(, usb_event_q) usb_events =
SIMPLEQ_HEAD_INITIALIZER(usb_events);
  123 int usb_nevents = 0;
  124 struct selinfo usb_selevent;
  125 struct proc *usb_async_proc;  /* process that wants USB SIGIO */
  126 int usb_dev_open = 0;
  127 void usb_add_event(int, struct usb_event *);
  129 int usb_get_next_event(struct usb_event *);
  131 const char *usbrev_str[] = USBREV_STR;
  133 int usb_match(struct device *, void *, void *); 
  134 void usb_attach(struct device *, struct device *, void *); 
  135 int usb_detach(struct device *, int); 
  136 int usb_activate(struct device *, enum devact); 
  138 struct cfdriver usb_cd = { 
NULL, "usb", DV_DULL 
  140 }; 
  142 const struct cfattach usb_ca = { 
  143         sizeof(struct usb_softc), 
usb_match, 
usb_attach, 
usb_detach, 
usb_activate, 
  148 };
  150 int
usb_match(struct device *parent, void *match, void *aux)
  152 {
DPRINTF(("usbd_match\n"));
  154         return (UMATCH_GENERIC);
  155 }
  157 void
usb_attach(struct device *parent, struct device *self, void *aux)
  159 {
  160         struct usb_softc *sc = (struct usb_softc *)self;
usbd_device_handle dev;
usbd_status err;
  163         int usbrev;
  164         int speed;
  165         struct usb_event ue;
DPRINTF(("usbd_attach\n"));
usbd_init();
sc->sc_bus = aux;
sc->sc_bus->usbctl = sc;
sc->sc_port.power = USB_MAX_POWER;
usbrev = sc->sc_bus->usbrev;
printf(": USB revision %s", usbrev_str[usbrev]);
  176         switch (usbrev) {
  177         case USBREV_1_0:
  178         case USBREV_1_1:
speed = USB_SPEED_FULL;
  180                 break;
  181         case USBREV_2_0:
speed = USB_SPEED_HIGH;
  183                 break;
  184         default:
printf(", not supported\n");
sc->sc_dying = 1;
  187                 return;
  188         }
printf("\n");
  191         /* Make sure not to use tsleep() if we are cold booting. */
  192         if (cold)
sc->sc_bus->use_polling++;
ue.u.ue_ctrlr.ue_bus = sc->sc_dev.dv_unit;
usb_add_event(USB_EVENT_CTRLR_ATTACH, &ue);
  198 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
  199         /* XXX we should have our own level */
sc->sc_bus->soft = softintr_establish(IPL_SOFTNET,
sc->sc_bus->methods->soft_intr, sc->sc_bus);
  202         if (sc->sc_bus->soft == NULL) {
printf("%s: can't register softintr\n", sc->sc_dev.dv_xname);
sc->sc_dying = 1;
  205                 return;
  206         }
  207 #endif
err = usbd_new_device(&sc->sc_dev, sc->sc_bus, 0, speed, 0,
  210                   &sc->sc_port);
  211         if (!err) {
dev = sc->sc_port.device;
  213                 if (dev->hub == NULL) {
sc->sc_dying = 1;
printf("%s: root device is not a hub\n",
sc->sc_dev.dv_xname);
  217                         return;
  218                 }
sc->sc_bus->root_hub = dev;
  220 #if 1
  221                 /*
  222                  * Turning this code off will delay attachment of USB devices
  223                  * until the USB event thread is running, which means that
  224                  * the keyboard will not work until after cold boot.
  225                  */
  226                 if (cold && (sc->sc_dev.dv_cfdata->cf_flags & 1))
dev->hub->explore(sc->sc_bus->root_hub);
  228 #endif
  229         } else {
printf("%s: root hub problem, error=%d\n",
sc->sc_dev.dv_xname, err);
sc->sc_dying = 1;
  233         }
  234         if (cold)
sc->sc_bus->use_polling--;
config_pending_incr();
kthread_create_deferred(usb_create_event_thread, sc);
  239 }
  241 void
usb_create_event_thread(void *arg)
  243 {
  244         struct usb_softc *sc = arg;
  245         static int created = 0;
  247         if (sc->sc_bus->usbrev == USBREV_2_0)
threads_pending++;
  250         if (kthread_create(usb_event_thread, sc, &sc->sc_event_thread,
  251             "%s", sc->sc_dev.dv_xname))
panic("unable to create event thread for %s",
sc->sc_dev.dv_xname);
  255         if (!created) {
created = 1;
TAILQ_INIT(&usb_all_tasks);
  258                 if (kthread_create(usb_task_thread, NULL,
  259                     &usb_task_thread_proc, "usbtask"))
panic("unable to create usb task thread");
  261         }
  262 }
  264 /*
  265  * Add a task to be performed by the task thread.  This function can be
  266  * called from any context and the task will be executed in a process
  267  * context ASAP.
  268  */
  269 void
usb_add_task(usbd_device_handle dev, struct usb_task *task)
  271 {
  272         int s;
s = splusb();
  275         if (!task->onqueue) {
DPRINTFN(2,("usb_add_task: task=%p\n", task));
TAILQ_INSERT_TAIL(&usb_all_tasks, task, next);
task->onqueue = 1;
  279         } else {
DPRINTFN(3,("usb_add_task: task=%p on q\n", task));
  281         }
wakeup(&usb_all_tasks);
splx(s);
  284 }
  286 void
usb_rem_task(usbd_device_handle dev, struct usb_task *task)
  288 {
  289         int s;
s = splusb();
  292         if (task->onqueue) {
TAILQ_REMOVE(&usb_all_tasks, task, next);
task->onqueue = 0;
  295         }
splx(s);
  297 }
  299 void
usb_event_thread(void *arg)
  301 {
  302         struct usb_softc *sc = arg;
  303         int pwrdly;
DPRINTF(("usb_event_thread: start\n"));
  307         /* Wait for power to come good. */
pwrdly = sc->sc_bus->root_hub->hub->hubdesc.bPwrOn2PwrGood * 
UHD_PWRON_FACTOR + USB_EXTRA_POWER_UP_TIME;
usb_delay_ms(sc->sc_bus, pwrdly);
  312         /* USB1 threads wait for USB2 threads to finish their first probe. */
  313         while (sc->sc_bus->usbrev != USBREV_2_0 && threads_pending)
  314                 (void)tsleep((void *)&threads_pending, PWAIT, "config", 0);
  316         /* Make sure first discover does something. */
sc->sc_bus->needs_explore = 1;
usb_discover(sc);
config_pending_decr();
  321         /* Wake up any companions waiting for handover before their probes. */
  322         if (sc->sc_bus->usbrev == USBREV_2_0) {
threads_pending--;
wakeup((void *)&threads_pending);
  325         }
  327         while (!sc->sc_dying) {
  328 #ifdef USB_DEBUG
  329                 if (usb_noexplore < 2)
  330 #endif
usb_discover(sc);
  332 #ifdef USB_DEBUG
  333                 (void)tsleep(&sc->sc_bus->needs_explore, PWAIT, "usbevt",
usb_noexplore ? 0 : hz * 60);
  335 #else
  336                 (void)tsleep(&sc->sc_bus->needs_explore, PWAIT, "usbevt",
hz * 60);
  338 #endif
DPRINTFN(2,("usb_event_thread: woke up\n"));
  340         }
sc->sc_event_thread = NULL;
  343         /* In case parent is waiting for us to exit. */
wakeup(sc);
DPRINTF(("usb_event_thread: exit\n"));
kthread_exit(0);
  348 }
  350 void
usb_task_thread(void *arg)
  352 {
  353         struct usb_task *task;
  354         int s;
DPRINTF(("usb_task_thread: start\n"));
s = splusb();
  359         for (;;) {
task = TAILQ_FIRST(&usb_all_tasks);
  361                 if (task == NULL) {
tsleep(&usb_all_tasks, PWAIT, "usbtsk", 0);
task = TAILQ_FIRST(&usb_all_tasks);
  364                 }
DPRINTFN(2,("usb_task_thread: woke up task=%p\n", task));
  366                 if (task != NULL) {
TAILQ_REMOVE(&usb_all_tasks, task, next);
task->onqueue = 0;
splx(s);
task->fun(task->arg);
s = splusb();
  372                 }
  373         }
  374 }
  376 int
usbctlprint(void *aux, const char *pnp)
  378 {
  379         /* only "usb"es can attach to host controllers */
  380         if (pnp)
printf("usb at %s", pnp);
  383         return (UNCONF);
  384 }
  386 int
  387 usbopen(dev_t dev, int flag, int mode, struct proc *p)
  388 {
  389         int unit = minor(dev);
  390         struct usb_softc *sc;
  392         if (unit == USB_DEV_MINOR) {
  393                 if (usb_dev_open)
  394                         return (EBUSY);
usb_dev_open = 1;
usb_async_proc = 0;
  397                 return (0);
  398         }
  400         if (unit >= usb_cd.cd_ndevs)
  401                 return (ENXIO);
sc = usb_cd.cd_devs[unit];
  403         if (sc == NULL)
  404                 return (ENXIO);
  406         if (sc->sc_dying)
  407                 return (EIO);
  409         return (0);
  410 }
  412 int
  413 usbread(dev_t dev, struct uio *uio, int flag)
  414 {
  415         struct usb_event ue;
  416         int s, error, n;
  418         if (minor(dev) != USB_DEV_MINOR)
  419                 return (ENXIO);
  421         if (uio->uio_resid != sizeof(struct usb_event))
  422                 return (EINVAL);
error = 0;
s = splusb();
  426         for (;;) {
n = usb_get_next_event(&ue);
  428                 if (n != 0)
  429                         break;
  430                 if (flag & IO_NDELAY) {
error = EWOULDBLOCK;
  432                         break;
  433                 }
error = tsleep(&usb_events, PZERO | PCATCH, "usbrea", 0);
  435                 if (error)
  436                         break;
  437         }
splx(s);
  439         if (!error)
error = uiomove((void *)&ue, uio->uio_resid, uio);
  442         return (error);
  443 }
  445 int
  446 usbclose(dev_t dev, int flag, int mode, struct proc *p)
  447 {
  448         int unit = minor(dev);
  450         if (unit == USB_DEV_MINOR) {
usb_async_proc = 0;
usb_dev_open = 0;
  453         }
  455         return (0);
  456 }
  458 int
  459 usbioctl(dev_t devt, u_long cmd, caddr_t data, int flag, struct proc *p)
  460 {
  461         struct usb_softc *sc;
  462         int unit = minor(devt);
  464         if (unit == USB_DEV_MINOR) {
  465                 switch (cmd) {
  466                 case FIONBIO:
  467                         /* All handled in the upper FS layer. */
  468                         return (0);
  470                 case FIOASYNC:
  471                         if (*(int *)data)
usb_async_proc = p;
  473                         else
usb_async_proc = 0;
  475                         return (0);
  477                 default:
  478                         return (EINVAL);
  479                 }
  480         }
sc = usb_cd.cd_devs[unit];
  484         if (sc->sc_dying)
  485                 return (EIO);
  487         switch (cmd) {
  488 #ifdef USB_DEBUG
  489         case USB_SETDEBUG:
  490                 if (!(flag & FWRITE))
  491                         return (EBADF);
usbdebug  = ((*(int *)data) & 0x000000ff);
  493 #if defined(UHCI_DEBUG) && NUHCI > 0
uhcidebug = ((*(int *)data) & 0x0000ff00) >> 8;
  495 #endif
  496 #if defined(OHCI_DEBUG) && NOHCI > 0
ohcidebug = ((*(int *)data) & 0x00ff0000) >> 16;
  498 #endif
  499                 break;
  500 #endif /* USB_DEBUG */
  501         case USB_REQUEST:
  502         {
  503                 struct usb_ctl_request *ur = (void *)data;
  504                 int len = UGETW(ur->ucr_request.wLength);
  505                 struct iovec iov;
  506                 struct uio uio;
  507                 void *ptr = 0;
  508                 int addr = ur->ucr_addr;
usbd_status err;
  510                 int error = 0;
  512                 if (!(flag & FWRITE))
  513                         return (EBADF);
DPRINTF(("usbioctl: USB_REQUEST addr=%d len=%d\n", addr, len));
  516                 if (len < 0 || len > 32768)
  517                         return (EINVAL);
  518                 if (addr < 0 || addr >= USB_MAX_DEVICES ||
sc->sc_bus->devices[addr] == 0)
  520                         return (EINVAL);
  521                 if (len != 0) {
iov.iov_base = (caddr_t)ur->ucr_data;
iov.iov_len = len;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_resid = len;
uio.uio_offset = 0;
uio.uio_segflg = UIO_USERSPACE;
uio.uio_rw =
ur->ucr_request.bmRequestType & UT_READ ?
UIO_READ : UIO_WRITE;
uio.uio_procp = p;
ptr = malloc(len, M_TEMP, M_WAITOK);
  534                         if (uio.uio_rw == UIO_WRITE) {
error = uiomove(ptr, len, &uio);
  536                                 if (error)
  537                                         goto ret;
  538                         }
  539                 }
err = usbd_do_request_flags(sc->sc_bus->devices[addr],
  541                           &ur->ucr_request, ptr, ur->ucr_flags,
  542                           &ur->ucr_actlen, USBD_DEFAULT_TIMEOUT);
  543                 if (err) {
error = EIO;
  545                         goto ret;
  546                 }
  547                 if (len != 0) {
  548                         if (uio.uio_rw == UIO_READ) {
error = uiomove(ptr, len, &uio);
  550                                 if (error)
  551                                         goto ret;
  552                         }
  553                 }
ret:
  555                 if (ptr)
free(ptr, M_TEMP);
  557                 return (error);
  558         }
  560         case USB_DEVICEINFO:
  561         {
  562                 struct usb_device_info *di = (void *)data;
  563                 int addr = di->udi_addr;
usbd_device_handle dev;
  566                 if (addr < 1 || addr >= USB_MAX_DEVICES)
  567                         return (EINVAL);
dev = sc->sc_bus->devices[addr];
  569                 if (dev == NULL)
  570                         return (ENXIO);
usbd_fill_deviceinfo(dev, di, 1);
  572                 break;
  573         }
  575         case USB_DEVICESTATS:
  576                 *(struct usb_device_stats *)data = sc->sc_bus->stats;
  577                 break;
  579         default:
  580                 return (EINVAL);
  581         }
  582         return (0);
  583 }
  585 int
  586 usbpoll(dev_t dev, int events, struct proc *p)
  587 {
  588         int revents, mask, s;
  590         if (minor(dev) == USB_DEV_MINOR) {
revents = 0;
mask = POLLIN | POLLRDNORM;
s = splusb();
  595                 if (events & mask && usb_nevents > 0)
revents |= events & mask;
  597                 if (revents == 0 && events & mask)
selrecord(p, &usb_selevent);
splx(s);
  601                 return (revents);
  602         } else {
  603                 return (POLLERR);
  604         }
  605 }
  607 void filt_usbrdetach(struct knote *);
  608 int filt_usbread(struct knote *, long);
  609 int usbkqfilter(dev_t, struct knote *);
  611 void
filt_usbrdetach(struct knote *kn)
  613 {
  614         int s;
s = splusb();
SLIST_REMOVE(&usb_selevent.si_note, kn, knote, kn_selnext);
splx(s);
  619 }
  621 int
filt_usbread(struct knote *kn, long hint)
  623 {
  625         if (usb_nevents == 0)
  626                 return (0);
kn->kn_data = sizeof(struct usb_event);
  629         return (1);
  630 }
  632 struct filterops usbread_filtops =
  633         { 1, NULL, filt_usbrdetach, filt_usbread };
  635 int
usbkqfilter(dev_t dev, struct knote *kn)
  637 {
  638         struct klist *klist;
  639         int s;
  641         switch (kn->kn_filter) {
  642         case EVFILT_READ:
  643                 if (minor(dev) != USB_DEV_MINOR)
  644                         return (1);
klist = &usb_selevent.si_note;
kn->kn_fop = &usbread_filtops;
  647                 break;
  649         default:
  650                 return (1);
  651         }
kn->kn_hook = NULL;
s = splusb();
SLIST_INSERT_HEAD(klist, kn, kn_selnext);
splx(s);
  659         return (0);
  660 }
  662 /* Explore device tree from the root. */
  663 void
usb_discover(void *v)
  665 {
  666         struct usb_softc *sc = v;
DPRINTFN(2,("usb_discover\n"));
  669 #ifdef USB_DEBUG
  670         if (usb_noexplore > 1)
  671                 return;
  672 #endif
  673         /*
  674          * We need mutual exclusion while traversing the device tree,
  675          * but this is guaranteed since this function is only called
  676          * from the event thread for the controller.
  677          */
  678         while (sc->sc_bus->needs_explore && !sc->sc_dying) {
sc->sc_bus->needs_explore = 0;
sc->sc_bus->root_hub->hub->explore(sc->sc_bus->root_hub);
  681         }
  682 }
  684 void
usb_needs_explore(usbd_device_handle dev)
  686 {
DPRINTFN(2,("usb_needs_explore\n"));
dev->bus->needs_explore = 1;
wakeup(&dev->bus->needs_explore);
  690 }
  692 void
usb_needs_reattach(usbd_device_handle dev)
  694 {
DPRINTFN(2,("usb_needs_reattach\n"));
dev->powersrc->reattach = 1;
dev->bus->needs_explore = 1;
wakeup(&dev->bus->needs_explore);
  699 }
  701 /* Called at splusb() */
  702 int
usb_get_next_event(struct usb_event *ue)
  704 {
  705         struct usb_event_q *ueq;
  707         if (usb_nevents <= 0)
  708                 return (0);
ueq = SIMPLEQ_FIRST(&usb_events);
  710 #ifdef DIAGNOSTIC
  711         if (ueq == NULL) {
printf("usb: usb_nevents got out of sync! %d\n", usb_nevents);
usb_nevents = 0;
  714                 return (0);
  715         }
  716 #endif
  717         *ue = ueq->ue;
SIMPLEQ_REMOVE_HEAD(&usb_events, next);
free(ueq, M_USBDEV);
usb_nevents--;
  721         return (1);
  722 }
  724 void
usbd_add_dev_event(int type, usbd_device_handle udev)
  726 {
  727         struct usb_event ue;
usbd_fill_deviceinfo(udev, &ue.u.ue_device, USB_EVENT_IS_ATTACH(type));
usb_add_event(type, &ue);
  731 }
  733 void
usbd_add_drv_event(int type, usbd_device_handle udev, struct device *dev)
  735 {
  736         struct usb_event ue;
ue.u.ue_driver.ue_cookie = udev->cookie;
strncpy(ue.u.ue_driver.ue_devname, dev->dv_xname,
  740             sizeof ue.u.ue_driver.ue_devname);
usb_add_event(type, &ue);
  742 }
  744 void
usb_add_event(int type, struct usb_event *uep)
  746 {
  747         struct usb_event_q *ueq;
  748         struct usb_event ue;
  749         struct timespec thetime;
  750         int s;
nanotime(&thetime);
  753         /* Don't want to wait here inside splusb() */
ueq = malloc(sizeof *ueq, M_USBDEV, M_WAITOK);
ueq->ue = *uep;
ueq->ue.ue_type = type;
ueq->ue.ue_time = thetime;
s = splusb();
  760         if (++usb_nevents >= USB_MAX_EVENTS) {
  761                 /* Too many queued events, drop an old one. */
DPRINTFN(-1,("usb: event dropped\n"));
  763                 (void)usb_get_next_event(&ue);
  764         }
SIMPLEQ_INSERT_TAIL(&usb_events, ueq, next);
wakeup(&usb_events);
selwakeup(&usb_selevent);
  768         if (usb_async_proc != NULL)
psignal(usb_async_proc, SIGIO);
splx(s);
  771 }
  773 void
usb_schedsoftintr(usbd_bus_handle bus)
  775 {
DPRINTFN(10,("usb_schedsoftintr: polling=%d\n", bus->use_polling));
  777 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
  778         if (bus->use_polling) {
bus->methods->soft_intr(bus);
  780         } else {
softintr_schedule(bus->soft);
  782         }
  783 #else
bus->methods->soft_intr(bus);
  785 #endif /* __HAVE_GENERIC_SOFT_INTERRUPTS */
  786 }
  788 int
usb_activate(struct device *self, enum devact act)
  790 {
  791         struct usb_softc *sc = (struct usb_softc *)self;
usbd_device_handle dev = sc->sc_port.device;
  793         int i, rv = 0;
  795         switch (act) {
  796         case DVACT_ACTIVATE:
  797                 break;
  799         case DVACT_DEACTIVATE:
sc->sc_dying = 1;
  801                 if (dev != NULL && dev->cdesc != NULL &&
dev->subdevs != NULL) {
  803                         for (i = 0; dev->subdevs[i]; i++)
rv |= config_deactivate(dev->subdevs[i]);
  805                 }
  806                 break;
  807         }
  808         return (rv);
  809 }
  811 int
usb_detach(struct device *self, int flags)
  813 {
  814         struct usb_softc *sc = (struct usb_softc *)self;
  815         struct usb_event ue;
DPRINTF(("usb_detach: start\n"));
sc->sc_dying = 1;
  821         /* Make all devices disconnect. */
  822         if (sc->sc_port.device != NULL)
usb_disconnect_port(&sc->sc_port, self);
  825         /* Kill off event thread. */
  826         if (sc->sc_event_thread != NULL) {
wakeup(&sc->sc_bus->needs_explore);
  828                 if (tsleep(sc, PWAIT, "usbdet", hz * 60))
printf("%s: event thread didn't die\n",
sc->sc_dev.dv_xname);
DPRINTF(("usb_detach: event thread dead\n"));
  832         }
usbd_finish();
  836 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
  837         if (sc->sc_bus->soft != NULL) {
softintr_disestablish(sc->sc_bus->soft);
sc->sc_bus->soft = NULL;
  840         }
  841 #endif
ue.u.ue_ctrlr.ue_bus = sc->sc_dev.dv_unit;
usb_add_event(USB_EVENT_CTRLR_DETACH, &ue);
  846         return (0);
  847 }