1/* $NetBSD: usb.c,v 1.164 2016/08/14 14:42:22 skrll Exp $ */
2
3/*
4 * Copyright (c) 1998, 2002, 2008, 2012 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart@augustsson.net) at
9 * Carlstedt Research & Technology and Matthew R. Green (mrg@eterna.com.au).
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33/*
34 * USB specifications and other documentation can be found at
35 * http://www.usb.org/developers/docs/ and
36 * http://www.usb.org/developers/devclass_docs/
37 */
38
39#include <sys/cdefs.h>
40__KERNEL_RCSID(0, "$NetBSD: usb.c,v 1.164 2016/08/14 14:42:22 skrll Exp $");
41
42#ifdef _KERNEL_OPT
43#include "opt_usb.h"
44#include "opt_compat_netbsd.h"
45#endif
46
47#include <sys/param.h>
48#include <sys/systm.h>
49#include <sys/kernel.h>
50#include <sys/kmem.h>
51#include <sys/device.h>
52#include <sys/kthread.h>
53#include <sys/proc.h>
54#include <sys/conf.h>
55#include <sys/fcntl.h>
56#include <sys/poll.h>
57#include <sys/select.h>
58#include <sys/vnode.h>
59#include <sys/signalvar.h>
60#include <sys/intr.h>
61#include <sys/module.h>
62#include <sys/mutex.h>
63#include <sys/bus.h>
64#include <sys/once.h>
65#include <sys/atomic.h>
66#include <sys/sysctl.h>
67
68#include <dev/usb/usb.h>
69#include <dev/usb/usbdi.h>
70#include <dev/usb/usbdi_util.h>
71#include <dev/usb/usbdivar.h>
72#include <dev/usb/usb_verbose.h>
73#include <dev/usb/usb_quirks.h>
74#include <dev/usb/usbhist.h>
75
76#if defined(USB_DEBUG)
77
78#ifndef USBHIST_SIZE
79#define USBHIST_SIZE 50000
80#endif
81
82static struct kern_history_ent usbhistbuf[USBHIST_SIZE];
83USBHIST_DEFINE(usbhist) = KERNHIST_INITIALIZER(usbhist, usbhistbuf);
84
85#endif
86
87#define USB_DEV_MINOR 255
88
89#ifdef USB_DEBUG
90/*
91 * 0 - do usual exploration
92 * 1 - do not use timeout exploration
93 * >1 - do no exploration
94 */
95int usb_noexplore = 0;
96
97int usbdebug = 0;
98SYSCTL_SETUP(sysctl_hw_usb_setup, "sysctl hw.usb setup")
99{
100 int err;
101 const struct sysctlnode *rnode;
102 const struct sysctlnode *cnode;
103
104 err = sysctl_createv(clog, 0, NULL, &rnode,
105 CTLFLAG_PERMANENT, CTLTYPE_NODE, "usb",
106 SYSCTL_DESCR("usb global controls"),
107 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL);
108
109 if (err)
110 goto fail;
111
112 /* control debugging printfs */
113 err = sysctl_createv(clog, 0, &rnode, &cnode,
114 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
115 "debug", SYSCTL_DESCR("Enable debugging output"),
116 NULL, 0, &usbdebug, sizeof(usbdebug), CTL_CREATE, CTL_EOL);
117 if (err)
118 goto fail;
119
120 return;
121fail:
122 aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
123}
124#else
125#define usb_noexplore 0
126#endif
127
128#define DPRINTF(FMT,A,B,C,D) USBHIST_LOG(usbdebug,FMT,A,B,C,D)
129#define DPRINTFN(N,FMT,A,B,C,D) USBHIST_LOGN(usbdebug,N,FMT,A,B,C,D)
130
131struct usb_softc {
132#if 0
133 device_t sc_dev; /* base device */
134#endif
135 struct usbd_bus *sc_bus; /* USB controller */
136 struct usbd_port sc_port; /* dummy port for root hub */
137
138 struct lwp *sc_event_thread;
139
140 char sc_dying;
141};
142
143struct usb_taskq {
144 TAILQ_HEAD(, usb_task) tasks;
145 kmutex_t lock;
146 kcondvar_t cv;
147 struct lwp *task_thread_lwp;
148 const char *name;
149};
150
151static struct usb_taskq usb_taskq[USB_NUM_TASKQS];
152
153dev_type_open(usbopen);
154dev_type_close(usbclose);
155dev_type_read(usbread);
156dev_type_ioctl(usbioctl);
157dev_type_poll(usbpoll);
158dev_type_kqfilter(usbkqfilter);
159
160const struct cdevsw usb_cdevsw = {
161 .d_open = usbopen,
162 .d_close = usbclose,
163 .d_read = usbread,
164 .d_write = nowrite,
165 .d_ioctl = usbioctl,
166 .d_stop = nostop,
167 .d_tty = notty,
168 .d_poll = usbpoll,
169 .d_mmap = nommap,
170 .d_kqfilter = usbkqfilter,
171 .d_discard = nodiscard,
172 .d_flag = D_OTHER
173};
174
175Static void usb_discover(struct usb_softc *);
176Static void usb_create_event_thread(device_t);
177Static void usb_event_thread(void *);
178Static void usb_task_thread(void *);
179
180#define USB_MAX_EVENTS 100
181struct usb_event_q {
182 struct usb_event ue;
183 SIMPLEQ_ENTRY(usb_event_q) next;
184};
185Static SIMPLEQ_HEAD(, usb_event_q) usb_events =
186 SIMPLEQ_HEAD_INITIALIZER(usb_events);
187Static int usb_nevents = 0;
188Static struct selinfo usb_selevent;
189Static kmutex_t usb_event_lock;
190Static kcondvar_t usb_event_cv;
191Static proc_t *usb_async_proc; /* process that wants USB SIGIO */
192Static void *usb_async_sih;
193Static int usb_dev_open = 0;
194Static struct usb_event *usb_alloc_event(void);
195Static void usb_free_event(struct usb_event *);
196Static void usb_add_event(int, struct usb_event *);
197Static int usb_get_next_event(struct usb_event *);
198Static void usb_async_intr(void *);
199Static void usb_soft_intr(void *);
200
201#ifdef COMPAT_30
202Static void usb_copy_old_devinfo(struct usb_device_info_old *, const struct usb_device_info *);
203#endif
204
205Static const char *usbrev_str[] = USBREV_STR;
206
207static int usb_match(device_t, cfdata_t, void *);
208static void usb_attach(device_t, device_t, void *);
209static int usb_detach(device_t, int);
210static int usb_activate(device_t, enum devact);
211static void usb_childdet(device_t, device_t);
212static int usb_once_init(void);
213static void usb_doattach(device_t);
214
215extern struct cfdriver usb_cd;
216
217CFATTACH_DECL3_NEW(usb, sizeof(struct usb_softc),
218 usb_match, usb_attach, usb_detach, usb_activate, NULL, usb_childdet,
219 DVF_DETACH_SHUTDOWN);
220
221static const char *taskq_names[] = USB_TASKQ_NAMES;
222
223int
224usb_match(device_t parent, cfdata_t match, void *aux)
225{
226 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
227
228 return UMATCH_GENERIC;
229}
230
231void
232usb_attach(device_t parent, device_t self, void *aux)
233{
234 static ONCE_DECL(init_control);
235 struct usb_softc *sc = device_private(self);
236 int usbrev;
237
238 sc->sc_bus = aux;
239 usbrev = sc->sc_bus->ub_revision;
240
241 aprint_naive("\n");
242 aprint_normal(": USB revision %s", usbrev_str[usbrev]);
243 switch (usbrev) {
244 case USBREV_1_0:
245 case USBREV_1_1:
246 case USBREV_2_0:
247 case USBREV_3_0:
248 break;
249 default:
250 aprint_error(", not supported\n");
251 sc->sc_dying = 1;
252 return;
253 }
254 aprint_normal("\n");
255
256 /* XXX we should have our own level */
257 sc->sc_bus->ub_soft = softint_establish(SOFTINT_USB | SOFTINT_MPSAFE,
258 usb_soft_intr, sc->sc_bus);
259 if (sc->sc_bus->ub_soft == NULL) {
260 aprint_error("%s: can't register softintr\n",
261 device_xname(self));
262 sc->sc_dying = 1;
263 return;
264 }
265
266 sc->sc_bus->ub_methods->ubm_getlock(sc->sc_bus, &sc->sc_bus->ub_lock);
267 KASSERT(sc->sc_bus->ub_lock != NULL);
268
269 RUN_ONCE(&init_control, usb_once_init);
270 config_interrupts(self, usb_doattach);
271}
272
273static int
274usb_once_init(void)
275{
276 struct usb_taskq *taskq;
277 int i;
278
279 USBHIST_LINK_STATIC(usbhist);
280
281 selinit(&usb_selevent);
282 mutex_init(&usb_event_lock, MUTEX_DEFAULT, IPL_NONE);
283 cv_init(&usb_event_cv, "usbrea");
284
285 for (i = 0; i < USB_NUM_TASKQS; i++) {
286 taskq = &usb_taskq[i];
287
288 TAILQ_INIT(&taskq->tasks);
289 /*
290 * Since USB task methods usb_{add,rem}_task are callable
291 * from any context, we have to make this lock a spinlock.
292 */
293 mutex_init(&taskq->lock, MUTEX_DEFAULT, IPL_USB);
294 cv_init(&taskq->cv, "usbtsk");
295 taskq->name = taskq_names[i];
296 if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
297 usb_task_thread, taskq, &taskq->task_thread_lwp,
298 "%s", taskq->name)) {
299 printf("unable to create task thread: %s\n", taskq->name);
300 panic("usb_create_event_thread task");
301 }
302 /*
303 * XXX we should make sure these threads are alive before
304 * end up using them in usb_doattach().
305 */
306 }
307 return 0;
308}
309
310static void
311usb_doattach(device_t self)
312{
313 struct usb_softc *sc = device_private(self);
314 struct usbd_device *dev;
315 usbd_status err;
316 int speed;
317 struct usb_event *ue;
318
319 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
320
321 sc->sc_bus->ub_usbctl = self;
322 sc->sc_port.up_power = USB_MAX_POWER;
323
324 switch (sc->sc_bus->ub_revision) {
325 case USBREV_1_0:
326 case USBREV_1_1:
327 speed = USB_SPEED_FULL;
328 break;
329 case USBREV_2_0:
330 speed = USB_SPEED_HIGH;
331 break;
332 case USBREV_3_0:
333 speed = USB_SPEED_SUPER;
334 break;
335 default:
336 panic("usb_doattach");
337 }
338
339 cv_init(&sc->sc_bus->ub_needsexplore_cv, "usbevt");
340
341 ue = usb_alloc_event();
342 ue->u.ue_ctrlr.ue_bus = device_unit(self);
343 usb_add_event(USB_EVENT_CTRLR_ATTACH, ue);
344
345 err = usbd_new_device(self, sc->sc_bus, 0, speed, 0,
346 &sc->sc_port);
347 if (!err) {
348 dev = sc->sc_port.up_dev;
349 if (dev->ud_hub == NULL) {
350 sc->sc_dying = 1;
351 aprint_error("%s: root device is not a hub\n",
352 device_xname(self));
353 return;
354 }
355 sc->sc_bus->ub_roothub = dev;
356 usb_create_event_thread(self);
357#if 1
358 /*
359 * Turning this code off will delay attachment of USB devices
360 * until the USB event thread is running, which means that
361 * the keyboard will not work until after cold boot.
362 */
363 if (cold && (device_cfdata(self)->cf_flags & 1))
364 dev->ud_hub->uh_explore(sc->sc_bus->ub_roothub);
365#endif
366 } else {
367 aprint_error("%s: root hub problem, error=%s\n",
368 device_xname(self), usbd_errstr(err));
369 sc->sc_dying = 1;
370 }
371
372 config_pending_incr(self);
373
374 if (!pmf_device_register(self, NULL, NULL))
375 aprint_error_dev(self, "couldn't establish power handler\n");
376
377 usb_async_sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE,
378 usb_async_intr, NULL);
379
380 return;
381}
382
383void
384usb_create_event_thread(device_t self)
385{
386 struct usb_softc *sc = device_private(self);
387
388 if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
389 usb_event_thread, sc, &sc->sc_event_thread,
390 "%s", device_xname(self))) {
391 printf("%s: unable to create event thread for\n",
392 device_xname(self));
393 panic("usb_create_event_thread");
394 }
395}
396
397/*
398 * Add a task to be performed by the task thread. This function can be
399 * called from any context and the task will be executed in a process
400 * context ASAP.
401 */
402void
403usb_add_task(struct usbd_device *dev, struct usb_task *task, int queue)
404{
405 struct usb_taskq *taskq;
406
407 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
408
409 KASSERT(0 <= queue);
410 KASSERT(queue < USB_NUM_TASKQS);
411 taskq = &usb_taskq[queue];
412 mutex_enter(&taskq->lock);
413 if (atomic_cas_uint(&task->queue, USB_NUM_TASKQS, queue) ==
414 USB_NUM_TASKQS) {
415 DPRINTFN(2, "task=%p", task, 0, 0, 0);
416 TAILQ_INSERT_TAIL(&taskq->tasks, task, next);
417 cv_signal(&taskq->cv);
418 } else {
419 DPRINTFN(2, "task=%p on q", task, 0, 0, 0);
420 }
421 mutex_exit(&taskq->lock);
422}
423
424/*
425 * XXX This does not wait for completion! Most uses need such an
426 * operation. Urgh...
427 */
428void
429usb_rem_task(struct usbd_device *dev, struct usb_task *task)
430{
431 unsigned queue;
432
433 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
434
435 while ((queue = task->queue) != USB_NUM_TASKQS) {
436 struct usb_taskq *taskq = &usb_taskq[queue];
437 mutex_enter(&taskq->lock);
438 if (__predict_true(task->queue == queue)) {
439 TAILQ_REMOVE(&taskq->tasks, task, next);
440 task->queue = USB_NUM_TASKQS;
441 mutex_exit(&taskq->lock);
442 break;
443 }
444 mutex_exit(&taskq->lock);
445 }
446}
447
448void
449usb_event_thread(void *arg)
450{
451 struct usb_softc *sc = arg;
452
453 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
454
455 /*
456 * In case this controller is a companion controller to an
457 * EHCI controller we need to wait until the EHCI controller
458 * has grabbed the port.
459 * XXX It would be nicer to do this with a tsleep(), but I don't
460 * know how to synchronize the creation of the threads so it
461 * will work.
462 */
463 usb_delay_ms(sc->sc_bus, 500);
464
465 /* Make sure first discover does something. */
466 mutex_enter(sc->sc_bus->ub_lock);
467 sc->sc_bus->ub_needsexplore = 1;
468 usb_discover(sc);
469 mutex_exit(sc->sc_bus->ub_lock);
470 config_pending_decr(sc->sc_bus->ub_usbctl);
471
472 mutex_enter(sc->sc_bus->ub_lock);
473 while (!sc->sc_dying) {
474 if (usb_noexplore < 2)
475 usb_discover(sc);
476
477 cv_timedwait(&sc->sc_bus->ub_needsexplore_cv,
478 sc->sc_bus->ub_lock, usb_noexplore ? 0 : hz * 60);
479
480 DPRINTFN(2, "sc %p woke up", sc, 0, 0, 0);
481 }
482 sc->sc_event_thread = NULL;
483
484 /* In case parent is waiting for us to exit. */
485 cv_signal(&sc->sc_bus->ub_needsexplore_cv);
486 mutex_exit(sc->sc_bus->ub_lock);
487
488 DPRINTF("sc %p exit", sc, 0, 0, 0);
489 kthread_exit(0);
490}
491
492void
493usb_task_thread(void *arg)
494{
495 struct usb_task *task;
496 struct usb_taskq *taskq;
497 bool mpsafe;
498
499 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
500
501 taskq = arg;
502 DPRINTF("start taskq %p", taskq, 0, 0, 0);
503
504 mutex_enter(&taskq->lock);
505 for (;;) {
506 task = TAILQ_FIRST(&taskq->tasks);
507 if (task == NULL) {
508 cv_wait(&taskq->cv, &taskq->lock);
509 task = TAILQ_FIRST(&taskq->tasks);
510 }
511 DPRINTFN(2, "woke up task=%p", task, 0, 0, 0);
512 if (task != NULL) {
513 mpsafe = ISSET(task->flags, USB_TASKQ_MPSAFE);
514 TAILQ_REMOVE(&taskq->tasks, task, next);
515 task->queue = USB_NUM_TASKQS;
516 mutex_exit(&taskq->lock);
517
518 if (!mpsafe)
519 KERNEL_LOCK(1, curlwp);
520 task->fun(task->arg);
521 /* Can't dereference task after this point. */
522 if (!mpsafe)
523 KERNEL_UNLOCK_ONE(curlwp);
524
525 mutex_enter(&taskq->lock);
526 }
527 }
528 mutex_exit(&taskq->lock);
529}
530
531int
532usbctlprint(void *aux, const char *pnp)
533{
534 /* only "usb"es can attach to host controllers */
535 if (pnp)
536 aprint_normal("usb at %s", pnp);
537
538 return UNCONF;
539}
540
541int
542usbopen(dev_t dev, int flag, int mode, struct lwp *l)
543{
544 int unit = minor(dev);
545 struct usb_softc *sc;
546
547 if (unit == USB_DEV_MINOR) {
548 if (usb_dev_open)
549 return EBUSY;
550 usb_dev_open = 1;
551 mutex_enter(proc_lock);
552 usb_async_proc = 0;
553 mutex_exit(proc_lock);
554 return 0;
555 }
556
557 sc = device_lookup_private(&usb_cd, unit);
558 if (!sc)
559 return ENXIO;
560
561 if (sc->sc_dying)
562 return EIO;
563
564 return 0;
565}
566
567int
568usbread(dev_t dev, struct uio *uio, int flag)
569{
570 struct usb_event *ue;
571#ifdef COMPAT_30
572 struct usb_event_old *ueo = NULL; /* XXXGCC */
573 int useold = 0;
574#endif
575 int error, n;
576
577 if (minor(dev) != USB_DEV_MINOR)
578 return ENXIO;
579
580 switch (uio->uio_resid) {
581#ifdef COMPAT_30
582 case sizeof(struct usb_event_old):
583 ueo = kmem_zalloc(sizeof(struct usb_event_old), KM_SLEEP);
584 useold = 1;
585 /* FALLTHRU */
586#endif
587 case sizeof(struct usb_event):
588 ue = usb_alloc_event();
589 break;
590 default:
591 return EINVAL;
592 }
593
594 error = 0;
595 mutex_enter(&usb_event_lock);
596 for (;;) {
597 n = usb_get_next_event(ue);
598 if (n != 0)
599 break;
600 if (flag & IO_NDELAY) {
601 error = EWOULDBLOCK;
602 break;
603 }
604 error = cv_wait_sig(&usb_event_cv, &usb_event_lock);
605 if (error)
606 break;
607 }
608 mutex_exit(&usb_event_lock);
609 if (!error) {
610#ifdef COMPAT_30
611 if (useold) { /* copy fields to old struct */
612 ueo->ue_type = ue->ue_type;
613 memcpy(&ueo->ue_time, &ue->ue_time,
614 sizeof(struct timespec));
615 switch (ue->ue_type) {
616 case USB_EVENT_DEVICE_ATTACH:
617 case USB_EVENT_DEVICE_DETACH:
618 usb_copy_old_devinfo(&ueo->u.ue_device, &ue->u.ue_device);
619 break;
620
621 case USB_EVENT_CTRLR_ATTACH:
622 case USB_EVENT_CTRLR_DETACH:
623 ueo->u.ue_ctrlr.ue_bus=ue->u.ue_ctrlr.ue_bus;
624 break;
625
626 case USB_EVENT_DRIVER_ATTACH:
627 case USB_EVENT_DRIVER_DETACH:
628 ueo->u.ue_driver.ue_cookie=ue->u.ue_driver.ue_cookie;
629 memcpy(ueo->u.ue_driver.ue_devname,
630 ue->u.ue_driver.ue_devname,
631 sizeof(ue->u.ue_driver.ue_devname));
632 break;
633 default:
634 ;
635 }
636
637 error = uiomove((void *)ueo, sizeof(*ueo), uio);
638 } else
639#endif
640 error = uiomove((void *)ue, sizeof(*ue), uio);
641 }
642 usb_free_event(ue);
643#ifdef COMPAT_30
644 if (useold)
645 kmem_free(ueo, sizeof(struct usb_event_old));
646#endif
647
648 return error;
649}
650
651int
652usbclose(dev_t dev, int flag, int mode,
653 struct lwp *l)
654{
655 int unit = minor(dev);
656
657 if (unit == USB_DEV_MINOR) {
658 mutex_enter(proc_lock);
659 usb_async_proc = 0;
660 mutex_exit(proc_lock);
661 usb_dev_open = 0;
662 }
663
664 return 0;
665}
666
667int
668usbioctl(dev_t devt, u_long cmd, void *data, int flag, struct lwp *l)
669{
670 struct usb_softc *sc;
671 int unit = minor(devt);
672
673 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
674
675 if (unit == USB_DEV_MINOR) {
676 switch (cmd) {
677 case FIONBIO:
678 /* All handled in the upper FS layer. */
679 return 0;
680
681 case FIOASYNC:
682 mutex_enter(proc_lock);
683 if (*(int *)data)
684 usb_async_proc = l->l_proc;
685 else
686 usb_async_proc = 0;
687 mutex_exit(proc_lock);
688 return 0;
689
690 default:
691 return EINVAL;
692 }
693 }
694
695 sc = device_lookup_private(&usb_cd, unit);
696
697 if (sc->sc_dying)
698 return EIO;
699
700 int error = 0;
701 DPRINTF("cmd %#x", cmd, 0, 0, 0);
702 switch (cmd) {
703#ifdef USB_DEBUG
704 case USB_SETDEBUG:
705 if (!(flag & FWRITE))
706 return EBADF;
707 usbdebug = ((*(int *)data) & 0x000000ff);
708 break;
709#endif /* USB_DEBUG */
710 case USB_REQUEST:
711 {
712 struct usb_ctl_request *ur = (void *)data;
713 int len = UGETW(ur->ucr_request.wLength);
714 struct iovec iov;
715 struct uio uio;
716 void *ptr = 0;
717 int addr = ur->ucr_addr;
718 usbd_status err;
719
720 if (!(flag & FWRITE)) {
721 error = EBADF;
722 goto fail;
723 }
724
725 DPRINTF("USB_REQUEST addr=%d len=%d", addr, len, 0, 0);
726 if (len < 0 || len > 32768) {
727 error = EINVAL;
728 goto fail;
729 }
730 if (addr < 0 || addr >= USB_MAX_DEVICES ||
731 sc->sc_bus->ub_devices[addr] == NULL) {
732 error = EINVAL;
733 goto fail;
734 }
735 if (len != 0) {
736 iov.iov_base = (void *)ur->ucr_data;
737 iov.iov_len = len;
738 uio.uio_iov = &iov;
739 uio.uio_iovcnt = 1;
740 uio.uio_resid = len;
741 uio.uio_offset = 0;
742 uio.uio_rw =
743 ur->ucr_request.bmRequestType & UT_READ ?
744 UIO_READ : UIO_WRITE;
745 uio.uio_vmspace = l->l_proc->p_vmspace;
746 ptr = kmem_alloc(len, KM_SLEEP);
747 if (uio.uio_rw == UIO_WRITE) {
748 error = uiomove(ptr, len, &uio);
749 if (error)
750 goto ret;
751 }
752 }
753 err = usbd_do_request_flags(sc->sc_bus->ub_devices[addr],
754 &ur->ucr_request, ptr, ur->ucr_flags, &ur->ucr_actlen,
755 USBD_DEFAULT_TIMEOUT);
756 if (err) {
757 error = EIO;
758 goto ret;
759 }
760 if (len > ur->ucr_actlen)
761 len = ur->ucr_actlen;
762 if (len != 0) {
763 if (uio.uio_rw == UIO_READ) {
764 error = uiomove(ptr, len, &uio);
765 if (error)
766 goto ret;
767 }
768 }
769 ret:
770 if (ptr) {
771 len = UGETW(ur->ucr_request.wLength);
772 kmem_free(ptr, len);
773 }
774 }
775
776 case USB_DEVICEINFO:
777 {
778 struct usbd_device *dev;
779 struct usb_device_info *di = (void *)data;
780 int addr = di->udi_addr;
781
782 if (addr < 0 || addr >= USB_MAX_DEVICES) {
783 error = EINVAL;
784 goto fail;
785 }
786 if ((dev = sc->sc_bus->ub_devices[addr]) == NULL) {
787 error = ENXIO;
788 goto fail;
789 }
790 usbd_fill_deviceinfo(dev, di, 1);
791 break;
792 }
793
794#ifdef COMPAT_30
795 case USB_DEVICEINFO_OLD:
796 {
797 struct usbd_device *dev;
798 struct usb_device_info_old *di = (void *)data;
799 int addr = di->udi_addr;
800
801 if (addr < 1 || addr >= USB_MAX_DEVICES) {
802 error = EINVAL;
803 goto fail;
804 }
805 if ((dev = sc->sc_bus->ub_devices[addr]) == NULL) {
806 error = ENXIO;
807 goto fail;
808 }
809 usbd_fill_deviceinfo_old(dev, di, 1);
810 break;
811 }
812#endif
813
814 case USB_DEVICESTATS:
815 *(struct usb_device_stats *)data = sc->sc_bus->ub_stats;
816 break;
817
818 default:
819 error = EINVAL;
820 }
821
822fail:
823
824 DPRINTF("... done (error = %d)", error, 0, 0, 0);
825
826 return error;
827}
828
829int
830usbpoll(dev_t dev, int events, struct lwp *l)
831{
832 int revents, mask;
833
834 if (minor(dev) == USB_DEV_MINOR) {
835 revents = 0;
836 mask = POLLIN | POLLRDNORM;
837
838 mutex_enter(&usb_event_lock);
839 if (events & mask && usb_nevents > 0)
840 revents |= events & mask;
841 if (revents == 0 && events & mask)
842 selrecord(l, &usb_selevent);
843 mutex_exit(&usb_event_lock);
844
845 return revents;
846 } else {
847 return 0;
848 }
849}
850
851static void
852filt_usbrdetach(struct knote *kn)
853{
854
855 mutex_enter(&usb_event_lock);
856 SLIST_REMOVE(&usb_selevent.sel_klist, kn, knote, kn_selnext);
857 mutex_exit(&usb_event_lock);
858}
859
860static int
861filt_usbread(struct knote *kn, long hint)
862{
863
864 if (usb_nevents == 0)
865 return 0;
866
867 kn->kn_data = sizeof(struct usb_event);
868 return 1;
869}
870
871static const struct filterops usbread_filtops =
872 { 1, NULL, filt_usbrdetach, filt_usbread };
873
874int
875usbkqfilter(dev_t dev, struct knote *kn)
876{
877 struct klist *klist;
878
879 switch (kn->kn_filter) {
880 case EVFILT_READ:
881 if (minor(dev) != USB_DEV_MINOR)
882 return 1;
883 klist = &usb_selevent.sel_klist;
884 kn->kn_fop = &usbread_filtops;
885 break;
886
887 default:
888 return EINVAL;
889 }
890
891 kn->kn_hook = NULL;
892
893 mutex_enter(&usb_event_lock);
894 SLIST_INSERT_HEAD(klist, kn, kn_selnext);
895 mutex_exit(&usb_event_lock);
896
897 return 0;
898}
899
900/* Explore device tree from the root. */
901Static void
902usb_discover(struct usb_softc *sc)
903{
904
905 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
906
907 KASSERT(mutex_owned(sc->sc_bus->ub_lock));
908
909 if (usb_noexplore > 1)
910 return;
911 /*
912 * We need mutual exclusion while traversing the device tree,
913 * but this is guaranteed since this function is only called
914 * from the event thread for the controller.
915 *
916 * Also, we now have sc_bus->ub_lock held.
917 */
918 while (sc->sc_bus->ub_needsexplore && !sc->sc_dying) {
919 sc->sc_bus->ub_needsexplore = 0;
920 mutex_exit(sc->sc_bus->ub_lock);
921 sc->sc_bus->ub_roothub->ud_hub->uh_explore(sc->sc_bus->ub_roothub);
922 mutex_enter(sc->sc_bus->ub_lock);
923 }
924}
925
926void
927usb_needs_explore(struct usbd_device *dev)
928{
929
930 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
931
932 mutex_enter(dev->ud_bus->ub_lock);
933 dev->ud_bus->ub_needsexplore = 1;
934 cv_signal(&dev->ud_bus->ub_needsexplore_cv);
935 mutex_exit(dev->ud_bus->ub_lock);
936}
937
938void
939usb_needs_reattach(struct usbd_device *dev)
940{
941
942 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
943
944 mutex_enter(dev->ud_bus->ub_lock);
945 dev->ud_powersrc->up_reattach = 1;
946 dev->ud_bus->ub_needsexplore = 1;
947 cv_signal(&dev->ud_bus->ub_needsexplore_cv);
948 mutex_exit(dev->ud_bus->ub_lock);
949}
950
951/* Called at with usb_event_lock held. */
952int
953usb_get_next_event(struct usb_event *ue)
954{
955 struct usb_event_q *ueq;
956
957 KASSERT(mutex_owned(&usb_event_lock));
958
959 if (usb_nevents <= 0)
960 return 0;
961 ueq = SIMPLEQ_FIRST(&usb_events);
962#ifdef DIAGNOSTIC
963 if (ueq == NULL) {
964 printf("usb: usb_nevents got out of sync! %d\n", usb_nevents);
965 usb_nevents = 0;
966 return 0;
967 }
968#endif
969 if (ue)
970 *ue = ueq->ue;
971 SIMPLEQ_REMOVE_HEAD(&usb_events, next);
972 usb_free_event((struct usb_event *)(void *)ueq);
973 usb_nevents--;
974 return 1;
975}
976
977void
978usbd_add_dev_event(int type, struct usbd_device *udev)
979{
980 struct usb_event *ue = usb_alloc_event();
981
982 usbd_fill_deviceinfo(udev, &ue->u.ue_device, false);
983 usb_add_event(type, ue);
984}
985
986void
987usbd_add_drv_event(int type, struct usbd_device *udev, device_t dev)
988{
989 struct usb_event *ue = usb_alloc_event();
990
991 ue->u.ue_driver.ue_cookie = udev->ud_cookie;
992 strncpy(ue->u.ue_driver.ue_devname, device_xname(dev),
993 sizeof(ue->u.ue_driver.ue_devname));
994 usb_add_event(type, ue);
995}
996
997Static struct usb_event *
998usb_alloc_event(void)
999{
1000 /* Yes, this is right; we allocate enough so that we can use it later */
1001 return kmem_zalloc(sizeof(struct usb_event_q), KM_SLEEP);
1002}
1003
1004Static void
1005usb_free_event(struct usb_event *uep)
1006{
1007 kmem_free(uep, sizeof(struct usb_event_q));
1008}
1009
1010Static void
1011usb_add_event(int type, struct usb_event *uep)
1012{
1013 struct usb_event_q *ueq;
1014 struct timeval thetime;
1015
1016 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
1017
1018 microtime(&thetime);
1019 /* Don't want to wait here with usb_event_lock held */
1020 ueq = (struct usb_event_q *)(void *)uep;
1021 ueq->ue = *uep;
1022 ueq->ue.ue_type = type;
1023 TIMEVAL_TO_TIMESPEC(&thetime, &ueq->ue.ue_time);
1024
1025 mutex_enter(&usb_event_lock);
1026 if (++usb_nevents >= USB_MAX_EVENTS) {
1027 /* Too many queued events, drop an old one. */
1028 DPRINTF("event dropped", 0, 0, 0, 0);
1029 (void)usb_get_next_event(0);
1030 }
1031 SIMPLEQ_INSERT_TAIL(&usb_events, ueq, next);
1032 cv_signal(&usb_event_cv);
1033 selnotify(&usb_selevent, 0, 0);
1034 if (usb_async_proc != NULL) {
1035 kpreempt_disable();
1036 softint_schedule(usb_async_sih);
1037 kpreempt_enable();
1038 }
1039 mutex_exit(&usb_event_lock);
1040}
1041
1042Static void
1043usb_async_intr(void *cookie)
1044{
1045 proc_t *proc;
1046
1047 mutex_enter(proc_lock);
1048 if ((proc = usb_async_proc) != NULL)
1049 psignal(proc, SIGIO);
1050 mutex_exit(proc_lock);
1051}
1052
1053Static void
1054usb_soft_intr(void *arg)
1055{
1056 struct usbd_bus *bus = arg;
1057
1058 mutex_enter(bus->ub_lock);
1059 bus->ub_methods->ubm_softint(bus);
1060 mutex_exit(bus->ub_lock);
1061}
1062
1063void
1064usb_schedsoftintr(struct usbd_bus *bus)
1065{
1066
1067 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
1068
1069 DPRINTFN(10, "polling=%d", bus->ub_usepolling, 0, 0, 0);
1070
1071 if (bus->ub_usepolling) {
1072 bus->ub_methods->ubm_softint(bus);
1073 } else {
1074 kpreempt_disable();
1075 softint_schedule(bus->ub_soft);
1076 kpreempt_enable();
1077 }
1078}
1079
1080int
1081usb_activate(device_t self, enum devact act)
1082{
1083 struct usb_softc *sc = device_private(self);
1084
1085 switch (act) {
1086 case DVACT_DEACTIVATE:
1087 sc->sc_dying = 1;
1088 return 0;
1089 default:
1090 return EOPNOTSUPP;
1091 }
1092}
1093
1094void
1095usb_childdet(device_t self, device_t child)
1096{
1097 int i;
1098 struct usb_softc *sc = device_private(self);
1099 struct usbd_device *dev;
1100
1101 if ((dev = sc->sc_port.up_dev) == NULL || dev->ud_subdevlen == 0)
1102 return;
1103
1104 for (i = 0; i < dev->ud_subdevlen; i++)
1105 if (dev->ud_subdevs[i] == child)
1106 dev->ud_subdevs[i] = NULL;
1107}
1108
1109int
1110usb_detach(device_t self, int flags)
1111{
1112 struct usb_softc *sc = device_private(self);
1113 struct usb_event *ue;
1114 int rc;
1115
1116 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
1117
1118 /* Make all devices disconnect. */
1119 if (sc->sc_port.up_dev != NULL &&
1120 (rc = usb_disconnect_port(&sc->sc_port, self, flags)) != 0)
1121 return rc;
1122
1123 pmf_device_deregister(self);
1124 /* Kill off event thread. */
1125 sc->sc_dying = 1;
1126 while (sc->sc_event_thread != NULL) {
1127 mutex_enter(sc->sc_bus->ub_lock);
1128 cv_signal(&sc->sc_bus->ub_needsexplore_cv);
1129 cv_timedwait(&sc->sc_bus->ub_needsexplore_cv,
1130 sc->sc_bus->ub_lock, hz * 60);
1131 mutex_exit(sc->sc_bus->ub_lock);
1132 }
1133 DPRINTF("event thread dead", 0, 0, 0, 0);
1134
1135 if (sc->sc_bus->ub_soft != NULL) {
1136 softint_disestablish(sc->sc_bus->ub_soft);
1137 sc->sc_bus->ub_soft = NULL;
1138 }
1139
1140 ue = usb_alloc_event();
1141 ue->u.ue_ctrlr.ue_bus = device_unit(self);
1142 usb_add_event(USB_EVENT_CTRLR_DETACH, ue);
1143
1144 cv_destroy(&sc->sc_bus->ub_needsexplore_cv);
1145
1146 return 0;
1147}
1148
1149#ifdef COMPAT_30
1150Static void
1151usb_copy_old_devinfo(struct usb_device_info_old *uo,
1152 const struct usb_device_info *ue)
1153{
1154 const unsigned char *p;
1155 unsigned char *q;
1156 int i, n;
1157
1158 uo->udi_bus = ue->udi_bus;
1159 uo->udi_addr = ue->udi_addr;
1160 uo->udi_cookie = ue->udi_cookie;
1161 for (i = 0, p = (const unsigned char *)ue->udi_product,
1162 q = (unsigned char *)uo->udi_product;
1163 *p && i < USB_MAX_STRING_LEN - 1; p++) {
1164 if (*p < 0x80)
1165 q[i++] = *p;
1166 else {
1167 q[i++] = '?';
1168 if ((*p & 0xe0) == 0xe0)
1169 p++;
1170 p++;
1171 }
1172 }
1173 q[i] = 0;
1174
1175 for (i = 0, p = ue->udi_vendor, q = uo->udi_vendor;
1176 *p && i < USB_MAX_STRING_LEN - 1; p++) {
1177 if (* p < 0x80)
1178 q[i++] = *p;
1179 else {
1180 q[i++] = '?';
1181 p++;
1182 if ((*p & 0xe0) == 0xe0)
1183 p++;
1184 }
1185 }
1186 q[i] = 0;
1187
1188 memcpy(uo->udi_release, ue->udi_release, sizeof(uo->udi_release));
1189
1190 uo->udi_productNo = ue->udi_productNo;
1191 uo->udi_vendorNo = ue->udi_vendorNo;
1192 uo->udi_releaseNo = ue->udi_releaseNo;
1193 uo->udi_class = ue->udi_class;
1194 uo->udi_subclass = ue->udi_subclass;
1195 uo->udi_protocol = ue->udi_protocol;
1196 uo->udi_config = ue->udi_config;
1197 uo->udi_speed = ue->udi_speed;
1198 uo->udi_power = ue->udi_power;
1199 uo->udi_nports = ue->udi_nports;
1200
1201 for (n=0; n<USB_MAX_DEVNAMES; n++)
1202 memcpy(uo->udi_devnames[n],
1203 ue->udi_devnames[n], USB_MAX_DEVNAMELEN);
1204 memcpy(uo->udi_ports, ue->udi_ports, sizeof(uo->udi_ports));
1205}
1206#endif
1207