sys/bus/usb/usb_dev.c

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