1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 2006-2008 Hans Petter Selasky. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * 27 * usb_dev.c - An abstraction layer for creating devices under /dev/... 28 */ 29 30 #include <sys/stdint.h> 31 #include <sys/param.h> 32 #include <sys/queue.h> 33 #include <sys/types.h> 34 #include <sys/systm.h> 35 #include <sys/kernel.h> 36 #include <sys/thread2.h> 37 #include <sys/bus.h> 38 #include <sys/module.h> 39 #include <sys/lock.h> 40 #include <sys/mutex.h> 41 #include <sys/condvar.h> 42 #include <sys/sysctl.h> 43 #include <sys/unistd.h> 44 #include <sys/callout.h> 45 #include <sys/malloc.h> 46 #include <sys/priv.h> 47 #include <sys/vnode.h> 48 #include <sys/conf.h> 49 #include <sys/fcntl.h> 50 51 #include <bus/u4b/usb.h> 52 #include <bus/u4b/usb_ioctl.h> 53 #include <bus/u4b/usbdi.h> 54 #include <bus/u4b/usbdi_util.h> 55 56 #define USB_DEBUG_VAR usb_fifo_debug 57 58 #include <bus/u4b/usb_core.h> 59 #include <bus/u4b/usb_dev.h> 60 #include <bus/u4b/usb_mbuf.h> 61 #include <bus/u4b/usb_process.h> 62 #include <bus/u4b/usb_device.h> 63 #include <bus/u4b/usb_debug.h> 64 #include <bus/u4b/usb_busdma.h> 65 #include <bus/u4b/usb_generic.h> 66 #include <bus/u4b/usb_dynamic.h> 67 #include <bus/u4b/usb_util.h> 68 69 #include <bus/u4b/usb_controller.h> 70 #include <bus/u4b/usb_bus.h> 71 72 #include <sys/filio.h> 73 #include <sys/ttycom.h> 74 #include <sys/kern_syscall.h> 75 76 #include <machine/stdarg.h> 77 78 #if USB_HAVE_UGEN 79 80 #ifdef USB_DEBUG 81 static int usb_fifo_debug = 0; 82 83 static SYSCTL_NODE(_hw_usb, OID_AUTO, dev, CTLFLAG_RW, 0, "USB device"); 84 SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RW, 85 &usb_fifo_debug, 0, "Debug Level"); 86 87 TUNABLE_INT("hw.usb.dev.debug", &usb_fifo_debug); 88 #endif 89 90 #define USB_UCRED struct ucred *ucred, 91 92 /* prototypes */ 93 94 static int usb_fifo_open(struct usb_cdev_privdata *, 95 struct usb_fifo *, int); 96 static void usb_fifo_close(struct usb_fifo *, int); 97 static void usb_dev_init(void *); 98 static void usb_dev_init_post(void *); 99 static void usb_dev_uninit(void *); 100 static int usb_fifo_uiomove(struct usb_fifo *, void *, int, 101 struct uio *); 102 static void usb_fifo_check_methods(struct usb_fifo_methods *); 103 static struct usb_fifo *usb_fifo_alloc(void); 104 static struct usb_endpoint *usb_dev_get_ep(struct usb_device *, uint8_t, 105 uint8_t); 106 static void usb_loc_fill(struct usb_fs_privdata *, 107 struct usb_cdev_privdata *); 108 static usb_error_t usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *, int); 109 static usb_error_t usb_usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *); 110 static void usb_unref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *); 111 112 static void usb_filter_detach(struct knote *kn); 113 static int usb_filter_read(struct knote *kn, long hint); 114 static int usb_filter_write(struct knote *kn, long hint); 115 116 static d_open_t usb_open; 117 static d_close_t usb_close; 118 static d_ioctl_t usb_ioctl; 119 static d_read_t usb_read; 120 static d_write_t usb_write; 121 static d_kqfilter_t usb_kqfilter; 122 123 static d_ioctl_t usb_static_ioctl; 124 static d_open_t usb_static_open; 125 static d_close_t usb_static_close; 126 127 static usb_fifo_open_t usb_fifo_dummy_open; 128 static usb_fifo_close_t usb_fifo_dummy_close; 129 static usb_fifo_ioctl_t usb_fifo_dummy_ioctl; 130 static usb_fifo_cmd_t usb_fifo_dummy_cmd; 131 132 /* character device structure used for devices (/dev/ugenX.Y and /dev/uXXX) */ 133 struct dev_ops usb_ops = { 134 { "usbdev", 0, D_MEM }, 135 .d_open = usb_open, 136 .d_close = usb_close, 137 .d_ioctl = usb_ioctl, 138 .d_read = usb_read, 139 .d_write = usb_write, 140 .d_kqfilter = usb_kqfilter 141 }; 142 143 static struct cdev* usb_dev = NULL; 144 145 /* character device structure used for /bus/u4b */ 146 static struct dev_ops usb_static_ops = { 147 { "usb", 0, D_MEM }, 148 .d_open = usb_static_open, 149 .d_close = usb_static_close, 150 .d_ioctl = usb_static_ioctl, 151 }; 152 153 static TAILQ_HEAD(, usb_symlink) usb_sym_head; 154 static struct lock usb_sym_lock; 155 156 struct lock usb_ref_lock; 157 158 #if 0 159 static int usb_nevents = 0; 160 static struct kqinfo usb_kqevent; 161 #endif 162 163 /*------------------------------------------------------------------------* 164 * usb_loc_fill 165 * 166 * This is used to fill out a usb_cdev_privdata structure based on the 167 * device's address as contained in usb_fs_privdata. 168 *------------------------------------------------------------------------*/ 169 static void 170 usb_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd) 171 { 172 cpd->bus_index = pd->bus_index; 173 cpd->dev_index = pd->dev_index; 174 cpd->ep_addr = pd->ep_addr; 175 cpd->fifo_index = pd->fifo_index; 176 } 177 178 /*------------------------------------------------------------------------* 179 * usb_ref_device 180 * 181 * This function is used to atomically refer an USB device by its 182 * device location. If this function returns success the USB device 183 * will not dissappear until the USB device is unreferenced. 184 * 185 * Return values: 186 * 0: Success, refcount incremented on the given USB device. 187 * Else: Failure. 188 *------------------------------------------------------------------------*/ 189 static usb_error_t 190 usb_ref_device(struct usb_cdev_privdata *cpd, 191 struct usb_cdev_refdata *crd, int need_uref) 192 { 193 struct usb_fifo **ppf; 194 struct usb_fifo *f; 195 196 DPRINTFN(2, "cpd=%p need uref=%d\n", cpd, need_uref); 197 198 /* clear all refs */ 199 memset(crd, 0, sizeof(*crd)); 200 201 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 202 cpd->bus = devclass_get_softc(usb_devclass_ptr, cpd->bus_index); 203 if (cpd->bus == NULL) { 204 DPRINTFN(2, "no bus at %u\n", cpd->bus_index); 205 goto error; 206 } 207 cpd->udev = cpd->bus->devices[cpd->dev_index]; 208 if (cpd->udev == NULL) { 209 DPRINTFN(2, "no device at %u\n", cpd->dev_index); 210 goto error; 211 } 212 if (cpd->udev->refcount == USB_DEV_REF_MAX) { 213 DPRINTFN(2, "no dev ref\n"); 214 goto error; 215 } 216 if (need_uref) { 217 DPRINTFN(2, "ref udev - needed\n"); 218 cpd->udev->refcount++; 219 220 lockmgr(&usb_ref_lock, LK_RELEASE); 221 222 /* 223 * We need to grab the sx-lock before grabbing the 224 * FIFO refs to avoid deadlock at detach! 225 */ 226 crd->do_unlock = usbd_enum_lock(cpd->udev); 227 228 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 229 230 /* 231 * Set "is_uref" after grabbing the default SX lock 232 */ 233 crd->is_uref = 1; 234 } 235 236 /* check if we are doing an open */ 237 if (cpd->fflags == 0) { 238 /* use zero defaults */ 239 } else { 240 /* check for write */ 241 if (cpd->fflags & FWRITE) { 242 ppf = cpd->udev->fifo; 243 f = ppf[cpd->fifo_index + USB_FIFO_TX]; 244 crd->txfifo = f; 245 crd->is_write = 1; /* ref */ 246 if (f == NULL || f->refcount == USB_FIFO_REF_MAX) 247 goto error; 248 if (f->curr_cpd != cpd) 249 goto error; 250 /* check if USB-FS is active */ 251 if (f->fs_ep_max != 0) { 252 crd->is_usbfs = 1; 253 } 254 } 255 256 /* check for read */ 257 if (cpd->fflags & FREAD) { 258 ppf = cpd->udev->fifo; 259 f = ppf[cpd->fifo_index + USB_FIFO_RX]; 260 crd->rxfifo = f; 261 crd->is_read = 1; /* ref */ 262 if (f == NULL || f->refcount == USB_FIFO_REF_MAX) 263 goto error; 264 if (f->curr_cpd != cpd) 265 goto error; 266 /* check if USB-FS is active */ 267 if (f->fs_ep_max != 0) { 268 crd->is_usbfs = 1; 269 } 270 } 271 } 272 273 /* when everything is OK we increment the refcounts */ 274 if (crd->is_write) { 275 DPRINTFN(2, "ref write\n"); 276 crd->txfifo->refcount++; 277 } 278 if (crd->is_read) { 279 DPRINTFN(2, "ref read\n"); 280 crd->rxfifo->refcount++; 281 } 282 lockmgr(&usb_ref_lock, LK_RELEASE); 283 284 return (0); 285 286 error: 287 if (crd->do_unlock) 288 usbd_enum_unlock(cpd->udev); 289 290 if (crd->is_uref) { 291 if (--(cpd->udev->refcount) == 0) { 292 cv_signal(&cpd->udev->ref_cv); 293 } 294 } 295 lockmgr(&usb_ref_lock, LK_RELEASE); 296 DPRINTFN(2, "fail\n"); 297 return (USB_ERR_INVAL); 298 } 299 300 /*------------------------------------------------------------------------* 301 * usb_usb_ref_device 302 * 303 * This function is used to upgrade an USB reference to include the 304 * USB device reference on a USB location. 305 * 306 * Return values: 307 * 0: Success, refcount incremented on the given USB device. 308 * Else: Failure. 309 *------------------------------------------------------------------------*/ 310 static usb_error_t 311 usb_usb_ref_device(struct usb_cdev_privdata *cpd, 312 struct usb_cdev_refdata *crd) 313 { 314 /* 315 * Check if we already got an USB reference on this location: 316 */ 317 if (crd->is_uref) 318 return (0); /* success */ 319 320 /* 321 * To avoid deadlock at detach we need to drop the FIFO ref 322 * and re-acquire a new ref! 323 */ 324 usb_unref_device(cpd, crd); 325 326 return (usb_ref_device(cpd, crd, 1 /* need uref */)); 327 } 328 329 /*------------------------------------------------------------------------* 330 * usb_unref_device 331 * 332 * This function will release the reference count by one unit for the 333 * given USB device. 334 *------------------------------------------------------------------------*/ 335 static void 336 usb_unref_device(struct usb_cdev_privdata *cpd, 337 struct usb_cdev_refdata *crd) 338 { 339 340 DPRINTFN(2, "cpd=%p is_uref=%d\n", cpd, crd->is_uref); 341 342 if (crd->do_unlock) 343 usbd_enum_unlock(cpd->udev); 344 345 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 346 if (crd->is_read) { 347 if (--(crd->rxfifo->refcount) == 0) { 348 cv_signal(&crd->rxfifo->cv_drain); 349 } 350 crd->is_read = 0; 351 } 352 if (crd->is_write) { 353 if (--(crd->txfifo->refcount) == 0) { 354 cv_signal(&crd->txfifo->cv_drain); 355 } 356 crd->is_write = 0; 357 } 358 if (crd->is_uref) { 359 if (--(cpd->udev->refcount) == 0) { 360 cv_signal(&cpd->udev->ref_cv); 361 } 362 crd->is_uref = 0; 363 } 364 lockmgr(&usb_ref_lock, LK_RELEASE); 365 } 366 367 static struct usb_fifo * 368 usb_fifo_alloc(void) 369 { 370 struct usb_fifo *f; 371 372 f = kmalloc(sizeof(*f), M_USBDEV, M_WAITOK | M_ZERO); 373 if (f) { 374 cv_init(&f->cv_io, "FIFO-IO"); 375 cv_init(&f->cv_drain, "FIFO-DRAIN"); 376 f->refcount = 1; 377 } 378 return (f); 379 } 380 381 /*------------------------------------------------------------------------* 382 * usb_fifo_create 383 *------------------------------------------------------------------------*/ 384 static int 385 usb_fifo_create(struct usb_cdev_privdata *cpd, 386 struct usb_cdev_refdata *crd) 387 { 388 struct usb_device *udev = cpd->udev; 389 struct usb_fifo *f; 390 struct usb_endpoint *ep; 391 uint8_t n; 392 uint8_t is_tx; 393 uint8_t is_rx; 394 uint8_t no_null; 395 uint8_t is_busy; 396 int e = cpd->ep_addr; 397 398 is_tx = (cpd->fflags & FWRITE) ? 1 : 0; 399 is_rx = (cpd->fflags & FREAD) ? 1 : 0; 400 no_null = 1; 401 is_busy = 0; 402 403 /* Preallocated FIFO */ 404 if (e < 0) { 405 DPRINTFN(5, "Preallocated FIFO\n"); 406 if (is_tx) { 407 f = udev->fifo[cpd->fifo_index + USB_FIFO_TX]; 408 if (f == NULL) 409 return (EINVAL); 410 crd->txfifo = f; 411 } 412 if (is_rx) { 413 f = udev->fifo[cpd->fifo_index + USB_FIFO_RX]; 414 if (f == NULL) 415 return (EINVAL); 416 crd->rxfifo = f; 417 } 418 return (0); 419 } 420 421 KASSERT(e >= 0 && e <= 15, ("endpoint %d out of range", e)); 422 423 /* search for a free FIFO slot */ 424 DPRINTFN(5, "Endpoint device, searching for 0x%02x\n", e); 425 for (n = 0;; n += 2) { 426 427 if (n == USB_FIFO_MAX) { 428 if (no_null) { 429 no_null = 0; 430 n = 0; 431 } else { 432 /* end of FIFOs reached */ 433 DPRINTFN(5, "out of FIFOs\n"); 434 return (ENOMEM); 435 } 436 } 437 /* Check for TX FIFO */ 438 if (is_tx) { 439 f = udev->fifo[n + USB_FIFO_TX]; 440 if (f != NULL) { 441 if (f->dev_ep_index != e) { 442 /* wrong endpoint index */ 443 continue; 444 } 445 if (f->curr_cpd != NULL) { 446 /* FIFO is opened */ 447 is_busy = 1; 448 continue; 449 } 450 } else if (no_null) { 451 continue; 452 } 453 } 454 /* Check for RX FIFO */ 455 if (is_rx) { 456 f = udev->fifo[n + USB_FIFO_RX]; 457 if (f != NULL) { 458 if (f->dev_ep_index != e) { 459 /* wrong endpoint index */ 460 continue; 461 } 462 if (f->curr_cpd != NULL) { 463 /* FIFO is opened */ 464 is_busy = 1; 465 continue; 466 } 467 } else if (no_null) { 468 continue; 469 } 470 } 471 break; 472 } 473 474 if (no_null == 0) { 475 if (e >= (USB_EP_MAX / 2)) { 476 /* we don't create any endpoints in this range */ 477 DPRINTFN(5, "ep out of range\n"); 478 return (is_busy ? EBUSY : EINVAL); 479 } 480 } 481 482 if ((e != 0) && is_busy) { 483 /* 484 * Only the default control endpoint is allowed to be 485 * opened multiple times! 486 */ 487 DPRINTFN(5, "busy\n"); 488 return (EBUSY); 489 } 490 491 /* Check TX FIFO */ 492 if (is_tx && 493 (udev->fifo[n + USB_FIFO_TX] == NULL)) { 494 ep = usb_dev_get_ep(udev, e, USB_FIFO_TX); 495 DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_TX); 496 if (ep == NULL) { 497 DPRINTFN(5, "dev_get_endpoint returned NULL\n"); 498 return (EINVAL); 499 } 500 f = usb_fifo_alloc(); 501 if (f == NULL) { 502 DPRINTFN(5, "could not alloc tx fifo\n"); 503 return (ENOMEM); 504 } 505 /* update some fields */ 506 f->fifo_index = n + USB_FIFO_TX; 507 f->dev_ep_index = e; 508 f->priv_lock = &udev->device_lock; 509 f->priv_sc0 = ep; 510 f->methods = &usb_ugen_methods; 511 f->iface_index = ep->iface_index; 512 f->udev = udev; 513 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 514 udev->fifo[n + USB_FIFO_TX] = f; 515 lockmgr(&usb_ref_lock, LK_RELEASE); 516 } 517 /* Check RX FIFO */ 518 if (is_rx && 519 (udev->fifo[n + USB_FIFO_RX] == NULL)) { 520 521 ep = usb_dev_get_ep(udev, e, USB_FIFO_RX); 522 DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_RX); 523 if (ep == NULL) { 524 DPRINTFN(5, "dev_get_endpoint returned NULL\n"); 525 return (EINVAL); 526 } 527 f = usb_fifo_alloc(); 528 if (f == NULL) { 529 DPRINTFN(5, "could not alloc rx fifo\n"); 530 return (ENOMEM); 531 } 532 /* update some fields */ 533 f->fifo_index = n + USB_FIFO_RX; 534 f->dev_ep_index = e; 535 f->priv_lock = &udev->device_lock; 536 f->priv_sc0 = ep; 537 f->methods = &usb_ugen_methods; 538 f->iface_index = ep->iface_index; 539 f->udev = udev; 540 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 541 udev->fifo[n + USB_FIFO_RX] = f; 542 lockmgr(&usb_ref_lock, LK_RELEASE); 543 } 544 if (is_tx) { 545 crd->txfifo = udev->fifo[n + USB_FIFO_TX]; 546 } 547 if (is_rx) { 548 crd->rxfifo = udev->fifo[n + USB_FIFO_RX]; 549 } 550 /* fill out fifo index */ 551 DPRINTFN(5, "fifo index = %d\n", n); 552 cpd->fifo_index = n; 553 554 /* complete */ 555 556 return (0); 557 } 558 559 void 560 usb_fifo_free(struct usb_fifo *f) 561 { 562 uint8_t n; 563 564 if (f == NULL) { 565 /* be NULL safe */ 566 return; 567 } 568 /* destroy symlink devices, if any */ 569 for (n = 0; n != 2; n++) { 570 if (f->symlink[n]) { 571 usb_free_symlink(f->symlink[n]); 572 f->symlink[n] = NULL; 573 } 574 } 575 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 576 577 /* delink ourselves to stop calls from userland */ 578 if ((f->fifo_index < USB_FIFO_MAX) && 579 (f->udev != NULL) && 580 (f->udev->fifo[f->fifo_index] == f)) { 581 f->udev->fifo[f->fifo_index] = NULL; 582 } else { 583 DPRINTFN(0, "USB FIFO %p has not been linked\n", f); 584 } 585 586 /* decrease refcount */ 587 f->refcount--; 588 /* prevent any write flush */ 589 f->flag_iserror = 1; 590 /* need to wait until all callers have exited */ 591 while (f->refcount != 0) { 592 lockmgr(&usb_ref_lock, LK_RELEASE); /* avoid LOR */ 593 lockmgr(f->priv_lock, LK_EXCLUSIVE); 594 /* get I/O thread out of any sleep state */ 595 if (f->flag_sleeping) { 596 f->flag_sleeping = 0; 597 cv_broadcast(&f->cv_io); 598 } 599 lockmgr(f->priv_lock, LK_RELEASE); 600 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 601 602 /* wait for sync */ 603 cv_wait(&f->cv_drain, &usb_ref_lock); 604 } 605 lockmgr(&usb_ref_lock, LK_RELEASE); 606 607 /* take care of closing the device here, if any */ 608 usb_fifo_close(f, 0); 609 610 cv_destroy(&f->cv_io); 611 cv_destroy(&f->cv_drain); 612 613 kfree(f, M_USBDEV); 614 } 615 616 static struct usb_endpoint * 617 usb_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir) 618 { 619 struct usb_endpoint *ep; 620 uint8_t ep_dir; 621 622 if (ep_index == 0) { 623 ep = &udev->ctrl_ep; 624 } else { 625 if (dir == USB_FIFO_RX) { 626 if (udev->flags.usb_mode == USB_MODE_HOST) { 627 ep_dir = UE_DIR_IN; 628 } else { 629 ep_dir = UE_DIR_OUT; 630 } 631 } else { 632 if (udev->flags.usb_mode == USB_MODE_HOST) { 633 ep_dir = UE_DIR_OUT; 634 } else { 635 ep_dir = UE_DIR_IN; 636 } 637 } 638 ep = usbd_get_ep_by_addr(udev, ep_index | ep_dir); 639 } 640 641 if (ep == NULL) { 642 /* if the endpoint does not exist then return */ 643 return (NULL); 644 } 645 if (ep->edesc == NULL) { 646 /* invalid endpoint */ 647 return (NULL); 648 } 649 return (ep); /* success */ 650 } 651 652 /*------------------------------------------------------------------------* 653 * usb_fifo_open 654 * 655 * Returns: 656 * 0: Success 657 * Else: Failure 658 *------------------------------------------------------------------------*/ 659 static int 660 usb_fifo_open(struct usb_cdev_privdata *cpd, 661 struct usb_fifo *f, int fflags) 662 { 663 int err; 664 665 if (f == NULL) { 666 /* no FIFO there */ 667 DPRINTFN(2, "no FIFO\n"); 668 return (ENXIO); 669 } 670 /* remove FWRITE and FREAD flags */ 671 fflags &= ~(FWRITE | FREAD); 672 673 /* set correct file flags */ 674 if ((f->fifo_index & 1) == USB_FIFO_TX) { 675 fflags |= FWRITE; 676 } else { 677 fflags |= FREAD; 678 } 679 680 /* check if we are already opened */ 681 /* we don't need any locks when checking this variable */ 682 if (f->curr_cpd != NULL) { 683 err = EBUSY; 684 goto done; 685 } 686 687 /* reset short flag before open */ 688 f->flag_short = 0; 689 690 /* call open method */ 691 err = (f->methods->f_open) (f, fflags); 692 if (err) { 693 goto done; 694 } 695 lockmgr(f->priv_lock, LK_EXCLUSIVE); 696 697 /* reset sleep flag */ 698 f->flag_sleeping = 0; 699 700 /* reset error flag */ 701 f->flag_iserror = 0; 702 703 /* reset complete flag */ 704 f->flag_iscomplete = 0; 705 706 /* reset select flag */ 707 f->flag_isselect = 0; 708 709 /* reset flushing flag */ 710 f->flag_flushing = 0; 711 712 /* reset ASYNC proc flag */ 713 f->async_p = NULL; 714 715 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 716 /* flag the fifo as opened to prevent others */ 717 f->curr_cpd = cpd; 718 lockmgr(&usb_ref_lock, LK_RELEASE); 719 720 /* reset queue */ 721 usb_fifo_reset(f); 722 723 lockmgr(f->priv_lock, LK_RELEASE); 724 done: 725 return (err); 726 } 727 728 /*------------------------------------------------------------------------* 729 * usb_fifo_reset 730 *------------------------------------------------------------------------*/ 731 void 732 usb_fifo_reset(struct usb_fifo *f) 733 { 734 struct usb_mbuf *m; 735 736 if (f == NULL) { 737 return; 738 } 739 while (1) { 740 USB_IF_DEQUEUE(&f->used_q, m); 741 if (m) { 742 USB_IF_ENQUEUE(&f->free_q, m); 743 } else { 744 break; 745 } 746 } 747 /* reset have fragment flag */ 748 f->flag_have_fragment = 0; 749 } 750 751 /*------------------------------------------------------------------------* 752 * usb_fifo_close 753 *------------------------------------------------------------------------*/ 754 static void 755 usb_fifo_close(struct usb_fifo *f, int fflags) 756 { 757 int err; 758 759 /* check if we are not opened */ 760 if (f->curr_cpd == NULL) { 761 /* nothing to do - already closed */ 762 return; 763 } 764 lockmgr(f->priv_lock, LK_EXCLUSIVE); 765 766 /* clear current cdev private data pointer */ 767 f->curr_cpd = NULL; 768 769 /* check if we are selected */ 770 if (f->flag_isselect) { 771 #if 0 /* XXXDF */ 772 selwakeup(&f->selinfo); 773 #endif 774 f->flag_isselect = 0; 775 } 776 /* check if a thread wants SIGIO */ 777 if (f->async_p != NULL && lwkt_trytoken(&f->async_p->p_token)) { 778 ksignal(f->async_p, SIGIO); 779 lwkt_reltoken(&f->async_p->p_token); 780 f->async_p = NULL; 781 } 782 /* remove FWRITE and FREAD flags */ 783 fflags &= ~(FWRITE | FREAD); 784 785 /* flush written data, if any */ 786 if ((f->fifo_index & 1) == USB_FIFO_TX) { 787 788 if (!f->flag_iserror) { 789 790 /* set flushing flag */ 791 f->flag_flushing = 1; 792 793 /* get the last packet in */ 794 if (f->flag_have_fragment) { 795 struct usb_mbuf *m; 796 f->flag_have_fragment = 0; 797 USB_IF_DEQUEUE(&f->free_q, m); 798 if (m) { 799 USB_IF_ENQUEUE(&f->used_q, m); 800 } 801 } 802 803 /* start write transfer, if not already started */ 804 (f->methods->f_start_write) (f); 805 806 /* check if flushed already */ 807 while (f->flag_flushing && 808 (!f->flag_iserror)) { 809 /* wait until all data has been written */ 810 f->flag_sleeping = 1; 811 err = cv_wait_sig(&f->cv_io, f->priv_lock); 812 if (err) { 813 DPRINTF("signal received\n"); 814 break; 815 } 816 } 817 } 818 fflags |= FWRITE; 819 820 /* stop write transfer, if not already stopped */ 821 (f->methods->f_stop_write) (f); 822 } else { 823 fflags |= FREAD; 824 825 /* stop write transfer, if not already stopped */ 826 (f->methods->f_stop_read) (f); 827 } 828 829 /* check if we are sleeping */ 830 if (f->flag_sleeping) { 831 DPRINTFN(2, "Sleeping at close!\n"); 832 } 833 lockmgr(f->priv_lock, LK_RELEASE); 834 835 /* call close method */ 836 (f->methods->f_close) (f, fflags); 837 838 DPRINTF("closed\n"); 839 } 840 841 /*------------------------------------------------------------------------* 842 * usb_open - cdev callback 843 *------------------------------------------------------------------------*/ 844 static int 845 usb_open(struct dev_open_args *ap) 846 { 847 struct cdev *dev = ap->a_head.a_dev; 848 int fflags = ap->a_oflags; 849 struct usb_fs_privdata* pd = (struct usb_fs_privdata*)dev->si_drv1; 850 struct usb_cdev_refdata refs; 851 struct usb_cdev_privdata *cpd; 852 int err, ep; 853 854 DPRINTFN(2, "%s fflags=0x%08x\n", devtoname(dev), fflags); 855 856 KASSERT(fflags & (FREAD|FWRITE), ("invalid open flags")); 857 if (((fflags & FREAD) && !(pd->mode & FREAD)) || 858 ((fflags & FWRITE) && !(pd->mode & FWRITE))) { 859 DPRINTFN(2, "access mode not supported\n"); 860 return (EPERM); 861 } 862 863 /* 864 * Allow re-opens as long as the perms are the same. 865 * (dunno if this is a good idea, but 'usbconfig list' 866 * wants to open at least one of the ugen devices up 867 * twice). 868 */ 869 cpd = dev->si_drv2; 870 if (cpd) { 871 if (((cpd->fflags ^ fflags) & (FREAD|FWRITE)) == 0) 872 return(0); 873 return EBUSY; 874 } 875 876 cpd = kmalloc(sizeof(*cpd), M_USBDEV, M_WAITOK | M_ZERO); 877 ep = cpd->ep_addr = pd->ep_addr; 878 879 usb_loc_fill(pd, cpd); 880 err = usb_ref_device(cpd, &refs, 1); 881 if (err) { 882 DPRINTFN(2, "cannot ref device\n"); 883 kfree(cpd, M_USBDEV); 884 return (ENXIO); 885 } 886 cpd->fflags = fflags; /* access mode for open lifetime */ 887 888 /* create FIFOs, if any */ 889 err = usb_fifo_create(cpd, &refs); 890 /* check for error */ 891 if (err) { 892 DPRINTFN(2, "cannot create fifo\n"); 893 usb_unref_device(cpd, &refs); 894 kfree(cpd, M_USBDEV); 895 return (err); 896 } 897 if (fflags & FREAD) { 898 err = usb_fifo_open(cpd, refs.rxfifo, fflags); 899 if (err) { 900 DPRINTFN(2, "read open failed\n"); 901 usb_unref_device(cpd, &refs); 902 kfree(cpd, M_USBDEV); 903 return (err); 904 } 905 } 906 if (fflags & FWRITE) { 907 err = usb_fifo_open(cpd, refs.txfifo, fflags); 908 if (err) { 909 DPRINTFN(2, "write open failed\n"); 910 if (fflags & FREAD) { 911 usb_fifo_close(refs.rxfifo, fflags); 912 } 913 usb_unref_device(cpd, &refs); 914 kfree(cpd, M_USBDEV); 915 return (err); 916 } 917 } 918 usb_unref_device(cpd, &refs); 919 #if 0 /* XXX: markusp: which privs? */ 920 devfs_set_cdevpriv(cpd, usb_close); 921 #endif 922 /* XXX: This might not work as I expect! */ 923 dev->si_drv2 = (void *)cpd; 924 return (0); 925 } 926 927 /*------------------------------------------------------------------------* 928 * usb_close - cdev callback 929 *------------------------------------------------------------------------*/ 930 static int 931 usb_close(struct dev_close_args *ap) 932 { 933 struct cdev *dev = ap->a_head.a_dev; 934 struct usb_cdev_refdata refs; 935 struct usb_cdev_privdata *cpd = (struct usb_cdev_privdata *)dev->si_drv2; 936 int err; 937 938 DPRINTFN(2, "cpd=%p\n", cpd); 939 940 err = usb_ref_device(cpd, &refs, 0); 941 if (err) 942 goto done; 943 944 /* 945 * If this function is not called directly from the root HUB 946 * thread, there is usually a need to lock the enumeration 947 * lock. Check this. 948 */ 949 if (!usbd_enum_is_locked(cpd->udev)) { 950 951 DPRINTFN(2, "Locking enumeration\n"); 952 953 /* reference device */ 954 err = usb_usb_ref_device(cpd, &refs); 955 if (err) 956 goto done; 957 } 958 if (cpd->fflags & FREAD) { 959 usb_fifo_close(refs.rxfifo, cpd->fflags); 960 } 961 if (cpd->fflags & FWRITE) { 962 usb_fifo_close(refs.txfifo, cpd->fflags); 963 } 964 usb_unref_device(cpd, &refs); 965 done: 966 dev->si_drv2 = NULL; 967 kfree(cpd, M_USBDEV); 968 return 0; 969 } 970 971 static void 972 usb_dev_init(void *arg) 973 { 974 lockinit(&usb_ref_lock, "USB ref mutex", 0, 0); 975 lockinit(&usb_sym_lock, "USB sym mutex", 0, 0); 976 TAILQ_INIT(&usb_sym_head); 977 978 /* check the UGEN methods */ 979 usb_fifo_check_methods(&usb_ugen_methods); 980 } 981 982 /* XXX SI_SUB_KLD? */ 983 SYSINIT(usb_dev_init, SI_SUB_PRE_DRIVERS, SI_ORDER_FIRST, usb_dev_init, NULL); 984 985 static void 986 usb_dev_init_post(void *arg) 987 { 988 /* 989 * Create /dev/usb - this is needed for usbconfig(8), which 990 * needs a well-known device name to access. 991 */ 992 usb_dev = make_dev(&usb_static_ops, 0, UID_ROOT, GID_OPERATOR, 993 0644, USB_DEVICE_NAME); 994 if (usb_dev == NULL) { 995 DPRINTFN(0, "Could not create usb bus device\n"); 996 } 997 } 998 999 SYSINIT(usb_dev_init_post, SI_SUB_DRIVERS, SI_ORDER_FIRST, usb_dev_init_post, 1000 NULL); 1001 1002 static void 1003 usb_dev_uninit(void *arg) 1004 { 1005 if (usb_dev != NULL) { 1006 destroy_dev(usb_dev); 1007 usb_dev = NULL; 1008 } 1009 lockuninit(&usb_ref_lock); 1010 lockuninit(&usb_sym_lock); 1011 } 1012 1013 SYSUNINIT(usb_dev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb_dev_uninit, NULL); 1014 1015 static int 1016 usb_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr, 1017 struct thread *td) 1018 { 1019 int error = 0; 1020 1021 switch (cmd) { 1022 case FIODTYPE: 1023 *(int *)addr = 0; /* character device */ 1024 break; 1025 1026 case FIONBIO: 1027 /* handled by upper FS layer */ 1028 break; 1029 1030 case FIOASYNC: 1031 if (*(int *)addr) { 1032 if (f->async_p != NULL) { 1033 error = EBUSY; 1034 break; 1035 } 1036 f->async_p = USB_TD_GET_PROC(td); 1037 } else { 1038 f->async_p = NULL; 1039 } 1040 break; 1041 1042 /* XXX this is not the most general solution */ 1043 case TIOCSPGRP: 1044 if (f->async_p == NULL) { 1045 error = EINVAL; 1046 break; 1047 } 1048 if (*(int *)addr != USB_PROC_GET_GID(f->async_p)) { 1049 error = EPERM; 1050 break; 1051 } 1052 break; 1053 default: 1054 return (ENOIOCTL); 1055 } 1056 DPRINTFN(3, "cmd 0x%lx = %d\n", cmd, error); 1057 return (error); 1058 } 1059 1060 /*------------------------------------------------------------------------* 1061 * usb_ioctl - cdev callback 1062 *------------------------------------------------------------------------*/ 1063 static int 1064 usb_ioctl(struct dev_ioctl_args *ap) 1065 { 1066 struct cdev *dev = ap->a_head.a_dev; 1067 u_long cmd = ap->a_cmd; 1068 caddr_t addr = ap->a_data; 1069 /* XXX: What is this thread and where is it supposed to come from */ 1070 struct thread *td = curthread; 1071 struct usb_cdev_refdata refs; 1072 struct usb_cdev_privdata* cpd; 1073 struct usb_fifo *f; 1074 int fflags; 1075 int err; 1076 1077 DPRINTFN(2, "cmd=0x%lx\n", cmd); 1078 1079 #if 0 /* XXX: cdev? */ 1080 err = devfs_get_cdevpriv((void **)&cpd); 1081 if (err != 0) 1082 return (err); 1083 #endif 1084 1085 /* 1086 * XXX: This might not work as I would like it to 1087 * also I need a proper return value if it does 1088 */ 1089 if (dev->si_drv2 == NULL) 1090 return(-1); 1091 1092 cpd = (struct usb_cdev_privdata *)dev->si_drv2; 1093 1094 /* 1095 * Performance optimisation: We try to check for IOCTL's that 1096 * don't need the USB reference first. Then we grab the USB 1097 * reference if we need it! 1098 */ 1099 err = usb_ref_device(cpd, &refs, 0 /* no uref */ ); 1100 if (err) 1101 return (ENXIO); 1102 1103 fflags = cpd->fflags; 1104 1105 f = NULL; /* set default value */ 1106 err = ENOIOCTL; /* set default value */ 1107 1108 if (fflags & FWRITE) { 1109 f = refs.txfifo; 1110 err = usb_ioctl_f_sub(f, cmd, addr, td); 1111 } 1112 if (fflags & FREAD) { 1113 f = refs.rxfifo; 1114 err = usb_ioctl_f_sub(f, cmd, addr, td); 1115 } 1116 KASSERT(f != NULL, ("fifo not found")); 1117 if (err != ENOIOCTL) 1118 goto done; 1119 1120 err = (f->methods->f_ioctl) (f, cmd, addr, fflags); 1121 1122 DPRINTFN(2, "f_ioctl cmd 0x%lx = %d\n", cmd, err); 1123 1124 if (err != ENOIOCTL) 1125 goto done; 1126 1127 if (usb_usb_ref_device(cpd, &refs)) { 1128 err = ENXIO; 1129 goto done; 1130 } 1131 1132 err = (f->methods->f_ioctl_post) (f, cmd, addr, fflags); 1133 1134 DPRINTFN(2, "f_ioctl_post cmd 0x%lx = %d\n", cmd, err); 1135 1136 if (err == ENOIOCTL) 1137 err = ENOTTY; 1138 1139 if (err) 1140 goto done; 1141 1142 /* Wait for re-enumeration, if any */ 1143 1144 while (f->udev->re_enumerate_wait != 0) { 1145 1146 usb_unref_device(cpd, &refs); 1147 1148 usb_pause_mtx(NULL, hz / 128); 1149 1150 if (usb_ref_device(cpd, &refs, 1 /* need uref */)) { 1151 err = ENXIO; 1152 goto done; 1153 } 1154 } 1155 1156 done: 1157 usb_unref_device(cpd, &refs); 1158 return (err); 1159 } 1160 1161 static struct filterops usb_filtops_read = 1162 { FILTEROP_ISFD, NULL, usb_filter_detach, usb_filter_read }; 1163 1164 static struct filterops usb_filtops_write = 1165 { FILTEROP_ISFD, NULL, usb_filter_detach, usb_filter_write }; 1166 1167 static int 1168 usb_kqfilter(struct dev_kqfilter_args *ap) 1169 { 1170 cdev_t dev = ap->a_head.a_dev; 1171 struct knote *kn = ap->a_kn; 1172 1173 ap->a_result = 0; 1174 1175 switch(kn->kn_filter) { 1176 case EVFILT_READ: 1177 kn->kn_fop = &usb_filtops_read; 1178 kn->kn_hook = (caddr_t)dev; 1179 break; 1180 case EVFILT_WRITE: 1181 kn->kn_fop = &usb_filtops_write; 1182 kn->kn_hook = (caddr_t)dev; 1183 break; 1184 default: 1185 ap->a_result = EOPNOTSUPP; 1186 return(0); 1187 } 1188 1189 return(0); 1190 } 1191 1192 static void 1193 usb_filter_detach(struct knote *kn) 1194 { 1195 #if 0 1196 struct klist *klist; 1197 1198 klist = &usb_kqevent.ki_note; 1199 knote_remove(klist, kn); 1200 #endif 1201 } 1202 1203 static int 1204 usb_filter_read(struct knote *kn, long hint) 1205 { 1206 return(0); 1207 } 1208 1209 static int 1210 usb_filter_write(struct knote *kn, long hint) 1211 { 1212 return(0); 1213 } 1214 1215 #if 0 /* XXX implement using kqfilter */ 1216 /* ARGSUSED */ 1217 static int 1218 usb_poll(struct cdev* dev, int events, struct thread* td) 1219 { 1220 struct usb_cdev_refdata refs; 1221 struct usb_cdev_privdata* cpd; 1222 struct usb_fifo *f; 1223 struct usb_mbuf *m; 1224 int fflags, revents; 1225 1226 if (devfs_get_cdevpriv((void **)&cpd) != 0 || 1227 usb_ref_device(cpd, &refs, 0) != 0) 1228 return (events & 1229 (POLLHUP|POLLIN|POLLRDNORM|POLLOUT|POLLWRNORM)); 1230 1231 fflags = cpd->fflags; 1232 1233 /* Figure out who needs service */ 1234 revents = 0; 1235 if ((events & (POLLOUT | POLLWRNORM)) && 1236 (fflags & FWRITE)) { 1237 1238 f = refs.txfifo; 1239 1240 lockmgr(f->priv_lock, LK_EXCLUSIVE); 1241 1242 if (!refs.is_usbfs) { 1243 if (f->flag_iserror) { 1244 /* we got an error */ 1245 m = (void *)1; 1246 } else { 1247 if (f->queue_data == NULL) { 1248 /* 1249 * start write transfer, if not 1250 * already started 1251 */ 1252 (f->methods->f_start_write) (f); 1253 } 1254 /* check if any packets are available */ 1255 USB_IF_POLL(&f->free_q, m); 1256 } 1257 } else { 1258 if (f->flag_iscomplete) { 1259 m = (void *)1; 1260 } else { 1261 m = NULL; 1262 } 1263 } 1264 1265 if (m) { 1266 revents |= events & (POLLOUT | POLLWRNORM); 1267 } else { 1268 f->flag_isselect = 1; 1269 selrecord(td, &f->selinfo); 1270 } 1271 1272 lockmgr(f->priv_lock); 1273 } 1274 if ((events & (POLLIN | POLLRDNORM)) && 1275 (fflags & FREAD)) { 1276 1277 f = refs.rxfifo; 1278 1279 lockmgr(f->priv_lock, LK_EXCLUSIVE); 1280 1281 if (!refs.is_usbfs) { 1282 if (f->flag_iserror) { 1283 /* we have and error */ 1284 m = (void *)1; 1285 } else { 1286 if (f->queue_data == NULL) { 1287 /* 1288 * start read transfer, if not 1289 * already started 1290 */ 1291 (f->methods->f_start_read) (f); 1292 } 1293 /* check if any packets are available */ 1294 USB_IF_POLL(&f->used_q, m); 1295 } 1296 } else { 1297 if (f->flag_iscomplete) { 1298 m = (void *)1; 1299 } else { 1300 m = NULL; 1301 } 1302 } 1303 1304 if (m) { 1305 revents |= events & (POLLIN | POLLRDNORM); 1306 } else { 1307 f->flag_isselect = 1; 1308 selrecord(td, &f->selinfo); 1309 1310 if (!refs.is_usbfs) { 1311 /* start reading data */ 1312 (f->methods->f_start_read) (f); 1313 } 1314 } 1315 1316 lockmgr(f->priv_lock, LK_RELEASE); 1317 } 1318 usb_unref_device(cpd, &refs); 1319 return (revents); 1320 } 1321 #endif 1322 1323 static int 1324 usb_read(struct dev_read_args *ap) 1325 { 1326 struct cdev *dev = ap->a_head.a_dev; 1327 struct uio *uio = ap->a_uio; 1328 int ioflag = ap->a_ioflag; 1329 struct usb_cdev_refdata refs; 1330 struct usb_cdev_privdata* cpd; 1331 struct usb_fifo *f; 1332 struct usb_mbuf *m; 1333 int fflags; 1334 int resid; 1335 int io_len; 1336 int err; 1337 uint8_t tr_data = 0; 1338 1339 #if 0 1340 err = devfs_get_cdevpriv((void **)&cpd); 1341 if (err != 0) 1342 return (err); 1343 #endif 1344 1345 if (dev->si_drv2 == NULL) 1346 return(-1); 1347 1348 cpd = (struct usb_cdev_privdata *)dev->si_drv2; 1349 1350 err = usb_ref_device(cpd, &refs, 0 /* no uref */ ); 1351 if (err) { 1352 return (ENXIO); 1353 } 1354 fflags = cpd->fflags; 1355 1356 f = refs.rxfifo; 1357 if (f == NULL) { 1358 /* should not happen */ 1359 usb_unref_device(cpd, &refs); 1360 return (EPERM); 1361 } 1362 1363 resid = uio->uio_resid; 1364 1365 lockmgr(f->priv_lock, LK_EXCLUSIVE); 1366 1367 /* check for permanent read error */ 1368 if (f->flag_iserror) { 1369 err = EIO; 1370 goto done; 1371 } 1372 /* check if USB-FS interface is active */ 1373 if (refs.is_usbfs) { 1374 /* 1375 * The queue is used for events that should be 1376 * retrieved using the "USB_FS_COMPLETE" ioctl. 1377 */ 1378 err = EINVAL; 1379 goto done; 1380 } 1381 while (uio->uio_resid > 0) { 1382 1383 USB_IF_DEQUEUE(&f->used_q, m); 1384 1385 if (m == NULL) { 1386 1387 /* start read transfer, if not already started */ 1388 1389 (f->methods->f_start_read) (f); 1390 1391 if (ioflag & IO_NDELAY) { 1392 if (tr_data) { 1393 /* return length before error */ 1394 break; 1395 } 1396 err = EWOULDBLOCK; 1397 break; 1398 } 1399 DPRINTF("sleeping\n"); 1400 1401 err = usb_fifo_wait(f); 1402 if (err) { 1403 break; 1404 } 1405 continue; 1406 } 1407 if (f->methods->f_filter_read) { 1408 /* 1409 * Sometimes it is convenient to process data at the 1410 * expense of a userland process instead of a kernel 1411 * process. 1412 */ 1413 (f->methods->f_filter_read) (f, m); 1414 } 1415 tr_data = 1; 1416 1417 io_len = MIN(m->cur_data_len, uio->uio_resid); 1418 1419 DPRINTFN(2, "transfer %d bytes from %p\n", 1420 io_len, m->cur_data_ptr); 1421 1422 err = usb_fifo_uiomove(f, 1423 m->cur_data_ptr, io_len, uio); 1424 1425 m->cur_data_len -= io_len; 1426 m->cur_data_ptr += io_len; 1427 1428 if (m->cur_data_len == 0) { 1429 1430 uint8_t last_packet; 1431 1432 last_packet = m->last_packet; 1433 1434 USB_IF_ENQUEUE(&f->free_q, m); 1435 1436 if (last_packet) { 1437 /* keep framing */ 1438 break; 1439 } 1440 } else { 1441 USB_IF_PREPEND(&f->used_q, m); 1442 } 1443 1444 if (err) { 1445 break; 1446 } 1447 } 1448 done: 1449 lockmgr(f->priv_lock, LK_RELEASE); 1450 1451 usb_unref_device(cpd, &refs); 1452 1453 return (err); 1454 } 1455 1456 static int 1457 usb_write(struct dev_write_args *ap) 1458 { 1459 struct cdev *dev = ap->a_head.a_dev; 1460 struct uio *uio = ap->a_uio; 1461 int ioflag = ap->a_ioflag; 1462 struct usb_cdev_refdata refs; 1463 struct usb_cdev_privdata* cpd; 1464 struct usb_fifo *f; 1465 struct usb_mbuf *m; 1466 uint8_t *pdata; 1467 int fflags; 1468 int resid; 1469 int io_len; 1470 int err; 1471 uint8_t tr_data = 0; 1472 1473 DPRINTFN(2, "\n"); 1474 1475 #if 0 /* XXXDF */ 1476 err = devfs_get_cdevpriv((void **)&cpd); 1477 if (err != 0) 1478 return (err); 1479 #endif 1480 1481 if (dev->si_drv2 == NULL) 1482 return(-1); 1483 1484 cpd = (struct usb_cdev_privdata *)dev->si_drv2; 1485 1486 err = usb_ref_device(cpd, &refs, 0 /* no uref */ ); 1487 if (err) { 1488 return (ENXIO); 1489 } 1490 fflags = cpd->fflags; 1491 1492 f = refs.txfifo; 1493 if (f == NULL) { 1494 /* should not happen */ 1495 usb_unref_device(cpd, &refs); 1496 return (EPERM); 1497 } 1498 resid = uio->uio_resid; 1499 1500 lockmgr(f->priv_lock, LK_EXCLUSIVE); 1501 1502 /* check for permanent write error */ 1503 if (f->flag_iserror) { 1504 err = EIO; 1505 goto done; 1506 } 1507 /* check if USB-FS interface is active */ 1508 if (refs.is_usbfs) { 1509 /* 1510 * The queue is used for events that should be 1511 * retrieved using the "USB_FS_COMPLETE" ioctl. 1512 */ 1513 err = EINVAL; 1514 goto done; 1515 } 1516 if (f->queue_data == NULL) { 1517 /* start write transfer, if not already started */ 1518 (f->methods->f_start_write) (f); 1519 } 1520 /* we allow writing zero length data */ 1521 do { 1522 USB_IF_DEQUEUE(&f->free_q, m); 1523 1524 if (m == NULL) { 1525 1526 if (ioflag & IO_NDELAY) { 1527 if (tr_data) { 1528 /* return length before error */ 1529 break; 1530 } 1531 err = EWOULDBLOCK; 1532 break; 1533 } 1534 DPRINTF("sleeping\n"); 1535 1536 err = usb_fifo_wait(f); 1537 if (err) { 1538 break; 1539 } 1540 continue; 1541 } 1542 tr_data = 1; 1543 1544 if (f->flag_have_fragment == 0) { 1545 USB_MBUF_RESET(m); 1546 io_len = m->cur_data_len; 1547 pdata = m->cur_data_ptr; 1548 if (io_len > uio->uio_resid) 1549 io_len = uio->uio_resid; 1550 m->cur_data_len = io_len; 1551 } else { 1552 io_len = m->max_data_len - m->cur_data_len; 1553 pdata = m->cur_data_ptr + m->cur_data_len; 1554 if (io_len > uio->uio_resid) 1555 io_len = uio->uio_resid; 1556 m->cur_data_len += io_len; 1557 } 1558 1559 DPRINTFN(2, "transfer %d bytes to %p\n", 1560 io_len, pdata); 1561 1562 err = usb_fifo_uiomove(f, pdata, io_len, uio); 1563 1564 if (err) { 1565 f->flag_have_fragment = 0; 1566 USB_IF_ENQUEUE(&f->free_q, m); 1567 break; 1568 } 1569 1570 /* check if the buffer is ready to be transmitted */ 1571 1572 if ((f->flag_write_defrag == 0) || 1573 (m->cur_data_len == m->max_data_len)) { 1574 f->flag_have_fragment = 0; 1575 1576 /* 1577 * Check for write filter: 1578 * 1579 * Sometimes it is convenient to process data 1580 * at the expense of a userland process 1581 * instead of a kernel process. 1582 */ 1583 if (f->methods->f_filter_write) { 1584 (f->methods->f_filter_write) (f, m); 1585 } 1586 1587 /* Put USB mbuf in the used queue */ 1588 USB_IF_ENQUEUE(&f->used_q, m); 1589 1590 /* Start writing data, if not already started */ 1591 (f->methods->f_start_write) (f); 1592 } else { 1593 /* Wait for more data or close */ 1594 f->flag_have_fragment = 1; 1595 USB_IF_PREPEND(&f->free_q, m); 1596 } 1597 1598 } while (uio->uio_resid > 0); 1599 done: 1600 lockmgr(f->priv_lock, LK_RELEASE); 1601 1602 usb_unref_device(cpd, &refs); 1603 1604 return (err); 1605 } 1606 1607 int 1608 usb_static_open(struct dev_open_args *ap) 1609 { 1610 return 0; 1611 } 1612 1613 int 1614 usb_static_close(struct dev_close_args *ap) 1615 { 1616 return 0; 1617 } 1618 1619 int 1620 usb_static_ioctl(struct dev_ioctl_args *ap) 1621 { 1622 u_long cmd = ap->a_cmd; 1623 caddr_t data = ap->a_data; 1624 struct thread *td = curthread; /* XXX: curthread the correct choice? */ 1625 int fflag = ap->a_fflag; 1626 union { 1627 struct usb_read_dir *urd; 1628 void* data; 1629 } u; 1630 int err; 1631 1632 u.data = data; 1633 switch (cmd) { 1634 case USB_READ_DIR: 1635 err = usb_read_symlink(u.urd->urd_data, 1636 u.urd->urd_startentry, u.urd->urd_maxlen); 1637 break; 1638 case USB_DEV_QUIRK_GET: 1639 case USB_QUIRK_NAME_GET: 1640 case USB_DEV_QUIRK_ADD: 1641 case USB_DEV_QUIRK_REMOVE: 1642 err = usb_quirk_ioctl_p(cmd, data, fflag, td); 1643 break; 1644 case USB_GET_TEMPLATE: 1645 *(int *)data = usb_template; 1646 err = 0; 1647 break; 1648 case USB_SET_TEMPLATE: 1649 err = priv_check(curthread, PRIV_DRIVER); 1650 if (err) 1651 break; 1652 usb_template = *(int *)data; 1653 break; 1654 default: 1655 err = ENOTTY; 1656 break; 1657 } 1658 return (err); 1659 } 1660 1661 static int 1662 usb_fifo_uiomove(struct usb_fifo *f, void *cp, 1663 int n, struct uio *uio) 1664 { 1665 int error; 1666 1667 lockmgr(f->priv_lock, LK_RELEASE); 1668 1669 /* 1670 * "uiomove()" can sleep so one needs to make a wrapper, 1671 * exiting the mutex and checking things: 1672 */ 1673 error = uiomove(cp, n, uio); 1674 1675 lockmgr(f->priv_lock, LK_EXCLUSIVE); 1676 1677 return (error); 1678 } 1679 1680 int 1681 usb_fifo_wait(struct usb_fifo *f) 1682 { 1683 int err; 1684 1685 KKASSERT(lockowned(f->priv_lock)); 1686 1687 if (f->flag_iserror) { 1688 /* we are gone */ 1689 return (EIO); 1690 } 1691 f->flag_sleeping = 1; 1692 1693 err = cv_wait_sig(&f->cv_io, f->priv_lock); 1694 1695 if (f->flag_iserror) { 1696 /* we are gone */ 1697 err = EIO; 1698 } 1699 return (err); 1700 } 1701 1702 void 1703 usb_fifo_signal(struct usb_fifo *f) 1704 { 1705 if (f->flag_sleeping) { 1706 f->flag_sleeping = 0; 1707 cv_broadcast(&f->cv_io); 1708 } 1709 } 1710 1711 void 1712 usb_fifo_wakeup(struct usb_fifo *f) 1713 { 1714 usb_fifo_signal(f); 1715 1716 if (f->flag_isselect) { 1717 #if 0 /* XXXDF */ 1718 selwakeup(&f->selinfo); 1719 #endif 1720 f->flag_isselect = 0; 1721 } 1722 if (f->async_p != NULL && lwkt_trytoken(&f->async_p->p_token)) { 1723 ksignal(f->async_p, SIGIO); 1724 lwkt_reltoken(&f->async_p->p_token); 1725 } 1726 } 1727 1728 static int 1729 usb_fifo_dummy_open(struct usb_fifo *fifo, int fflags) 1730 { 1731 return (0); 1732 } 1733 1734 static void 1735 usb_fifo_dummy_close(struct usb_fifo *fifo, int fflags) 1736 { 1737 return; 1738 } 1739 1740 static int 1741 usb_fifo_dummy_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags) 1742 { 1743 return (ENOIOCTL); 1744 } 1745 1746 static void 1747 usb_fifo_dummy_cmd(struct usb_fifo *fifo) 1748 { 1749 fifo->flag_flushing = 0; /* not flushing */ 1750 } 1751 1752 static void 1753 usb_fifo_check_methods(struct usb_fifo_methods *pm) 1754 { 1755 /* check that all callback functions are OK */ 1756 1757 if (pm->f_open == NULL) 1758 pm->f_open = &usb_fifo_dummy_open; 1759 1760 if (pm->f_close == NULL) 1761 pm->f_close = &usb_fifo_dummy_close; 1762 1763 if (pm->f_ioctl == NULL) 1764 pm->f_ioctl = &usb_fifo_dummy_ioctl; 1765 1766 if (pm->f_ioctl_post == NULL) 1767 pm->f_ioctl_post = &usb_fifo_dummy_ioctl; 1768 1769 if (pm->f_start_read == NULL) 1770 pm->f_start_read = &usb_fifo_dummy_cmd; 1771 1772 if (pm->f_stop_read == NULL) 1773 pm->f_stop_read = &usb_fifo_dummy_cmd; 1774 1775 if (pm->f_start_write == NULL) 1776 pm->f_start_write = &usb_fifo_dummy_cmd; 1777 1778 if (pm->f_stop_write == NULL) 1779 pm->f_stop_write = &usb_fifo_dummy_cmd; 1780 } 1781 1782 /*------------------------------------------------------------------------* 1783 * usb_fifo_attach 1784 * 1785 * The following function will create a duplex FIFO. 1786 * 1787 * Return values: 1788 * 0: Success. 1789 * Else: Failure. 1790 *------------------------------------------------------------------------*/ 1791 int 1792 usb_fifo_attach(struct usb_device *udev, void *priv_sc, 1793 struct lock *priv_lock, struct usb_fifo_methods *pm, 1794 struct usb_fifo_sc *f_sc, uint16_t unit, int16_t subunit, 1795 uint8_t iface_index, uid_t uid, gid_t gid, int mode) 1796 { 1797 struct usb_fifo *f_tx; 1798 struct usb_fifo *f_rx; 1799 char devname[32]; 1800 uint8_t n; 1801 1802 f_sc->fp[USB_FIFO_TX] = NULL; 1803 f_sc->fp[USB_FIFO_RX] = NULL; 1804 1805 if (pm == NULL) 1806 return (EINVAL); 1807 1808 /* check the methods */ 1809 usb_fifo_check_methods(pm); 1810 1811 /* search for a free FIFO slot */ 1812 for (n = 0;; n += 2) { 1813 1814 if (n == USB_FIFO_MAX) { 1815 /* end of FIFOs reached */ 1816 return (ENOMEM); 1817 } 1818 /* Check for TX FIFO */ 1819 if (udev->fifo[n + USB_FIFO_TX] != NULL) { 1820 continue; 1821 } 1822 /* Check for RX FIFO */ 1823 if (udev->fifo[n + USB_FIFO_RX] != NULL) { 1824 continue; 1825 } 1826 break; 1827 } 1828 1829 f_tx = usb_fifo_alloc(); 1830 f_rx = usb_fifo_alloc(); 1831 1832 if ((f_tx == NULL) || (f_rx == NULL)) { 1833 usb_fifo_free(f_tx); 1834 usb_fifo_free(f_rx); 1835 return (ENOMEM); 1836 } 1837 /* initialise FIFO structures */ 1838 1839 f_tx->fifo_index = n + USB_FIFO_TX; 1840 f_tx->dev_ep_index = -1; 1841 f_tx->priv_lock = priv_lock; 1842 f_tx->priv_sc0 = priv_sc; 1843 f_tx->methods = pm; 1844 f_tx->iface_index = iface_index; 1845 f_tx->udev = udev; 1846 1847 f_rx->fifo_index = n + USB_FIFO_RX; 1848 f_rx->dev_ep_index = -1; 1849 f_rx->priv_lock = priv_lock; 1850 f_rx->priv_sc0 = priv_sc; 1851 f_rx->methods = pm; 1852 f_rx->iface_index = iface_index; 1853 f_rx->udev = udev; 1854 1855 f_sc->fp[USB_FIFO_TX] = f_tx; 1856 f_sc->fp[USB_FIFO_RX] = f_rx; 1857 1858 lockmgr(&usb_ref_lock, LK_EXCLUSIVE); 1859 udev->fifo[f_tx->fifo_index] = f_tx; 1860 udev->fifo[f_rx->fifo_index] = f_rx; 1861 lockmgr(&usb_ref_lock, LK_RELEASE); 1862 1863 for (n = 0; n != 4; n++) { 1864 1865 if (pm->basename[n] == NULL) { 1866 continue; 1867 } 1868 if (subunit == 0xFFFF) { 1869 if (ksnprintf(devname, sizeof(devname), 1870 "%s%u%s", pm->basename[n], 1871 unit, pm->postfix[n] ? 1872 pm->postfix[n] : "")) { 1873 /* ignore */ 1874 } 1875 } else { 1876 if (ksnprintf(devname, sizeof(devname), 1877 "%s%u.%u%s", pm->basename[n], 1878 unit, subunit, pm->postfix[n] ? 1879 pm->postfix[n] : "")) { 1880 /* ignore */ 1881 } 1882 } 1883 1884 /* 1885 * Distribute the symbolic links into two FIFO structures: 1886 */ 1887 if (n & 1) { 1888 f_rx->symlink[n / 2] = 1889 usb_alloc_symlink(devname); 1890 } else { 1891 f_tx->symlink[n / 2] = 1892 usb_alloc_symlink(devname); 1893 } 1894 1895 /* Create the device */ 1896 f_sc->dev = usb_make_dev(udev, devname, -1, 1897 f_tx->fifo_index & f_rx->fifo_index, 1898 FREAD|FWRITE, uid, gid, mode); 1899 } 1900 1901 DPRINTFN(2, "attached %p/%p\n", f_tx, f_rx); 1902 return (0); 1903 } 1904 1905 /*------------------------------------------------------------------------* 1906 * usb_fifo_alloc_buffer 1907 * 1908 * Return values: 1909 * 0: Success 1910 * Else failure 1911 *------------------------------------------------------------------------*/ 1912 int 1913 usb_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize, 1914 uint16_t nbuf) 1915 { 1916 usb_fifo_free_buffer(f); 1917 1918 /* allocate an endpoint */ 1919 f->free_q.ifq_maxlen = nbuf; 1920 f->used_q.ifq_maxlen = nbuf; 1921 1922 f->queue_data = usb_alloc_mbufs( 1923 M_USBDEV, &f->free_q, bufsize, nbuf); 1924 1925 if ((f->queue_data == NULL) && bufsize && nbuf) { 1926 return (ENOMEM); 1927 } 1928 return (0); /* success */ 1929 } 1930 1931 /*------------------------------------------------------------------------* 1932 * usb_fifo_free_buffer 1933 * 1934 * This function will free the buffers associated with a FIFO. This 1935 * function can be called multiple times in a row. 1936 *------------------------------------------------------------------------*/ 1937 void 1938 usb_fifo_free_buffer(struct usb_fifo *f) 1939 { 1940 if (f->queue_data) { 1941 /* free old buffer */ 1942 kfree(f->queue_data, M_USBDEV); 1943 f->queue_data = NULL; 1944 } 1945 /* reset queues */ 1946 1947 memset(&f->free_q, 0, sizeof(f->free_q)); 1948 memset(&f->used_q, 0, sizeof(f->used_q)); 1949 } 1950 1951 void 1952 usb_fifo_detach(struct usb_fifo_sc *f_sc) 1953 { 1954 if (f_sc == NULL) { 1955 return; 1956 } 1957 usb_fifo_free(f_sc->fp[USB_FIFO_TX]); 1958 usb_fifo_free(f_sc->fp[USB_FIFO_RX]); 1959 1960 f_sc->fp[USB_FIFO_TX] = NULL; 1961 f_sc->fp[USB_FIFO_RX] = NULL; 1962 1963 usb_destroy_dev(f_sc->dev); 1964 1965 f_sc->dev = NULL; 1966 1967 DPRINTFN(2, "detached %p\n", f_sc); 1968 } 1969 1970 usb_size_t 1971 usb_fifo_put_bytes_max(struct usb_fifo *f) 1972 { 1973 struct usb_mbuf *m; 1974 usb_size_t len; 1975 1976 USB_IF_POLL(&f->free_q, m); 1977 1978 if (m) { 1979 len = m->max_data_len; 1980 } else { 1981 len = 0; 1982 } 1983 return (len); 1984 } 1985 1986 /*------------------------------------------------------------------------* 1987 * usb_fifo_put_data 1988 * 1989 * what: 1990 * 0 - normal operation 1991 * 1 - set last packet flag to enforce framing 1992 *------------------------------------------------------------------------*/ 1993 void 1994 usb_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc, 1995 usb_frlength_t offset, usb_frlength_t len, uint8_t what) 1996 { 1997 struct usb_mbuf *m; 1998 usb_frlength_t io_len; 1999 2000 while (len || (what == 1)) { 2001 2002 USB_IF_DEQUEUE(&f->free_q, m); 2003 2004 if (m) { 2005 USB_MBUF_RESET(m); 2006 2007 io_len = MIN(len, m->cur_data_len); 2008 2009 usbd_copy_out(pc, offset, m->cur_data_ptr, io_len); 2010 2011 m->cur_data_len = io_len; 2012 offset += io_len; 2013 len -= io_len; 2014 2015 if ((len == 0) && (what == 1)) { 2016 m->last_packet = 1; 2017 } 2018 USB_IF_ENQUEUE(&f->used_q, m); 2019 2020 usb_fifo_wakeup(f); 2021 2022 if ((len == 0) || (what == 1)) { 2023 break; 2024 } 2025 } else { 2026 break; 2027 } 2028 } 2029 } 2030 2031 void 2032 usb_fifo_put_data_linear(struct usb_fifo *f, void *ptr, 2033 usb_size_t len, uint8_t what) 2034 { 2035 struct usb_mbuf *m; 2036 usb_size_t io_len; 2037 2038 while (len || (what == 1)) { 2039 2040 USB_IF_DEQUEUE(&f->free_q, m); 2041 2042 if (m) { 2043 USB_MBUF_RESET(m); 2044 2045 io_len = MIN(len, m->cur_data_len); 2046 2047 memcpy(m->cur_data_ptr, ptr, io_len); 2048 2049 m->cur_data_len = io_len; 2050 ptr = USB_ADD_BYTES(ptr, io_len); 2051 len -= io_len; 2052 2053 if ((len == 0) && (what == 1)) { 2054 m->last_packet = 1; 2055 } 2056 USB_IF_ENQUEUE(&f->used_q, m); 2057 2058 usb_fifo_wakeup(f); 2059 2060 if ((len == 0) || (what == 1)) { 2061 break; 2062 } 2063 } else { 2064 break; 2065 } 2066 } 2067 } 2068 2069 uint8_t 2070 usb_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len) 2071 { 2072 struct usb_mbuf *m; 2073 2074 USB_IF_DEQUEUE(&f->free_q, m); 2075 2076 if (m) { 2077 m->cur_data_len = len; 2078 m->cur_data_ptr = ptr; 2079 USB_IF_ENQUEUE(&f->used_q, m); 2080 usb_fifo_wakeup(f); 2081 return (1); 2082 } 2083 return (0); 2084 } 2085 2086 void 2087 usb_fifo_put_data_error(struct usb_fifo *f) 2088 { 2089 f->flag_iserror = 1; 2090 usb_fifo_wakeup(f); 2091 } 2092 2093 /*------------------------------------------------------------------------* 2094 * usb_fifo_get_data 2095 * 2096 * what: 2097 * 0 - normal operation 2098 * 1 - only get one "usb_mbuf" 2099 * 2100 * returns: 2101 * 0 - no more data 2102 * 1 - data in buffer 2103 *------------------------------------------------------------------------*/ 2104 uint8_t 2105 usb_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc, 2106 usb_frlength_t offset, usb_frlength_t len, usb_frlength_t *actlen, 2107 uint8_t what) 2108 { 2109 struct usb_mbuf *m; 2110 usb_frlength_t io_len; 2111 uint8_t tr_data = 0; 2112 2113 actlen[0] = 0; 2114 2115 while (1) { 2116 2117 USB_IF_DEQUEUE(&f->used_q, m); 2118 2119 if (m) { 2120 2121 tr_data = 1; 2122 2123 io_len = MIN(len, m->cur_data_len); 2124 2125 usbd_copy_in(pc, offset, m->cur_data_ptr, io_len); 2126 2127 len -= io_len; 2128 offset += io_len; 2129 actlen[0] += io_len; 2130 m->cur_data_ptr += io_len; 2131 m->cur_data_len -= io_len; 2132 2133 if ((m->cur_data_len == 0) || (what == 1)) { 2134 USB_IF_ENQUEUE(&f->free_q, m); 2135 2136 usb_fifo_wakeup(f); 2137 2138 if (what == 1) { 2139 break; 2140 } 2141 } else { 2142 USB_IF_PREPEND(&f->used_q, m); 2143 } 2144 } else { 2145 2146 if (tr_data) { 2147 /* wait for data to be written out */ 2148 break; 2149 } 2150 if (f->flag_flushing) { 2151 /* check if we should send a short packet */ 2152 if (f->flag_short != 0) { 2153 f->flag_short = 0; 2154 tr_data = 1; 2155 break; 2156 } 2157 /* flushing complete */ 2158 f->flag_flushing = 0; 2159 usb_fifo_wakeup(f); 2160 } 2161 break; 2162 } 2163 if (len == 0) { 2164 break; 2165 } 2166 } 2167 return (tr_data); 2168 } 2169 2170 uint8_t 2171 usb_fifo_get_data_linear(struct usb_fifo *f, void *ptr, 2172 usb_size_t len, usb_size_t *actlen, uint8_t what) 2173 { 2174 struct usb_mbuf *m; 2175 usb_size_t io_len; 2176 uint8_t tr_data = 0; 2177 2178 actlen[0] = 0; 2179 2180 while (1) { 2181 2182 USB_IF_DEQUEUE(&f->used_q, m); 2183 2184 if (m) { 2185 2186 tr_data = 1; 2187 2188 io_len = MIN(len, m->cur_data_len); 2189 2190 memcpy(ptr, m->cur_data_ptr, io_len); 2191 2192 len -= io_len; 2193 ptr = USB_ADD_BYTES(ptr, io_len); 2194 actlen[0] += io_len; 2195 m->cur_data_ptr += io_len; 2196 m->cur_data_len -= io_len; 2197 2198 if ((m->cur_data_len == 0) || (what == 1)) { 2199 USB_IF_ENQUEUE(&f->free_q, m); 2200 2201 usb_fifo_wakeup(f); 2202 2203 if (what == 1) { 2204 break; 2205 } 2206 } else { 2207 USB_IF_PREPEND(&f->used_q, m); 2208 } 2209 } else { 2210 2211 if (tr_data) { 2212 /* wait for data to be written out */ 2213 break; 2214 } 2215 if (f->flag_flushing) { 2216 /* check if we should send a short packet */ 2217 if (f->flag_short != 0) { 2218 f->flag_short = 0; 2219 tr_data = 1; 2220 break; 2221 } 2222 /* flushing complete */ 2223 f->flag_flushing = 0; 2224 usb_fifo_wakeup(f); 2225 } 2226 break; 2227 } 2228 if (len == 0) { 2229 break; 2230 } 2231 } 2232 return (tr_data); 2233 } 2234 2235 uint8_t 2236 usb_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen) 2237 { 2238 struct usb_mbuf *m; 2239 2240 USB_IF_POLL(&f->used_q, m); 2241 2242 if (m) { 2243 *plen = m->cur_data_len; 2244 *pptr = m->cur_data_ptr; 2245 2246 return (1); 2247 } 2248 return (0); 2249 } 2250 2251 void 2252 usb_fifo_get_data_error(struct usb_fifo *f) 2253 { 2254 f->flag_iserror = 1; 2255 usb_fifo_wakeup(f); 2256 } 2257 2258 /*------------------------------------------------------------------------* 2259 * usb_alloc_symlink 2260 * 2261 * Return values: 2262 * NULL: Failure 2263 * Else: Pointer to symlink entry 2264 *------------------------------------------------------------------------*/ 2265 struct usb_symlink * 2266 usb_alloc_symlink(const char *target) 2267 { 2268 struct usb_symlink *ps; 2269 2270 ps = kmalloc(sizeof(*ps), M_USBDEV, M_WAITOK); 2271 if (ps == NULL) { 2272 return (ps); 2273 } 2274 /* XXX no longer needed */ 2275 strlcpy(ps->src_path, target, sizeof(ps->src_path)); 2276 ps->src_len = strlen(ps->src_path); 2277 strlcpy(ps->dst_path, target, sizeof(ps->dst_path)); 2278 ps->dst_len = strlen(ps->dst_path); 2279 2280 lockmgr(&usb_sym_lock, LK_EXCLUSIVE); 2281 TAILQ_INSERT_TAIL(&usb_sym_head, ps, sym_entry); 2282 lockmgr(&usb_sym_lock, LK_RELEASE); 2283 return (ps); 2284 } 2285 2286 /*------------------------------------------------------------------------* 2287 * usb_free_symlink 2288 *------------------------------------------------------------------------*/ 2289 void 2290 usb_free_symlink(struct usb_symlink *ps) 2291 { 2292 if (ps == NULL) { 2293 return; 2294 } 2295 lockmgr(&usb_sym_lock, LK_EXCLUSIVE); 2296 TAILQ_REMOVE(&usb_sym_head, ps, sym_entry); 2297 lockmgr(&usb_sym_lock, LK_RELEASE); 2298 2299 kfree(ps, M_USBDEV); 2300 } 2301 2302 /*------------------------------------------------------------------------* 2303 * usb_read_symlink 2304 * 2305 * Return value: 2306 * 0: Success 2307 * Else: Failure 2308 *------------------------------------------------------------------------*/ 2309 int 2310 usb_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len) 2311 { 2312 struct usb_symlink *ps; 2313 uint32_t temp; 2314 uint32_t delta = 0; 2315 uint8_t len; 2316 int error = 0; 2317 2318 lockmgr(&usb_sym_lock, LK_EXCLUSIVE); 2319 2320 TAILQ_FOREACH(ps, &usb_sym_head, sym_entry) { 2321 2322 /* 2323 * Compute total length of source and destination symlink 2324 * strings pluss one length byte and two NUL bytes: 2325 */ 2326 temp = ps->src_len + ps->dst_len + 3; 2327 2328 if (temp > 255) { 2329 /* 2330 * Skip entry because this length cannot fit 2331 * into one byte: 2332 */ 2333 continue; 2334 } 2335 if (startentry != 0) { 2336 /* decrement read offset */ 2337 startentry--; 2338 continue; 2339 } 2340 if (temp > user_len) { 2341 /* out of buffer space */ 2342 break; 2343 } 2344 len = temp; 2345 2346 /* copy out total length */ 2347 2348 error = copyout(&len, 2349 USB_ADD_BYTES(user_ptr, delta), 1); 2350 if (error) { 2351 break; 2352 } 2353 delta += 1; 2354 2355 /* copy out source string */ 2356 2357 error = copyout(ps->src_path, 2358 USB_ADD_BYTES(user_ptr, delta), ps->src_len); 2359 if (error) { 2360 break; 2361 } 2362 len = 0; 2363 delta += ps->src_len; 2364 error = copyout(&len, 2365 USB_ADD_BYTES(user_ptr, delta), 1); 2366 if (error) { 2367 break; 2368 } 2369 delta += 1; 2370 2371 /* copy out destination string */ 2372 2373 error = copyout(ps->dst_path, 2374 USB_ADD_BYTES(user_ptr, delta), ps->dst_len); 2375 if (error) { 2376 break; 2377 } 2378 len = 0; 2379 delta += ps->dst_len; 2380 error = copyout(&len, 2381 USB_ADD_BYTES(user_ptr, delta), 1); 2382 if (error) { 2383 break; 2384 } 2385 delta += 1; 2386 2387 user_len -= temp; 2388 } 2389 2390 /* a zero length entry indicates the end */ 2391 2392 if ((user_len != 0) && (error == 0)) { 2393 2394 len = 0; 2395 2396 error = copyout(&len, 2397 USB_ADD_BYTES(user_ptr, delta), 1); 2398 } 2399 lockmgr(&usb_sym_lock, LK_RELEASE); 2400 return (error); 2401 } 2402 2403 void 2404 usb_fifo_set_close_zlp(struct usb_fifo *f, uint8_t onoff) 2405 { 2406 if (f == NULL) 2407 return; 2408 2409 /* send a Zero Length Packet, ZLP, before close */ 2410 f->flag_short = onoff; 2411 } 2412 2413 void 2414 usb_fifo_set_write_defrag(struct usb_fifo *f, uint8_t onoff) 2415 { 2416 if (f == NULL) 2417 return; 2418 2419 /* defrag written data */ 2420 f->flag_write_defrag = onoff; 2421 /* reset defrag state */ 2422 f->flag_have_fragment = 0; 2423 } 2424 2425 void * 2426 usb_fifo_softc(struct usb_fifo *f) 2427 { 2428 return (f->priv_sc0); 2429 } 2430 #endif /* USB_HAVE_UGEN */ 2431