1 /* $OpenBSD: ugen.c,v 1.119 2024/12/30 02:46:00 guenther Exp $ */
2 /* $NetBSD: ugen.c,v 1.63 2002/11/26 18:49:48 christos Exp $ */
3 /* $FreeBSD: src/sys/dev/usb/ugen.c,v 1.26 1999/11/17 22:33:41 n_hibma Exp $ */
4
5 /*
6 * Copyright (c) 1998 The NetBSD Foundation, Inc.
7 * All rights reserved.
8 *
9 * This code is derived from software contributed to The NetBSD Foundation
10 * by Lennart Augustsson (lennart@augustsson.net) at
11 * Carlstedt Research & Technology.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/malloc.h>
39 #include <sys/device.h>
40 #include <sys/ioctl.h>
41 #include <sys/conf.h>
42 #include <sys/tty.h>
43 #include <sys/fcntl.h>
44 #include <sys/selinfo.h>
45 #include <sys/vnode.h>
46
47 #include <machine/bus.h>
48
49 #include <dev/usb/usb.h>
50 #include <dev/usb/usbdi.h>
51 #include <dev/usb/usbdi_util.h>
52
53 #ifdef UGEN_DEBUG
54 #define DPRINTF(x) do { if (ugendebug) printf x; } while (0)
55 #define DPRINTFN(n,x) do { if (ugendebug>(n)) printf x; } while (0)
56 int ugendebug = 0;
57 #else
58 #define DPRINTF(x)
59 #define DPRINTFN(n,x)
60 #endif
61
62 #define UGEN_CHUNK 128 /* chunk size for read */
63 #define UGEN_IBSIZE 1020 /* buffer size */
64 #define UGEN_BBSIZE 1024
65
66 #define UGEN_NISOFRAMES 500 /* 0.5 seconds worth */
67 #define UGEN_NISOREQS 6 /* number of outstanding xfer requests */
68 #define UGEN_NISORFRMS 4 /* number of frames (milliseconds) per req */
69
70 struct ugen_endpoint {
71 struct ugen_softc *sc;
72 usb_endpoint_descriptor_t *edesc;
73 struct usbd_interface *iface;
74 int state;
75 #define UGEN_ASLP 0x02 /* waiting for data */
76 #define UGEN_SHORT_OK 0x04 /* short xfers are OK */
77 struct usbd_pipe *pipeh;
78 struct clist q;
79 struct selinfo rsel;
80 u_char *ibuf; /* start of buffer (circular for isoc) */
81 size_t ibuflen;
82 u_char *fill; /* location for input (isoc) */
83 u_char *limit; /* end of circular buffer (isoc) */
84 u_char *cur; /* current read location (isoc) */
85 u_int32_t timeout;
86 struct isoreq {
87 struct ugen_endpoint *sce;
88 struct usbd_xfer *xfer;
89 void *dmabuf;
90 u_int16_t sizes[UGEN_NISORFRMS];
91 } isoreqs[UGEN_NISOREQS];
92 };
93
94 struct ugen_softc {
95 struct device sc_dev; /* base device */
96 struct usbd_device *sc_udev;
97
98 char sc_is_open[USB_MAX_ENDPOINTS];
99 struct ugen_endpoint sc_endpoints[USB_MAX_ENDPOINTS][2];
100 #define OUT 0
101 #define IN 1
102
103 int sc_refcnt;
104 u_char sc_secondary;
105 };
106
107 void ugenintr(struct usbd_xfer *, void *, usbd_status);
108 void ugen_isoc_rintr(struct usbd_xfer *, void *, usbd_status);
109 int ugen_do_read(struct ugen_softc *, int, struct uio *, int);
110 int ugen_do_write(struct ugen_softc *, int, struct uio *, int);
111 int ugen_do_ioctl(struct ugen_softc *, int, u_long, caddr_t, int,
112 struct proc *);
113 int ugen_do_close(struct ugen_softc *, int, int);
114 int ugen_set_config(struct ugen_softc *, int);
115 int ugen_set_interface(struct ugen_softc *, int, int);
116 int ugen_get_alt_index(struct ugen_softc *, int);
117 void ugen_clear_iface_eps(struct ugen_softc *, struct usbd_interface *);
118
119 #define UGENUNIT(n) ((minor(n) >> 4) & 0xf)
120 #define UGENENDPOINT(n) (minor(n) & 0xf)
121 #define UGENDEV(u, e) (makedev(0, ((u) << 4) | (e)))
122
123 int ugen_match(struct device *, void *, void *);
124 void ugen_attach(struct device *, struct device *, void *);
125 int ugen_detach(struct device *, int);
126
127 struct cfdriver ugen_cd = {
128 NULL, "ugen", DV_DULL
129 };
130
131 const struct cfattach ugen_ca = {
132 sizeof(struct ugen_softc), ugen_match, ugen_attach, ugen_detach
133 };
134
135 int
ugen_match(struct device * parent,void * match,void * aux)136 ugen_match(struct device *parent, void *match, void *aux)
137 {
138 struct usb_attach_arg *uaa = aux;
139
140 if (uaa->usegeneric) {
141 return (UMATCH_GENERIC);
142 } else
143 return (UMATCH_NONE);
144 }
145
146 void
ugen_attach(struct device * parent,struct device * self,void * aux)147 ugen_attach(struct device *parent, struct device *self, void *aux)
148 {
149 struct ugen_softc *sc = (struct ugen_softc *)self;
150 struct usb_attach_arg *uaa = aux;
151 struct usbd_device *udev;
152 usbd_status err;
153 int conf;
154
155 sc->sc_udev = udev = uaa->device;
156
157 if (usbd_get_devcnt(udev) > 0)
158 sc->sc_secondary = 1;
159
160 if (!sc->sc_secondary) {
161 /* First set configuration index 0, the default one for ugen. */
162 err = usbd_set_config_index(udev, 0, 0);
163 if (err) {
164 printf("%s: setting configuration index 0 failed\n",
165 sc->sc_dev.dv_xname);
166 usbd_deactivate(sc->sc_udev);
167 return;
168 }
169 }
170 conf = usbd_get_config_descriptor(udev)->bConfigurationValue;
171
172 /* Set up all the local state for this configuration. */
173 err = ugen_set_config(sc, conf);
174 if (err) {
175 printf("%s: setting configuration %d failed\n",
176 sc->sc_dev.dv_xname, conf);
177 usbd_deactivate(sc->sc_udev);
178 return;
179 }
180 }
181
182 int
ugen_set_config(struct ugen_softc * sc,int configno)183 ugen_set_config(struct ugen_softc *sc, int configno)
184 {
185 struct usbd_device *dev = sc->sc_udev;
186 usb_config_descriptor_t *cdesc;
187 usb_interface_descriptor_t *id;
188 struct usbd_interface *iface;
189 usb_endpoint_descriptor_t *ed;
190 struct ugen_endpoint *sce;
191 int ifaceno, endptno, endpt;
192 int err, dir;
193
194 DPRINTFN(1,("ugen_set_config: %s to configno %d, sc=%p\n",
195 sc->sc_dev.dv_xname, configno, sc));
196
197 /*
198 * We start at 1, not 0, because we don't care whether the
199 * control endpoint is open or not. It is always present.
200 */
201 for (endptno = 1; endptno < USB_MAX_ENDPOINTS; endptno++)
202 if (sc->sc_is_open[endptno]) {
203 DPRINTFN(1,
204 ("ugen_set_config: %s - endpoint %d is open\n",
205 sc->sc_dev.dv_xname, endptno));
206 return (USBD_IN_USE);
207 }
208
209 /* Avoid setting the current value. */
210 cdesc = usbd_get_config_descriptor(dev);
211 if (cdesc == NULL || cdesc->bConfigurationValue != configno) {
212 if (sc->sc_secondary) {
213 printf("%s: secondary, not changing config to %d\n",
214 __func__, configno);
215 return (USBD_IN_USE);
216 } else {
217 err = usbd_set_config_no(dev, configno, 1);
218 if (err)
219 return (err);
220 cdesc = usbd_get_config_descriptor(dev);
221 if (cdesc == NULL ||
222 cdesc->bConfigurationValue != configno)
223 return (USBD_INVAL);
224 }
225 }
226
227 memset(sc->sc_endpoints, 0, sizeof sc->sc_endpoints);
228 for (ifaceno = 0; ifaceno < cdesc->bNumInterfaces; ifaceno++) {
229 DPRINTFN(1,("ugen_set_config: ifaceno %d\n", ifaceno));
230 if (usbd_iface_claimed(sc->sc_udev, ifaceno)) {
231 DPRINTF(("%s: iface %d not available\n", __func__,
232 ifaceno));
233 continue;
234 }
235 err = usbd_device2interface_handle(dev, ifaceno, &iface);
236 if (err)
237 return (err);
238 id = usbd_get_interface_descriptor(iface);
239 for (endptno = 0; endptno < id->bNumEndpoints; endptno++) {
240 ed = usbd_interface2endpoint_descriptor(iface,endptno);
241 endpt = ed->bEndpointAddress;
242 dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT;
243 sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir];
244 DPRINTFN(1,("ugen_set_config: endptno %d, endpt=0x%02x"
245 "(%d,%d), sce=%p\n",
246 endptno, endpt, UE_GET_ADDR(endpt),
247 UE_GET_DIR(endpt), sce));
248 sce->sc = sc;
249 sce->edesc = ed;
250 sce->iface = iface;
251 }
252 }
253 return (0);
254 }
255
256 int
ugenopen(dev_t dev,int flag,int mode,struct proc * p)257 ugenopen(dev_t dev, int flag, int mode, struct proc *p)
258 {
259 struct ugen_softc *sc;
260 int unit = UGENUNIT(dev);
261 int endpt = UGENENDPOINT(dev);
262 usb_endpoint_descriptor_t *edesc;
263 struct ugen_endpoint *sce;
264 int dir, isize;
265 usbd_status err;
266 struct usbd_xfer *xfer;
267 void *buf;
268 int i, j;
269
270 if (unit >= ugen_cd.cd_ndevs)
271 return (ENXIO);
272 sc = ugen_cd.cd_devs[unit];
273 if (sc == NULL)
274 return (ENXIO);
275
276 DPRINTFN(5, ("ugenopen: flag=%d, mode=%d, unit=%d endpt=%d\n",
277 flag, mode, unit, endpt));
278
279 if (sc == NULL || usbd_is_dying(sc->sc_udev))
280 return (ENXIO);
281
282 if (sc->sc_is_open[endpt])
283 return (EBUSY);
284
285 if (endpt == USB_CONTROL_ENDPOINT) {
286 sc->sc_is_open[USB_CONTROL_ENDPOINT] = 1;
287 return (0);
288 }
289
290 /* Make sure there are pipes for all directions. */
291 for (dir = OUT; dir <= IN; dir++) {
292 if (flag & (dir == OUT ? FWRITE : FREAD)) {
293 sce = &sc->sc_endpoints[endpt][dir];
294 if (sce == 0 || sce->edesc == 0)
295 return (ENXIO);
296 }
297 }
298
299 /* Actually open the pipes. */
300 /* XXX Should back out properly if it fails. */
301 for (dir = OUT; dir <= IN; dir++) {
302 if (!(flag & (dir == OUT ? FWRITE : FREAD)))
303 continue;
304 sce = &sc->sc_endpoints[endpt][dir];
305 sce->state = 0;
306 sce->timeout = USBD_NO_TIMEOUT;
307 DPRINTFN(5, ("ugenopen: sc=%p, endpt=%d, dir=%d, sce=%p\n",
308 sc, endpt, dir, sce));
309 edesc = sce->edesc;
310 /* Clear device endpoint toggle. */
311 ugen_clear_iface_eps(sc, sce->iface);
312 switch (UE_GET_XFERTYPE(edesc->bmAttributes)) {
313 case UE_INTERRUPT:
314 if (dir == OUT) {
315 err = usbd_open_pipe(sce->iface,
316 edesc->bEndpointAddress, 0, &sce->pipeh);
317 if (err)
318 return (EIO);
319 break;
320 }
321 isize = UGETW(edesc->wMaxPacketSize);
322 if (isize == 0) /* shouldn't happen */
323 return (EINVAL);
324 sce->ibuflen = isize;
325 sce->ibuf = malloc(sce->ibuflen, M_USBDEV, M_WAITOK);
326 DPRINTFN(5, ("ugenopen: intr endpt=%d,isize=%d\n",
327 endpt, isize));
328 clalloc(&sce->q, UGEN_IBSIZE, 0);
329 err = usbd_open_pipe_intr(sce->iface,
330 edesc->bEndpointAddress,
331 USBD_SHORT_XFER_OK, &sce->pipeh, sce,
332 sce->ibuf, isize, ugenintr,
333 USBD_DEFAULT_INTERVAL);
334 if (err) {
335 free(sce->ibuf, M_USBDEV, sce->ibuflen);
336 clfree(&sce->q);
337 return (EIO);
338 }
339 /* Clear HC endpoint toggle. */
340 usbd_clear_endpoint_toggle(sce->pipeh);
341 DPRINTFN(5, ("ugenopen: interrupt open done\n"));
342 break;
343 case UE_BULK:
344 err = usbd_open_pipe(sce->iface,
345 edesc->bEndpointAddress, 0, &sce->pipeh);
346 if (err)
347 return (EIO);
348 /* Clear HC endpoint toggle. */
349 usbd_clear_endpoint_toggle(sce->pipeh);
350 break;
351 case UE_ISOCHRONOUS:
352 if (dir == OUT)
353 return (EINVAL);
354 isize = UGETW(edesc->wMaxPacketSize);
355 if (isize == 0) /* shouldn't happen */
356 return (EINVAL);
357 sce->ibuflen = isize * UGEN_NISOFRAMES;
358 sce->ibuf = mallocarray(isize, UGEN_NISOFRAMES,
359 M_USBDEV, M_WAITOK);
360 sce->cur = sce->fill = sce->ibuf;
361 sce->limit = sce->ibuf + isize * UGEN_NISOFRAMES;
362 DPRINTFN(5, ("ugenopen: isoc endpt=%d, isize=%d\n",
363 endpt, isize));
364 err = usbd_open_pipe(sce->iface,
365 edesc->bEndpointAddress, 0, &sce->pipeh);
366 if (err) {
367 free(sce->ibuf, M_USBDEV, sce->ibuflen);
368 return (EIO);
369 }
370 for(i = 0; i < UGEN_NISOREQS; ++i) {
371 sce->isoreqs[i].sce = sce;
372 xfer = usbd_alloc_xfer(sc->sc_udev);
373 if (xfer == 0)
374 goto bad;
375 sce->isoreqs[i].xfer = xfer;
376 buf = usbd_alloc_buffer
377 (xfer, isize * UGEN_NISORFRMS);
378 if (buf == 0) {
379 i++;
380 goto bad;
381 }
382 sce->isoreqs[i].dmabuf = buf;
383 for(j = 0; j < UGEN_NISORFRMS; ++j)
384 sce->isoreqs[i].sizes[j] = isize;
385 usbd_setup_isoc_xfer(xfer, sce->pipeh,
386 &sce->isoreqs[i], sce->isoreqs[i].sizes,
387 UGEN_NISORFRMS, USBD_NO_COPY |
388 USBD_SHORT_XFER_OK, ugen_isoc_rintr);
389 (void)usbd_transfer(xfer);
390 }
391 DPRINTFN(5, ("ugenopen: isoc open done\n"));
392 break;
393 bad:
394 while (--i >= 0) /* implicit buffer free */
395 usbd_free_xfer(sce->isoreqs[i].xfer);
396 return (ENOMEM);
397 case UE_CONTROL:
398 sce->timeout = USBD_DEFAULT_TIMEOUT;
399 return (EINVAL);
400 }
401 }
402 sc->sc_is_open[endpt] = 1;
403 return (0);
404 }
405
406 int
ugenclose(dev_t dev,int flag,int mode,struct proc * p)407 ugenclose(dev_t dev, int flag, int mode, struct proc *p)
408 {
409 struct ugen_softc *sc = ugen_cd.cd_devs[UGENUNIT(dev)];
410 int endpt = UGENENDPOINT(dev);
411 int error;
412
413 if (sc == NULL || usbd_is_dying(sc->sc_udev))
414 return (EIO);
415
416 DPRINTFN(5, ("ugenclose: flag=%d, mode=%d, unit=%d, endpt=%d\n",
417 flag, mode, UGENUNIT(dev), endpt));
418
419 sc->sc_refcnt++;
420 error = ugen_do_close(sc, endpt, flag);
421 if (--sc->sc_refcnt < 0)
422 usb_detach_wakeup(&sc->sc_dev);
423
424 return (error);
425 }
426
427 int
ugen_do_close(struct ugen_softc * sc,int endpt,int flag)428 ugen_do_close(struct ugen_softc *sc, int endpt, int flag)
429 {
430 struct ugen_endpoint *sce;
431 int dir, i;
432
433 #ifdef DIAGNOSTIC
434 if (!sc->sc_is_open[endpt]) {
435 printf("ugenclose: not open\n");
436 return (EINVAL);
437 }
438 #endif
439
440 if (endpt == USB_CONTROL_ENDPOINT) {
441 DPRINTFN(5, ("ugenclose: close control\n"));
442 sc->sc_is_open[endpt] = 0;
443 return (0);
444 }
445
446 for (dir = OUT; dir <= IN; dir++) {
447 if (!(flag & (dir == OUT ? FWRITE : FREAD)))
448 continue;
449 sce = &sc->sc_endpoints[endpt][dir];
450 if (sce == NULL || sce->pipeh == NULL)
451 continue;
452 DPRINTFN(5, ("ugenclose: endpt=%d dir=%d sce=%p\n",
453 endpt, dir, sce));
454
455 usbd_close_pipe(sce->pipeh);
456 sce->pipeh = NULL;
457
458 switch (UE_GET_XFERTYPE(sce->edesc->bmAttributes)) {
459 case UE_INTERRUPT:
460 ndflush(&sce->q, sce->q.c_cc);
461 clfree(&sce->q);
462 break;
463 case UE_ISOCHRONOUS:
464 for (i = 0; i < UGEN_NISOREQS; ++i)
465 usbd_free_xfer(sce->isoreqs[i].xfer);
466
467 default:
468 break;
469 }
470
471 if (sce->ibuf != NULL) {
472 free(sce->ibuf, M_USBDEV, sce->ibuflen);
473 sce->ibuf = NULL;
474 }
475 }
476 sc->sc_is_open[endpt] = 0;
477
478 return (0);
479 }
480
481 int
ugen_do_read(struct ugen_softc * sc,int endpt,struct uio * uio,int flag)482 ugen_do_read(struct ugen_softc *sc, int endpt, struct uio *uio, int flag)
483 {
484 struct ugen_endpoint *sce = &sc->sc_endpoints[endpt][IN];
485 u_int32_t tn;
486 size_t n;
487 char buf[UGEN_BBSIZE];
488 struct usbd_xfer *xfer;
489 usbd_status err;
490 int s;
491 int flags, error = 0;
492 u_char buffer[UGEN_CHUNK];
493
494 DPRINTFN(5, ("%s: ugenread: %d\n", sc->sc_dev.dv_xname, endpt));
495
496 if (usbd_is_dying(sc->sc_udev))
497 return (EIO);
498
499 if (endpt == USB_CONTROL_ENDPOINT)
500 return (ENODEV);
501
502 #ifdef DIAGNOSTIC
503 if (sce->edesc == NULL) {
504 printf("ugenread: no edesc\n");
505 return (EIO);
506 }
507 if (sce->pipeh == NULL) {
508 printf("ugenread: no pipe\n");
509 return (EIO);
510 }
511 #endif
512
513 switch (UE_GET_XFERTYPE(sce->edesc->bmAttributes)) {
514 case UE_INTERRUPT:
515 /* Block until activity occurred. */
516 s = splusb();
517 while (sce->q.c_cc == 0) {
518 if (flag & IO_NDELAY) {
519 splx(s);
520 return (EWOULDBLOCK);
521 }
522 sce->state |= UGEN_ASLP;
523 DPRINTFN(5, ("ugenread: sleep on %p\n", sce));
524 error = tsleep_nsec(sce, PZERO | PCATCH, "ugenrintr",
525 MSEC_TO_NSEC(sce->timeout));
526 sce->state &= ~UGEN_ASLP;
527 DPRINTFN(5, ("ugenread: woke, error=%d\n", error));
528 if (usbd_is_dying(sc->sc_udev))
529 error = EIO;
530 if (error == EWOULDBLOCK) { /* timeout, return 0 */
531 error = 0;
532 break;
533 }
534 if (error)
535 break;
536 }
537 splx(s);
538
539 /* Transfer as many chunks as possible. */
540 while (sce->q.c_cc > 0 && uio->uio_resid > 0 && !error) {
541 n = ulmin(sce->q.c_cc, uio->uio_resid);
542 if (n > sizeof(buffer))
543 n = sizeof(buffer);
544
545 /* Remove a small chunk from the input queue. */
546 q_to_b(&sce->q, buffer, n);
547 DPRINTFN(5, ("ugenread: got %zu chars\n", n));
548
549 /* Copy the data to the user process. */
550 error = uiomove(buffer, n, uio);
551 if (error)
552 break;
553 }
554 break;
555 case UE_BULK:
556 xfer = usbd_alloc_xfer(sc->sc_udev);
557 if (xfer == 0)
558 return (ENOMEM);
559 flags = USBD_SYNCHRONOUS;
560 if (sce->state & UGEN_SHORT_OK)
561 flags |= USBD_SHORT_XFER_OK;
562 if (sce->timeout == 0)
563 flags |= USBD_CATCH;
564 while ((n = ulmin(UGEN_BBSIZE, uio->uio_resid)) != 0) {
565 DPRINTFN(1, ("ugenread: start transfer %zu bytes\n",n));
566 usbd_setup_xfer(xfer, sce->pipeh, 0, buf, n,
567 flags, sce->timeout, NULL);
568 err = usbd_transfer(xfer);
569 if (err) {
570 usbd_clear_endpoint_stall(sce->pipeh);
571 if (err == USBD_INTERRUPTED)
572 error = EINTR;
573 else if (err == USBD_TIMEOUT)
574 error = ETIMEDOUT;
575 else
576 error = EIO;
577 break;
578 }
579 usbd_get_xfer_status(xfer, NULL, NULL, &tn, NULL);
580 DPRINTFN(1, ("ugenread: got %u bytes\n", tn));
581 error = uiomove(buf, tn, uio);
582 if (error || tn < n)
583 break;
584 }
585 usbd_free_xfer(xfer);
586 break;
587 case UE_ISOCHRONOUS:
588 s = splusb();
589 while (sce->cur == sce->fill) {
590 if (flag & IO_NDELAY) {
591 splx(s);
592 return (EWOULDBLOCK);
593 }
594 sce->state |= UGEN_ASLP;
595 DPRINTFN(5, ("ugenread: sleep on %p\n", sce));
596 error = tsleep_nsec(sce, PZERO | PCATCH, "ugenriso",
597 MSEC_TO_NSEC(sce->timeout));
598 sce->state &= ~UGEN_ASLP;
599 DPRINTFN(5, ("ugenread: woke, error=%d\n", error));
600 if (usbd_is_dying(sc->sc_udev))
601 error = EIO;
602 if (error == EWOULDBLOCK) { /* timeout, return 0 */
603 error = 0;
604 break;
605 }
606 if (error)
607 break;
608 }
609
610 while (sce->cur != sce->fill && uio->uio_resid > 0 && !error) {
611 if(sce->fill > sce->cur)
612 n = ulmin(sce->fill - sce->cur, uio->uio_resid);
613 else
614 n = ulmin(sce->limit - sce->cur, uio->uio_resid);
615
616 DPRINTFN(5, ("ugenread: isoc got %zu chars\n", n));
617
618 /* Copy the data to the user process. */
619 error = uiomove(sce->cur, n, uio);
620 if (error)
621 break;
622 sce->cur += n;
623 if(sce->cur >= sce->limit)
624 sce->cur = sce->ibuf;
625 }
626 splx(s);
627 break;
628
629
630 default:
631 return (ENXIO);
632 }
633 return (error);
634 }
635
636 int
ugenread(dev_t dev,struct uio * uio,int flag)637 ugenread(dev_t dev, struct uio *uio, int flag)
638 {
639 int endpt = UGENENDPOINT(dev);
640 struct ugen_softc *sc;
641 int error;
642
643 sc = ugen_cd.cd_devs[UGENUNIT(dev)];
644
645 sc->sc_refcnt++;
646 error = ugen_do_read(sc, endpt, uio, flag);
647 if (--sc->sc_refcnt < 0)
648 usb_detach_wakeup(&sc->sc_dev);
649 return (error);
650 }
651
652 int
ugen_do_write(struct ugen_softc * sc,int endpt,struct uio * uio,int flag)653 ugen_do_write(struct ugen_softc *sc, int endpt, struct uio *uio, int flag)
654 {
655 struct ugen_endpoint *sce = &sc->sc_endpoints[endpt][OUT];
656 size_t n;
657 int flags, error = 0;
658 char buf[UGEN_BBSIZE];
659 struct usbd_xfer *xfer;
660 usbd_status err;
661
662 DPRINTFN(5, ("%s: ugenwrite: %d\n", sc->sc_dev.dv_xname, endpt));
663
664 if (usbd_is_dying(sc->sc_udev))
665 return (EIO);
666
667 if (endpt == USB_CONTROL_ENDPOINT)
668 return (ENODEV);
669
670 #ifdef DIAGNOSTIC
671 if (sce->edesc == NULL) {
672 printf("ugenwrite: no edesc\n");
673 return (EIO);
674 }
675 if (sce->pipeh == NULL) {
676 printf("ugenwrite: no pipe\n");
677 return (EIO);
678 }
679 #endif
680 flags = USBD_SYNCHRONOUS;
681 if (sce->timeout == 0)
682 flags |= USBD_CATCH;
683
684 switch (UE_GET_XFERTYPE(sce->edesc->bmAttributes)) {
685 case UE_BULK:
686 xfer = usbd_alloc_xfer(sc->sc_udev);
687 if (xfer == 0)
688 return (EIO);
689 while ((n = ulmin(UGEN_BBSIZE, uio->uio_resid)) != 0) {
690 error = uiomove(buf, n, uio);
691 if (error)
692 break;
693 DPRINTFN(1, ("ugenwrite: transfer %zu bytes\n", n));
694 usbd_setup_xfer(xfer, sce->pipeh, 0, buf, n,
695 flags, sce->timeout, NULL);
696 err = usbd_transfer(xfer);
697 if (err) {
698 usbd_clear_endpoint_stall(sce->pipeh);
699 if (err == USBD_INTERRUPTED)
700 error = EINTR;
701 else if (err == USBD_TIMEOUT)
702 error = ETIMEDOUT;
703 else
704 error = EIO;
705 break;
706 }
707 }
708 usbd_free_xfer(xfer);
709 break;
710 case UE_INTERRUPT:
711 xfer = usbd_alloc_xfer(sc->sc_udev);
712 if (xfer == 0)
713 return (EIO);
714 while ((n = ulmin(UGETW(sce->edesc->wMaxPacketSize),
715 uio->uio_resid)) != 0) {
716 error = uiomove(buf, n, uio);
717 if (error)
718 break;
719 DPRINTFN(1, ("ugenwrite: transfer %zu bytes\n", n));
720 usbd_setup_xfer(xfer, sce->pipeh, 0, buf, n,
721 flags, sce->timeout, NULL);
722 err = usbd_transfer(xfer);
723 if (err) {
724 usbd_clear_endpoint_stall(sce->pipeh);
725 if (err == USBD_INTERRUPTED)
726 error = EINTR;
727 else if (err == USBD_TIMEOUT)
728 error = ETIMEDOUT;
729 else
730 error = EIO;
731 break;
732 }
733 }
734 usbd_free_xfer(xfer);
735 break;
736 default:
737 return (ENXIO);
738 }
739 return (error);
740 }
741
742 int
ugenwrite(dev_t dev,struct uio * uio,int flag)743 ugenwrite(dev_t dev, struct uio *uio, int flag)
744 {
745 int endpt = UGENENDPOINT(dev);
746 struct ugen_softc *sc;
747 int error;
748
749 sc = ugen_cd.cd_devs[UGENUNIT(dev)];
750
751 sc->sc_refcnt++;
752 error = ugen_do_write(sc, endpt, uio, flag);
753 if (--sc->sc_refcnt < 0)
754 usb_detach_wakeup(&sc->sc_dev);
755 return (error);
756 }
757
758 int
ugen_detach(struct device * self,int flags)759 ugen_detach(struct device *self, int flags)
760 {
761 struct ugen_softc *sc = (struct ugen_softc *)self;
762 struct ugen_endpoint *sce;
763 int i, dir, endptno;
764 int s, maj, mn;
765
766 DPRINTF(("ugen_detach: sc=%p flags=%d\n", sc, flags));
767
768 /* Abort all pipes. Causes processes waiting for transfer to wake. */
769 for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
770 for (dir = OUT; dir <= IN; dir++) {
771 sce = &sc->sc_endpoints[i][dir];
772 if (sce && sce->pipeh)
773 usbd_abort_pipe(sce->pipeh);
774 }
775 }
776
777 s = splusb();
778 if (--sc->sc_refcnt >= 0) {
779 /* Wake everyone */
780 for (i = 0; i < USB_MAX_ENDPOINTS; i++)
781 wakeup(&sc->sc_endpoints[i][IN]);
782 /* Wait for processes to go away. */
783 usb_detach_wait(&sc->sc_dev);
784 }
785 splx(s);
786
787 /* locate the major number */
788 for (maj = 0; maj < nchrdev; maj++)
789 if (cdevsw[maj].d_open == ugenopen)
790 break;
791
792 /* Nuke the vnodes for any open instances (calls close). */
793 mn = self->dv_unit * USB_MAX_ENDPOINTS;
794 vdevgone(maj, mn, mn + USB_MAX_ENDPOINTS - 1, VCHR);
795
796 for (endptno = 0; endptno < USB_MAX_ENDPOINTS; endptno++) {
797 if (sc->sc_is_open[endptno])
798 ugen_do_close(sc, endptno, FREAD|FWRITE);
799
800 /* ugenkqfilter() always uses IN. */
801 sce = &sc->sc_endpoints[endptno][IN];
802 klist_invalidate(&sce->rsel.si_note);
803 }
804 return (0);
805 }
806
807 void
ugenintr(struct usbd_xfer * xfer,void * addr,usbd_status status)808 ugenintr(struct usbd_xfer *xfer, void *addr, usbd_status status)
809 {
810 struct ugen_endpoint *sce = addr;
811 /*struct ugen_softc *sc = sce->sc;*/
812 u_int32_t count;
813 u_char *ibuf;
814
815 if (status == USBD_CANCELLED)
816 return;
817
818 if (status != USBD_NORMAL_COMPLETION) {
819 DPRINTF(("ugenintr: status=%d\n", status));
820 if (status == USBD_STALLED)
821 usbd_clear_endpoint_stall_async(sce->pipeh);
822 return;
823 }
824
825 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
826 ibuf = sce->ibuf;
827
828 DPRINTFN(5, ("ugenintr: xfer=%p status=%d count=%d\n",
829 xfer, status, count));
830 DPRINTFN(5, (" data = %02x %02x %02x\n",
831 ibuf[0], ibuf[1], ibuf[2]));
832
833 (void)b_to_q(ibuf, count, &sce->q);
834
835 if (sce->state & UGEN_ASLP) {
836 sce->state &= ~UGEN_ASLP;
837 DPRINTFN(5, ("ugen_intr: waking %p\n", sce));
838 wakeup(sce);
839 }
840 selwakeup(&sce->rsel);
841 }
842
843 void
ugen_isoc_rintr(struct usbd_xfer * xfer,void * addr,usbd_status status)844 ugen_isoc_rintr(struct usbd_xfer *xfer, void *addr, usbd_status status)
845 {
846 struct isoreq *req = addr;
847 struct ugen_endpoint *sce = req->sce;
848 u_int32_t count, n;
849 int i, isize;
850
851 /* Return if we are aborting. */
852 if (status == USBD_CANCELLED)
853 return;
854
855 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
856 DPRINTFN(5,("%s: xfer %ld, count=%d\n", __func__, req - sce->isoreqs,
857 count));
858
859 /* throw away oldest input if the buffer is full */
860 if(sce->fill < sce->cur && sce->cur <= sce->fill + count) {
861 sce->cur += count;
862 if(sce->cur >= sce->limit)
863 sce->cur = sce->ibuf + (sce->limit - sce->cur);
864 DPRINTFN(5, ("%s: throwing away %d bytes\n", __func__, count));
865 }
866
867 isize = UGETW(sce->edesc->wMaxPacketSize);
868 for (i = 0; i < UGEN_NISORFRMS; i++) {
869 u_int32_t actlen = req->sizes[i];
870 char const *buf = (char const *)req->dmabuf + isize * i;
871
872 /* copy data to buffer */
873 while (actlen > 0) {
874 n = min(actlen, sce->limit - sce->fill);
875 memcpy(sce->fill, buf, n);
876
877 buf += n;
878 actlen -= n;
879 sce->fill += n;
880 if(sce->fill == sce->limit)
881 sce->fill = sce->ibuf;
882 }
883
884 /* setup size for next transfer */
885 req->sizes[i] = isize;
886 }
887
888 usbd_setup_isoc_xfer(xfer, sce->pipeh, req, req->sizes, UGEN_NISORFRMS,
889 USBD_NO_COPY | USBD_SHORT_XFER_OK, ugen_isoc_rintr);
890 (void)usbd_transfer(xfer);
891
892 if (sce->state & UGEN_ASLP) {
893 sce->state &= ~UGEN_ASLP;
894 DPRINTFN(5, ("ugen_isoc_rintr: waking %p\n", sce));
895 wakeup(sce);
896 }
897 selwakeup(&sce->rsel);
898 }
899
900 int
ugen_set_interface(struct ugen_softc * sc,int ifaceno,int altno)901 ugen_set_interface(struct ugen_softc *sc, int ifaceno, int altno)
902 {
903 struct usbd_interface *iface;
904 usb_config_descriptor_t *cdesc;
905 usb_interface_descriptor_t *id;
906 usb_endpoint_descriptor_t *ed;
907 struct ugen_endpoint *sce;
908 uint8_t endptno, endpt;
909 int dir, err;
910
911 DPRINTFN(15, ("ugen_set_interface %d %d\n", ifaceno, altno));
912
913 cdesc = usbd_get_config_descriptor(sc->sc_udev);
914 if (ifaceno < 0 || ifaceno >= cdesc->bNumInterfaces ||
915 usbd_iface_claimed(sc->sc_udev, ifaceno))
916 return (USBD_INVAL);
917
918 err = usbd_device2interface_handle(sc->sc_udev, ifaceno, &iface);
919 if (err)
920 return (err);
921 id = usbd_get_interface_descriptor(iface);
922 for (endptno = 0; endptno < id->bNumEndpoints; endptno++) {
923 ed = usbd_interface2endpoint_descriptor(iface,endptno);
924 endpt = ed->bEndpointAddress;
925 dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT;
926 sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir];
927 sce->sc = 0;
928 sce->edesc = 0;
929 sce->iface = 0;
930 }
931
932 /* Try to change setting, if this fails put back the descriptors. */
933 err = usbd_set_interface(iface, altno);
934
935 id = usbd_get_interface_descriptor(iface);
936 for (endptno = 0; endptno < id->bNumEndpoints; endptno++) {
937 ed = usbd_interface2endpoint_descriptor(iface,endptno);
938 endpt = ed->bEndpointAddress;
939 dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT;
940 sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir];
941 sce->sc = sc;
942 sce->edesc = ed;
943 sce->iface = iface;
944 }
945 return (err);
946 }
947
948 int
ugen_get_alt_index(struct ugen_softc * sc,int ifaceno)949 ugen_get_alt_index(struct ugen_softc *sc, int ifaceno)
950 {
951 struct usbd_interface *iface;
952 usbd_status err;
953
954 err = usbd_device2interface_handle(sc->sc_udev, ifaceno, &iface);
955 if (err)
956 return (-1);
957 return (usbd_get_interface_altindex(iface));
958 }
959
960 int
ugen_do_ioctl(struct ugen_softc * sc,int endpt,u_long cmd,caddr_t addr,int flag,struct proc * p)961 ugen_do_ioctl(struct ugen_softc *sc, int endpt, u_long cmd, caddr_t addr,
962 int flag, struct proc *p)
963 {
964 struct ugen_endpoint *sce;
965 int err, cdesc_len;
966 struct usbd_interface *iface;
967 struct usb_config_desc *cd;
968 usb_config_descriptor_t *cdesc;
969 struct usb_interface_desc *id;
970 usb_interface_descriptor_t *idesc;
971 struct usb_endpoint_desc *ed;
972 usb_endpoint_descriptor_t *edesc;
973 struct usb_alt_interface *ai;
974 u_int8_t conf, alt;
975
976 DPRINTFN(5, ("ugenioctl: cmd=%08lx\n", cmd));
977 if (usbd_is_dying(sc->sc_udev))
978 return (EIO);
979
980 switch (cmd) {
981 case USB_SET_SHORT_XFER:
982 if (endpt == USB_CONTROL_ENDPOINT)
983 return (EINVAL);
984 /* This flag only affects read */
985 sce = &sc->sc_endpoints[endpt][IN];
986 if (sce == NULL || sce->pipeh == NULL)
987 return (EINVAL);
988 if (*(int *)addr)
989 sce->state |= UGEN_SHORT_OK;
990 else
991 sce->state &= ~UGEN_SHORT_OK;
992 return (0);
993 case USB_SET_TIMEOUT:
994 sce = &sc->sc_endpoints[endpt][IN];
995 if (sce == NULL)
996 return (EINVAL);
997 sce->timeout = *(int *)addr;
998 sce = &sc->sc_endpoints[endpt][OUT];
999 if (sce == NULL)
1000 return (EINVAL);
1001 sce->timeout = *(int *)addr;
1002 return (0);
1003 default:
1004 break;
1005 }
1006
1007 if (endpt != USB_CONTROL_ENDPOINT)
1008 return (EINVAL);
1009
1010 switch (cmd) {
1011 #ifdef UGEN_DEBUG
1012 case USB_SETDEBUG:
1013 ugendebug = *(int *)addr;
1014 break;
1015 #endif
1016 case USB_GET_CONFIG:
1017 err = usbd_get_config(sc->sc_udev, &conf);
1018 if (err)
1019 return (EIO);
1020 *(int *)addr = conf;
1021 break;
1022 case USB_SET_CONFIG:
1023 if (!(flag & FWRITE))
1024 return (EPERM);
1025 err = ugen_set_config(sc, *(int *)addr);
1026 switch (err) {
1027 case USBD_NORMAL_COMPLETION:
1028 break;
1029 case USBD_IN_USE:
1030 return (EBUSY);
1031 default:
1032 return (EIO);
1033 }
1034 break;
1035 case USB_GET_ALTINTERFACE:
1036 ai = (struct usb_alt_interface *)addr;
1037 err = usbd_device2interface_handle(sc->sc_udev,
1038 ai->uai_interface_index, &iface);
1039 if (err)
1040 return (EINVAL);
1041 idesc = usbd_get_interface_descriptor(iface);
1042 if (idesc == NULL)
1043 return (EIO);
1044 ai->uai_alt_no = idesc->bAlternateSetting;
1045 break;
1046 case USB_SET_ALTINTERFACE:
1047 if (!(flag & FWRITE))
1048 return (EPERM);
1049 ai = (struct usb_alt_interface *)addr;
1050 err = usbd_device2interface_handle(sc->sc_udev,
1051 ai->uai_interface_index, &iface);
1052 if (err)
1053 return (EINVAL);
1054 err = ugen_set_interface(sc, ai->uai_interface_index,
1055 ai->uai_alt_no);
1056 if (err)
1057 return (EINVAL);
1058 break;
1059 case USB_GET_NO_ALT:
1060 ai = (struct usb_alt_interface *)addr;
1061 cdesc = usbd_get_cdesc(sc->sc_udev, ai->uai_config_index,
1062 &cdesc_len);
1063 if (cdesc == NULL)
1064 return (EINVAL);
1065 idesc = usbd_find_idesc(cdesc, ai->uai_interface_index, 0);
1066 if (idesc == NULL) {
1067 free(cdesc, M_TEMP, UGETW(cdesc->wTotalLength));
1068 return (EINVAL);
1069 }
1070 ai->uai_alt_no = usbd_get_no_alts(cdesc,
1071 idesc->bInterfaceNumber);
1072 free(cdesc, M_TEMP, cdesc_len);
1073 break;
1074 case USB_GET_DEVICE_DESC:
1075 *(usb_device_descriptor_t *)addr =
1076 *usbd_get_device_descriptor(sc->sc_udev);
1077 break;
1078 case USB_GET_CONFIG_DESC:
1079 cd = (struct usb_config_desc *)addr;
1080 cdesc = usbd_get_cdesc(sc->sc_udev, cd->ucd_config_index,
1081 &cdesc_len);
1082 if (cdesc == NULL)
1083 return (EINVAL);
1084 cd->ucd_desc = *cdesc;
1085 free(cdesc, M_TEMP, cdesc_len);
1086 break;
1087 case USB_GET_INTERFACE_DESC:
1088 id = (struct usb_interface_desc *)addr;
1089 cdesc = usbd_get_cdesc(sc->sc_udev, id->uid_config_index,
1090 &cdesc_len);
1091 if (cdesc == NULL)
1092 return (EINVAL);
1093 if (id->uid_config_index == USB_CURRENT_CONFIG_INDEX &&
1094 id->uid_alt_index == USB_CURRENT_ALT_INDEX)
1095 alt = ugen_get_alt_index(sc, id->uid_interface_index);
1096 else
1097 alt = id->uid_alt_index;
1098 idesc = usbd_find_idesc(cdesc, id->uid_interface_index, alt);
1099 if (idesc == NULL) {
1100 free(cdesc, M_TEMP, UGETW(cdesc->wTotalLength));
1101 return (EINVAL);
1102 }
1103 id->uid_desc = *idesc;
1104 free(cdesc, M_TEMP, cdesc_len);
1105 break;
1106 case USB_GET_ENDPOINT_DESC:
1107 ed = (struct usb_endpoint_desc *)addr;
1108 cdesc = usbd_get_cdesc(sc->sc_udev, ed->ued_config_index,
1109 &cdesc_len);
1110 if (cdesc == NULL)
1111 return (EINVAL);
1112 if (ed->ued_config_index == USB_CURRENT_CONFIG_INDEX &&
1113 ed->ued_alt_index == USB_CURRENT_ALT_INDEX)
1114 alt = ugen_get_alt_index(sc, ed->ued_interface_index);
1115 else
1116 alt = ed->ued_alt_index;
1117 edesc = usbd_find_edesc(cdesc, ed->ued_interface_index,
1118 alt, ed->ued_endpoint_index);
1119 if (edesc == NULL) {
1120 free(cdesc, M_TEMP, UGETW(cdesc->wTotalLength));
1121 return (EINVAL);
1122 }
1123 ed->ued_desc = *edesc;
1124 free(cdesc, M_TEMP, cdesc_len);
1125 break;
1126 case USB_GET_FULL_DESC:
1127 {
1128 u_int len;
1129 struct iovec iov;
1130 struct uio uio;
1131 struct usb_full_desc *fd = (struct usb_full_desc *)addr;
1132 int error;
1133
1134 cdesc = usbd_get_cdesc(sc->sc_udev, fd->ufd_config_index,
1135 &cdesc_len);
1136 if (cdesc == NULL)
1137 return (EINVAL);
1138 len = cdesc_len;
1139 if (len > fd->ufd_size)
1140 len = fd->ufd_size;
1141 iov.iov_base = (caddr_t)fd->ufd_data;
1142 iov.iov_len = len;
1143 uio.uio_iov = &iov;
1144 uio.uio_iovcnt = 1;
1145 uio.uio_resid = len;
1146 uio.uio_offset = 0;
1147 uio.uio_segflg = UIO_USERSPACE;
1148 uio.uio_rw = UIO_READ;
1149 uio.uio_procp = p;
1150 error = uiomove((void *)cdesc, len, &uio);
1151 free(cdesc, M_TEMP, cdesc_len);
1152 return (error);
1153 }
1154 case USB_DO_REQUEST:
1155 {
1156 struct usb_ctl_request *ur = (void *)addr;
1157 size_t len = UGETW(ur->ucr_request.wLength), mlen;
1158 struct iovec iov;
1159 struct uio uio;
1160 void *ptr = NULL;
1161 int error = 0;
1162
1163 if (!(flag & FWRITE))
1164 return (EPERM);
1165 /* Avoid requests that would damage the bus integrity. */
1166 if ((ur->ucr_request.bmRequestType == UT_WRITE_DEVICE &&
1167 ur->ucr_request.bRequest == UR_SET_ADDRESS) ||
1168 (ur->ucr_request.bmRequestType == UT_WRITE_DEVICE &&
1169 ur->ucr_request.bRequest == UR_SET_CONFIG) ||
1170 (ur->ucr_request.bmRequestType == UT_WRITE_INTERFACE &&
1171 ur->ucr_request.bRequest == UR_SET_INTERFACE))
1172 return (EINVAL);
1173
1174 if (len > 32767)
1175 return (EINVAL);
1176 if (len != 0) {
1177 iov.iov_base = (caddr_t)ur->ucr_data;
1178 iov.iov_len = len;
1179 uio.uio_iov = &iov;
1180 uio.uio_iovcnt = 1;
1181 uio.uio_resid = len;
1182 uio.uio_offset = 0;
1183 uio.uio_segflg = UIO_USERSPACE;
1184 uio.uio_rw =
1185 ur->ucr_request.bmRequestType & UT_READ ?
1186 UIO_READ : UIO_WRITE;
1187 uio.uio_procp = p;
1188 if ((ptr = malloc(len, M_TEMP, M_NOWAIT)) == NULL) {
1189 error = ENOMEM;
1190 goto ret;
1191 }
1192 if (uio.uio_rw == UIO_WRITE) {
1193 error = uiomove(ptr, len, &uio);
1194 if (error)
1195 goto ret;
1196 }
1197 }
1198 sce = &sc->sc_endpoints[endpt][IN];
1199 err = usbd_do_request_flags(sc->sc_udev, &ur->ucr_request,
1200 ptr, ur->ucr_flags, &ur->ucr_actlen, sce->timeout);
1201 if (err) {
1202 error = EIO;
1203 goto ret;
1204 }
1205 /* Only if USBD_SHORT_XFER_OK is set. */
1206 mlen = len;
1207 if (mlen > ur->ucr_actlen)
1208 mlen = ur->ucr_actlen;
1209 if (mlen != 0) {
1210 if (uio.uio_rw == UIO_READ) {
1211 error = uiomove(ptr, mlen, &uio);
1212 if (error)
1213 goto ret;
1214 }
1215 }
1216 ret:
1217 free(ptr, M_TEMP, len);
1218 return (error);
1219 }
1220 case USB_GET_DEVICEINFO:
1221 usbd_fill_deviceinfo(sc->sc_udev,
1222 (struct usb_device_info *)addr);
1223 break;
1224 default:
1225 return (EINVAL);
1226 }
1227 return (0);
1228 }
1229
1230 int
ugenioctl(dev_t dev,u_long cmd,caddr_t addr,int flag,struct proc * p)1231 ugenioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
1232 {
1233 int endpt = UGENENDPOINT(dev);
1234 struct ugen_softc *sc;
1235 int error;
1236
1237 sc = ugen_cd.cd_devs[UGENUNIT(dev)];
1238
1239 sc->sc_refcnt++;
1240 error = ugen_do_ioctl(sc, endpt, cmd, addr, flag, p);
1241 if (--sc->sc_refcnt < 0)
1242 usb_detach_wakeup(&sc->sc_dev);
1243 return (error);
1244 }
1245
1246 void filt_ugenrdetach(struct knote *);
1247 int filt_ugenread_intr(struct knote *, long);
1248 int filt_ugenread_isoc(struct knote *, long);
1249 int ugenkqfilter(dev_t, struct knote *);
1250
1251 void
filt_ugenrdetach(struct knote * kn)1252 filt_ugenrdetach(struct knote *kn)
1253 {
1254 struct ugen_endpoint *sce = (void *)kn->kn_hook;
1255 int s;
1256
1257 s = splusb();
1258 klist_remove_locked(&sce->rsel.si_note, kn);
1259 splx(s);
1260 }
1261
1262 int
filt_ugenread_intr(struct knote * kn,long hint)1263 filt_ugenread_intr(struct knote *kn, long hint)
1264 {
1265 struct ugen_endpoint *sce = (void *)kn->kn_hook;
1266
1267 kn->kn_data = sce->q.c_cc;
1268 return (kn->kn_data > 0);
1269 }
1270
1271 int
filt_ugenread_isoc(struct knote * kn,long hint)1272 filt_ugenread_isoc(struct knote *kn, long hint)
1273 {
1274 struct ugen_endpoint *sce = (void *)kn->kn_hook;
1275
1276 if (sce->cur == sce->fill)
1277 return (0);
1278
1279 if (sce->cur < sce->fill)
1280 kn->kn_data = sce->fill - sce->cur;
1281 else
1282 kn->kn_data = (sce->limit - sce->cur) +
1283 (sce->fill - sce->ibuf);
1284
1285 return (1);
1286 }
1287
1288 const struct filterops ugenread_intr_filtops = {
1289 .f_flags = FILTEROP_ISFD,
1290 .f_attach = NULL,
1291 .f_detach = filt_ugenrdetach,
1292 .f_event = filt_ugenread_intr,
1293 };
1294
1295 const struct filterops ugenread_isoc_filtops = {
1296 .f_flags = FILTEROP_ISFD,
1297 .f_attach = NULL,
1298 .f_detach = filt_ugenrdetach,
1299 .f_event = filt_ugenread_isoc,
1300 };
1301
1302 int
ugenkqfilter(dev_t dev,struct knote * kn)1303 ugenkqfilter(dev_t dev, struct knote *kn)
1304 {
1305 struct ugen_softc *sc;
1306 struct ugen_endpoint *sce;
1307 struct klist *klist;
1308 int s;
1309
1310 sc = ugen_cd.cd_devs[UGENUNIT(dev)];
1311
1312 if (usbd_is_dying(sc->sc_udev))
1313 return (ENXIO);
1314
1315 /* XXX always IN */
1316 sce = &sc->sc_endpoints[UGENENDPOINT(dev)][IN];
1317 if (sce == NULL)
1318 return (ENXIO);
1319
1320 switch (kn->kn_filter) {
1321 case EVFILT_READ:
1322 klist = &sce->rsel.si_note;
1323 switch (UE_GET_XFERTYPE(sce->edesc->bmAttributes)) {
1324 case UE_INTERRUPT:
1325 kn->kn_fop = &ugenread_intr_filtops;
1326 break;
1327 case UE_ISOCHRONOUS:
1328 kn->kn_fop = &ugenread_isoc_filtops;
1329 break;
1330 case UE_BULK:
1331 /*
1332 * We have no easy way of determining if a read will
1333 * yield any data or a write will happen.
1334 */
1335 return (seltrue_kqfilter(dev, kn));
1336 default:
1337 return (EINVAL);
1338 }
1339 break;
1340
1341 case EVFILT_WRITE:
1342 klist = &sce->rsel.si_note;
1343 switch (UE_GET_XFERTYPE(sce->edesc->bmAttributes)) {
1344 case UE_INTERRUPT:
1345 case UE_ISOCHRONOUS:
1346 /* XXX poll doesn't support this */
1347 return (EINVAL);
1348
1349 case UE_BULK:
1350 /*
1351 * We have no easy way of determining if a read will
1352 * yield any data or a write will happen.
1353 */
1354 return (seltrue_kqfilter(dev, kn));
1355 default:
1356 return (EINVAL);
1357 }
1358 break;
1359
1360 default:
1361 return (EINVAL);
1362 }
1363
1364 kn->kn_hook = (void *)sce;
1365
1366 s = splusb();
1367 klist_insert_locked(klist, kn);
1368 splx(s);
1369
1370 return (0);
1371 }
1372
1373 void
ugen_clear_iface_eps(struct ugen_softc * sc,struct usbd_interface * iface)1374 ugen_clear_iface_eps(struct ugen_softc *sc, struct usbd_interface *iface)
1375 {
1376 usb_interface_descriptor_t *id;
1377 usb_endpoint_descriptor_t *ed;
1378 uint8_t xfertype;
1379 int i;
1380
1381 /* Only clear interface endpoints when none are in use. */
1382 for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
1383 if (i == USB_CONTROL_ENDPOINT)
1384 continue;
1385 if (sc->sc_is_open[i] != 0)
1386 return;
1387 }
1388 DPRINTFN(1,("%s: clear interface eps\n", __func__));
1389
1390 id = usbd_get_interface_descriptor(iface);
1391 if (id == NULL)
1392 goto bad;
1393
1394 for (i = 0; i < id->bNumEndpoints; i++) {
1395 ed = usbd_interface2endpoint_descriptor(iface, i);
1396 if (ed == NULL)
1397 goto bad;
1398
1399 xfertype = UE_GET_XFERTYPE(ed->bmAttributes);
1400 if (xfertype == UE_BULK || xfertype == UE_INTERRUPT) {
1401 if (usbd_clear_endpoint_feature(sc->sc_udev,
1402 ed->bEndpointAddress, UF_ENDPOINT_HALT))
1403 goto bad;
1404 }
1405 }
1406 return;
1407 bad:
1408 printf("%s: clear endpoints failed!\n", __func__);
1409 }
1410