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