usb.c revision 1.112.2.5
1 /* $NetBSD: usb.c,v 1.112.2.5 2010/03/11 15:04:07 yamt Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2002, 2008 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 (at) augustsson.net) at 9 * Carlstedt Research & Technology. 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.112.2.5 2010/03/11 15:04:07 yamt Exp $"); 41 42 #include "opt_compat_netbsd.h" 43 44 #include <sys/param.h> 45 #include <sys/systm.h> 46 #include <sys/kernel.h> 47 #include <sys/malloc.h> 48 #include <sys/device.h> 49 #include <sys/kthread.h> 50 #include <sys/proc.h> 51 #include <sys/conf.h> 52 #include <sys/fcntl.h> 53 #include <sys/poll.h> 54 #include <sys/select.h> 55 #include <sys/vnode.h> 56 #include <sys/signalvar.h> 57 #include <sys/intr.h> 58 59 #include <dev/usb/usb.h> 60 #include <dev/usb/usbdi.h> 61 #include <dev/usb/usbdi_util.h> 62 63 #define USB_DEV_MINOR 255 64 65 #include <sys/bus.h> 66 67 #include <dev/usb/usbdivar.h> 68 #include <dev/usb/usb_quirks.h> 69 70 #ifdef USB_DEBUG 71 #define DPRINTF(x) if (usbdebug) logprintf x 72 #define DPRINTFN(n,x) if (usbdebug>(n)) logprintf x 73 int usbdebug = 0; 74 /* 75 * 0 - do usual exploration 76 * 1 - do not use timeout exploration 77 * >1 - do no exploration 78 */ 79 int usb_noexplore = 0; 80 #else 81 #define DPRINTF(x) 82 #define DPRINTFN(n,x) 83 #endif 84 85 struct usb_softc { 86 #if 0 87 USBBASEDEVICE sc_dev; /* base device */ 88 #endif 89 usbd_bus_handle sc_bus; /* USB controller */ 90 struct usbd_port sc_port; /* dummy port for root hub */ 91 92 struct lwp *sc_event_thread; 93 94 char sc_dying; 95 }; 96 97 struct usb_taskq { 98 TAILQ_HEAD(, usb_task) tasks; 99 struct lwp *task_thread_lwp; 100 const char *name; 101 int taskcreated; /* task thread exists. */ 102 }; 103 104 static struct usb_taskq usb_taskq[USB_NUM_TASKQS]; 105 106 dev_type_open(usbopen); 107 dev_type_close(usbclose); 108 dev_type_read(usbread); 109 dev_type_ioctl(usbioctl); 110 dev_type_poll(usbpoll); 111 dev_type_kqfilter(usbkqfilter); 112 113 const struct cdevsw usb_cdevsw = { 114 usbopen, usbclose, usbread, nowrite, usbioctl, 115 nostop, notty, usbpoll, nommap, usbkqfilter, D_OTHER, 116 }; 117 118 Static void usb_discover(struct usb_softc *); 119 Static void usb_create_event_thread(device_t); 120 Static void usb_event_thread(void *); 121 Static void usb_task_thread(void *); 122 123 #define USB_MAX_EVENTS 100 124 struct usb_event_q { 125 struct usb_event ue; 126 SIMPLEQ_ENTRY(usb_event_q) next; 127 }; 128 Static SIMPLEQ_HEAD(, usb_event_q) usb_events = 129 SIMPLEQ_HEAD_INITIALIZER(usb_events); 130 Static int usb_nevents = 0; 131 Static struct selinfo usb_selevent; 132 Static usb_proc_ptr usb_async_proc; /* process that wants USB SIGIO */ 133 Static void *usb_async_sih; 134 Static int usb_dev_open = 0; 135 Static struct usb_event *usb_alloc_event(void); 136 Static void usb_free_event(struct usb_event *); 137 Static void usb_add_event(int, struct usb_event *); 138 Static int usb_get_next_event(struct usb_event *); 139 Static void usb_async_intr(void *); 140 141 #ifdef COMPAT_30 142 Static void usb_copy_old_devinfo(struct usb_device_info_old *, const struct usb_device_info *); 143 #endif 144 145 Static const char *usbrev_str[] = USBREV_STR; 146 147 static int usb_match(device_t, cfdata_t, void *); 148 static void usb_attach(device_t, device_t, void *); 149 static int usb_detach(device_t, int); 150 static int usb_activate(device_t, enum devact); 151 static void usb_childdet(device_t, device_t); 152 static void usb_doattach(device_t); 153 154 extern struct cfdriver usb_cd; 155 156 CFATTACH_DECL3_NEW(usb, sizeof(struct usb_softc), 157 usb_match, usb_attach, usb_detach, usb_activate, NULL, usb_childdet, 158 DVF_DETACH_SHUTDOWN); 159 160 int 161 usb_match(device_t parent, cfdata_t match, void *aux) 162 { 163 DPRINTF(("usbd_match\n")); 164 return (UMATCH_GENERIC); 165 } 166 167 void 168 usb_attach(device_t parent, device_t self, void *aux) 169 { 170 struct usb_softc *sc = device_private(self); 171 int usbrev; 172 173 sc->sc_bus = aux; 174 usbrev = sc->sc_bus->usbrev; 175 176 aprint_naive("\n"); 177 aprint_normal(": USB revision %s", usbrev_str[usbrev]); 178 switch (usbrev) { 179 case USBREV_1_0: 180 case USBREV_1_1: 181 case USBREV_2_0: 182 break; 183 default: 184 aprint_error(", not supported\n"); 185 sc->sc_dying = 1; 186 USB_ATTACH_ERROR_RETURN; 187 } 188 aprint_normal("\n"); 189 190 config_interrupts(self, usb_doattach); 191 } 192 193 static void 194 usb_doattach(device_t self) 195 { 196 static bool usb_selevent_init; /* XXX */ 197 struct usb_softc *sc = device_private(self); 198 usbd_device_handle dev; 199 usbd_status err; 200 int speed; 201 struct usb_event *ue; 202 203 if (!usb_selevent_init) { 204 selinit(&usb_selevent); 205 usb_selevent_init = true; 206 } 207 DPRINTF(("usbd_doattach\n")); 208 209 sc->sc_bus->usbctl = self; 210 sc->sc_port.power = USB_MAX_POWER; 211 212 switch (sc->sc_bus->usbrev) { 213 case USBREV_1_0: 214 case USBREV_1_1: 215 speed = USB_SPEED_FULL; 216 break; 217 case USBREV_2_0: 218 speed = USB_SPEED_HIGH; 219 break; 220 default: 221 panic("usb_doattach"); 222 } 223 224 ue = usb_alloc_event(); 225 ue->u.ue_ctrlr.ue_bus = device_unit(self); 226 usb_add_event(USB_EVENT_CTRLR_ATTACH, ue); 227 228 #ifdef USB_USE_SOFTINTR 229 /* XXX we should have our own level */ 230 sc->sc_bus->soft = softint_establish(SOFTINT_NET, 231 sc->sc_bus->methods->soft_intr, sc->sc_bus); 232 if (sc->sc_bus->soft == NULL) { 233 aprint_error("%s: can't register softintr\n", 234 device_xname(self)); 235 sc->sc_dying = 1; 236 USB_ATTACH_ERROR_RETURN; 237 } 238 #endif 239 240 err = usbd_new_device(self, sc->sc_bus, 0, speed, 0, 241 &sc->sc_port); 242 if (!err) { 243 dev = sc->sc_port.device; 244 if (dev->hub == NULL) { 245 sc->sc_dying = 1; 246 aprint_error("%s: root device is not a hub\n", 247 device_xname(self)); 248 USB_ATTACH_ERROR_RETURN; 249 } 250 sc->sc_bus->root_hub = dev; 251 #if 1 252 /* 253 * Turning this code off will delay attachment of USB devices 254 * until the USB event thread is running, which means that 255 * the keyboard will not work until after cold boot. 256 */ 257 if (cold && (device_cfdata(self)->cf_flags & 1)) 258 dev->hub->explore(sc->sc_bus->root_hub); 259 #endif 260 } else { 261 aprint_error("%s: root hub problem, error=%d\n", 262 device_xname(self), err); 263 sc->sc_dying = 1; 264 } 265 266 config_pending_incr(); 267 usb_create_event_thread(self); 268 269 if (!pmf_device_register(self, NULL, NULL)) 270 aprint_error_dev(self, "couldn't establish power handler\n"); 271 272 usb_async_sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE, 273 usb_async_intr, NULL); 274 275 USB_ATTACH_SUCCESS_RETURN; 276 } 277 278 static const char *taskq_names[] = USB_TASKQ_NAMES; 279 280 void 281 usb_create_event_thread(device_t self) 282 { 283 struct usb_softc *sc = device_private(self); 284 struct usb_taskq *taskq; 285 int i; 286 287 if (usb_kthread_create1(PRI_NONE, 0, NULL, usb_event_thread, sc, 288 &sc->sc_event_thread, "%s", device_xname(self))) { 289 printf("%s: unable to create event thread for\n", 290 device_xname(self)); 291 panic("usb_create_event_thread"); 292 } 293 for (i = 0; i < USB_NUM_TASKQS; i++) { 294 taskq = &usb_taskq[i]; 295 296 if (taskq->taskcreated) 297 continue; 298 299 TAILQ_INIT(&taskq->tasks); 300 taskq->taskcreated = 1; 301 taskq->name = taskq_names[i]; 302 if (usb_kthread_create1(PRI_NONE, 0, NULL, usb_task_thread, 303 taskq, &taskq->task_thread_lwp, taskq->name)) { 304 printf("unable to create task thread: %s\n", taskq->name); 305 panic("usb_create_event_thread task"); 306 } 307 } 308 } 309 310 /* 311 * Add a task to be performed by the task thread. This function can be 312 * called from any context and the task will be executed in a process 313 * context ASAP. 314 */ 315 void 316 usb_add_task(usbd_device_handle dev, struct usb_task *task, int queue) 317 { 318 struct usb_taskq *taskq; 319 int s; 320 321 taskq = &usb_taskq[queue]; 322 s = splusb(); 323 if (task->queue == -1) { 324 DPRINTFN(2,("usb_add_task: task=%p\n", task)); 325 TAILQ_INSERT_TAIL(&taskq->tasks, task, next); 326 task->queue = queue; 327 } else { 328 DPRINTFN(3,("usb_add_task: task=%p on q\n", task)); 329 } 330 wakeup(&taskq->tasks); 331 splx(s); 332 } 333 334 void 335 usb_rem_task(usbd_device_handle dev, struct usb_task *task) 336 { 337 struct usb_taskq *taskq; 338 int s; 339 340 taskq = &usb_taskq[task->queue]; 341 s = splusb(); 342 if (task->queue != -1) { 343 TAILQ_REMOVE(&taskq->tasks, task, next); 344 task->queue = -1; 345 } 346 splx(s); 347 } 348 349 void 350 usb_event_thread(void *arg) 351 { 352 struct usb_softc *sc = arg; 353 354 DPRINTF(("usb_event_thread: start\n")); 355 356 /* 357 * In case this controller is a companion controller to an 358 * EHCI controller we need to wait until the EHCI controller 359 * has grabbed the port. 360 * XXX It would be nicer to do this with a tsleep(), but I don't 361 * know how to synchronize the creation of the threads so it 362 * will work. 363 */ 364 usb_delay_ms(sc->sc_bus, 500); 365 366 /* Make sure first discover does something. */ 367 sc->sc_bus->needs_explore = 1; 368 usb_discover(sc); 369 config_pending_decr(); 370 371 while (!sc->sc_dying) { 372 #ifdef USB_DEBUG 373 if (usb_noexplore < 2) 374 #endif 375 usb_discover(sc); 376 #ifdef USB_DEBUG 377 (void)tsleep(&sc->sc_bus->needs_explore, PWAIT, "usbevt", 378 usb_noexplore ? 0 : hz * 60); 379 #else 380 (void)tsleep(&sc->sc_bus->needs_explore, PWAIT, "usbevt", 381 hz * 60); 382 #endif 383 DPRINTFN(2,("usb_event_thread: woke up\n")); 384 } 385 sc->sc_event_thread = NULL; 386 387 /* In case parent is waiting for us to exit. */ 388 wakeup(sc); 389 390 DPRINTF(("usb_event_thread: exit\n")); 391 kthread_exit(0); 392 } 393 394 void 395 usb_task_thread(void *arg) 396 { 397 struct usb_task *task; 398 struct usb_taskq *taskq; 399 int s; 400 401 taskq = arg; 402 DPRINTF(("usb_task_thread: start taskq %s\n", taskq->name)); 403 404 s = splusb(); 405 for (;;) { 406 task = TAILQ_FIRST(&taskq->tasks); 407 if (task == NULL) { 408 tsleep(&taskq->tasks, PWAIT, "usbtsk", 0); 409 task = TAILQ_FIRST(&taskq->tasks); 410 } 411 DPRINTFN(2,("usb_task_thread: woke up task=%p\n", task)); 412 if (task != NULL) { 413 TAILQ_REMOVE(&taskq->tasks, task, next); 414 task->queue = -1; 415 splx(s); 416 task->fun(task->arg); 417 s = splusb(); 418 } 419 } 420 } 421 422 int 423 usbctlprint(void *aux, const char *pnp) 424 { 425 /* only "usb"es can attach to host controllers */ 426 if (pnp) 427 aprint_normal("usb at %s", pnp); 428 429 return (UNCONF); 430 } 431 432 int 433 usbopen(dev_t dev, int flag, int mode, struct lwp *l) 434 { 435 int unit = minor(dev); 436 struct usb_softc *sc; 437 438 if (unit == USB_DEV_MINOR) { 439 if (usb_dev_open) 440 return (EBUSY); 441 usb_dev_open = 1; 442 mutex_enter(proc_lock); 443 usb_async_proc = 0; 444 mutex_exit(proc_lock); 445 return (0); 446 } 447 448 sc = device_lookup_private(&usb_cd, unit); 449 if (!sc) 450 return (ENXIO); 451 452 if (sc->sc_dying) 453 return (EIO); 454 455 return (0); 456 } 457 458 int 459 usbread(dev_t dev, struct uio *uio, int flag) 460 { 461 struct usb_event *ue; 462 #ifdef COMPAT_30 463 struct usb_event_old *ueo = NULL; /* XXXGCC */ 464 #endif 465 int s, error, n, useold; 466 467 if (minor(dev) != USB_DEV_MINOR) 468 return (ENXIO); 469 470 useold = 0; 471 switch (uio->uio_resid) { 472 #ifdef COMPAT_30 473 case sizeof(struct usb_event_old): 474 ueo = malloc(sizeof(struct usb_event_old), M_USBDEV, 475 M_WAITOK|M_ZERO); 476 useold = 1; 477 /* FALLTHRU */ 478 #endif 479 case sizeof(struct usb_event): 480 ue = usb_alloc_event(); 481 break; 482 default: 483 return (EINVAL); 484 } 485 486 error = 0; 487 s = splusb(); 488 for (;;) { 489 n = usb_get_next_event(ue); 490 if (n != 0) 491 break; 492 if (flag & IO_NDELAY) { 493 error = EWOULDBLOCK; 494 break; 495 } 496 error = tsleep(&usb_events, PZERO | PCATCH, "usbrea", 0); 497 if (error) 498 break; 499 } 500 splx(s); 501 if (!error) { 502 #ifdef COMPAT_30 503 if (useold) { /* copy fields to old struct */ 504 ueo->ue_type = ue->ue_type; 505 memcpy(&ueo->ue_time, &ue->ue_time, 506 sizeof(struct timespec)); 507 switch (ue->ue_type) { 508 case USB_EVENT_DEVICE_ATTACH: 509 case USB_EVENT_DEVICE_DETACH: 510 usb_copy_old_devinfo(&ueo->u.ue_device, &ue->u.ue_device); 511 break; 512 513 case USB_EVENT_CTRLR_ATTACH: 514 case USB_EVENT_CTRLR_DETACH: 515 ueo->u.ue_ctrlr.ue_bus=ue->u.ue_ctrlr.ue_bus; 516 break; 517 518 case USB_EVENT_DRIVER_ATTACH: 519 case USB_EVENT_DRIVER_DETACH: 520 ueo->u.ue_driver.ue_cookie=ue->u.ue_driver.ue_cookie; 521 memcpy(ueo->u.ue_driver.ue_devname, 522 ue->u.ue_driver.ue_devname, 523 sizeof(ue->u.ue_driver.ue_devname)); 524 break; 525 default: 526 ; 527 } 528 529 error = uiomove((void *)ueo, sizeof *ueo, uio); 530 } else 531 #endif 532 error = uiomove((void *)ue, sizeof *ue, uio); 533 } 534 usb_free_event(ue); 535 #ifdef COMPAT_30 536 if (useold) 537 free(ueo, M_USBDEV); 538 #endif 539 540 return (error); 541 } 542 543 int 544 usbclose(dev_t dev, int flag, int mode, 545 struct lwp *l) 546 { 547 int unit = minor(dev); 548 549 if (unit == USB_DEV_MINOR) { 550 mutex_enter(proc_lock); 551 usb_async_proc = 0; 552 mutex_exit(proc_lock); 553 usb_dev_open = 0; 554 } 555 556 return (0); 557 } 558 559 int 560 usbioctl(dev_t devt, u_long cmd, void *data, int flag, struct lwp *l) 561 { 562 struct usb_softc *sc; 563 int unit = minor(devt); 564 565 if (unit == USB_DEV_MINOR) { 566 switch (cmd) { 567 case FIONBIO: 568 /* All handled in the upper FS layer. */ 569 return (0); 570 571 case FIOASYNC: 572 mutex_enter(proc_lock); 573 if (*(int *)data) 574 usb_async_proc = l->l_proc; 575 else 576 usb_async_proc = 0; 577 mutex_exit(proc_lock); 578 return (0); 579 580 default: 581 return (EINVAL); 582 } 583 } 584 585 sc = device_lookup_private(&usb_cd, unit); 586 587 if (sc->sc_dying) 588 return (EIO); 589 590 switch (cmd) { 591 #ifdef USB_DEBUG 592 case USB_SETDEBUG: 593 if (!(flag & FWRITE)) 594 return (EBADF); 595 usbdebug = ((*(int *)data) & 0x000000ff); 596 break; 597 #endif /* USB_DEBUG */ 598 case USB_REQUEST: 599 { 600 struct usb_ctl_request *ur = (void *)data; 601 int len = UGETW(ur->ucr_request.wLength); 602 struct iovec iov; 603 struct uio uio; 604 void *ptr = 0; 605 int addr = ur->ucr_addr; 606 usbd_status err; 607 int error = 0; 608 609 if (!(flag & FWRITE)) 610 return (EBADF); 611 612 DPRINTF(("usbioctl: USB_REQUEST addr=%d len=%d\n", addr, len)); 613 if (len < 0 || len > 32768) 614 return (EINVAL); 615 if (addr < 0 || addr >= USB_MAX_DEVICES || 616 sc->sc_bus->devices[addr] == 0) 617 return (EINVAL); 618 if (len != 0) { 619 iov.iov_base = (void *)ur->ucr_data; 620 iov.iov_len = len; 621 uio.uio_iov = &iov; 622 uio.uio_iovcnt = 1; 623 uio.uio_resid = len; 624 uio.uio_offset = 0; 625 uio.uio_rw = 626 ur->ucr_request.bmRequestType & UT_READ ? 627 UIO_READ : UIO_WRITE; 628 uio.uio_vmspace = l->l_proc->p_vmspace; 629 ptr = malloc(len, M_TEMP, M_WAITOK); 630 if (uio.uio_rw == UIO_WRITE) { 631 error = uiomove(ptr, len, &uio); 632 if (error) 633 goto ret; 634 } 635 } 636 err = usbd_do_request_flags(sc->sc_bus->devices[addr], 637 &ur->ucr_request, ptr, ur->ucr_flags, &ur->ucr_actlen, 638 USBD_DEFAULT_TIMEOUT); 639 if (err) { 640 error = EIO; 641 goto ret; 642 } 643 if (len > ur->ucr_actlen) 644 len = ur->ucr_actlen; 645 if (len != 0) { 646 if (uio.uio_rw == UIO_READ) { 647 error = uiomove(ptr, len, &uio); 648 if (error) 649 goto ret; 650 } 651 } 652 ret: 653 if (ptr) 654 free(ptr, M_TEMP); 655 return (error); 656 } 657 658 case USB_DEVICEINFO: 659 { 660 usbd_device_handle dev; 661 struct usb_device_info *di = (void *)data; 662 int addr = di->udi_addr; 663 664 if (addr < 1 || addr >= USB_MAX_DEVICES) 665 return EINVAL; 666 if ((dev = sc->sc_bus->devices[addr]) == NULL) 667 return ENXIO; 668 usbd_fill_deviceinfo(dev, di, 1); 669 break; 670 } 671 672 #ifdef COMPAT_30 673 case USB_DEVICEINFO_OLD: 674 { 675 usbd_device_handle dev; 676 struct usb_device_info_old *di = (void *)data; 677 int addr = di->udi_addr; 678 679 if (addr < 1 || addr >= USB_MAX_DEVICES) 680 return EINVAL; 681 if ((dev = sc->sc_bus->devices[addr]) == NULL) 682 return ENXIO; 683 usbd_fill_deviceinfo_old(dev, di, 1); 684 break; 685 } 686 #endif 687 688 case USB_DEVICESTATS: 689 *(struct usb_device_stats *)data = sc->sc_bus->stats; 690 break; 691 692 default: 693 return (EINVAL); 694 } 695 return (0); 696 } 697 698 int 699 usbpoll(dev_t dev, int events, struct lwp *l) 700 { 701 int revents, mask, s; 702 703 if (minor(dev) == USB_DEV_MINOR) { 704 revents = 0; 705 mask = POLLIN | POLLRDNORM; 706 707 s = splusb(); 708 if (events & mask && usb_nevents > 0) 709 revents |= events & mask; 710 if (revents == 0 && events & mask) 711 selrecord(l, &usb_selevent); 712 splx(s); 713 714 return (revents); 715 } else { 716 return (0); 717 } 718 } 719 720 static void 721 filt_usbrdetach(struct knote *kn) 722 { 723 int s; 724 725 s = splusb(); 726 SLIST_REMOVE(&usb_selevent.sel_klist, kn, knote, kn_selnext); 727 splx(s); 728 } 729 730 static int 731 filt_usbread(struct knote *kn, long hint) 732 { 733 734 if (usb_nevents == 0) 735 return (0); 736 737 kn->kn_data = sizeof(struct usb_event); 738 return (1); 739 } 740 741 static const struct filterops usbread_filtops = 742 { 1, NULL, filt_usbrdetach, filt_usbread }; 743 744 int 745 usbkqfilter(dev_t dev, struct knote *kn) 746 { 747 struct klist *klist; 748 int s; 749 750 switch (kn->kn_filter) { 751 case EVFILT_READ: 752 if (minor(dev) != USB_DEV_MINOR) 753 return (1); 754 klist = &usb_selevent.sel_klist; 755 kn->kn_fop = &usbread_filtops; 756 break; 757 758 default: 759 return (EINVAL); 760 } 761 762 kn->kn_hook = NULL; 763 764 s = splusb(); 765 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 766 splx(s); 767 768 return (0); 769 } 770 771 /* Explore device tree from the root. */ 772 Static void 773 usb_discover(struct usb_softc *sc) 774 { 775 776 DPRINTFN(2,("usb_discover\n")); 777 #ifdef USB_DEBUG 778 if (usb_noexplore > 1) 779 return; 780 #endif 781 /* 782 * We need mutual exclusion while traversing the device tree, 783 * but this is guaranteed since this function is only called 784 * from the event thread for the controller. 785 */ 786 while (sc->sc_bus->needs_explore && !sc->sc_dying) { 787 sc->sc_bus->needs_explore = 0; 788 sc->sc_bus->root_hub->hub->explore(sc->sc_bus->root_hub); 789 } 790 } 791 792 void 793 usb_needs_explore(usbd_device_handle dev) 794 { 795 DPRINTFN(2,("usb_needs_explore\n")); 796 dev->bus->needs_explore = 1; 797 wakeup(&dev->bus->needs_explore); 798 } 799 800 void 801 usb_needs_reattach(usbd_device_handle dev) 802 { 803 DPRINTFN(2,("usb_needs_reattach\n")); 804 dev->powersrc->reattach = 1; 805 dev->bus->needs_explore = 1; 806 wakeup(&dev->bus->needs_explore); 807 } 808 809 /* Called at splusb() */ 810 int 811 usb_get_next_event(struct usb_event *ue) 812 { 813 struct usb_event_q *ueq; 814 815 if (usb_nevents <= 0) 816 return (0); 817 ueq = SIMPLEQ_FIRST(&usb_events); 818 #ifdef DIAGNOSTIC 819 if (ueq == NULL) { 820 printf("usb: usb_nevents got out of sync! %d\n", usb_nevents); 821 usb_nevents = 0; 822 return (0); 823 } 824 #endif 825 if (ue) 826 *ue = ueq->ue; 827 SIMPLEQ_REMOVE_HEAD(&usb_events, next); 828 usb_free_event((struct usb_event *)(void *)ueq); 829 usb_nevents--; 830 return (1); 831 } 832 833 void 834 usbd_add_dev_event(int type, usbd_device_handle udev) 835 { 836 struct usb_event *ue = usb_alloc_event(); 837 838 usbd_fill_deviceinfo(udev, &ue->u.ue_device, USB_EVENT_IS_ATTACH(type)); 839 usb_add_event(type, ue); 840 } 841 842 void 843 usbd_add_drv_event(int type, usbd_device_handle udev, device_t dev) 844 { 845 struct usb_event *ue = usb_alloc_event(); 846 847 ue->u.ue_driver.ue_cookie = udev->cookie; 848 strncpy(ue->u.ue_driver.ue_devname, USBDEVPTRNAME(dev), 849 sizeof ue->u.ue_driver.ue_devname); 850 usb_add_event(type, ue); 851 } 852 853 Static struct usb_event * 854 usb_alloc_event(void) 855 { 856 /* Yes, this is right; we allocate enough so that we can use it later */ 857 return malloc(sizeof(struct usb_event_q), M_USBDEV, M_WAITOK|M_ZERO); 858 } 859 860 Static void 861 usb_free_event(struct usb_event *uep) 862 { 863 free(uep, M_USBDEV); 864 } 865 866 Static void 867 usb_add_event(int type, struct usb_event *uep) 868 { 869 struct usb_event_q *ueq; 870 struct timeval thetime; 871 int s; 872 873 microtime(&thetime); 874 /* Don't want to wait here inside splusb() */ 875 ueq = (struct usb_event_q *)(void *)uep; 876 ueq->ue = *uep; 877 ueq->ue.ue_type = type; 878 TIMEVAL_TO_TIMESPEC(&thetime, &ueq->ue.ue_time); 879 880 s = splusb(); 881 if (++usb_nevents >= USB_MAX_EVENTS) { 882 /* Too many queued events, drop an old one. */ 883 DPRINTFN(-1,("usb: event dropped\n")); 884 (void)usb_get_next_event(0); 885 } 886 SIMPLEQ_INSERT_TAIL(&usb_events, ueq, next); 887 wakeup(&usb_events); 888 selnotify(&usb_selevent, 0, 0); 889 if (usb_async_proc != NULL) { 890 softint_schedule(usb_async_sih); 891 } 892 splx(s); 893 } 894 895 Static void 896 usb_async_intr(void *cookie) 897 { 898 proc_t *proc; 899 900 mutex_enter(proc_lock); 901 if ((proc = usb_async_proc) != NULL) 902 psignal(proc, SIGIO); 903 mutex_exit(proc_lock); 904 } 905 906 void 907 usb_schedsoftintr(usbd_bus_handle bus) 908 { 909 DPRINTFN(10,("usb_schedsoftintr: polling=%d\n", bus->use_polling)); 910 #ifdef USB_USE_SOFTINTR 911 if (bus->use_polling) { 912 bus->methods->soft_intr(bus); 913 } else { 914 softint_schedule(bus->soft); 915 } 916 #else 917 bus->methods->soft_intr(bus); 918 #endif /* USB_USE_SOFTINTR */ 919 } 920 921 int 922 usb_activate(device_t self, enum devact act) 923 { 924 struct usb_softc *sc = device_private(self); 925 926 switch (act) { 927 case DVACT_DEACTIVATE: 928 sc->sc_dying = 1; 929 return 0; 930 default: 931 return EOPNOTSUPP; 932 } 933 } 934 935 void 936 usb_childdet(device_t self, device_t child) 937 { 938 int i; 939 struct usb_softc *sc = device_private(self); 940 struct usbd_device *dev; 941 942 if ((dev = sc->sc_port.device) == NULL || dev->subdevlen == 0) 943 return; 944 945 for (i = 0; i < dev->subdevlen; i++) 946 if (dev->subdevs[i] == child) 947 dev->subdevs[i] = NULL; 948 } 949 950 int 951 usb_detach(device_t self, int flags) 952 { 953 struct usb_softc *sc = device_private(self); 954 struct usb_event *ue; 955 int rc; 956 957 DPRINTF(("usb_detach: start\n")); 958 959 /* Make all devices disconnect. */ 960 if (sc->sc_port.device != NULL && 961 (rc = usb_disconnect_port(&sc->sc_port, self, flags)) != 0) 962 return rc; 963 964 pmf_device_deregister(self); 965 /* Kill off event thread. */ 966 sc->sc_dying = 1; 967 while (sc->sc_event_thread != NULL) { 968 wakeup(&sc->sc_bus->needs_explore); 969 tsleep(sc, PWAIT, "usbdet", hz * 60); 970 } 971 DPRINTF(("usb_detach: event thread dead\n")); 972 973 #ifdef USB_USE_SOFTINTR 974 if (sc->sc_bus->soft != NULL) { 975 softint_disestablish(sc->sc_bus->soft); 976 sc->sc_bus->soft = NULL; 977 } 978 #endif 979 980 ue = usb_alloc_event(); 981 ue->u.ue_ctrlr.ue_bus = device_unit(self); 982 usb_add_event(USB_EVENT_CTRLR_DETACH, ue); 983 984 return (0); 985 } 986 987 #ifdef COMPAT_30 988 Static void 989 usb_copy_old_devinfo(struct usb_device_info_old *uo, 990 const struct usb_device_info *ue) 991 { 992 const unsigned char *p; 993 unsigned char *q; 994 int i, n; 995 996 uo->udi_bus = ue->udi_bus; 997 uo->udi_addr = ue->udi_addr; 998 uo->udi_cookie = ue->udi_cookie; 999 for (i = 0, p = (const unsigned char *)ue->udi_product, 1000 q = (unsigned char *)uo->udi_product; 1001 *p && i < USB_MAX_STRING_LEN - 1; p++) { 1002 if (*p < 0x80) 1003 q[i++] = *p; 1004 else { 1005 q[i++] = '?'; 1006 if ((*p & 0xe0) == 0xe0) 1007 p++; 1008 p++; 1009 } 1010 } 1011 q[i] = 0; 1012 1013 for (i = 0, p = ue->udi_vendor, q = uo->udi_vendor; 1014 *p && i < USB_MAX_STRING_LEN - 1; p++) { 1015 if (* p < 0x80) 1016 q[i++] = *p; 1017 else { 1018 q[i++] = '?'; 1019 p++; 1020 if ((*p & 0xe0) == 0xe0) 1021 p++; 1022 } 1023 } 1024 q[i] = 0; 1025 1026 memcpy(uo->udi_release, ue->udi_release, sizeof(uo->udi_release)); 1027 1028 uo->udi_productNo = ue->udi_productNo; 1029 uo->udi_vendorNo = ue->udi_vendorNo; 1030 uo->udi_releaseNo = ue->udi_releaseNo; 1031 uo->udi_class = ue->udi_class; 1032 uo->udi_subclass = ue->udi_subclass; 1033 uo->udi_protocol = ue->udi_protocol; 1034 uo->udi_config = ue->udi_config; 1035 uo->udi_speed = ue->udi_speed; 1036 uo->udi_power = ue->udi_power; 1037 uo->udi_nports = ue->udi_nports; 1038 1039 for (n=0; n<USB_MAX_DEVNAMES; n++) 1040 memcpy(uo->udi_devnames[n], 1041 ue->udi_devnames[n], USB_MAX_DEVNAMELEN); 1042 memcpy(uo->udi_ports, ue->udi_ports, sizeof(uo->udi_ports)); 1043 } 1044 #endif 1045
Indexes created Mon Sep 29 21:09:56 GMT 2025