3 * Copyright (c) 2006-2008 Hans Petter Selasky. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
27 * usb_dev.c - An abstraction layer for creating devices under /dev/...
30 #include <sys/stdint.h>
31 #include <sys/stddef.h>
32 #include <sys/param.h>
33 #include <sys/queue.h>
34 #include <sys/types.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
38 #include <sys/linker_set.h>
39 #include <sys/module.h>
41 #include <sys/mutex.h>
42 #include <sys/condvar.h>
43 #include <sys/sysctl.h>
45 #include <sys/unistd.h>
46 #include <sys/callout.h>
47 #include <sys/malloc.h>
49 #include <sys/vnode.h>
51 #include <sys/fcntl.h>
53 #include <dev/usb/usb.h>
54 #include <dev/usb/usb_ioctl.h>
55 #include <dev/usb/usbdi.h>
56 #include <dev/usb/usbdi_util.h>
58 #define USB_DEBUG_VAR usb_fifo_debug
60 #include <dev/usb/usb_core.h>
61 #include <dev/usb/usb_dev.h>
62 #include <dev/usb/usb_mbuf.h>
63 #include <dev/usb/usb_process.h>
64 #include <dev/usb/usb_device.h>
65 #include <dev/usb/usb_debug.h>
66 #include <dev/usb/usb_busdma.h>
67 #include <dev/usb/usb_generic.h>
68 #include <dev/usb/usb_dynamic.h>
69 #include <dev/usb/usb_util.h>
71 #include <dev/usb/usb_controller.h>
72 #include <dev/usb/usb_bus.h>
74 #include <sys/filio.h>
75 #include <sys/ttycom.h>
76 #include <sys/syscallsubr.h>
78 #include <machine/stdarg.h>
83 static int usb_fifo_debug = 0;
85 SYSCTL_NODE(_hw_usb, OID_AUTO, dev, CTLFLAG_RW, 0, "USB device");
86 SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RW,
87 &usb_fifo_debug, 0, "Debug Level");
90 #if ((__FreeBSD_version >= 700001) || (__FreeBSD_version == 0) || \
91 ((__FreeBSD_version >= 600034) && (__FreeBSD_version < 700000)))
92 #define USB_UCRED struct ucred *ucred,
99 static int usb_fifo_open(struct usb_cdev_privdata *,
100 struct usb_fifo *, int);
101 static void usb_fifo_close(struct usb_fifo *, int);
102 static void usb_dev_init(void *);
103 static void usb_dev_init_post(void *);
104 static void usb_dev_uninit(void *);
105 static int usb_fifo_uiomove(struct usb_fifo *, void *, int,
107 static void usb_fifo_check_methods(struct usb_fifo_methods *);
108 static struct usb_fifo *usb_fifo_alloc(void);
109 static struct usb_endpoint *usb_dev_get_ep(struct usb_device *, uint8_t,
111 static void usb_loc_fill(struct usb_fs_privdata *,
112 struct usb_cdev_privdata *);
113 static void usb_close(void *);
114 static usb_error_t usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *, int);
115 static usb_error_t usb_usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *);
116 static void usb_unref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *);
118 static d_open_t usb_open;
119 static d_ioctl_t usb_ioctl;
120 static d_read_t usb_read;
121 static d_write_t usb_write;
122 static d_poll_t usb_poll;
124 static d_ioctl_t usb_static_ioctl;
126 static usb_fifo_open_t usb_fifo_dummy_open;
127 static usb_fifo_close_t usb_fifo_dummy_close;
128 static usb_fifo_ioctl_t usb_fifo_dummy_ioctl;
129 static usb_fifo_cmd_t usb_fifo_dummy_cmd;
131 /* character device structure used for devices (/dev/ugenX.Y and /dev/uXXX) */
132 struct cdevsw usb_devsw = {
133 .d_version = D_VERSION,
135 .d_ioctl = usb_ioctl,
137 .d_flags = D_TRACKCLOSE,
139 .d_write = usb_write,
143 static struct cdev* usb_dev = NULL;
145 /* character device structure used for /dev/usb */
146 static struct cdevsw usb_static_devsw = {
147 .d_version = D_VERSION,
148 .d_ioctl = usb_static_ioctl,
152 static TAILQ_HEAD(, usb_symlink) usb_sym_head;
153 static struct sx usb_sym_lock;
155 struct mtx usb_ref_lock;
157 /*------------------------------------------------------------------------*
160 * This is used to fill out a usb_cdev_privdata structure based on the
161 * device's address as contained in usb_fs_privdata.
162 *------------------------------------------------------------------------*/
164 usb_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd)
166 cpd->bus_index = pd->bus_index;
167 cpd->dev_index = pd->dev_index;
168 cpd->ep_addr = pd->ep_addr;
169 cpd->fifo_index = pd->fifo_index;
172 /*------------------------------------------------------------------------*
175 * This function is used to atomically refer an USB device by its
176 * device location. If this function returns success the USB device
177 * will not dissappear until the USB device is unreferenced.
180 * 0: Success, refcount incremented on the given USB device.
182 *------------------------------------------------------------------------*/
184 usb_ref_device(struct usb_cdev_privdata *cpd,
185 struct usb_cdev_refdata *crd, int need_uref)
187 struct usb_fifo **ppf;
190 DPRINTFN(2, "cpd=%p need uref=%d\n", cpd, need_uref);
193 memset(crd, 0, sizeof(*crd));
195 mtx_lock(&usb_ref_lock);
196 cpd->bus = devclass_get_softc(usb_devclass_ptr, cpd->bus_index);
197 if (cpd->bus == NULL) {
198 DPRINTFN(2, "no bus at %u\n", cpd->bus_index);
201 cpd->udev = cpd->bus->devices[cpd->dev_index];
202 if (cpd->udev == NULL) {
203 DPRINTFN(2, "no device at %u\n", cpd->dev_index);
206 if (cpd->udev->refcount == USB_DEV_REF_MAX) {
207 DPRINTFN(2, "no dev ref\n");
211 DPRINTFN(2, "ref udev - needed\n");
212 cpd->udev->refcount++;
214 mtx_unlock(&usb_ref_lock);
217 * We need to grab the sx-lock before grabbing the
218 * FIFO refs to avoid deadlock at detach!
220 sx_xlock(cpd->udev->default_sx + 1);
222 mtx_lock(&usb_ref_lock);
225 * Set "is_uref" after grabbing the default SX lock
230 /* check if we are doing an open */
231 if (cpd->fflags == 0) {
232 /* use zero defaults */
234 /* check for write */
235 if (cpd->fflags & FWRITE) {
236 ppf = cpd->udev->fifo;
237 f = ppf[cpd->fifo_index + USB_FIFO_TX];
239 crd->is_write = 1; /* ref */
240 if (f == NULL || f->refcount == USB_FIFO_REF_MAX)
242 if (f->curr_cpd != cpd)
244 /* check if USB-FS is active */
245 if (f->fs_ep_max != 0) {
251 if (cpd->fflags & FREAD) {
252 ppf = cpd->udev->fifo;
253 f = ppf[cpd->fifo_index + USB_FIFO_RX];
255 crd->is_read = 1; /* ref */
256 if (f == NULL || f->refcount == USB_FIFO_REF_MAX)
258 if (f->curr_cpd != cpd)
260 /* check if USB-FS is active */
261 if (f->fs_ep_max != 0) {
267 /* when everything is OK we increment the refcounts */
269 DPRINTFN(2, "ref write\n");
270 crd->txfifo->refcount++;
273 DPRINTFN(2, "ref read\n");
274 crd->rxfifo->refcount++;
276 mtx_unlock(&usb_ref_lock);
279 mtx_lock(&Giant); /* XXX */
285 sx_unlock(cpd->udev->default_sx + 1);
286 if (--(cpd->udev->refcount) == 0) {
287 cv_signal(cpd->udev->default_cv + 1);
290 mtx_unlock(&usb_ref_lock);
291 DPRINTFN(2, "fail\n");
292 return (USB_ERR_INVAL);
295 /*------------------------------------------------------------------------*
298 * This function is used to upgrade an USB reference to include the
299 * USB device reference on a USB location.
302 * 0: Success, refcount incremented on the given USB device.
304 *------------------------------------------------------------------------*/
306 usb_usb_ref_device(struct usb_cdev_privdata *cpd,
307 struct usb_cdev_refdata *crd)
310 * Check if we already got an USB reference on this location:
313 return (0); /* success */
316 * To avoid deadlock at detach we need to drop the FIFO ref
317 * and re-acquire a new ref!
319 usb_unref_device(cpd, crd);
321 return (usb_ref_device(cpd, crd, 1 /* need uref */));
324 /*------------------------------------------------------------------------*
327 * This function will release the reference count by one unit for the
329 *------------------------------------------------------------------------*/
331 usb_unref_device(struct usb_cdev_privdata *cpd,
332 struct usb_cdev_refdata *crd)
335 DPRINTFN(2, "cpd=%p is_uref=%d\n", cpd, crd->is_uref);
338 mtx_unlock(&Giant); /* XXX */
339 sx_unlock(cpd->udev->default_sx + 1);
341 mtx_lock(&usb_ref_lock);
343 if (--(crd->rxfifo->refcount) == 0) {
344 cv_signal(&crd->rxfifo->cv_drain);
349 if (--(crd->txfifo->refcount) == 0) {
350 cv_signal(&crd->txfifo->cv_drain);
355 if (--(cpd->udev->refcount) == 0) {
356 cv_signal(cpd->udev->default_cv + 1);
360 mtx_unlock(&usb_ref_lock);
363 static struct usb_fifo *
368 f = malloc(sizeof(*f), M_USBDEV, M_WAITOK | M_ZERO);
370 cv_init(&f->cv_io, "FIFO-IO");
371 cv_init(&f->cv_drain, "FIFO-DRAIN");
377 /*------------------------------------------------------------------------*
379 *------------------------------------------------------------------------*/
381 usb_fifo_create(struct usb_cdev_privdata *cpd,
382 struct usb_cdev_refdata *crd)
384 struct usb_device *udev = cpd->udev;
386 struct usb_endpoint *ep;
392 int e = cpd->ep_addr;
394 is_tx = (cpd->fflags & FWRITE) ? 1 : 0;
395 is_rx = (cpd->fflags & FREAD) ? 1 : 0;
399 /* Preallocated FIFO */
401 DPRINTFN(5, "Preallocated FIFO\n");
403 f = udev->fifo[cpd->fifo_index + USB_FIFO_TX];
409 f = udev->fifo[cpd->fifo_index + USB_FIFO_RX];
417 KASSERT(e >= 0 && e <= 15, ("endpoint %d out of range", e));
419 /* search for a free FIFO slot */
420 DPRINTFN(5, "Endpoint device, searching for 0x%02x\n", e);
421 for (n = 0;; n += 2) {
423 if (n == USB_FIFO_MAX) {
428 /* end of FIFOs reached */
429 DPRINTFN(5, "out of FIFOs\n");
433 /* Check for TX FIFO */
435 f = udev->fifo[n + USB_FIFO_TX];
437 if (f->dev_ep_index != e) {
438 /* wrong endpoint index */
441 if (f->curr_cpd != NULL) {
446 } else if (no_null) {
450 /* Check for RX FIFO */
452 f = udev->fifo[n + USB_FIFO_RX];
454 if (f->dev_ep_index != e) {
455 /* wrong endpoint index */
458 if (f->curr_cpd != NULL) {
463 } else if (no_null) {
471 if (e >= (USB_EP_MAX / 2)) {
472 /* we don't create any endpoints in this range */
473 DPRINTFN(5, "ep out of range\n");
474 return (is_busy ? EBUSY : EINVAL);
478 if ((e != 0) && is_busy) {
480 * Only the default control endpoint is allowed to be
481 * opened multiple times!
483 DPRINTFN(5, "busy\n");
489 (udev->fifo[n + USB_FIFO_TX] == NULL)) {
490 ep = usb_dev_get_ep(udev, e, USB_FIFO_TX);
491 DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_TX);
493 DPRINTFN(5, "dev_get_endpoint returned NULL\n");
496 f = usb_fifo_alloc();
498 DPRINTFN(5, "could not alloc tx fifo\n");
501 /* update some fields */
502 f->fifo_index = n + USB_FIFO_TX;
504 f->priv_mtx = udev->default_mtx;
506 f->methods = &usb_ugen_methods;
507 f->iface_index = ep->iface_index;
509 mtx_lock(&usb_ref_lock);
510 udev->fifo[n + USB_FIFO_TX] = f;
511 mtx_unlock(&usb_ref_lock);
515 (udev->fifo[n + USB_FIFO_RX] == NULL)) {
517 ep = usb_dev_get_ep(udev, e, USB_FIFO_RX);
518 DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_RX);
520 DPRINTFN(5, "dev_get_endpoint returned NULL\n");
523 f = usb_fifo_alloc();
525 DPRINTFN(5, "could not alloc rx fifo\n");
528 /* update some fields */
529 f->fifo_index = n + USB_FIFO_RX;
531 f->priv_mtx = udev->default_mtx;
533 f->methods = &usb_ugen_methods;
534 f->iface_index = ep->iface_index;
536 mtx_lock(&usb_ref_lock);
537 udev->fifo[n + USB_FIFO_RX] = f;
538 mtx_unlock(&usb_ref_lock);
541 crd->txfifo = udev->fifo[n + USB_FIFO_TX];
544 crd->rxfifo = udev->fifo[n + USB_FIFO_RX];
546 /* fill out fifo index */
547 DPRINTFN(5, "fifo index = %d\n", n);
556 usb_fifo_free(struct usb_fifo *f)
564 /* destroy symlink devices, if any */
565 for (n = 0; n != 2; n++) {
567 usb_free_symlink(f->symlink[n]);
568 f->symlink[n] = NULL;
571 mtx_lock(&usb_ref_lock);
573 /* delink ourselves to stop calls from userland */
574 if ((f->fifo_index < USB_FIFO_MAX) &&
576 (f->udev->fifo[f->fifo_index] == f)) {
577 f->udev->fifo[f->fifo_index] = NULL;
579 DPRINTFN(0, "USB FIFO %p has not been linked!\n", f);
582 /* decrease refcount */
584 /* prevent any write flush */
586 /* need to wait until all callers have exited */
587 while (f->refcount != 0) {
588 mtx_unlock(&usb_ref_lock); /* avoid LOR */
589 mtx_lock(f->priv_mtx);
590 /* get I/O thread out of any sleep state */
591 if (f->flag_sleeping) {
592 f->flag_sleeping = 0;
593 cv_broadcast(&f->cv_io);
595 mtx_unlock(f->priv_mtx);
596 mtx_lock(&usb_ref_lock);
599 cv_wait(&f->cv_drain, &usb_ref_lock);
601 mtx_unlock(&usb_ref_lock);
603 /* take care of closing the device here, if any */
604 usb_fifo_close(f, 0);
606 cv_destroy(&f->cv_io);
607 cv_destroy(&f->cv_drain);
612 static struct usb_endpoint *
613 usb_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir)
615 struct usb_endpoint *ep;
619 ep = &udev->default_ep;
621 if (dir == USB_FIFO_RX) {
622 if (udev->flags.usb_mode == USB_MODE_HOST) {
628 if (udev->flags.usb_mode == USB_MODE_HOST) {
634 ep = usbd_get_ep_by_addr(udev, ep_index | ep_dir);
638 /* if the endpoint does not exist then return */
641 if (ep->edesc == NULL) {
642 /* invalid endpoint */
645 return (ep); /* success */
648 /*------------------------------------------------------------------------*
654 *------------------------------------------------------------------------*/
656 usb_fifo_open(struct usb_cdev_privdata *cpd,
657 struct usb_fifo *f, int fflags)
663 DPRINTFN(2, "no FIFO\n");
666 /* remove FWRITE and FREAD flags */
667 fflags &= ~(FWRITE | FREAD);
669 /* set correct file flags */
670 if ((f->fifo_index & 1) == USB_FIFO_TX) {
676 /* check if we are already opened */
677 /* we don't need any locks when checking this variable */
678 if (f->curr_cpd != NULL) {
683 /* reset short flag before open */
686 /* call open method */
687 err = (f->methods->f_open) (f, fflags);
691 mtx_lock(f->priv_mtx);
693 /* reset sleep flag */
694 f->flag_sleeping = 0;
696 /* reset error flag */
699 /* reset complete flag */
700 f->flag_iscomplete = 0;
702 /* reset select flag */
703 f->flag_isselect = 0;
705 /* reset flushing flag */
706 f->flag_flushing = 0;
708 /* reset ASYNC proc flag */
711 mtx_lock(&usb_ref_lock);
712 /* flag the fifo as opened to prevent others */
714 mtx_unlock(&usb_ref_lock);
719 mtx_unlock(f->priv_mtx);
724 /*------------------------------------------------------------------------*
726 *------------------------------------------------------------------------*/
728 usb_fifo_reset(struct usb_fifo *f)
736 USB_IF_DEQUEUE(&f->used_q, m);
738 USB_IF_ENQUEUE(&f->free_q, m);
743 /* reset have fragment flag */
744 f->flag_have_fragment = 0;
747 /*------------------------------------------------------------------------*
749 *------------------------------------------------------------------------*/
751 usb_fifo_close(struct usb_fifo *f, int fflags)
755 /* check if we are not opened */
756 if (f->curr_cpd == NULL) {
757 /* nothing to do - already closed */
760 mtx_lock(f->priv_mtx);
762 /* clear current cdev private data pointer */
765 /* check if we are selected */
766 if (f->flag_isselect) {
767 selwakeup(&f->selinfo);
768 f->flag_isselect = 0;
770 /* check if a thread wants SIGIO */
771 if (f->async_p != NULL) {
772 PROC_LOCK(f->async_p);
773 psignal(f->async_p, SIGIO);
774 PROC_UNLOCK(f->async_p);
777 /* remove FWRITE and FREAD flags */
778 fflags &= ~(FWRITE | FREAD);
780 /* flush written data, if any */
781 if ((f->fifo_index & 1) == USB_FIFO_TX) {
783 if (!f->flag_iserror) {
785 /* set flushing flag */
786 f->flag_flushing = 1;
788 /* get the last packet in */
789 if (f->flag_have_fragment) {
791 f->flag_have_fragment = 0;
792 USB_IF_DEQUEUE(&f->free_q, m);
794 USB_IF_ENQUEUE(&f->used_q, m);
798 /* start write transfer, if not already started */
799 (f->methods->f_start_write) (f);
801 /* check if flushed already */
802 while (f->flag_flushing &&
803 (!f->flag_iserror)) {
804 /* wait until all data has been written */
805 f->flag_sleeping = 1;
806 err = cv_wait_sig(&f->cv_io, f->priv_mtx);
808 DPRINTF("signal received\n");
815 /* stop write transfer, if not already stopped */
816 (f->methods->f_stop_write) (f);
820 /* stop write transfer, if not already stopped */
821 (f->methods->f_stop_read) (f);
824 /* check if we are sleeping */
825 if (f->flag_sleeping) {
826 DPRINTFN(2, "Sleeping at close!\n");
828 mtx_unlock(f->priv_mtx);
830 /* call close method */
831 (f->methods->f_close) (f, fflags);
836 /*------------------------------------------------------------------------*
837 * usb_open - cdev callback
838 *------------------------------------------------------------------------*/
840 usb_open(struct cdev *dev, int fflags, int devtype, struct thread *td)
842 struct usb_fs_privdata* pd = (struct usb_fs_privdata*)dev->si_drv1;
843 struct usb_cdev_refdata refs;
844 struct usb_cdev_privdata *cpd;
847 DPRINTFN(2, "%s fflags=0x%08x\n", dev->si_name, fflags);
849 KASSERT(fflags & (FREAD|FWRITE), ("invalid open flags"));
850 if (((fflags & FREAD) && !(pd->mode & FREAD)) ||
851 ((fflags & FWRITE) && !(pd->mode & FWRITE))) {
852 DPRINTFN(2, "access mode not supported\n");
856 cpd = malloc(sizeof(*cpd), M_USBDEV, M_WAITOK | M_ZERO);
857 ep = cpd->ep_addr = pd->ep_addr;
859 usb_loc_fill(pd, cpd);
860 err = usb_ref_device(cpd, &refs, 1);
862 DPRINTFN(2, "cannot ref device\n");
866 cpd->fflags = fflags; /* access mode for open lifetime */
868 /* create FIFOs, if any */
869 err = usb_fifo_create(cpd, &refs);
870 /* check for error */
872 DPRINTFN(2, "cannot create fifo\n");
873 usb_unref_device(cpd, &refs);
877 if (fflags & FREAD) {
878 err = usb_fifo_open(cpd, refs.rxfifo, fflags);
880 DPRINTFN(2, "read open failed\n");
881 usb_unref_device(cpd, &refs);
886 if (fflags & FWRITE) {
887 err = usb_fifo_open(cpd, refs.txfifo, fflags);
889 DPRINTFN(2, "write open failed\n");
890 if (fflags & FREAD) {
891 usb_fifo_close(refs.rxfifo, fflags);
893 usb_unref_device(cpd, &refs);
898 usb_unref_device(cpd, &refs);
899 devfs_set_cdevpriv(cpd, usb_close);
904 /*------------------------------------------------------------------------*
905 * usb_close - cdev callback
906 *------------------------------------------------------------------------*/
910 struct usb_cdev_refdata refs;
911 struct usb_cdev_privdata *cpd = arg;
914 DPRINTFN(2, "cpd=%p\n", cpd);
916 err = usb_ref_device(cpd, &refs, 1);
921 if (cpd->fflags & FREAD) {
922 usb_fifo_close(refs.rxfifo, cpd->fflags);
924 if (cpd->fflags & FWRITE) {
925 usb_fifo_close(refs.txfifo, cpd->fflags);
928 usb_unref_device(cpd, &refs);
934 usb_dev_init(void *arg)
936 mtx_init(&usb_ref_lock, "USB ref mutex", NULL, MTX_DEF);
937 sx_init(&usb_sym_lock, "USB sym mutex");
938 TAILQ_INIT(&usb_sym_head);
940 /* check the UGEN methods */
941 usb_fifo_check_methods(&usb_ugen_methods);
944 SYSINIT(usb_dev_init, SI_SUB_KLD, SI_ORDER_FIRST, usb_dev_init, NULL);
947 usb_dev_init_post(void *arg)
950 * Create /dev/usb - this is needed for usbconfig(8), which
951 * needs a well-known device name to access.
953 usb_dev = make_dev(&usb_static_devsw, 0, UID_ROOT, GID_OPERATOR,
954 0644, USB_DEVICE_NAME);
955 if (usb_dev == NULL) {
956 DPRINTFN(0, "Could not create usb bus device!\n");
960 SYSINIT(usb_dev_init_post, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, usb_dev_init_post, NULL);
963 usb_dev_uninit(void *arg)
965 if (usb_dev != NULL) {
966 destroy_dev(usb_dev);
970 mtx_destroy(&usb_ref_lock);
971 sx_destroy(&usb_sym_lock);
974 SYSUNINIT(usb_dev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb_dev_uninit, NULL);
977 usb_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr,
984 *(int *)addr = 0; /* character device */
988 /* handled by upper FS layer */
993 if (f->async_p != NULL) {
997 f->async_p = USB_TD_GET_PROC(td);
1003 /* XXX this is not the most general solution */
1005 if (f->async_p == NULL) {
1009 if (*(int *)addr != USB_PROC_GET_GID(f->async_p)) {
1017 DPRINTFN(3, "cmd 0x%lx = %d\n", cmd, error);
1021 /*------------------------------------------------------------------------*
1022 * usb_ioctl - cdev callback
1023 *------------------------------------------------------------------------*/
1025 usb_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* td)
1027 struct usb_cdev_refdata refs;
1028 struct usb_cdev_privdata* cpd;
1033 DPRINTFN(2, "cmd=0x%lx\n", cmd);
1035 err = devfs_get_cdevpriv((void **)&cpd);
1040 * Performance optimisation: We try to check for IOCTL's that
1041 * don't need the USB reference first. Then we grab the USB
1042 * reference if we need it!
1043 * Note that some ioctl_post handlers would need to run with the
1044 * newbus lock held. It cannot be acquired later because it can
1045 * introduce a LOR, so acquire it here.
1048 err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
1053 fflags = cpd->fflags;
1055 f = NULL; /* set default value */
1056 err = ENOIOCTL; /* set default value */
1058 if (fflags & FWRITE) {
1060 err = usb_ioctl_f_sub(f, cmd, addr, td);
1062 if (fflags & FREAD) {
1064 err = usb_ioctl_f_sub(f, cmd, addr, td);
1066 KASSERT(f != NULL, ("fifo not found"));
1067 if (err == ENOIOCTL) {
1068 err = (f->methods->f_ioctl) (f, cmd, addr, fflags);
1069 DPRINTFN(2, "f_ioctl cmd 0x%lx = %d\n", cmd, err);
1070 if (err == ENOIOCTL) {
1071 if (usb_usb_ref_device(cpd, &refs)) {
1075 err = (f->methods->f_ioctl_post) (f, cmd, addr, fflags);
1076 DPRINTFN(2, "f_ioctl_post cmd 0x%lx = %d\n", cmd, err);
1079 if (err == ENOIOCTL) {
1083 usb_unref_device(cpd, &refs);
1090 usb_poll(struct cdev* dev, int events, struct thread* td)
1092 struct usb_cdev_refdata refs;
1093 struct usb_cdev_privdata* cpd;
1096 int fflags, revents;
1098 if (devfs_get_cdevpriv((void **)&cpd) != 0 ||
1099 usb_ref_device(cpd, &refs, 0) != 0)
1101 (POLLHUP|POLLIN|POLLRDNORM|POLLOUT|POLLWRNORM));
1103 fflags = cpd->fflags;
1105 /* Figure out who needs service */
1107 if ((events & (POLLOUT | POLLWRNORM)) &&
1108 (fflags & FWRITE)) {
1112 mtx_lock(f->priv_mtx);
1114 if (!refs.is_usbfs) {
1115 if (f->flag_iserror) {
1116 /* we got an error */
1119 if (f->queue_data == NULL) {
1121 * start write transfer, if not
1124 (f->methods->f_start_write) (f);
1126 /* check if any packets are available */
1127 USB_IF_POLL(&f->free_q, m);
1130 if (f->flag_iscomplete) {
1138 revents |= events & (POLLOUT | POLLWRNORM);
1140 f->flag_isselect = 1;
1141 selrecord(td, &f->selinfo);
1144 mtx_unlock(f->priv_mtx);
1146 if ((events & (POLLIN | POLLRDNORM)) &&
1151 mtx_lock(f->priv_mtx);
1153 if (!refs.is_usbfs) {
1154 if (f->flag_iserror) {
1155 /* we have and error */
1158 if (f->queue_data == NULL) {
1160 * start read transfer, if not
1163 (f->methods->f_start_read) (f);
1165 /* check if any packets are available */
1166 USB_IF_POLL(&f->used_q, m);
1169 if (f->flag_iscomplete) {
1177 revents |= events & (POLLIN | POLLRDNORM);
1179 f->flag_isselect = 1;
1180 selrecord(td, &f->selinfo);
1182 if (!refs.is_usbfs) {
1183 /* start reading data */
1184 (f->methods->f_start_read) (f);
1188 mtx_unlock(f->priv_mtx);
1190 usb_unref_device(cpd, &refs);
1195 usb_read(struct cdev *dev, struct uio *uio, int ioflag)
1197 struct usb_cdev_refdata refs;
1198 struct usb_cdev_privdata* cpd;
1205 uint8_t tr_data = 0;
1207 err = devfs_get_cdevpriv((void **)&cpd);
1211 err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
1215 fflags = cpd->fflags;
1219 /* should not happen */
1220 usb_unref_device(cpd, &refs);
1224 resid = uio->uio_resid;
1226 mtx_lock(f->priv_mtx);
1228 /* check for permanent read error */
1229 if (f->flag_iserror) {
1233 /* check if USB-FS interface is active */
1234 if (refs.is_usbfs) {
1236 * The queue is used for events that should be
1237 * retrieved using the "USB_FS_COMPLETE" ioctl.
1242 while (uio->uio_resid > 0) {
1244 USB_IF_DEQUEUE(&f->used_q, m);
1248 /* start read transfer, if not already started */
1250 (f->methods->f_start_read) (f);
1252 if (ioflag & IO_NDELAY) {
1254 /* return length before error */
1260 DPRINTF("sleeping\n");
1262 err = usb_fifo_wait(f);
1268 if (f->methods->f_filter_read) {
1270 * Sometimes it is convenient to process data at the
1271 * expense of a userland process instead of a kernel
1274 (f->methods->f_filter_read) (f, m);
1278 io_len = MIN(m->cur_data_len, uio->uio_resid);
1280 DPRINTFN(2, "transfer %d bytes from %p\n",
1281 io_len, m->cur_data_ptr);
1283 err = usb_fifo_uiomove(f,
1284 m->cur_data_ptr, io_len, uio);
1286 m->cur_data_len -= io_len;
1287 m->cur_data_ptr += io_len;
1289 if (m->cur_data_len == 0) {
1291 uint8_t last_packet;
1293 last_packet = m->last_packet;
1295 USB_IF_ENQUEUE(&f->free_q, m);
1302 USB_IF_PREPEND(&f->used_q, m);
1310 mtx_unlock(f->priv_mtx);
1312 usb_unref_device(cpd, &refs);
1318 usb_write(struct cdev *dev, struct uio *uio, int ioflag)
1320 struct usb_cdev_refdata refs;
1321 struct usb_cdev_privdata* cpd;
1329 uint8_t tr_data = 0;
1333 err = devfs_get_cdevpriv((void **)&cpd);
1337 err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
1341 fflags = cpd->fflags;
1345 /* should not happen */
1346 usb_unref_device(cpd, &refs);
1349 resid = uio->uio_resid;
1351 mtx_lock(f->priv_mtx);
1353 /* check for permanent write error */
1354 if (f->flag_iserror) {
1358 /* check if USB-FS interface is active */
1359 if (refs.is_usbfs) {
1361 * The queue is used for events that should be
1362 * retrieved using the "USB_FS_COMPLETE" ioctl.
1367 if (f->queue_data == NULL) {
1368 /* start write transfer, if not already started */
1369 (f->methods->f_start_write) (f);
1371 /* we allow writing zero length data */
1373 USB_IF_DEQUEUE(&f->free_q, m);
1377 if (ioflag & IO_NDELAY) {
1379 /* return length before error */
1385 DPRINTF("sleeping\n");
1387 err = usb_fifo_wait(f);
1395 if (f->flag_have_fragment == 0) {
1397 io_len = m->cur_data_len;
1398 pdata = m->cur_data_ptr;
1399 if (io_len > uio->uio_resid)
1400 io_len = uio->uio_resid;
1401 m->cur_data_len = io_len;
1403 io_len = m->max_data_len - m->cur_data_len;
1404 pdata = m->cur_data_ptr + m->cur_data_len;
1405 if (io_len > uio->uio_resid)
1406 io_len = uio->uio_resid;
1407 m->cur_data_len += io_len;
1410 DPRINTFN(2, "transfer %d bytes to %p\n",
1413 err = usb_fifo_uiomove(f, pdata, io_len, uio);
1416 f->flag_have_fragment = 0;
1417 USB_IF_ENQUEUE(&f->free_q, m);
1421 /* check if the buffer is ready to be transmitted */
1423 if ((f->flag_write_defrag == 0) ||
1424 (m->cur_data_len == m->max_data_len)) {
1425 f->flag_have_fragment = 0;
1428 * Check for write filter:
1430 * Sometimes it is convenient to process data
1431 * at the expense of a userland process
1432 * instead of a kernel process.
1434 if (f->methods->f_filter_write) {
1435 (f->methods->f_filter_write) (f, m);
1438 /* Put USB mbuf in the used queue */
1439 USB_IF_ENQUEUE(&f->used_q, m);
1441 /* Start writing data, if not already started */
1442 (f->methods->f_start_write) (f);
1444 /* Wait for more data or close */
1445 f->flag_have_fragment = 1;
1446 USB_IF_PREPEND(&f->free_q, m);
1449 } while (uio->uio_resid > 0);
1451 mtx_unlock(f->priv_mtx);
1453 usb_unref_device(cpd, &refs);
1459 usb_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
1463 struct usb_read_dir *urd;
1471 err = usb_read_symlink(u.urd->urd_data,
1472 u.urd->urd_startentry, u.urd->urd_maxlen);
1474 case USB_DEV_QUIRK_GET:
1475 case USB_QUIRK_NAME_GET:
1476 case USB_DEV_QUIRK_ADD:
1477 case USB_DEV_QUIRK_REMOVE:
1478 err = usb_quirk_ioctl_p(cmd, data, fflag, td);
1480 case USB_GET_TEMPLATE:
1481 *(int *)data = usb_template;
1483 case USB_SET_TEMPLATE:
1484 err = priv_check(curthread, PRIV_DRIVER);
1487 usb_template = *(int *)data;
1494 usb_fifo_uiomove(struct usb_fifo *f, void *cp,
1495 int n, struct uio *uio)
1499 mtx_unlock(f->priv_mtx);
1502 * "uiomove()" can sleep so one needs to make a wrapper,
1503 * exiting the mutex and checking things:
1505 error = uiomove(cp, n, uio);
1507 mtx_lock(f->priv_mtx);
1513 usb_fifo_wait(struct usb_fifo *f)
1517 mtx_assert(f->priv_mtx, MA_OWNED);
1519 if (f->flag_iserror) {
1523 f->flag_sleeping = 1;
1525 err = cv_wait_sig(&f->cv_io, f->priv_mtx);
1527 if (f->flag_iserror) {
1535 usb_fifo_signal(struct usb_fifo *f)
1537 if (f->flag_sleeping) {
1538 f->flag_sleeping = 0;
1539 cv_broadcast(&f->cv_io);
1544 usb_fifo_wakeup(struct usb_fifo *f)
1548 if (f->flag_isselect) {
1549 selwakeup(&f->selinfo);
1550 f->flag_isselect = 0;
1552 if (f->async_p != NULL) {
1553 PROC_LOCK(f->async_p);
1554 psignal(f->async_p, SIGIO);
1555 PROC_UNLOCK(f->async_p);
1560 usb_fifo_dummy_open(struct usb_fifo *fifo, int fflags)
1566 usb_fifo_dummy_close(struct usb_fifo *fifo, int fflags)
1572 usb_fifo_dummy_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags)
1578 usb_fifo_dummy_cmd(struct usb_fifo *fifo)
1580 fifo->flag_flushing = 0; /* not flushing */
1584 usb_fifo_check_methods(struct usb_fifo_methods *pm)
1586 /* check that all callback functions are OK */
1588 if (pm->f_open == NULL)
1589 pm->f_open = &usb_fifo_dummy_open;
1591 if (pm->f_close == NULL)
1592 pm->f_close = &usb_fifo_dummy_close;
1594 if (pm->f_ioctl == NULL)
1595 pm->f_ioctl = &usb_fifo_dummy_ioctl;
1597 if (pm->f_ioctl_post == NULL)
1598 pm->f_ioctl_post = &usb_fifo_dummy_ioctl;
1600 if (pm->f_start_read == NULL)
1601 pm->f_start_read = &usb_fifo_dummy_cmd;
1603 if (pm->f_stop_read == NULL)
1604 pm->f_stop_read = &usb_fifo_dummy_cmd;
1606 if (pm->f_start_write == NULL)
1607 pm->f_start_write = &usb_fifo_dummy_cmd;
1609 if (pm->f_stop_write == NULL)
1610 pm->f_stop_write = &usb_fifo_dummy_cmd;
1613 /*------------------------------------------------------------------------*
1616 * The following function will create a duplex FIFO.
1621 *------------------------------------------------------------------------*/
1623 usb_fifo_attach(struct usb_device *udev, void *priv_sc,
1624 struct mtx *priv_mtx, struct usb_fifo_methods *pm,
1625 struct usb_fifo_sc *f_sc, uint16_t unit, uint16_t subunit,
1626 uint8_t iface_index, uid_t uid, gid_t gid, int mode)
1628 struct usb_fifo *f_tx;
1629 struct usb_fifo *f_rx;
1632 struct usb_fs_privdata* pd;
1634 f_sc->fp[USB_FIFO_TX] = NULL;
1635 f_sc->fp[USB_FIFO_RX] = NULL;
1640 /* check the methods */
1641 usb_fifo_check_methods(pm);
1643 if (priv_mtx == NULL)
1646 /* search for a free FIFO slot */
1647 for (n = 0;; n += 2) {
1649 if (n == USB_FIFO_MAX) {
1650 /* end of FIFOs reached */
1653 /* Check for TX FIFO */
1654 if (udev->fifo[n + USB_FIFO_TX] != NULL) {
1657 /* Check for RX FIFO */
1658 if (udev->fifo[n + USB_FIFO_RX] != NULL) {
1664 f_tx = usb_fifo_alloc();
1665 f_rx = usb_fifo_alloc();
1667 if ((f_tx == NULL) || (f_rx == NULL)) {
1668 usb_fifo_free(f_tx);
1669 usb_fifo_free(f_rx);
1672 /* initialise FIFO structures */
1674 f_tx->fifo_index = n + USB_FIFO_TX;
1675 f_tx->dev_ep_index = -1;
1676 f_tx->priv_mtx = priv_mtx;
1677 f_tx->priv_sc0 = priv_sc;
1679 f_tx->iface_index = iface_index;
1682 f_rx->fifo_index = n + USB_FIFO_RX;
1683 f_rx->dev_ep_index = -1;
1684 f_rx->priv_mtx = priv_mtx;
1685 f_rx->priv_sc0 = priv_sc;
1687 f_rx->iface_index = iface_index;
1690 f_sc->fp[USB_FIFO_TX] = f_tx;
1691 f_sc->fp[USB_FIFO_RX] = f_rx;
1693 mtx_lock(&usb_ref_lock);
1694 udev->fifo[f_tx->fifo_index] = f_tx;
1695 udev->fifo[f_rx->fifo_index] = f_rx;
1696 mtx_unlock(&usb_ref_lock);
1698 for (n = 0; n != 4; n++) {
1700 if (pm->basename[n] == NULL) {
1703 if (subunit == 0xFFFF) {
1704 if (snprintf(devname, sizeof(devname),
1705 "%s%u%s", pm->basename[n],
1706 unit, pm->postfix[n] ?
1707 pm->postfix[n] : "")) {
1711 if (snprintf(devname, sizeof(devname),
1712 "%s%u.%u%s", pm->basename[n],
1713 unit, subunit, pm->postfix[n] ?
1714 pm->postfix[n] : "")) {
1720 * Distribute the symbolic links into two FIFO structures:
1723 f_rx->symlink[n / 2] =
1724 usb_alloc_symlink(devname);
1726 f_tx->symlink[n / 2] =
1727 usb_alloc_symlink(devname);
1731 * Initialize device private data - this is used to find the
1732 * actual USB device itself.
1734 pd = malloc(sizeof(struct usb_fs_privdata), M_USBDEV, M_WAITOK | M_ZERO);
1735 pd->bus_index = device_get_unit(udev->bus->bdev);
1736 pd->dev_index = udev->device_index;
1737 pd->ep_addr = -1; /* not an endpoint */
1738 pd->fifo_index = f_tx->fifo_index & f_rx->fifo_index;
1739 pd->mode = FREAD|FWRITE;
1741 /* Now, create the device itself */
1742 f_sc->dev = make_dev(&usb_devsw, 0, uid, gid, mode,
1744 /* XXX setting si_drv1 and creating the device is not atomic! */
1745 f_sc->dev->si_drv1 = pd;
1748 DPRINTFN(2, "attached %p/%p\n", f_tx, f_rx);
1752 /*------------------------------------------------------------------------*
1753 * usb_fifo_alloc_buffer
1758 *------------------------------------------------------------------------*/
1760 usb_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize,
1763 usb_fifo_free_buffer(f);
1765 /* allocate an endpoint */
1766 f->free_q.ifq_maxlen = nbuf;
1767 f->used_q.ifq_maxlen = nbuf;
1769 f->queue_data = usb_alloc_mbufs(
1770 M_USBDEV, &f->free_q, bufsize, nbuf);
1772 if ((f->queue_data == NULL) && bufsize && nbuf) {
1775 return (0); /* success */
1778 /*------------------------------------------------------------------------*
1779 * usb_fifo_free_buffer
1781 * This function will free the buffers associated with a FIFO. This
1782 * function can be called multiple times in a row.
1783 *------------------------------------------------------------------------*/
1785 usb_fifo_free_buffer(struct usb_fifo *f)
1787 if (f->queue_data) {
1788 /* free old buffer */
1789 free(f->queue_data, M_USBDEV);
1790 f->queue_data = NULL;
1794 bzero(&f->free_q, sizeof(f->free_q));
1795 bzero(&f->used_q, sizeof(f->used_q));
1799 usb_fifo_cleanup(void* ptr)
1801 free(ptr, M_USBDEV);
1805 usb_fifo_detach(struct usb_fifo_sc *f_sc)
1810 usb_fifo_free(f_sc->fp[USB_FIFO_TX]);
1811 usb_fifo_free(f_sc->fp[USB_FIFO_RX]);
1813 f_sc->fp[USB_FIFO_TX] = NULL;
1814 f_sc->fp[USB_FIFO_RX] = NULL;
1816 if (f_sc->dev != NULL) {
1817 destroy_dev_sched_cb(f_sc->dev,
1818 usb_fifo_cleanup, f_sc->dev->si_drv1);
1822 DPRINTFN(2, "detached %p\n", f_sc);
1826 usb_fifo_put_bytes_max(struct usb_fifo *f)
1831 USB_IF_POLL(&f->free_q, m);
1834 len = m->max_data_len;
1841 /*------------------------------------------------------------------------*
1845 * 0 - normal operation
1846 * 1 - set last packet flag to enforce framing
1847 *------------------------------------------------------------------------*/
1849 usb_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc,
1850 usb_frlength_t offset, usb_frlength_t len, uint8_t what)
1853 usb_frlength_t io_len;
1855 while (len || (what == 1)) {
1857 USB_IF_DEQUEUE(&f->free_q, m);
1862 io_len = MIN(len, m->cur_data_len);
1864 usbd_copy_out(pc, offset, m->cur_data_ptr, io_len);
1866 m->cur_data_len = io_len;
1870 if ((len == 0) && (what == 1)) {
1873 USB_IF_ENQUEUE(&f->used_q, m);
1877 if ((len == 0) || (what == 1)) {
1887 usb_fifo_put_data_linear(struct usb_fifo *f, void *ptr,
1888 usb_size_t len, uint8_t what)
1893 while (len || (what == 1)) {
1895 USB_IF_DEQUEUE(&f->free_q, m);
1900 io_len = MIN(len, m->cur_data_len);
1902 bcopy(ptr, m->cur_data_ptr, io_len);
1904 m->cur_data_len = io_len;
1905 ptr = USB_ADD_BYTES(ptr, io_len);
1908 if ((len == 0) && (what == 1)) {
1911 USB_IF_ENQUEUE(&f->used_q, m);
1915 if ((len == 0) || (what == 1)) {
1925 usb_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len)
1929 USB_IF_DEQUEUE(&f->free_q, m);
1932 m->cur_data_len = len;
1933 m->cur_data_ptr = ptr;
1934 USB_IF_ENQUEUE(&f->used_q, m);
1942 usb_fifo_put_data_error(struct usb_fifo *f)
1944 f->flag_iserror = 1;
1948 /*------------------------------------------------------------------------*
1952 * 0 - normal operation
1953 * 1 - only get one "usb_mbuf"
1957 * 1 - data in buffer
1958 *------------------------------------------------------------------------*/
1960 usb_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,
1961 usb_frlength_t offset, usb_frlength_t len, usb_frlength_t *actlen,
1965 usb_frlength_t io_len;
1966 uint8_t tr_data = 0;
1972 USB_IF_DEQUEUE(&f->used_q, m);
1978 io_len = MIN(len, m->cur_data_len);
1980 usbd_copy_in(pc, offset, m->cur_data_ptr, io_len);
1984 actlen[0] += io_len;
1985 m->cur_data_ptr += io_len;
1986 m->cur_data_len -= io_len;
1988 if ((m->cur_data_len == 0) || (what == 1)) {
1989 USB_IF_ENQUEUE(&f->free_q, m);
1997 USB_IF_PREPEND(&f->used_q, m);
2002 /* wait for data to be written out */
2005 if (f->flag_flushing) {
2006 /* check if we should send a short packet */
2007 if (f->flag_short != 0) {
2012 /* flushing complete */
2013 f->flag_flushing = 0;
2026 usb_fifo_get_data_linear(struct usb_fifo *f, void *ptr,
2027 usb_size_t len, usb_size_t *actlen, uint8_t what)
2031 uint8_t tr_data = 0;
2037 USB_IF_DEQUEUE(&f->used_q, m);
2043 io_len = MIN(len, m->cur_data_len);
2045 bcopy(m->cur_data_ptr, ptr, io_len);
2048 ptr = USB_ADD_BYTES(ptr, io_len);
2049 actlen[0] += io_len;
2050 m->cur_data_ptr += io_len;
2051 m->cur_data_len -= io_len;
2053 if ((m->cur_data_len == 0) || (what == 1)) {
2054 USB_IF_ENQUEUE(&f->free_q, m);
2062 USB_IF_PREPEND(&f->used_q, m);
2067 /* wait for data to be written out */
2070 if (f->flag_flushing) {
2071 /* check if we should send a short packet */
2072 if (f->flag_short != 0) {
2077 /* flushing complete */
2078 f->flag_flushing = 0;
2091 usb_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen)
2095 USB_IF_POLL(&f->used_q, m);
2098 *plen = m->cur_data_len;
2099 *pptr = m->cur_data_ptr;
2107 usb_fifo_get_data_error(struct usb_fifo *f)
2109 f->flag_iserror = 1;
2113 /*------------------------------------------------------------------------*
2118 * Else: Pointer to symlink entry
2119 *------------------------------------------------------------------------*/
2120 struct usb_symlink *
2121 usb_alloc_symlink(const char *target)
2123 struct usb_symlink *ps;
2125 ps = malloc(sizeof(*ps), M_USBDEV, M_WAITOK);
2129 /* XXX no longer needed */
2130 strlcpy(ps->src_path, target, sizeof(ps->src_path));
2131 ps->src_len = strlen(ps->src_path);
2132 strlcpy(ps->dst_path, target, sizeof(ps->dst_path));
2133 ps->dst_len = strlen(ps->dst_path);
2135 sx_xlock(&usb_sym_lock);
2136 TAILQ_INSERT_TAIL(&usb_sym_head, ps, sym_entry);
2137 sx_unlock(&usb_sym_lock);
2141 /*------------------------------------------------------------------------*
2143 *------------------------------------------------------------------------*/
2145 usb_free_symlink(struct usb_symlink *ps)
2150 sx_xlock(&usb_sym_lock);
2151 TAILQ_REMOVE(&usb_sym_head, ps, sym_entry);
2152 sx_unlock(&usb_sym_lock);
2157 /*------------------------------------------------------------------------*
2163 *------------------------------------------------------------------------*/
2165 usb_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len)
2167 struct usb_symlink *ps;
2173 sx_xlock(&usb_sym_lock);
2175 TAILQ_FOREACH(ps, &usb_sym_head, sym_entry) {
2178 * Compute total length of source and destination symlink
2179 * strings pluss one length byte and two NUL bytes:
2181 temp = ps->src_len + ps->dst_len + 3;
2185 * Skip entry because this length cannot fit
2190 if (startentry != 0) {
2191 /* decrement read offset */
2195 if (temp > user_len) {
2196 /* out of buffer space */
2201 /* copy out total length */
2203 error = copyout(&len,
2204 USB_ADD_BYTES(user_ptr, delta), 1);
2210 /* copy out source string */
2212 error = copyout(ps->src_path,
2213 USB_ADD_BYTES(user_ptr, delta), ps->src_len);
2218 delta += ps->src_len;
2219 error = copyout(&len,
2220 USB_ADD_BYTES(user_ptr, delta), 1);
2226 /* copy out destination string */
2228 error = copyout(ps->dst_path,
2229 USB_ADD_BYTES(user_ptr, delta), ps->dst_len);
2234 delta += ps->dst_len;
2235 error = copyout(&len,
2236 USB_ADD_BYTES(user_ptr, delta), 1);
2245 /* a zero length entry indicates the end */
2247 if ((user_len != 0) && (error == 0)) {
2251 error = copyout(&len,
2252 USB_ADD_BYTES(user_ptr, delta), 1);
2254 sx_unlock(&usb_sym_lock);
2259 usb_fifo_set_close_zlp(struct usb_fifo *f, uint8_t onoff)
2264 /* send a Zero Length Packet, ZLP, before close */
2265 f->flag_short = onoff;
2269 usb_fifo_set_write_defrag(struct usb_fifo *f, uint8_t onoff)
2274 /* defrag written data */
2275 f->flag_write_defrag = onoff;
2276 /* reset defrag state */
2277 f->flag_have_fragment = 0;
2281 usb_fifo_softc(struct usb_fifo *f)
2283 return (f->priv_sc0);
2285 #endif /* USB_HAVE_UGEN */