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