ugen.c revision 1.171.2.2
1 /* $NetBSD: ugen.c,v 1.171.2.2 2024/04/16 18:59:49 martin Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2004 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 * Copyright (c) 2006 BBN Technologies Corp. All rights reserved. 12 * Effort sponsored in part by the Defense Advanced Research Projects 13 * Agency (DARPA) and the Department of the Interior National Business 14 * Center under agreement number NBCHC050166. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 26 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: ugen.c,v 1.171.2.2 2024/04/16 18:59:49 martin Exp $"); 41 42 #ifdef _KERNEL_OPT 43 #include "opt_compat_netbsd.h" 44 #include "opt_usb.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/ioctl.h> 53 #include <sys/conf.h> 54 #include <sys/tty.h> 55 #include <sys/file.h> 56 #include <sys/select.h> 57 #include <sys/proc.h> 58 #include <sys/vnode.h> 59 #include <sys/poll.h> 60 #include <sys/compat_stub.h> 61 #include <sys/module.h> 62 #include <sys/rbtree.h> 63 64 #include <dev/usb/usb.h> 65 #include <dev/usb/usbdi.h> 66 #include <dev/usb/usbdi_util.h> 67 #include <dev/usb/usbhist.h> 68 69 #include "ioconf.h" 70 71 #ifdef USB_DEBUG 72 #ifndef UGEN_DEBUG 73 #define ugendebug 0 74 #else 75 int ugendebug = 0; 76 77 SYSCTL_SETUP(sysctl_hw_ugen_setup, "sysctl hw.ugen setup") 78 { 79 int err; 80 const struct sysctlnode *rnode; 81 const struct sysctlnode *cnode; 82 83 err = sysctl_createv(clog, 0, NULL, &rnode, 84 CTLFLAG_PERMANENT, CTLTYPE_NODE, "ugen", 85 SYSCTL_DESCR("ugen global controls"), 86 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL); 87 88 if (err) 89 goto fail; 90 91 /* control debugging printfs */ 92 err = sysctl_createv(clog, 0, &rnode, &cnode, 93 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, 94 "debug", SYSCTL_DESCR("Enable debugging output"), 95 NULL, 0, &ugendebug, sizeof(ugendebug), CTL_CREATE, CTL_EOL); 96 if (err) 97 goto fail; 98 99 return; 100 fail: 101 aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err); 102 } 103 104 #endif /* UGEN_DEBUG */ 105 #endif /* USB_DEBUG */ 106 107 #define DPRINTF(FMT,A,B,C,D) USBHIST_LOGN(ugendebug,1,FMT,A,B,C,D) 108 #define DPRINTFN(N,FMT,A,B,C,D) USBHIST_LOGN(ugendebug,N,FMT,A,B,C,D) 109 #define UGENHIST_FUNC() USBHIST_FUNC() 110 #define UGENHIST_CALLED(name) USBHIST_CALLED(ugendebug) 111 112 #define UGEN_CHUNK 128 /* chunk size for read */ 113 #define UGEN_IBSIZE 1020 /* buffer size */ 114 #define UGEN_BBSIZE 1024 115 116 #define UGEN_NISOREQS 4 /* number of outstanding xfer requests */ 117 #define UGEN_NISORFRMS 8 /* number of transactions per req */ 118 #define UGEN_NISOFRAMES (UGEN_NISORFRMS * UGEN_NISOREQS) 119 120 #define UGEN_BULK_RA_WB_BUFSIZE 16384 /* default buffer size */ 121 #define UGEN_BULK_RA_WB_BUFMAX (1 << 20) /* maximum allowed buffer */ 122 123 struct isoreq { 124 struct ugen_endpoint *sce; 125 struct usbd_xfer *xfer; 126 void *dmabuf; 127 uint16_t sizes[UGEN_NISORFRMS]; 128 }; 129 130 struct ugen_endpoint { 131 struct ugen_softc *sc; 132 usb_endpoint_descriptor_t *edesc; 133 struct usbd_interface *iface; 134 int state; 135 #define UGEN_SHORT_OK 0x04 /* short xfers are OK */ 136 #define UGEN_BULK_RA 0x08 /* in bulk read-ahead mode */ 137 #define UGEN_BULK_WB 0x10 /* in bulk write-behind mode */ 138 #define UGEN_RA_WB_STOP 0x20 /* RA/WB xfer is stopped (buffer full/empty) */ 139 struct usbd_pipe *pipeh; 140 struct clist q; 141 u_char *ibuf; /* start of buffer (circular for isoc) */ 142 u_char *fill; /* location for input (isoc) */ 143 u_char *limit; /* end of circular buffer (isoc) */ 144 u_char *cur; /* current read location (isoc) */ 145 uint32_t timeout; 146 uint32_t ra_wb_bufsize; /* requested size for RA/WB buffer */ 147 uint32_t ra_wb_reqsize; /* requested xfer length for RA/WB */ 148 uint32_t ra_wb_used; /* how much is in buffer */ 149 uint32_t ra_wb_xferlen; /* current xfer length for RA/WB */ 150 struct usbd_xfer *ra_wb_xfer; 151 struct isoreq isoreqs[UGEN_NISOREQS]; 152 /* Keep these last; we don't overwrite them in ugen_set_config() */ 153 #define UGEN_ENDPOINT_NONZERO_CRUFT offsetof(struct ugen_endpoint, rsel) 154 struct selinfo rsel; 155 kcondvar_t cv; 156 }; 157 158 struct ugen_softc { 159 device_t sc_dev; /* base device */ 160 struct usbd_device *sc_udev; 161 struct rb_node sc_node; 162 unsigned sc_unit; 163 164 kmutex_t sc_lock; 165 kcondvar_t sc_detach_cv; 166 167 char sc_is_open[USB_MAX_ENDPOINTS]; 168 struct ugen_endpoint sc_endpoints[USB_MAX_ENDPOINTS][2]; 169 #define OUT 0 170 #define IN 1 171 172 int sc_refcnt; 173 char sc_buffer[UGEN_BBSIZE]; 174 u_char sc_dying; 175 u_char sc_attached; 176 }; 177 178 static struct { 179 kmutex_t lock; 180 rb_tree_t tree; 181 } ugenif __cacheline_aligned; 182 183 static int 184 compare_ugen(void *cookie, const void *vsca, const void *vscb) 185 { 186 const struct ugen_softc *sca = vsca; 187 const struct ugen_softc *scb = vscb; 188 189 if (sca->sc_unit < scb->sc_unit) 190 return -1; 191 if (sca->sc_unit > scb->sc_unit) 192 return +1; 193 return 0; 194 } 195 196 static int 197 compare_ugen_key(void *cookie, const void *vsc, const void *vk) 198 { 199 const struct ugen_softc *sc = vsc; 200 const unsigned *k = vk; 201 202 if (sc->sc_unit < *k) 203 return -1; 204 if (sc->sc_unit > *k) 205 return +1; 206 return 0; 207 } 208 209 static const rb_tree_ops_t ugenif_tree_ops = { 210 .rbto_compare_nodes = compare_ugen, 211 .rbto_compare_key = compare_ugen_key, 212 .rbto_node_offset = offsetof(struct ugen_softc, sc_node), 213 }; 214 215 static void 216 ugenif_get_unit(struct ugen_softc *sc) 217 { 218 struct ugen_softc *sc0; 219 unsigned i; 220 221 mutex_enter(&ugenif.lock); 222 for (i = 0, sc0 = RB_TREE_MIN(&ugenif.tree); 223 sc0 != NULL && i == sc0->sc_unit; 224 i++, sc0 = RB_TREE_NEXT(&ugenif.tree, sc0)) 225 KASSERT(i < UINT_MAX); 226 KASSERT(rb_tree_find_node(&ugenif.tree, &i) == NULL); 227 sc->sc_unit = i; 228 sc0 = rb_tree_insert_node(&ugenif.tree, sc); 229 KASSERT(sc0 == sc); 230 KASSERT(rb_tree_find_node(&ugenif.tree, &i) == sc); 231 mutex_exit(&ugenif.lock); 232 233 prop_dictionary_set_uint(device_properties(sc->sc_dev), 234 "ugen-unit", sc->sc_unit); 235 } 236 237 static void 238 ugenif_put_unit(struct ugen_softc *sc) 239 { 240 241 prop_dictionary_remove(device_properties(sc->sc_dev), 242 "ugen-unit"); 243 244 mutex_enter(&ugenif.lock); 245 KASSERT(rb_tree_find_node(&ugenif.tree, &sc->sc_unit) == sc); 246 rb_tree_remove_node(&ugenif.tree, sc); 247 sc->sc_unit = -1; 248 mutex_exit(&ugenif.lock); 249 } 250 251 static struct ugen_softc * 252 ugenif_acquire(unsigned unit) 253 { 254 struct ugen_softc *sc; 255 256 mutex_enter(&ugenif.lock); 257 sc = rb_tree_find_node(&ugenif.tree, &unit); 258 if (sc == NULL) 259 goto out; 260 mutex_enter(&sc->sc_lock); 261 if (sc->sc_dying) { 262 mutex_exit(&sc->sc_lock); 263 sc = NULL; 264 goto out; 265 } 266 KASSERT(sc->sc_refcnt < INT_MAX); 267 sc->sc_refcnt++; 268 mutex_exit(&sc->sc_lock); 269 out: mutex_exit(&ugenif.lock); 270 271 return sc; 272 } 273 274 static void 275 ugenif_release(struct ugen_softc *sc) 276 { 277 278 mutex_enter(&sc->sc_lock); 279 if (--sc->sc_refcnt < 0) 280 cv_broadcast(&sc->sc_detach_cv); 281 mutex_exit(&sc->sc_lock); 282 } 283 284 static dev_type_open(ugenopen); 285 static dev_type_close(ugenclose); 286 static dev_type_read(ugenread); 287 static dev_type_write(ugenwrite); 288 static dev_type_ioctl(ugenioctl); 289 static dev_type_poll(ugenpoll); 290 static dev_type_kqfilter(ugenkqfilter); 291 292 const struct cdevsw ugen_cdevsw = { 293 .d_open = ugenopen, 294 .d_close = ugenclose, 295 .d_read = ugenread, 296 .d_write = ugenwrite, 297 .d_ioctl = ugenioctl, 298 .d_stop = nostop, 299 .d_tty = notty, 300 .d_poll = ugenpoll, 301 .d_mmap = nommap, 302 .d_kqfilter = ugenkqfilter, 303 .d_discard = nodiscard, 304 .d_flag = D_OTHER, 305 }; 306 307 Static void ugenintr(struct usbd_xfer *, void *, 308 usbd_status); 309 Static void ugen_isoc_rintr(struct usbd_xfer *, void *, 310 usbd_status); 311 Static void ugen_bulkra_intr(struct usbd_xfer *, void *, 312 usbd_status); 313 Static void ugen_bulkwb_intr(struct usbd_xfer *, void *, 314 usbd_status); 315 Static int ugen_do_read(struct ugen_softc *, int, struct uio *, int); 316 Static int ugen_do_write(struct ugen_softc *, int, struct uio *, int); 317 Static int ugen_do_ioctl(struct ugen_softc *, int, u_long, 318 void *, int, struct lwp *); 319 Static int ugen_set_config(struct ugen_softc *, int, int); 320 Static usb_config_descriptor_t *ugen_get_cdesc(struct ugen_softc *, 321 int, int *); 322 Static usbd_status ugen_set_interface(struct ugen_softc *, int, int); 323 Static int ugen_get_alt_index(struct ugen_softc *, int); 324 Static void ugen_clear_endpoints(struct ugen_softc *); 325 326 #define UGENUNIT(n) ((minor(n) >> 4) & 0xf) 327 #define UGENENDPOINT(n) (minor(n) & 0xf) 328 #define UGENDEV(u, e) (makedev(0, ((u) << 4) | (e))) 329 330 static int ugenif_match(device_t, cfdata_t, void *); 331 static void ugenif_attach(device_t, device_t, void *); 332 static int ugen_match(device_t, cfdata_t, void *); 333 static void ugen_attach(device_t, device_t, void *); 334 static int ugen_detach(device_t, int); 335 static int ugen_activate(device_t, enum devact); 336 337 CFATTACH_DECL_NEW(ugen, sizeof(struct ugen_softc), ugen_match, 338 ugen_attach, ugen_detach, ugen_activate); 339 CFATTACH_DECL_NEW(ugenif, sizeof(struct ugen_softc), ugenif_match, 340 ugenif_attach, ugen_detach, ugen_activate); 341 342 /* toggle to control attach priority. -1 means "let autoconf decide" */ 343 int ugen_override = -1; 344 345 static int 346 ugen_match(device_t parent, cfdata_t match, void *aux) 347 { 348 struct usb_attach_arg *uaa = aux; 349 int override; 350 351 if (ugen_override != -1) 352 override = ugen_override; 353 else 354 override = match->cf_flags & 1; 355 356 if (override) 357 return UMATCH_HIGHEST; 358 else if (uaa->uaa_usegeneric) 359 return UMATCH_GENERIC; 360 else 361 return UMATCH_NONE; 362 } 363 364 static int 365 ugenif_match(device_t parent, cfdata_t match, void *aux) 366 { 367 /* 368 * Like ugen(4), ugenif(4) also has an override flag. It has the 369 * opposite effect, however, causing us to match with GENERIC 370 * priority rather than HIGHEST. 371 */ 372 return (match->cf_flags & 1) ? UMATCH_GENERIC : UMATCH_HIGHEST; 373 } 374 375 static void 376 ugen_attach(device_t parent, device_t self, void *aux) 377 { 378 struct usb_attach_arg *uaa = aux; 379 struct usbif_attach_arg uiaa; 380 381 memset(&uiaa, 0, sizeof(uiaa)); 382 uiaa.uiaa_port = uaa->uaa_port; 383 uiaa.uiaa_vendor = uaa->uaa_vendor; 384 uiaa.uiaa_product = uaa->uaa_product; 385 uiaa.uiaa_release = uaa->uaa_release; 386 uiaa.uiaa_device = uaa->uaa_device; 387 uiaa.uiaa_configno = -1; 388 uiaa.uiaa_ifaceno = -1; 389 390 ugenif_attach(parent, self, &uiaa); 391 } 392 393 static void 394 ugenif_attach(device_t parent, device_t self, void *aux) 395 { 396 struct ugen_softc *sc = device_private(self); 397 struct usbif_attach_arg *uiaa = aux; 398 struct usbd_device *udev; 399 char *devinfop; 400 usbd_status err; 401 int i, dir, conf; 402 403 aprint_naive("\n"); 404 aprint_normal("\n"); 405 406 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB); 407 cv_init(&sc->sc_detach_cv, "ugendet"); 408 409 devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0); 410 aprint_normal_dev(self, "%s\n", devinfop); 411 usbd_devinfo_free(devinfop); 412 413 sc->sc_dev = self; 414 sc->sc_udev = udev = uiaa->uiaa_device; 415 416 for (i = 0; i < USB_MAX_ENDPOINTS; i++) { 417 for (dir = OUT; dir <= IN; dir++) { 418 struct ugen_endpoint *sce; 419 420 sce = &sc->sc_endpoints[i][dir]; 421 selinit(&sce->rsel); 422 cv_init(&sce->cv, "ugensce"); 423 } 424 } 425 426 if (!pmf_device_register(self, NULL, NULL)) 427 aprint_error_dev(self, "couldn't establish power handler\n"); 428 429 if (uiaa->uiaa_ifaceno < 0) { 430 /* 431 * If we attach the whole device, 432 * set configuration index 0, the default one. 433 */ 434 err = usbd_set_config_index(udev, 0, 0); 435 if (err) { 436 aprint_error_dev(self, 437 "setting configuration index 0 failed\n"); 438 return; 439 } 440 } 441 442 /* Get current configuration */ 443 conf = usbd_get_config_descriptor(udev)->bConfigurationValue; 444 445 /* Set up all the local state for this configuration. */ 446 err = ugen_set_config(sc, conf, uiaa->uiaa_ifaceno < 0); 447 if (err) { 448 aprint_error_dev(self, "setting configuration %d failed\n", 449 conf); 450 return; 451 } 452 453 ugenif_get_unit(sc); 454 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev); 455 sc->sc_attached = 1; 456 } 457 458 Static void 459 ugen_clear_endpoints(struct ugen_softc *sc) 460 { 461 462 /* Clear out the old info, but leave the selinfo and cv initialised. */ 463 for (int i = 0; i < USB_MAX_ENDPOINTS; i++) { 464 for (int dir = OUT; dir <= IN; dir++) { 465 struct ugen_endpoint *sce = &sc->sc_endpoints[i][dir]; 466 memset(sce, 0, UGEN_ENDPOINT_NONZERO_CRUFT); 467 } 468 } 469 } 470 471 Static int 472 ugen_set_config(struct ugen_softc *sc, int configno, int chkopen) 473 { 474 struct usbd_device *dev = sc->sc_udev; 475 usb_config_descriptor_t *cdesc; 476 struct usbd_interface *iface; 477 usb_endpoint_descriptor_t *ed; 478 struct ugen_endpoint *sce; 479 uint8_t niface, nendpt; 480 int ifaceno, endptno, endpt; 481 usbd_status err; 482 int dir; 483 484 UGENHIST_FUNC(); UGENHIST_CALLED(); 485 486 DPRINTFN(1, "ugen%jd: to configno %jd, sc=%jx", 487 device_unit(sc->sc_dev), configno, (uintptr_t)sc, 0); 488 489 KASSERT(KERNEL_LOCKED_P()); /* sc_is_open */ 490 491 if (chkopen) { 492 /* 493 * We start at 1, not 0, because we don't care whether the 494 * control endpoint is open or not. It is always present. 495 */ 496 for (endptno = 1; endptno < USB_MAX_ENDPOINTS; endptno++) 497 if (sc->sc_is_open[endptno]) { 498 DPRINTFN(1, 499 "ugen%jd - endpoint %d is open", 500 device_unit(sc->sc_dev), endptno, 0, 0); 501 return USBD_IN_USE; 502 } 503 504 /* Prevent opening while we're setting the config. */ 505 for (endptno = 1; endptno < USB_MAX_ENDPOINTS; endptno++) { 506 KASSERT(!sc->sc_is_open[endptno]); 507 sc->sc_is_open[endptno] = 1; 508 } 509 } 510 511 /* Avoid setting the current value. */ 512 cdesc = usbd_get_config_descriptor(dev); 513 if (!cdesc || cdesc->bConfigurationValue != configno) { 514 err = usbd_set_config_no(dev, configno, 1); 515 if (err) 516 goto out; 517 } 518 519 ugen_clear_endpoints(sc); 520 521 err = usbd_interface_count(dev, &niface); 522 if (err) 523 goto out; 524 525 for (ifaceno = 0; ifaceno < niface; ifaceno++) { 526 DPRINTFN(1, "ifaceno %jd", ifaceno, 0, 0, 0); 527 err = usbd_device2interface_handle(dev, ifaceno, &iface); 528 if (err) 529 goto out; 530 err = usbd_endpoint_count(iface, &nendpt); 531 if (err) 532 goto out; 533 for (endptno = 0; endptno < nendpt; endptno++) { 534 ed = usbd_interface2endpoint_descriptor(iface,endptno); 535 KASSERT(ed != NULL); 536 endpt = ed->bEndpointAddress; 537 dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT; 538 sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir]; 539 DPRINTFN(1, "endptno %jd, endpt=0x%02jx (%jd,%jd)", 540 endptno, endpt, UE_GET_ADDR(endpt), 541 UE_GET_DIR(endpt)); 542 sce->sc = sc; 543 sce->edesc = ed; 544 sce->iface = iface; 545 } 546 } 547 err = USBD_NORMAL_COMPLETION; 548 549 out: if (chkopen) { 550 /* 551 * Allow open again now that we're done trying to set 552 * the config. 553 */ 554 for (endptno = 1; endptno < USB_MAX_ENDPOINTS; endptno++) { 555 KASSERT(sc->sc_is_open[endptno]); 556 sc->sc_is_open[endptno] = 0; 557 } 558 } 559 return err; 560 } 561 562 static int 563 ugenopen(dev_t dev, int flag, int mode, struct lwp *l) 564 { 565 struct ugen_softc *sc; 566 int unit = UGENUNIT(dev); 567 int endpt = UGENENDPOINT(dev); 568 usb_endpoint_descriptor_t *edesc; 569 struct ugen_endpoint *sce; 570 int dir, isize; 571 usbd_status err; 572 struct usbd_xfer *xfer; 573 int i, j; 574 int error; 575 int opened = 0; 576 577 UGENHIST_FUNC(); UGENHIST_CALLED(); 578 579 KASSERT(KERNEL_LOCKED_P()); /* sc_is_open */ 580 581 if ((sc = ugenif_acquire(unit)) == NULL) 582 return ENXIO; 583 584 DPRINTFN(5, "flag=%jd, mode=%jd, unit=%jd endpt=%jd", 585 flag, mode, unit, endpt); 586 587 /* The control endpoint allows multiple opens. */ 588 if (endpt == USB_CONTROL_ENDPOINT) { 589 opened = sc->sc_is_open[USB_CONTROL_ENDPOINT] = 1; 590 error = 0; 591 goto out; 592 } 593 594 if (sc->sc_is_open[endpt]) { 595 error = EBUSY; 596 goto out; 597 } 598 opened = sc->sc_is_open[endpt] = 1; 599 600 /* Make sure there are pipes for all directions. */ 601 for (dir = OUT; dir <= IN; dir++) { 602 if (flag & (dir == OUT ? FWRITE : FREAD)) { 603 sce = &sc->sc_endpoints[endpt][dir]; 604 if (sce->edesc == NULL) { 605 error = ENXIO; 606 goto out; 607 } 608 } 609 } 610 611 /* Actually open the pipes. */ 612 /* XXX Should back out properly if it fails. */ 613 for (dir = OUT; dir <= IN; dir++) { 614 if (!(flag & (dir == OUT ? FWRITE : FREAD))) 615 continue; 616 sce = &sc->sc_endpoints[endpt][dir]; 617 sce->state = 0; 618 sce->timeout = USBD_NO_TIMEOUT; 619 DPRINTFN(5, "sc=%jx, endpt=%jd, dir=%jd, sce=%jp", 620 (uintptr_t)sc, endpt, dir, (uintptr_t)sce); 621 edesc = sce->edesc; 622 switch (edesc->bmAttributes & UE_XFERTYPE) { 623 case UE_INTERRUPT: 624 if (dir == OUT) { 625 err = usbd_open_pipe(sce->iface, 626 edesc->bEndpointAddress, 0, &sce->pipeh); 627 if (err) { 628 error = EIO; 629 goto out; 630 } 631 break; 632 } 633 isize = UGETW(edesc->wMaxPacketSize); 634 if (isize == 0) { /* shouldn't happen */ 635 error = EINVAL; 636 goto out; 637 } 638 sce->ibuf = kmem_alloc(isize, KM_SLEEP); 639 DPRINTFN(5, "intr endpt=%d, isize=%d", 640 endpt, isize, 0, 0); 641 if (clalloc(&sce->q, UGEN_IBSIZE, 0) == -1) { 642 kmem_free(sce->ibuf, isize); 643 sce->ibuf = NULL; 644 error = ENOMEM; 645 goto out; 646 } 647 err = usbd_open_pipe_intr(sce->iface, 648 edesc->bEndpointAddress, 649 USBD_SHORT_XFER_OK, &sce->pipeh, sce, 650 sce->ibuf, isize, ugenintr, 651 USBD_DEFAULT_INTERVAL); 652 if (err) { 653 clfree(&sce->q); 654 kmem_free(sce->ibuf, isize); 655 sce->ibuf = NULL; 656 error = EIO; 657 goto out; 658 } 659 DPRINTFN(5, "interrupt open done", 0, 0, 0, 0); 660 break; 661 case UE_BULK: 662 err = usbd_open_pipe(sce->iface, 663 edesc->bEndpointAddress, 0, &sce->pipeh); 664 if (err) { 665 error = EIO; 666 goto out; 667 } 668 sce->ra_wb_bufsize = UGEN_BULK_RA_WB_BUFSIZE; 669 /* 670 * Use request size for non-RA/WB transfers 671 * as the default. 672 */ 673 sce->ra_wb_reqsize = UGEN_BBSIZE; 674 break; 675 case UE_ISOCHRONOUS: 676 if (dir == OUT) { 677 error = EINVAL; 678 goto out; 679 } 680 isize = UGETW(edesc->wMaxPacketSize); 681 if (isize == 0) { /* shouldn't happen */ 682 error = EINVAL; 683 goto out; 684 } 685 sce->ibuf = kmem_alloc(isize * UGEN_NISOFRAMES, 686 KM_SLEEP); 687 sce->cur = sce->fill = sce->ibuf; 688 sce->limit = sce->ibuf + isize * UGEN_NISOFRAMES; 689 DPRINTFN(5, "isoc endpt=%d, isize=%d", 690 endpt, isize, 0, 0); 691 err = usbd_open_pipe(sce->iface, 692 edesc->bEndpointAddress, 0, &sce->pipeh); 693 if (err) { 694 kmem_free(sce->ibuf, isize * UGEN_NISOFRAMES); 695 sce->ibuf = NULL; 696 error = EIO; 697 goto out; 698 } 699 for (i = 0; i < UGEN_NISOREQS; ++i) { 700 sce->isoreqs[i].sce = sce; 701 err = usbd_create_xfer(sce->pipeh, 702 isize * UGEN_NISORFRMS, 0, UGEN_NISORFRMS, 703 &xfer); 704 if (err) 705 goto bad; 706 sce->isoreqs[i].xfer = xfer; 707 sce->isoreqs[i].dmabuf = usbd_get_buffer(xfer); 708 for (j = 0; j < UGEN_NISORFRMS; ++j) 709 sce->isoreqs[i].sizes[j] = isize; 710 usbd_setup_isoc_xfer(xfer, &sce->isoreqs[i], 711 sce->isoreqs[i].sizes, UGEN_NISORFRMS, 0, 712 ugen_isoc_rintr); 713 (void)usbd_transfer(xfer); 714 } 715 DPRINTFN(5, "isoc open done", 0, 0, 0, 0); 716 break; 717 bad: 718 while (--i >= 0) { /* implicit buffer free */ 719 usbd_destroy_xfer(sce->isoreqs[i].xfer); 720 sce->isoreqs[i].xfer = NULL; 721 } 722 usbd_close_pipe(sce->pipeh); 723 sce->pipeh = NULL; 724 kmem_free(sce->ibuf, isize * UGEN_NISOFRAMES); 725 sce->ibuf = NULL; 726 error = ENOMEM; 727 goto out; 728 case UE_CONTROL: 729 sce->timeout = USBD_DEFAULT_TIMEOUT; 730 error = EINVAL; 731 goto out; 732 } 733 } 734 error = 0; 735 out: if (error && opened) 736 sc->sc_is_open[endpt] = 0; 737 ugenif_release(sc); 738 return error; 739 } 740 741 static void 742 ugen_do_close(struct ugen_softc *sc, int flag, int endpt) 743 { 744 struct ugen_endpoint *sce; 745 int dir; 746 int i; 747 748 UGENHIST_FUNC(); UGENHIST_CALLED(); 749 750 KASSERT(KERNEL_LOCKED_P()); /* sc_is_open */ 751 752 if (!sc->sc_is_open[endpt]) 753 goto out; 754 755 if (endpt == USB_CONTROL_ENDPOINT) { 756 DPRINTFN(5, "close control", 0, 0, 0, 0); 757 goto out; 758 } 759 760 for (dir = OUT; dir <= IN; dir++) { 761 if (!(flag & (dir == OUT ? FWRITE : FREAD))) 762 continue; 763 sce = &sc->sc_endpoints[endpt][dir]; 764 if (sce->pipeh == NULL) 765 continue; 766 DPRINTFN(5, "endpt=%jd dir=%jd sce=%jx", 767 endpt, dir, (uintptr_t)sce, 0); 768 769 usbd_abort_pipe(sce->pipeh); 770 771 int isize = UGETW(sce->edesc->wMaxPacketSize); 772 int msize = 0; 773 774 switch (sce->edesc->bmAttributes & UE_XFERTYPE) { 775 case UE_INTERRUPT: 776 ndflush(&sce->q, sce->q.c_cc); 777 clfree(&sce->q); 778 msize = isize; 779 break; 780 case UE_ISOCHRONOUS: 781 for (i = 0; i < UGEN_NISOREQS; ++i) { 782 usbd_destroy_xfer(sce->isoreqs[i].xfer); 783 sce->isoreqs[i].xfer = NULL; 784 } 785 msize = isize * UGEN_NISOFRAMES; 786 break; 787 case UE_BULK: 788 if (sce->state & (UGEN_BULK_RA | UGEN_BULK_WB)) { 789 usbd_destroy_xfer(sce->ra_wb_xfer); 790 sce->ra_wb_xfer = NULL; 791 msize = sce->ra_wb_bufsize; 792 } 793 break; 794 default: 795 break; 796 } 797 usbd_close_pipe(sce->pipeh); 798 sce->pipeh = NULL; 799 if (sce->ibuf != NULL) { 800 kmem_free(sce->ibuf, msize); 801 sce->ibuf = NULL; 802 } 803 } 804 805 out: sc->sc_is_open[endpt] = 0; 806 for (dir = OUT; dir <= IN; dir++) { 807 sce = &sc->sc_endpoints[endpt][dir]; 808 KASSERT(sce->pipeh == NULL); 809 KASSERT(sce->ibuf == NULL); 810 KASSERT(sce->ra_wb_xfer == NULL); 811 for (i = 0; i < UGEN_NISOREQS; i++) 812 KASSERT(sce->isoreqs[i].xfer == NULL); 813 } 814 } 815 816 static int 817 ugenclose(dev_t dev, int flag, int mode, struct lwp *l) 818 { 819 int endpt = UGENENDPOINT(dev); 820 struct ugen_softc *sc; 821 822 UGENHIST_FUNC(); UGENHIST_CALLED(); 823 824 DPRINTFN(5, "flag=%jd, mode=%jd, unit=%jd, endpt=%jd", 825 flag, mode, UGENUNIT(dev), endpt); 826 827 KASSERT(KERNEL_LOCKED_P()); /* ugen_do_close */ 828 829 if ((sc = ugenif_acquire(UGENUNIT(dev))) == NULL) 830 return ENXIO; 831 832 KASSERT(sc->sc_is_open[endpt]); 833 ugen_do_close(sc, flag, endpt); 834 KASSERT(!sc->sc_is_open[endpt]); 835 836 ugenif_release(sc); 837 838 return 0; 839 } 840 841 Static int 842 ugen_do_read(struct ugen_softc *sc, int endpt, struct uio *uio, int flag) 843 { 844 struct ugen_endpoint *sce = &sc->sc_endpoints[endpt][IN]; 845 uint32_t n, tn; 846 struct usbd_xfer *xfer; 847 usbd_status err; 848 int error = 0; 849 850 UGENHIST_FUNC(); UGENHIST_CALLED(); 851 852 DPRINTFN(5, "ugen%d: %jd", device_unit(sc->sc_dev), endpt, 0, 0); 853 854 if (endpt == USB_CONTROL_ENDPOINT) 855 return ENODEV; 856 857 KASSERT(sce->edesc); 858 KASSERT(sce->pipeh); 859 860 switch (sce->edesc->bmAttributes & UE_XFERTYPE) { 861 case UE_INTERRUPT: 862 /* Block until activity occurred. */ 863 mutex_enter(&sc->sc_lock); 864 while (sce->q.c_cc == 0) { 865 if (flag & IO_NDELAY) { 866 mutex_exit(&sc->sc_lock); 867 return EWOULDBLOCK; 868 } 869 DPRINTFN(5, "sleep on %jx", (uintptr_t)sce, 0, 0, 0); 870 /* "ugenri" */ 871 error = cv_timedwait_sig(&sce->cv, &sc->sc_lock, 872 mstohz(sce->timeout)); 873 DPRINTFN(5, "woke, error=%jd", 874 error, 0, 0, 0); 875 if (sc->sc_dying) 876 error = EIO; 877 if (error) 878 break; 879 } 880 mutex_exit(&sc->sc_lock); 881 882 /* Transfer as many chunks as possible. */ 883 while (sce->q.c_cc > 0 && uio->uio_resid > 0 && !error) { 884 n = uimin(sce->q.c_cc, uio->uio_resid); 885 if (n > sizeof(sc->sc_buffer)) 886 n = sizeof(sc->sc_buffer); 887 888 /* Remove a small chunk from the input queue. */ 889 q_to_b(&sce->q, sc->sc_buffer, n); 890 DPRINTFN(5, "got %jd chars", n, 0, 0, 0); 891 892 /* Copy the data to the user process. */ 893 error = uiomove(sc->sc_buffer, n, uio); 894 if (error) 895 break; 896 } 897 break; 898 case UE_BULK: 899 if (sce->state & UGEN_BULK_RA) { 900 DPRINTFN(5, "BULK_RA req: %zd used: %d", 901 uio->uio_resid, sce->ra_wb_used, 0, 0); 902 xfer = sce->ra_wb_xfer; 903 904 mutex_enter(&sc->sc_lock); 905 if (sce->ra_wb_used == 0 && flag & IO_NDELAY) { 906 mutex_exit(&sc->sc_lock); 907 return EWOULDBLOCK; 908 } 909 while (uio->uio_resid > 0 && !error) { 910 while (sce->ra_wb_used == 0) { 911 DPRINTFN(5, "sleep on %jx", 912 (uintptr_t)sce, 0, 0, 0); 913 /* "ugenrb" */ 914 error = cv_timedwait_sig(&sce->cv, 915 &sc->sc_lock, mstohz(sce->timeout)); 916 DPRINTFN(5, "woke, error=%jd", 917 error, 0, 0, 0); 918 if (sc->sc_dying) 919 error = EIO; 920 if (error) 921 break; 922 } 923 924 /* Copy data to the process. */ 925 while (uio->uio_resid > 0 926 && sce->ra_wb_used > 0) { 927 n = uimin(uio->uio_resid, 928 sce->ra_wb_used); 929 n = uimin(n, sce->limit - sce->cur); 930 error = uiomove(sce->cur, n, uio); 931 if (error) 932 break; 933 sce->cur += n; 934 sce->ra_wb_used -= n; 935 if (sce->cur == sce->limit) 936 sce->cur = sce->ibuf; 937 } 938 939 /* 940 * If the transfers stopped because the 941 * buffer was full, restart them. 942 */ 943 if (sce->state & UGEN_RA_WB_STOP && 944 sce->ra_wb_used < sce->limit - sce->ibuf) { 945 n = (sce->limit - sce->ibuf) 946 - sce->ra_wb_used; 947 usbd_setup_xfer(xfer, sce, NULL, 948 uimin(n, sce->ra_wb_xferlen), 949 0, USBD_NO_TIMEOUT, 950 ugen_bulkra_intr); 951 sce->state &= ~UGEN_RA_WB_STOP; 952 err = usbd_transfer(xfer); 953 if (err != USBD_IN_PROGRESS) 954 /* 955 * The transfer has not been 956 * queued. Setting STOP 957 * will make us try 958 * again at the next read. 959 */ 960 sce->state |= UGEN_RA_WB_STOP; 961 } 962 } 963 mutex_exit(&sc->sc_lock); 964 break; 965 } 966 error = usbd_create_xfer(sce->pipeh, UGEN_BBSIZE, 967 0, 0, &xfer); 968 if (error) 969 return error; 970 while ((n = uimin(UGEN_BBSIZE, uio->uio_resid)) != 0) { 971 DPRINTFN(1, "start transfer %jd bytes", n, 0, 0, 0); 972 tn = n; 973 err = usbd_bulk_transfer(xfer, sce->pipeh, 974 sce->state & UGEN_SHORT_OK ? USBD_SHORT_XFER_OK : 0, 975 sce->timeout, sc->sc_buffer, &tn); 976 if (err) { 977 if (err == USBD_INTERRUPTED) 978 error = EINTR; 979 else if (err == USBD_TIMEOUT) 980 error = ETIMEDOUT; 981 else 982 error = EIO; 983 break; 984 } 985 DPRINTFN(1, "got %jd bytes", tn, 0, 0, 0); 986 error = uiomove(sc->sc_buffer, tn, uio); 987 if (error || tn < n) 988 break; 989 } 990 usbd_destroy_xfer(xfer); 991 break; 992 case UE_ISOCHRONOUS: 993 mutex_enter(&sc->sc_lock); 994 while (sce->cur == sce->fill) { 995 if (flag & IO_NDELAY) { 996 mutex_exit(&sc->sc_lock); 997 return EWOULDBLOCK; 998 } 999 /* "ugenri" */ 1000 DPRINTFN(5, "sleep on %jx", (uintptr_t)sce, 0, 0, 0); 1001 error = cv_timedwait_sig(&sce->cv, &sc->sc_lock, 1002 mstohz(sce->timeout)); 1003 DPRINTFN(5, "woke, error=%jd", error, 0, 0, 0); 1004 if (sc->sc_dying) 1005 error = EIO; 1006 if (error) 1007 break; 1008 } 1009 1010 while (sce->cur != sce->fill && uio->uio_resid > 0 && !error) { 1011 if(sce->fill > sce->cur) 1012 n = uimin(sce->fill - sce->cur, uio->uio_resid); 1013 else 1014 n = uimin(sce->limit - sce->cur, uio->uio_resid); 1015 1016 DPRINTFN(5, "isoc got %jd chars", n, 0, 0, 0); 1017 1018 /* Copy the data to the user process. */ 1019 error = uiomove(sce->cur, n, uio); 1020 if (error) 1021 break; 1022 sce->cur += n; 1023 if (sce->cur >= sce->limit) 1024 sce->cur = sce->ibuf; 1025 } 1026 mutex_exit(&sc->sc_lock); 1027 break; 1028 1029 1030 default: 1031 return ENXIO; 1032 } 1033 return error; 1034 } 1035 1036 static int 1037 ugenread(dev_t dev, struct uio *uio, int flag) 1038 { 1039 int endpt = UGENENDPOINT(dev); 1040 struct ugen_softc *sc; 1041 int error; 1042 1043 if ((sc = ugenif_acquire(UGENUNIT(dev))) == NULL) 1044 return ENXIO; 1045 error = ugen_do_read(sc, endpt, uio, flag); 1046 ugenif_release(sc); 1047 1048 return error; 1049 } 1050 1051 Static int 1052 ugen_do_write(struct ugen_softc *sc, int endpt, struct uio *uio, 1053 int flag) 1054 { 1055 struct ugen_endpoint *sce = &sc->sc_endpoints[endpt][OUT]; 1056 uint32_t n; 1057 int error = 0; 1058 uint32_t tn; 1059 char *dbuf; 1060 struct usbd_xfer *xfer; 1061 usbd_status err; 1062 1063 UGENHIST_FUNC(); UGENHIST_CALLED(); 1064 1065 DPRINTFN(5, "ugen%jd: %jd", device_unit(sc->sc_dev), endpt, 0, 0); 1066 1067 if (endpt == USB_CONTROL_ENDPOINT) 1068 return ENODEV; 1069 1070 KASSERT(sce->edesc); 1071 KASSERT(sce->pipeh); 1072 1073 switch (sce->edesc->bmAttributes & UE_XFERTYPE) { 1074 case UE_BULK: 1075 if (sce->state & UGEN_BULK_WB) { 1076 DPRINTFN(5, "BULK_WB req: %jd used: %jd", 1077 uio->uio_resid, sce->ra_wb_used, 0, 0); 1078 xfer = sce->ra_wb_xfer; 1079 1080 mutex_enter(&sc->sc_lock); 1081 if (sce->ra_wb_used == sce->limit - sce->ibuf && 1082 flag & IO_NDELAY) { 1083 mutex_exit(&sc->sc_lock); 1084 return EWOULDBLOCK; 1085 } 1086 while (uio->uio_resid > 0 && !error) { 1087 while (sce->ra_wb_used == 1088 sce->limit - sce->ibuf) { 1089 DPRINTFN(5, "sleep on %#jx", 1090 (uintptr_t)sce, 0, 0, 0); 1091 /* "ugenwb" */ 1092 error = cv_timedwait_sig(&sce->cv, 1093 &sc->sc_lock, mstohz(sce->timeout)); 1094 DPRINTFN(5, "woke, error=%d", 1095 error, 0, 0, 0); 1096 if (sc->sc_dying) 1097 error = EIO; 1098 if (error) 1099 break; 1100 } 1101 1102 /* Copy data from the process. */ 1103 while (uio->uio_resid > 0 && 1104 sce->ra_wb_used < sce->limit - sce->ibuf) { 1105 n = uimin(uio->uio_resid, 1106 (sce->limit - sce->ibuf) 1107 - sce->ra_wb_used); 1108 n = uimin(n, sce->limit - sce->fill); 1109 error = uiomove(sce->fill, n, uio); 1110 if (error) 1111 break; 1112 sce->fill += n; 1113 sce->ra_wb_used += n; 1114 if (sce->fill == sce->limit) 1115 sce->fill = sce->ibuf; 1116 } 1117 1118 /* 1119 * If the transfers stopped because the 1120 * buffer was empty, restart them. 1121 */ 1122 if (sce->state & UGEN_RA_WB_STOP && 1123 sce->ra_wb_used > 0) { 1124 dbuf = (char *)usbd_get_buffer(xfer); 1125 n = uimin(sce->ra_wb_used, 1126 sce->ra_wb_xferlen); 1127 tn = uimin(n, sce->limit - sce->cur); 1128 memcpy(dbuf, sce->cur, tn); 1129 dbuf += tn; 1130 if (n - tn > 0) 1131 memcpy(dbuf, sce->ibuf, 1132 n - tn); 1133 usbd_setup_xfer(xfer, sce, NULL, n, 1134 0, USBD_NO_TIMEOUT, 1135 ugen_bulkwb_intr); 1136 sce->state &= ~UGEN_RA_WB_STOP; 1137 err = usbd_transfer(xfer); 1138 if (err != USBD_IN_PROGRESS) 1139 /* 1140 * The transfer has not been 1141 * queued. Setting STOP 1142 * will make us try again 1143 * at the next read. 1144 */ 1145 sce->state |= UGEN_RA_WB_STOP; 1146 } 1147 } 1148 mutex_exit(&sc->sc_lock); 1149 break; 1150 } 1151 error = usbd_create_xfer(sce->pipeh, UGEN_BBSIZE, 1152 0, 0, &xfer); 1153 if (error) 1154 return error; 1155 while ((n = uimin(UGEN_BBSIZE, uio->uio_resid)) != 0) { 1156 error = uiomove(sc->sc_buffer, n, uio); 1157 if (error) 1158 break; 1159 DPRINTFN(1, "transfer %jd bytes", n, 0, 0, 0); 1160 err = usbd_bulk_transfer(xfer, sce->pipeh, 0, sce->timeout, 1161 sc->sc_buffer, &n); 1162 if (err) { 1163 if (err == USBD_INTERRUPTED) 1164 error = EINTR; 1165 else if (err == USBD_TIMEOUT) 1166 error = ETIMEDOUT; 1167 else 1168 error = EIO; 1169 break; 1170 } 1171 } 1172 usbd_destroy_xfer(xfer); 1173 break; 1174 case UE_INTERRUPT: 1175 error = usbd_create_xfer(sce->pipeh, 1176 UGETW(sce->edesc->wMaxPacketSize), 0, 0, &xfer); 1177 if (error) 1178 return error; 1179 while ((n = uimin(UGETW(sce->edesc->wMaxPacketSize), 1180 uio->uio_resid)) != 0) { 1181 error = uiomove(sc->sc_buffer, n, uio); 1182 if (error) 1183 break; 1184 DPRINTFN(1, "transfer %jd bytes", n, 0, 0, 0); 1185 err = usbd_intr_transfer(xfer, sce->pipeh, 0, 1186 sce->timeout, sc->sc_buffer, &n); 1187 if (err) { 1188 if (err == USBD_INTERRUPTED) 1189 error = EINTR; 1190 else if (err == USBD_TIMEOUT) 1191 error = ETIMEDOUT; 1192 else 1193 error = EIO; 1194 break; 1195 } 1196 } 1197 usbd_destroy_xfer(xfer); 1198 break; 1199 default: 1200 return ENXIO; 1201 } 1202 return error; 1203 } 1204 1205 static int 1206 ugenwrite(dev_t dev, struct uio *uio, int flag) 1207 { 1208 int endpt = UGENENDPOINT(dev); 1209 struct ugen_softc *sc; 1210 int error; 1211 1212 if ((sc = ugenif_acquire(UGENUNIT(dev))) == NULL) 1213 return ENXIO; 1214 error = ugen_do_write(sc, endpt, uio, flag); 1215 ugenif_release(sc); 1216 1217 return error; 1218 } 1219 1220 static int 1221 ugen_activate(device_t self, enum devact act) 1222 { 1223 struct ugen_softc *sc = device_private(self); 1224 1225 switch (act) { 1226 case DVACT_DEACTIVATE: 1227 sc->sc_dying = 1; 1228 return 0; 1229 default: 1230 return EOPNOTSUPP; 1231 } 1232 } 1233 1234 static int 1235 ugen_detach(device_t self, int flags) 1236 { 1237 struct ugen_softc *sc = device_private(self); 1238 struct ugen_endpoint *sce; 1239 int i, dir; 1240 int maj, mn; 1241 1242 UGENHIST_FUNC(); UGENHIST_CALLED(); 1243 1244 DPRINTF("sc=%ju flags=%ju", (uintptr_t)sc, flags, 0, 0); 1245 1246 KASSERT(KERNEL_LOCKED_P()); /* sc_is_open */ 1247 1248 /* 1249 * Fail if we're not forced to detach and userland has any 1250 * endpoints open. 1251 */ 1252 if ((flags & DETACH_FORCE) == 0) { 1253 for (i = 0; i < USB_MAX_ENDPOINTS; i++) { 1254 if (sc->sc_is_open[i]) 1255 return EBUSY; 1256 } 1257 } 1258 1259 /* Prevent new users. Prevent suspend/resume. */ 1260 sc->sc_dying = 1; 1261 pmf_device_deregister(self); 1262 1263 /* 1264 * If we never finished attaching, skip nixing endpoints and 1265 * users because there aren't any. 1266 */ 1267 if (!sc->sc_attached) 1268 goto out; 1269 1270 /* Abort all pipes. */ 1271 for (i = 0; i < USB_MAX_ENDPOINTS; i++) { 1272 for (dir = OUT; dir <= IN; dir++) { 1273 sce = &sc->sc_endpoints[i][dir]; 1274 if (sce->pipeh) 1275 usbd_abort_pipe(sce->pipeh); 1276 } 1277 } 1278 1279 /* 1280 * Wait for users to drain. Before this point there can be no 1281 * more I/O operations started because we set sc_dying; after 1282 * this, there can be no more I/O operations in progress, so it 1283 * will be safe to free things. 1284 */ 1285 mutex_enter(&sc->sc_lock); 1286 if (--sc->sc_refcnt >= 0) { 1287 /* Wake everyone */ 1288 for (i = 0; i < USB_MAX_ENDPOINTS; i++) { 1289 for (dir = OUT; dir <= IN; dir++) 1290 cv_broadcast(&sc->sc_endpoints[i][dir].cv); 1291 } 1292 /* Wait for processes to go away. */ 1293 do { 1294 cv_wait(&sc->sc_detach_cv, &sc->sc_lock); 1295 } while (sc->sc_refcnt >= 0); 1296 } 1297 mutex_exit(&sc->sc_lock); 1298 1299 /* locate the major number */ 1300 maj = cdevsw_lookup_major(&ugen_cdevsw); 1301 1302 /* 1303 * Nuke the vnodes for any open instances (calls ugenclose, but 1304 * with no effect because we already set sc_dying). 1305 */ 1306 mn = sc->sc_unit * USB_MAX_ENDPOINTS; 1307 vdevgone(maj, mn, mn + USB_MAX_ENDPOINTS - 1, VCHR); 1308 1309 /* Actually close any lingering pipes. */ 1310 for (i = 0; i < USB_MAX_ENDPOINTS; i++) 1311 ugen_do_close(sc, FREAD|FWRITE, i); 1312 1313 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev); 1314 ugenif_put_unit(sc); 1315 1316 out: for (i = 0; i < USB_MAX_ENDPOINTS; i++) { 1317 for (dir = OUT; dir <= IN; dir++) { 1318 sce = &sc->sc_endpoints[i][dir]; 1319 seldestroy(&sce->rsel); 1320 cv_destroy(&sce->cv); 1321 } 1322 } 1323 1324 cv_destroy(&sc->sc_detach_cv); 1325 mutex_destroy(&sc->sc_lock); 1326 1327 return 0; 1328 } 1329 1330 Static void 1331 ugenintr(struct usbd_xfer *xfer, void *addr, usbd_status status) 1332 { 1333 struct ugen_endpoint *sce = addr; 1334 struct ugen_softc *sc = sce->sc; 1335 uint32_t count; 1336 u_char *ibuf; 1337 1338 UGENHIST_FUNC(); UGENHIST_CALLED(); 1339 1340 if (status == USBD_CANCELLED) 1341 return; 1342 1343 if (status != USBD_NORMAL_COMPLETION) { 1344 DPRINTF("status=%jd", status, 0, 0, 0); 1345 if (status == USBD_STALLED) 1346 usbd_clear_endpoint_stall_async(sce->pipeh); 1347 return; 1348 } 1349 1350 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1351 ibuf = sce->ibuf; 1352 1353 DPRINTFN(5, "xfer=%#jx status=%d count=%d", 1354 (uintptr_t)xfer, status, count, 0); 1355 DPRINTFN(5, " data = %02x %02x %02x", 1356 ibuf[0], ibuf[1], ibuf[2], 0); 1357 1358 mutex_enter(&sc->sc_lock); 1359 (void)b_to_q(ibuf, count, &sce->q); 1360 cv_signal(&sce->cv); 1361 mutex_exit(&sc->sc_lock); 1362 selnotify(&sce->rsel, 0, 0); 1363 } 1364 1365 Static void 1366 ugen_isoc_rintr(struct usbd_xfer *xfer, void *addr, 1367 usbd_status status) 1368 { 1369 struct isoreq *req = addr; 1370 struct ugen_endpoint *sce = req->sce; 1371 struct ugen_softc *sc = sce->sc; 1372 uint32_t count, n; 1373 int i, isize; 1374 1375 UGENHIST_FUNC(); UGENHIST_CALLED(); 1376 1377 /* Return if we are aborting. */ 1378 if (status == USBD_CANCELLED) 1379 return; 1380 1381 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1382 DPRINTFN(5, "xfer %ld, count=%d", 1383 (long)(req - sce->isoreqs), count, 0, 0); 1384 1385 mutex_enter(&sc->sc_lock); 1386 1387 /* throw away oldest input if the buffer is full */ 1388 if (sce->fill < sce->cur && sce->cur <= sce->fill + count) { 1389 sce->cur += count; 1390 if (sce->cur >= sce->limit) 1391 sce->cur = sce->ibuf + (sce->limit - sce->cur); 1392 DPRINTFN(5, "throwing away %jd bytes", 1393 count, 0, 0, 0); 1394 } 1395 1396 isize = UGETW(sce->edesc->wMaxPacketSize); 1397 for (i = 0; i < UGEN_NISORFRMS; i++) { 1398 uint32_t actlen = req->sizes[i]; 1399 char const *tbuf = (char const *)req->dmabuf + isize * i; 1400 1401 /* copy data to buffer */ 1402 while (actlen > 0) { 1403 n = uimin(actlen, sce->limit - sce->fill); 1404 memcpy(sce->fill, tbuf, n); 1405 1406 tbuf += n; 1407 actlen -= n; 1408 sce->fill += n; 1409 if (sce->fill == sce->limit) 1410 sce->fill = sce->ibuf; 1411 } 1412 1413 /* setup size for next transfer */ 1414 req->sizes[i] = isize; 1415 } 1416 1417 usbd_setup_isoc_xfer(xfer, req, req->sizes, UGEN_NISORFRMS, 0, 1418 ugen_isoc_rintr); 1419 (void)usbd_transfer(xfer); 1420 1421 cv_signal(&sce->cv); 1422 mutex_exit(&sc->sc_lock); 1423 selnotify(&sce->rsel, 0, 0); 1424 } 1425 1426 Static void 1427 ugen_bulkra_intr(struct usbd_xfer *xfer, void *addr, 1428 usbd_status status) 1429 { 1430 struct ugen_endpoint *sce = addr; 1431 struct ugen_softc *sc = sce->sc; 1432 uint32_t count, n; 1433 char const *tbuf; 1434 usbd_status err; 1435 1436 UGENHIST_FUNC(); UGENHIST_CALLED(); 1437 1438 /* Return if we are aborting. */ 1439 if (status == USBD_CANCELLED) 1440 return; 1441 1442 if (status != USBD_NORMAL_COMPLETION) { 1443 DPRINTF("status=%jd", status, 0, 0, 0); 1444 sce->state |= UGEN_RA_WB_STOP; 1445 if (status == USBD_STALLED) 1446 usbd_clear_endpoint_stall_async(sce->pipeh); 1447 return; 1448 } 1449 1450 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1451 1452 mutex_enter(&sc->sc_lock); 1453 1454 /* Keep track of how much is in the buffer. */ 1455 sce->ra_wb_used += count; 1456 1457 /* Copy data to buffer. */ 1458 tbuf = (char const *)usbd_get_buffer(sce->ra_wb_xfer); 1459 n = uimin(count, sce->limit - sce->fill); 1460 memcpy(sce->fill, tbuf, n); 1461 tbuf += n; 1462 count -= n; 1463 sce->fill += n; 1464 if (sce->fill == sce->limit) 1465 sce->fill = sce->ibuf; 1466 if (count > 0) { 1467 memcpy(sce->fill, tbuf, count); 1468 sce->fill += count; 1469 } 1470 1471 /* Set up the next request if necessary. */ 1472 n = (sce->limit - sce->ibuf) - sce->ra_wb_used; 1473 if (n > 0) { 1474 usbd_setup_xfer(xfer, sce, NULL, uimin(n, sce->ra_wb_xferlen), 0, 1475 USBD_NO_TIMEOUT, ugen_bulkra_intr); 1476 err = usbd_transfer(xfer); 1477 if (err != USBD_IN_PROGRESS) { 1478 printf("error=%d", err); 1479 /* 1480 * The transfer has not been queued. Setting STOP 1481 * will make us try again at the next read. 1482 */ 1483 sce->state |= UGEN_RA_WB_STOP; 1484 } 1485 } 1486 else 1487 sce->state |= UGEN_RA_WB_STOP; 1488 1489 cv_signal(&sce->cv); 1490 mutex_exit(&sc->sc_lock); 1491 selnotify(&sce->rsel, 0, 0); 1492 } 1493 1494 Static void 1495 ugen_bulkwb_intr(struct usbd_xfer *xfer, void *addr, 1496 usbd_status status) 1497 { 1498 struct ugen_endpoint *sce = addr; 1499 struct ugen_softc *sc = sce->sc; 1500 uint32_t count, n; 1501 char *tbuf; 1502 usbd_status err; 1503 1504 UGENHIST_FUNC(); UGENHIST_CALLED(); 1505 1506 /* Return if we are aborting. */ 1507 if (status == USBD_CANCELLED) 1508 return; 1509 1510 if (status != USBD_NORMAL_COMPLETION) { 1511 DPRINTF("status=%jd", status, 0, 0, 0); 1512 sce->state |= UGEN_RA_WB_STOP; 1513 if (status == USBD_STALLED) 1514 usbd_clear_endpoint_stall_async(sce->pipeh); 1515 return; 1516 } 1517 1518 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1519 1520 mutex_enter(&sc->sc_lock); 1521 1522 /* Keep track of how much is in the buffer. */ 1523 sce->ra_wb_used -= count; 1524 1525 /* Update buffer pointers. */ 1526 sce->cur += count; 1527 if (sce->cur >= sce->limit) 1528 sce->cur = sce->ibuf + (sce->cur - sce->limit); 1529 1530 /* Set up next request if necessary. */ 1531 if (sce->ra_wb_used > 0) { 1532 /* copy data from buffer */ 1533 tbuf = (char *)usbd_get_buffer(sce->ra_wb_xfer); 1534 count = uimin(sce->ra_wb_used, sce->ra_wb_xferlen); 1535 n = uimin(count, sce->limit - sce->cur); 1536 memcpy(tbuf, sce->cur, n); 1537 tbuf += n; 1538 if (count - n > 0) 1539 memcpy(tbuf, sce->ibuf, count - n); 1540 1541 usbd_setup_xfer(xfer, sce, NULL, count, 0, USBD_NO_TIMEOUT, 1542 ugen_bulkwb_intr); 1543 err = usbd_transfer(xfer); 1544 if (err != USBD_IN_PROGRESS) { 1545 printf("error=%d", err); 1546 /* 1547 * The transfer has not been queued. Setting STOP 1548 * will make us try again at the next write. 1549 */ 1550 sce->state |= UGEN_RA_WB_STOP; 1551 } 1552 } 1553 else 1554 sce->state |= UGEN_RA_WB_STOP; 1555 1556 cv_signal(&sce->cv); 1557 mutex_exit(&sc->sc_lock); 1558 selnotify(&sce->rsel, 0, 0); 1559 } 1560 1561 Static usbd_status 1562 ugen_set_interface(struct ugen_softc *sc, int ifaceidx, int altno) 1563 { 1564 struct usbd_interface *iface; 1565 usb_endpoint_descriptor_t *ed; 1566 usbd_status err; 1567 struct ugen_endpoint *sce; 1568 uint8_t niface, nendpt, endptno, endpt; 1569 int dir; 1570 1571 UGENHIST_FUNC(); UGENHIST_CALLED(); 1572 1573 DPRINTFN(15, "%d %d", ifaceidx, altno, 0, 0); 1574 1575 err = usbd_interface_count(sc->sc_udev, &niface); 1576 if (err) 1577 return err; 1578 if (ifaceidx < 0 || ifaceidx >= niface) 1579 return USBD_INVAL; 1580 1581 err = usbd_device2interface_handle(sc->sc_udev, ifaceidx, &iface); 1582 if (err) 1583 return err; 1584 err = usbd_endpoint_count(iface, &nendpt); 1585 if (err) 1586 return err; 1587 1588 /* change setting */ 1589 err = usbd_set_interface(iface, altno); 1590 if (err) 1591 return err; 1592 1593 err = usbd_endpoint_count(iface, &nendpt); 1594 if (err) 1595 return err; 1596 1597 ugen_clear_endpoints(sc); 1598 1599 for (endptno = 0; endptno < nendpt; endptno++) { 1600 ed = usbd_interface2endpoint_descriptor(iface,endptno); 1601 KASSERT(ed != NULL); 1602 endpt = ed->bEndpointAddress; 1603 dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT; 1604 sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir]; 1605 sce->sc = sc; 1606 sce->edesc = ed; 1607 sce->iface = iface; 1608 } 1609 return 0; 1610 } 1611 1612 /* Retrieve a complete descriptor for a certain device and index. */ 1613 Static usb_config_descriptor_t * 1614 ugen_get_cdesc(struct ugen_softc *sc, int index, int *lenp) 1615 { 1616 usb_config_descriptor_t *cdesc, *tdesc, cdescr; 1617 int len; 1618 usbd_status err; 1619 1620 UGENHIST_FUNC(); UGENHIST_CALLED(); 1621 1622 if (index == USB_CURRENT_CONFIG_INDEX) { 1623 tdesc = usbd_get_config_descriptor(sc->sc_udev); 1624 if (tdesc == NULL) 1625 return NULL; 1626 len = UGETW(tdesc->wTotalLength); 1627 if (lenp) 1628 *lenp = len; 1629 cdesc = kmem_alloc(len, KM_SLEEP); 1630 memcpy(cdesc, tdesc, len); 1631 DPRINTFN(5, "current, len=%jd", len, 0, 0, 0); 1632 } else { 1633 err = usbd_get_config_desc(sc->sc_udev, index, &cdescr); 1634 if (err) 1635 return 0; 1636 len = UGETW(cdescr.wTotalLength); 1637 DPRINTFN(5, "index=%jd, len=%jd", index, len, 0, 0); 1638 if (lenp) 1639 *lenp = len; 1640 cdesc = kmem_alloc(len, KM_SLEEP); 1641 err = usbd_get_config_desc_full(sc->sc_udev, index, cdesc, len); 1642 if (err) { 1643 kmem_free(cdesc, len); 1644 return 0; 1645 } 1646 } 1647 return cdesc; 1648 } 1649 1650 Static int 1651 ugen_get_alt_index(struct ugen_softc *sc, int ifaceidx) 1652 { 1653 struct usbd_interface *iface; 1654 usbd_status err; 1655 1656 err = usbd_device2interface_handle(sc->sc_udev, ifaceidx, &iface); 1657 if (err) 1658 return -1; 1659 return usbd_get_interface_altindex(iface); 1660 } 1661 1662 Static int 1663 ugen_do_ioctl(struct ugen_softc *sc, int endpt, u_long cmd, 1664 void *addr, int flag, struct lwp *l) 1665 { 1666 struct ugen_endpoint *sce; 1667 usbd_status err; 1668 struct usbd_interface *iface; 1669 struct usb_config_desc *cd; 1670 usb_config_descriptor_t *cdesc; 1671 struct usb_interface_desc *id; 1672 usb_interface_descriptor_t *idesc; 1673 struct usb_endpoint_desc *ed; 1674 usb_endpoint_descriptor_t *edesc; 1675 struct usb_alt_interface *ai; 1676 struct usb_string_desc *si; 1677 uint8_t conf, alt; 1678 int cdesclen; 1679 int error; 1680 int dir; 1681 1682 UGENHIST_FUNC(); UGENHIST_CALLED(); 1683 1684 KASSERT(KERNEL_LOCKED_P()); /* ugen_set_config */ 1685 1686 DPRINTFN(5, "cmd=%08jx", cmd, 0, 0, 0); 1687 1688 switch (cmd) { 1689 case FIONBIO: 1690 /* All handled in the upper FS layer. */ 1691 return 0; 1692 case USB_SET_SHORT_XFER: 1693 if (endpt == USB_CONTROL_ENDPOINT) 1694 return EINVAL; 1695 /* This flag only affects read */ 1696 sce = &sc->sc_endpoints[endpt][IN]; 1697 if (sce == NULL || sce->pipeh == NULL) 1698 return EINVAL; 1699 if (*(int *)addr) 1700 sce->state |= UGEN_SHORT_OK; 1701 else 1702 sce->state &= ~UGEN_SHORT_OK; 1703 return 0; 1704 case USB_SET_TIMEOUT: 1705 for (dir = OUT; dir <= IN; dir++) { 1706 sce = &sc->sc_endpoints[endpt][dir]; 1707 if (sce == NULL) 1708 return EINVAL; 1709 1710 sce->timeout = *(int *)addr; 1711 } 1712 return 0; 1713 case USB_SET_BULK_RA: 1714 if (endpt == USB_CONTROL_ENDPOINT) 1715 return EINVAL; 1716 sce = &sc->sc_endpoints[endpt][IN]; 1717 if (sce == NULL || sce->pipeh == NULL) 1718 return EINVAL; 1719 edesc = sce->edesc; 1720 if ((edesc->bmAttributes & UE_XFERTYPE) != UE_BULK) 1721 return EINVAL; 1722 1723 if (*(int *)addr) { 1724 /* Only turn RA on if it's currently off. */ 1725 if (sce->state & UGEN_BULK_RA) 1726 return 0; 1727 KASSERT(sce->ra_wb_xfer == NULL); 1728 KASSERT(sce->ibuf == NULL); 1729 1730 if (sce->ra_wb_bufsize == 0 || sce->ra_wb_reqsize == 0) 1731 /* shouldn't happen */ 1732 return EINVAL; 1733 error = usbd_create_xfer(sce->pipeh, 1734 sce->ra_wb_reqsize, 0, 0, &sce->ra_wb_xfer); 1735 if (error) 1736 return error; 1737 sce->ra_wb_xferlen = sce->ra_wb_reqsize; 1738 sce->ibuf = kmem_alloc(sce->ra_wb_bufsize, KM_SLEEP); 1739 sce->fill = sce->cur = sce->ibuf; 1740 sce->limit = sce->ibuf + sce->ra_wb_bufsize; 1741 sce->ra_wb_used = 0; 1742 sce->state |= UGEN_BULK_RA; 1743 sce->state &= ~UGEN_RA_WB_STOP; 1744 /* Now start reading. */ 1745 usbd_setup_xfer(sce->ra_wb_xfer, sce, NULL, 1746 uimin(sce->ra_wb_xferlen, sce->ra_wb_bufsize), 1747 0, USBD_NO_TIMEOUT, ugen_bulkra_intr); 1748 err = usbd_transfer(sce->ra_wb_xfer); 1749 if (err != USBD_IN_PROGRESS) { 1750 sce->state &= ~UGEN_BULK_RA; 1751 kmem_free(sce->ibuf, sce->ra_wb_bufsize); 1752 sce->ibuf = NULL; 1753 usbd_destroy_xfer(sce->ra_wb_xfer); 1754 sce->ra_wb_xfer = NULL; 1755 return EIO; 1756 } 1757 } else { 1758 /* Only turn RA off if it's currently on. */ 1759 if (!(sce->state & UGEN_BULK_RA)) 1760 return 0; 1761 1762 sce->state &= ~UGEN_BULK_RA; 1763 usbd_abort_pipe(sce->pipeh); 1764 usbd_destroy_xfer(sce->ra_wb_xfer); 1765 sce->ra_wb_xfer = NULL; 1766 /* 1767 * XXX Discard whatever's in the buffer, but we 1768 * should keep it around and drain the buffer 1769 * instead. 1770 */ 1771 kmem_free(sce->ibuf, sce->ra_wb_bufsize); 1772 sce->ibuf = NULL; 1773 } 1774 return 0; 1775 case USB_SET_BULK_WB: 1776 if (endpt == USB_CONTROL_ENDPOINT) 1777 return EINVAL; 1778 sce = &sc->sc_endpoints[endpt][OUT]; 1779 if (sce == NULL || sce->pipeh == NULL) 1780 return EINVAL; 1781 edesc = sce->edesc; 1782 if ((edesc->bmAttributes & UE_XFERTYPE) != UE_BULK) 1783 return EINVAL; 1784 1785 if (*(int *)addr) { 1786 /* Only turn WB on if it's currently off. */ 1787 if (sce->state & UGEN_BULK_WB) 1788 return 0; 1789 KASSERT(sce->ra_wb_xfer == NULL); 1790 KASSERT(sce->ibuf == NULL); 1791 1792 if (sce->ra_wb_bufsize == 0 || sce->ra_wb_reqsize == 0) 1793 /* shouldn't happen */ 1794 return EINVAL; 1795 error = usbd_create_xfer(sce->pipeh, sce->ra_wb_reqsize, 1796 0, 0, &sce->ra_wb_xfer); 1797 /* XXX check error??? */ 1798 sce->ra_wb_xferlen = sce->ra_wb_reqsize; 1799 sce->ibuf = kmem_alloc(sce->ra_wb_bufsize, KM_SLEEP); 1800 sce->fill = sce->cur = sce->ibuf; 1801 sce->limit = sce->ibuf + sce->ra_wb_bufsize; 1802 sce->ra_wb_used = 0; 1803 sce->state |= UGEN_BULK_WB | UGEN_RA_WB_STOP; 1804 } else { 1805 /* Only turn WB off if it's currently on. */ 1806 if (!(sce->state & UGEN_BULK_WB)) 1807 return 0; 1808 1809 sce->state &= ~UGEN_BULK_WB; 1810 /* 1811 * XXX Discard whatever's in the buffer, but we 1812 * should keep it around and keep writing to 1813 * drain the buffer instead. 1814 */ 1815 usbd_abort_pipe(sce->pipeh); 1816 usbd_destroy_xfer(sce->ra_wb_xfer); 1817 sce->ra_wb_xfer = NULL; 1818 kmem_free(sce->ibuf, sce->ra_wb_bufsize); 1819 sce->ibuf = NULL; 1820 } 1821 return 0; 1822 case USB_SET_BULK_RA_OPT: 1823 case USB_SET_BULK_WB_OPT: 1824 { 1825 struct usb_bulk_ra_wb_opt *opt; 1826 1827 if (endpt == USB_CONTROL_ENDPOINT) 1828 return EINVAL; 1829 opt = (struct usb_bulk_ra_wb_opt *)addr; 1830 if (cmd == USB_SET_BULK_RA_OPT) 1831 sce = &sc->sc_endpoints[endpt][IN]; 1832 else 1833 sce = &sc->sc_endpoints[endpt][OUT]; 1834 if (sce == NULL || sce->pipeh == NULL) 1835 return EINVAL; 1836 if (opt->ra_wb_buffer_size < 1 || 1837 opt->ra_wb_buffer_size > UGEN_BULK_RA_WB_BUFMAX || 1838 opt->ra_wb_request_size < 1 || 1839 opt->ra_wb_request_size > opt->ra_wb_buffer_size) 1840 return EINVAL; 1841 /* 1842 * XXX These changes do not take effect until the 1843 * next time RA/WB mode is enabled but they ought to 1844 * take effect immediately. 1845 */ 1846 sce->ra_wb_bufsize = opt->ra_wb_buffer_size; 1847 sce->ra_wb_reqsize = opt->ra_wb_request_size; 1848 return 0; 1849 } 1850 default: 1851 break; 1852 } 1853 1854 if (endpt != USB_CONTROL_ENDPOINT) 1855 return EINVAL; 1856 1857 switch (cmd) { 1858 #ifdef UGEN_DEBUG 1859 case USB_SETDEBUG: 1860 ugendebug = *(int *)addr; 1861 break; 1862 #endif 1863 case USB_GET_CONFIG: 1864 err = usbd_get_config(sc->sc_udev, &conf); 1865 if (err) 1866 return EIO; 1867 *(int *)addr = conf; 1868 break; 1869 case USB_SET_CONFIG: 1870 if (!(flag & FWRITE)) 1871 return EPERM; 1872 err = ugen_set_config(sc, *(int *)addr, 1); 1873 switch (err) { 1874 case USBD_NORMAL_COMPLETION: 1875 break; 1876 case USBD_IN_USE: 1877 return EBUSY; 1878 default: 1879 return EIO; 1880 } 1881 break; 1882 case USB_GET_ALTINTERFACE: 1883 ai = (struct usb_alt_interface *)addr; 1884 err = usbd_device2interface_handle(sc->sc_udev, 1885 ai->uai_interface_index, &iface); 1886 if (err) 1887 return EINVAL; 1888 idesc = usbd_get_interface_descriptor(iface); 1889 if (idesc == NULL) 1890 return EIO; 1891 ai->uai_alt_no = idesc->bAlternateSetting; 1892 break; 1893 case USB_SET_ALTINTERFACE: 1894 if (!(flag & FWRITE)) 1895 return EPERM; 1896 ai = (struct usb_alt_interface *)addr; 1897 err = usbd_device2interface_handle(sc->sc_udev, 1898 ai->uai_interface_index, &iface); 1899 if (err) 1900 return EINVAL; 1901 err = ugen_set_interface(sc, ai->uai_interface_index, 1902 ai->uai_alt_no); 1903 if (err) 1904 return EINVAL; 1905 break; 1906 case USB_GET_NO_ALT: 1907 ai = (struct usb_alt_interface *)addr; 1908 cdesc = ugen_get_cdesc(sc, ai->uai_config_index, &cdesclen); 1909 if (cdesc == NULL) 1910 return EINVAL; 1911 idesc = usbd_find_idesc(cdesc, ai->uai_interface_index, 0); 1912 if (idesc == NULL) { 1913 kmem_free(cdesc, cdesclen); 1914 return EINVAL; 1915 } 1916 ai->uai_alt_no = usbd_get_no_alts(cdesc, 1917 idesc->bInterfaceNumber); 1918 kmem_free(cdesc, cdesclen); 1919 break; 1920 case USB_GET_DEVICE_DESC: 1921 *(usb_device_descriptor_t *)addr = 1922 *usbd_get_device_descriptor(sc->sc_udev); 1923 break; 1924 case USB_GET_CONFIG_DESC: 1925 cd = (struct usb_config_desc *)addr; 1926 cdesc = ugen_get_cdesc(sc, cd->ucd_config_index, &cdesclen); 1927 if (cdesc == NULL) 1928 return EINVAL; 1929 cd->ucd_desc = *cdesc; 1930 kmem_free(cdesc, cdesclen); 1931 break; 1932 case USB_GET_INTERFACE_DESC: 1933 id = (struct usb_interface_desc *)addr; 1934 cdesc = ugen_get_cdesc(sc, id->uid_config_index, &cdesclen); 1935 if (cdesc == NULL) 1936 return EINVAL; 1937 if (id->uid_config_index == USB_CURRENT_CONFIG_INDEX && 1938 id->uid_alt_index == USB_CURRENT_ALT_INDEX) 1939 alt = ugen_get_alt_index(sc, id->uid_interface_index); 1940 else 1941 alt = id->uid_alt_index; 1942 idesc = usbd_find_idesc(cdesc, id->uid_interface_index, alt); 1943 if (idesc == NULL) { 1944 kmem_free(cdesc, cdesclen); 1945 return EINVAL; 1946 } 1947 id->uid_desc = *idesc; 1948 kmem_free(cdesc, cdesclen); 1949 break; 1950 case USB_GET_ENDPOINT_DESC: 1951 ed = (struct usb_endpoint_desc *)addr; 1952 cdesc = ugen_get_cdesc(sc, ed->ued_config_index, &cdesclen); 1953 if (cdesc == NULL) 1954 return EINVAL; 1955 if (ed->ued_config_index == USB_CURRENT_CONFIG_INDEX && 1956 ed->ued_alt_index == USB_CURRENT_ALT_INDEX) 1957 alt = ugen_get_alt_index(sc, ed->ued_interface_index); 1958 else 1959 alt = ed->ued_alt_index; 1960 edesc = usbd_find_edesc(cdesc, ed->ued_interface_index, 1961 alt, ed->ued_endpoint_index); 1962 if (edesc == NULL) { 1963 kmem_free(cdesc, cdesclen); 1964 return EINVAL; 1965 } 1966 ed->ued_desc = *edesc; 1967 kmem_free(cdesc, cdesclen); 1968 break; 1969 case USB_GET_FULL_DESC: 1970 { 1971 int len; 1972 struct iovec iov; 1973 struct uio uio; 1974 struct usb_full_desc *fd = (struct usb_full_desc *)addr; 1975 1976 cdesc = ugen_get_cdesc(sc, fd->ufd_config_index, &cdesclen); 1977 if (cdesc == NULL) 1978 return EINVAL; 1979 len = cdesclen; 1980 if (len > fd->ufd_size) 1981 len = fd->ufd_size; 1982 iov.iov_base = (void *)fd->ufd_data; 1983 iov.iov_len = len; 1984 uio.uio_iov = &iov; 1985 uio.uio_iovcnt = 1; 1986 uio.uio_resid = len; 1987 uio.uio_offset = 0; 1988 uio.uio_rw = UIO_READ; 1989 uio.uio_vmspace = l->l_proc->p_vmspace; 1990 error = uiomove((void *)cdesc, len, &uio); 1991 kmem_free(cdesc, cdesclen); 1992 return error; 1993 } 1994 case USB_GET_STRING_DESC: { 1995 int len; 1996 si = (struct usb_string_desc *)addr; 1997 err = usbd_get_string_desc(sc->sc_udev, si->usd_string_index, 1998 si->usd_language_id, &si->usd_desc, &len); 1999 if (err) 2000 return EINVAL; 2001 break; 2002 } 2003 case USB_DO_REQUEST: 2004 { 2005 struct usb_ctl_request *ur = (void *)addr; 2006 int len = UGETW(ur->ucr_request.wLength); 2007 struct iovec iov; 2008 struct uio uio; 2009 void *ptr = 0; 2010 usbd_status xerr; 2011 2012 error = 0; 2013 2014 if (!(flag & FWRITE)) 2015 return EPERM; 2016 /* Avoid requests that would damage the bus integrity. */ 2017 if ((ur->ucr_request.bmRequestType == UT_WRITE_DEVICE && 2018 ur->ucr_request.bRequest == UR_SET_ADDRESS) || 2019 (ur->ucr_request.bmRequestType == UT_WRITE_DEVICE && 2020 ur->ucr_request.bRequest == UR_SET_CONFIG) || 2021 (ur->ucr_request.bmRequestType == UT_WRITE_INTERFACE && 2022 ur->ucr_request.bRequest == UR_SET_INTERFACE)) 2023 return EINVAL; 2024 2025 if (len < 0 || len > 32767) 2026 return EINVAL; 2027 if (len != 0) { 2028 iov.iov_base = (void *)ur->ucr_data; 2029 iov.iov_len = len; 2030 uio.uio_iov = &iov; 2031 uio.uio_iovcnt = 1; 2032 uio.uio_resid = len; 2033 uio.uio_offset = 0; 2034 uio.uio_rw = 2035 ur->ucr_request.bmRequestType & UT_READ ? 2036 UIO_READ : UIO_WRITE; 2037 uio.uio_vmspace = l->l_proc->p_vmspace; 2038 ptr = kmem_alloc(len, KM_SLEEP); 2039 if (uio.uio_rw == UIO_WRITE) { 2040 error = uiomove(ptr, len, &uio); 2041 if (error) 2042 goto ret; 2043 } 2044 } 2045 sce = &sc->sc_endpoints[endpt][IN]; 2046 xerr = usbd_do_request_flags(sc->sc_udev, &ur->ucr_request, 2047 ptr, ur->ucr_flags, &ur->ucr_actlen, sce->timeout); 2048 if (xerr) { 2049 error = EIO; 2050 goto ret; 2051 } 2052 if (len != 0) { 2053 if (uio.uio_rw == UIO_READ) { 2054 size_t alen = uimin(len, ur->ucr_actlen); 2055 error = uiomove(ptr, alen, &uio); 2056 if (error) 2057 goto ret; 2058 } 2059 } 2060 ret: 2061 if (ptr) 2062 kmem_free(ptr, len); 2063 return error; 2064 } 2065 case USB_GET_DEVICEINFO: 2066 usbd_fill_deviceinfo(sc->sc_udev, 2067 (struct usb_device_info *)addr, 0); 2068 break; 2069 case USB_GET_DEVICEINFO_OLD: 2070 { 2071 int ret; 2072 MODULE_HOOK_CALL(usb_subr_fill_30_hook, 2073 (sc->sc_udev, (struct usb_device_info_old *)addr, 0, 2074 usbd_devinfo_vp, usbd_printBCD), 2075 enosys(), ret); 2076 if (ret == 0) 2077 return 0; 2078 return EINVAL; 2079 } 2080 default: 2081 return EINVAL; 2082 } 2083 return 0; 2084 } 2085 2086 static int 2087 ugenioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l) 2088 { 2089 int endpt = UGENENDPOINT(dev); 2090 struct ugen_softc *sc; 2091 int error; 2092 2093 if ((sc = ugenif_acquire(UGENUNIT(dev))) == 0) 2094 return ENXIO; 2095 error = ugen_do_ioctl(sc, endpt, cmd, addr, flag, l); 2096 ugenif_release(sc); 2097 2098 return error; 2099 } 2100 2101 static int 2102 ugenpoll(dev_t dev, int events, struct lwp *l) 2103 { 2104 struct ugen_softc *sc; 2105 struct ugen_endpoint *sce_in, *sce_out; 2106 int revents = 0; 2107 2108 if ((sc = ugenif_acquire(UGENUNIT(dev))) == NULL) 2109 return POLLHUP; 2110 2111 if (UGENENDPOINT(dev) == USB_CONTROL_ENDPOINT) { 2112 revents |= POLLERR; 2113 goto out; 2114 } 2115 2116 sce_in = &sc->sc_endpoints[UGENENDPOINT(dev)][IN]; 2117 sce_out = &sc->sc_endpoints[UGENENDPOINT(dev)][OUT]; 2118 KASSERT(sce_in->edesc || sce_out->edesc); 2119 KASSERT(sce_in->pipeh || sce_out->pipeh); 2120 2121 mutex_enter(&sc->sc_lock); 2122 if (sce_in && sce_in->pipeh && (events & (POLLIN | POLLRDNORM))) 2123 switch (sce_in->edesc->bmAttributes & UE_XFERTYPE) { 2124 case UE_INTERRUPT: 2125 if (sce_in->q.c_cc > 0) 2126 revents |= events & (POLLIN | POLLRDNORM); 2127 else 2128 selrecord(l, &sce_in->rsel); 2129 break; 2130 case UE_ISOCHRONOUS: 2131 if (sce_in->cur != sce_in->fill) 2132 revents |= events & (POLLIN | POLLRDNORM); 2133 else 2134 selrecord(l, &sce_in->rsel); 2135 break; 2136 case UE_BULK: 2137 if (sce_in->state & UGEN_BULK_RA) { 2138 if (sce_in->ra_wb_used > 0) 2139 revents |= events & 2140 (POLLIN | POLLRDNORM); 2141 else 2142 selrecord(l, &sce_in->rsel); 2143 break; 2144 } 2145 /* 2146 * We have no easy way of determining if a read will 2147 * yield any data or a write will happen. 2148 * Pretend they will. 2149 */ 2150 revents |= events & (POLLIN | POLLRDNORM); 2151 break; 2152 default: 2153 break; 2154 } 2155 if (sce_out && sce_out->pipeh && (events & (POLLOUT | POLLWRNORM))) 2156 switch (sce_out->edesc->bmAttributes & UE_XFERTYPE) { 2157 case UE_INTERRUPT: 2158 case UE_ISOCHRONOUS: 2159 /* XXX unimplemented */ 2160 break; 2161 case UE_BULK: 2162 if (sce_out->state & UGEN_BULK_WB) { 2163 if (sce_out->ra_wb_used < 2164 sce_out->limit - sce_out->ibuf) 2165 revents |= events & 2166 (POLLOUT | POLLWRNORM); 2167 else 2168 selrecord(l, &sce_out->rsel); 2169 break; 2170 } 2171 /* 2172 * We have no easy way of determining if a read will 2173 * yield any data or a write will happen. 2174 * Pretend they will. 2175 */ 2176 revents |= events & (POLLOUT | POLLWRNORM); 2177 break; 2178 default: 2179 break; 2180 } 2181 2182 mutex_exit(&sc->sc_lock); 2183 2184 out: ugenif_release(sc); 2185 return revents; 2186 } 2187 2188 static void 2189 filt_ugenrdetach(struct knote *kn) 2190 { 2191 struct ugen_endpoint *sce = kn->kn_hook; 2192 struct ugen_softc *sc = sce->sc; 2193 2194 mutex_enter(&sc->sc_lock); 2195 selremove_knote(&sce->rsel, kn); 2196 mutex_exit(&sc->sc_lock); 2197 } 2198 2199 static int 2200 filt_ugenread_intr(struct knote *kn, long hint) 2201 { 2202 struct ugen_endpoint *sce = kn->kn_hook; 2203 struct ugen_softc *sc = sce->sc; 2204 int ret; 2205 2206 mutex_enter(&sc->sc_lock); 2207 if (sc->sc_dying) { 2208 ret = 0; 2209 } else { 2210 kn->kn_data = sce->q.c_cc; 2211 ret = kn->kn_data > 0; 2212 } 2213 mutex_exit(&sc->sc_lock); 2214 2215 return ret; 2216 } 2217 2218 static int 2219 filt_ugenread_isoc(struct knote *kn, long hint) 2220 { 2221 struct ugen_endpoint *sce = kn->kn_hook; 2222 struct ugen_softc *sc = sce->sc; 2223 int ret; 2224 2225 mutex_enter(&sc->sc_lock); 2226 if (sc->sc_dying) { 2227 ret = 0; 2228 } else if (sce->cur == sce->fill) { 2229 ret = 0; 2230 } else if (sce->cur < sce->fill) { 2231 kn->kn_data = sce->fill - sce->cur; 2232 ret = 1; 2233 } else { 2234 kn->kn_data = (sce->limit - sce->cur) + 2235 (sce->fill - sce->ibuf); 2236 ret = 1; 2237 } 2238 mutex_exit(&sc->sc_lock); 2239 2240 return ret; 2241 } 2242 2243 static int 2244 filt_ugenread_bulk(struct knote *kn, long hint) 2245 { 2246 struct ugen_endpoint *sce = kn->kn_hook; 2247 struct ugen_softc *sc = sce->sc; 2248 int ret; 2249 2250 mutex_enter(&sc->sc_lock); 2251 if (sc->sc_dying) { 2252 ret = 0; 2253 } else if (!(sce->state & UGEN_BULK_RA)) { 2254 /* 2255 * We have no easy way of determining if a read will 2256 * yield any data or a write will happen. 2257 * So, emulate "seltrue". 2258 */ 2259 ret = filt_seltrue(kn, hint); 2260 } else if (sce->ra_wb_used == 0) { 2261 ret = 0; 2262 } else { 2263 kn->kn_data = sce->ra_wb_used; 2264 ret = 1; 2265 } 2266 mutex_exit(&sc->sc_lock); 2267 2268 return ret; 2269 } 2270 2271 static int 2272 filt_ugenwrite_bulk(struct knote *kn, long hint) 2273 { 2274 struct ugen_endpoint *sce = kn->kn_hook; 2275 struct ugen_softc *sc = sce->sc; 2276 int ret; 2277 2278 mutex_enter(&sc->sc_lock); 2279 if (sc->sc_dying) { 2280 ret = 0; 2281 } else if (!(sce->state & UGEN_BULK_WB)) { 2282 /* 2283 * We have no easy way of determining if a read will 2284 * yield any data or a write will happen. 2285 * So, emulate "seltrue". 2286 */ 2287 ret = filt_seltrue(kn, hint); 2288 } else if (sce->ra_wb_used == sce->limit - sce->ibuf) { 2289 ret = 0; 2290 } else { 2291 kn->kn_data = (sce->limit - sce->ibuf) - sce->ra_wb_used; 2292 ret = 1; 2293 } 2294 mutex_exit(&sc->sc_lock); 2295 2296 return ret; 2297 } 2298 2299 static const struct filterops ugenread_intr_filtops = { 2300 .f_flags = FILTEROP_ISFD, 2301 .f_attach = NULL, 2302 .f_detach = filt_ugenrdetach, 2303 .f_event = filt_ugenread_intr, 2304 }; 2305 2306 static const struct filterops ugenread_isoc_filtops = { 2307 .f_flags = FILTEROP_ISFD, 2308 .f_attach = NULL, 2309 .f_detach = filt_ugenrdetach, 2310 .f_event = filt_ugenread_isoc, 2311 }; 2312 2313 static const struct filterops ugenread_bulk_filtops = { 2314 .f_flags = FILTEROP_ISFD, 2315 .f_attach = NULL, 2316 .f_detach = filt_ugenrdetach, 2317 .f_event = filt_ugenread_bulk, 2318 }; 2319 2320 static const struct filterops ugenwrite_bulk_filtops = { 2321 .f_flags = FILTEROP_ISFD, 2322 .f_attach = NULL, 2323 .f_detach = filt_ugenrdetach, 2324 .f_event = filt_ugenwrite_bulk, 2325 }; 2326 2327 static int 2328 ugenkqfilter(dev_t dev, struct knote *kn) 2329 { 2330 struct ugen_softc *sc; 2331 struct ugen_endpoint *sce; 2332 struct selinfo *sip; 2333 int error; 2334 2335 if ((sc = ugenif_acquire(UGENUNIT(dev))) == NULL) 2336 return ENXIO; 2337 2338 if (UGENENDPOINT(dev) == USB_CONTROL_ENDPOINT) { 2339 error = ENODEV; 2340 goto out; 2341 } 2342 2343 switch (kn->kn_filter) { 2344 case EVFILT_READ: 2345 sce = &sc->sc_endpoints[UGENENDPOINT(dev)][IN]; 2346 if (sce == NULL) { 2347 error = EINVAL; 2348 goto out; 2349 } 2350 2351 sip = &sce->rsel; 2352 switch (sce->edesc->bmAttributes & UE_XFERTYPE) { 2353 case UE_INTERRUPT: 2354 kn->kn_fop = &ugenread_intr_filtops; 2355 break; 2356 case UE_ISOCHRONOUS: 2357 kn->kn_fop = &ugenread_isoc_filtops; 2358 break; 2359 case UE_BULK: 2360 kn->kn_fop = &ugenread_bulk_filtops; 2361 break; 2362 default: 2363 error = EINVAL; 2364 goto out; 2365 } 2366 break; 2367 2368 case EVFILT_WRITE: 2369 sce = &sc->sc_endpoints[UGENENDPOINT(dev)][OUT]; 2370 if (sce == NULL) { 2371 error = EINVAL; 2372 goto out; 2373 } 2374 2375 sip = &sce->rsel; 2376 switch (sce->edesc->bmAttributes & UE_XFERTYPE) { 2377 case UE_INTERRUPT: 2378 case UE_ISOCHRONOUS: 2379 /* XXX poll doesn't support this */ 2380 error = EINVAL; 2381 goto out; 2382 2383 case UE_BULK: 2384 kn->kn_fop = &ugenwrite_bulk_filtops; 2385 break; 2386 default: 2387 error = EINVAL; 2388 goto out; 2389 } 2390 break; 2391 2392 default: 2393 error = EINVAL; 2394 goto out; 2395 } 2396 2397 kn->kn_hook = sce; 2398 2399 mutex_enter(&sc->sc_lock); 2400 selrecord_knote(sip, kn); 2401 mutex_exit(&sc->sc_lock); 2402 2403 error = 0; 2404 2405 out: ugenif_release(sc); 2406 return error; 2407 } 2408 2409 MODULE(MODULE_CLASS_DRIVER, ugen, NULL); 2410 2411 static int 2412 ugen_modcmd(modcmd_t cmd, void *aux) 2413 { 2414 2415 switch (cmd) { 2416 case MODULE_CMD_INIT: 2417 mutex_init(&ugenif.lock, MUTEX_DEFAULT, IPL_NONE); 2418 rb_tree_init(&ugenif.tree, &ugenif_tree_ops); 2419 return 0; 2420 default: 2421 return ENOTTY; 2422 } 2423 } 2424
Indexes created Sun Oct 19 21:10:07 GMT 2025