3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <dev/usb/usb_mfunc.h>
28 #include <dev/usb/usb.h>
29 #include <dev/usb/usb_ioctl.h>
30 #include <dev/usb/usb_error.h>
32 #define USB_DEBUG_VAR ugen_debug
34 #include <dev/usb/usb_core.h>
35 #include <dev/usb/usb_mbuf.h>
36 #include <dev/usb/usb_dev.h>
37 #include <dev/usb/usb_process.h>
38 #include <dev/usb/usb_device.h>
39 #include <dev/usb/usb_debug.h>
40 #include <dev/usb/usb_request.h>
41 #include <dev/usb/usb_busdma.h>
42 #include <dev/usb/usb_util.h>
43 #include <dev/usb/usb_hub.h>
44 #include <dev/usb/usb_generic.h>
45 #include <dev/usb/usb_transfer.h>
47 #include <dev/usb/usb_controller.h>
48 #include <dev/usb/usb_bus.h>
54 #define UGEN_BULK_FS_BUFFER_SIZE (64*32) /* bytes */
55 #define UGEN_BULK_HS_BUFFER_SIZE (1024*32) /* bytes */
56 #define UGEN_HW_FRAMES 50 /* number of milliseconds per transfer */
58 /* function prototypes */
60 static usb2_callback_t ugen_read_clear_stall_callback;
61 static usb2_callback_t ugen_write_clear_stall_callback;
62 static usb2_callback_t ugen_default_read_callback;
63 static usb2_callback_t ugen_default_write_callback;
64 static usb2_callback_t ugen_isoc_read_callback;
65 static usb2_callback_t ugen_isoc_write_callback;
66 static usb2_callback_t ugen_default_fs_callback;
68 static usb2_fifo_open_t ugen_open;
69 static usb2_fifo_close_t ugen_close;
70 static usb2_fifo_ioctl_t ugen_ioctl;
71 static usb2_fifo_ioctl_t ugen_ioctl_post;
72 static usb2_fifo_cmd_t ugen_start_read;
73 static usb2_fifo_cmd_t ugen_start_write;
74 static usb2_fifo_cmd_t ugen_stop_io;
76 static int ugen_transfer_setup(struct usb2_fifo *,
77 const struct usb2_config *, uint8_t);
78 static int ugen_open_pipe_write(struct usb2_fifo *);
79 static int ugen_open_pipe_read(struct usb2_fifo *);
80 static int ugen_set_config(struct usb2_fifo *, uint8_t);
81 static int ugen_set_interface(struct usb2_fifo *, uint8_t, uint8_t);
82 static int ugen_get_cdesc(struct usb2_fifo *, struct usb2_gen_descriptor *);
83 static int ugen_get_sdesc(struct usb2_fifo *, struct usb2_gen_descriptor *);
84 static int ugen_get_iface_driver(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd);
85 static int usb2_gen_fill_deviceinfo(struct usb2_fifo *,
86 struct usb2_device_info *);
87 static int ugen_re_enumerate(struct usb2_fifo *);
88 static int ugen_iface_ioctl(struct usb2_fifo *, u_long, void *, int);
89 static uint8_t ugen_fs_get_complete(struct usb2_fifo *, uint8_t *);
90 static int ugen_fs_uninit(struct usb2_fifo *f);
94 struct usb2_fifo_methods usb2_ugen_methods = {
96 .f_close = &ugen_close,
97 .f_ioctl = &ugen_ioctl,
98 .f_ioctl_post = &ugen_ioctl_post,
99 .f_start_read = &ugen_start_read,
100 .f_stop_read = &ugen_stop_io,
101 .f_start_write = &ugen_start_write,
102 .f_stop_write = &ugen_stop_io,
106 static int ugen_debug = 0;
108 SYSCTL_NODE(_hw_usb2, OID_AUTO, ugen, CTLFLAG_RW, 0, "USB generic");
109 SYSCTL_INT(_hw_usb2_ugen, OID_AUTO, debug, CTLFLAG_RW, &ugen_debug,
117 ugen_transfer_setup(struct usb2_fifo *f,
118 const struct usb2_config *setup, uint8_t n_setup)
120 struct usb2_pipe *pipe = f->priv_sc0;
121 struct usb2_device *udev = f->udev;
122 uint8_t iface_index = pipe->iface_index;
125 mtx_unlock(f->priv_mtx);
128 * "usb2_transfer_setup()" can sleep so one needs to make a wrapper,
129 * exiting the mutex and checking things
131 error = usb2_transfer_setup(udev, &iface_index, f->xfer,
132 setup, n_setup, f, f->priv_mtx);
135 if (f->xfer[0]->nframes == 1) {
136 error = usb2_fifo_alloc_buffer(f,
137 f->xfer[0]->max_data_length, 2);
139 error = usb2_fifo_alloc_buffer(f,
140 f->xfer[0]->max_frame_size,
141 2 * f->xfer[0]->nframes);
144 usb2_transfer_unsetup(f->xfer, n_setup);
147 mtx_lock(f->priv_mtx);
153 ugen_open(struct usb2_fifo *f, int fflags)
155 struct usb2_pipe *pipe = f->priv_sc0;
156 struct usb2_endpoint_descriptor *ed = pipe->edesc;
159 DPRINTFN(6, "flag=0x%x\n", fflags);
161 mtx_lock(f->priv_mtx);
162 switch (usb2_get_speed(f->udev)) {
165 f->nframes = UGEN_HW_FRAMES;
166 f->bufsize = UGEN_BULK_FS_BUFFER_SIZE;
169 f->nframes = UGEN_HW_FRAMES * 8;
170 f->bufsize = UGEN_BULK_HS_BUFFER_SIZE;
174 type = ed->bmAttributes & UE_XFERTYPE;
175 if (type == UE_INTERRUPT) {
176 f->bufsize = 0; /* use "wMaxPacketSize" */
178 f->timeout = USB_NO_TIMEOUT;
181 mtx_unlock(f->priv_mtx);
187 ugen_close(struct usb2_fifo *f, int fflags)
189 DPRINTFN(6, "flag=0x%x\n", fflags);
193 mtx_lock(f->priv_mtx);
194 usb2_transfer_stop(f->xfer[0]);
195 usb2_transfer_stop(f->xfer[1]);
196 mtx_unlock(f->priv_mtx);
198 usb2_transfer_unsetup(f->xfer, 2);
199 usb2_fifo_free_buffer(f);
201 if (ugen_fs_uninit(f)) {
202 /* ignore any errors - we are closing */
203 DPRINTFN(6, "no FIFOs\n");
208 ugen_open_pipe_write(struct usb2_fifo *f)
210 struct usb2_config usb2_config[2];
211 struct usb2_pipe *pipe = f->priv_sc0;
212 struct usb2_endpoint_descriptor *ed = pipe->edesc;
214 mtx_assert(f->priv_mtx, MA_OWNED);
216 if (f->xfer[0] || f->xfer[1]) {
217 /* transfers are already opened */
220 bzero(usb2_config, sizeof(usb2_config));
222 usb2_config[1].type = UE_CONTROL;
223 usb2_config[1].endpoint = 0;
224 usb2_config[1].direction = UE_DIR_ANY;
225 usb2_config[1].mh.timeout = 1000; /* 1 second */
226 usb2_config[1].mh.interval = 50;/* 50 milliseconds */
227 usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request);
228 usb2_config[1].mh.callback = &ugen_write_clear_stall_callback;
230 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
231 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
232 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
233 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL;
234 usb2_config[0].mh.flags.proxy_buffer = 1;
236 switch (ed->bmAttributes & UE_XFERTYPE) {
240 usb2_config[0].mh.flags.force_short_xfer = 1;
242 usb2_config[0].mh.callback = &ugen_default_write_callback;
243 usb2_config[0].mh.timeout = f->timeout;
244 usb2_config[0].mh.frames = 1;
245 usb2_config[0].mh.bufsize = f->bufsize;
246 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */
247 if (ugen_transfer_setup(f, usb2_config, 2)) {
250 /* first transfer does not clear stall */
255 usb2_config[0].mh.flags.short_xfer_ok = 1;
256 usb2_config[0].mh.bufsize = 0; /* use default */
257 usb2_config[0].mh.frames = f->nframes;
258 usb2_config[0].mh.callback = &ugen_isoc_write_callback;
259 usb2_config[0].mh.timeout = 0;
260 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */
262 /* clone configuration */
263 usb2_config[1] = usb2_config[0];
265 if (ugen_transfer_setup(f, usb2_config, 2)) {
276 ugen_open_pipe_read(struct usb2_fifo *f)
278 struct usb2_config usb2_config[2];
279 struct usb2_pipe *pipe = f->priv_sc0;
280 struct usb2_endpoint_descriptor *ed = pipe->edesc;
282 mtx_assert(f->priv_mtx, MA_OWNED);
284 if (f->xfer[0] || f->xfer[1]) {
285 /* transfers are already opened */
288 bzero(usb2_config, sizeof(usb2_config));
290 usb2_config[1].type = UE_CONTROL;
291 usb2_config[1].endpoint = 0;
292 usb2_config[1].direction = UE_DIR_ANY;
293 usb2_config[1].mh.timeout = 1000; /* 1 second */
294 usb2_config[1].mh.interval = 50;/* 50 milliseconds */
295 usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request);
296 usb2_config[1].mh.callback = &ugen_read_clear_stall_callback;
298 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
299 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
300 usb2_config[0].direction = UE_DIR_IN;
301 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL;
302 usb2_config[0].mh.flags.proxy_buffer = 1;
304 switch (ed->bmAttributes & UE_XFERTYPE) {
308 usb2_config[0].mh.flags.short_xfer_ok = 1;
310 usb2_config[0].mh.timeout = f->timeout;
311 usb2_config[0].mh.frames = 1;
312 usb2_config[0].mh.callback = &ugen_default_read_callback;
313 usb2_config[0].mh.bufsize = f->bufsize;
314 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */
316 if (ugen_transfer_setup(f, usb2_config, 2)) {
319 /* first transfer does not clear stall */
324 usb2_config[0].mh.flags.short_xfer_ok = 1;
325 usb2_config[0].mh.bufsize = 0; /* use default */
326 usb2_config[0].mh.frames = f->nframes;
327 usb2_config[0].mh.callback = &ugen_isoc_read_callback;
328 usb2_config[0].mh.timeout = 0;
329 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */
331 /* clone configuration */
332 usb2_config[1] = usb2_config[0];
334 if (ugen_transfer_setup(f, usb2_config, 2)) {
346 ugen_start_read(struct usb2_fifo *f)
348 /* check that pipes are open */
349 if (ugen_open_pipe_read(f)) {
351 usb2_fifo_put_data_error(f);
353 /* start transfers */
354 usb2_transfer_start(f->xfer[0]);
355 usb2_transfer_start(f->xfer[1]);
359 ugen_start_write(struct usb2_fifo *f)
361 /* check that pipes are open */
362 if (ugen_open_pipe_write(f)) {
364 usb2_fifo_get_data_error(f);
366 /* start transfers */
367 usb2_transfer_start(f->xfer[0]);
368 usb2_transfer_start(f->xfer[1]);
372 ugen_stop_io(struct usb2_fifo *f)
375 usb2_transfer_stop(f->xfer[0]);
376 usb2_transfer_stop(f->xfer[1]);
380 ugen_default_read_callback(struct usb2_xfer *xfer)
382 struct usb2_fifo *f = xfer->priv_sc;
385 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
387 switch (USB_GET_STATE(xfer)) {
388 case USB_ST_TRANSFERRED:
389 if (xfer->actlen == 0) {
390 if (f->fifo_zlp != 4) {
394 * Throttle a little bit we have multiple ZLPs
397 xfer->interval = 64; /* ms */
404 usb2_fifo_put_data(f, xfer->frbuffers, 0,
409 usb2_transfer_start(f->xfer[1]);
412 USB_IF_POLL(&f->free_q, m);
414 xfer->frlengths[0] = xfer->max_data_length;
415 usb2_start_hardware(xfer);
420 if (xfer->error != USB_ERR_CANCELLED) {
421 /* send a zero length packet to userland */
422 usb2_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
425 usb2_transfer_start(f->xfer[1]);
432 ugen_default_write_callback(struct usb2_xfer *xfer)
434 struct usb2_fifo *f = xfer->priv_sc;
435 usb2_frlength_t actlen;
437 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
439 switch (USB_GET_STATE(xfer)) {
441 case USB_ST_TRANSFERRED:
443 * If writing is in stall, just jump to clear stall
444 * callback and solve the situation.
447 usb2_transfer_start(f->xfer[1]);
451 * Write data, setup and perform hardware transfer.
453 if (usb2_fifo_get_data(f, xfer->frbuffers, 0,
454 xfer->max_data_length, &actlen, 0)) {
455 xfer->frlengths[0] = actlen;
456 usb2_start_hardware(xfer);
461 if (xfer->error != USB_ERR_CANCELLED) {
463 usb2_transfer_start(f->xfer[1]);
470 ugen_read_clear_stall_callback(struct usb2_xfer *xfer)
472 struct usb2_fifo *f = xfer->priv_sc;
473 struct usb2_xfer *xfer_other = f->xfer[0];
475 if (f->flag_stall == 0) {
479 if (usb2_clear_stall_callback(xfer, xfer_other)) {
480 DPRINTFN(5, "f=%p: stall cleared\n", f);
482 usb2_transfer_start(xfer_other);
487 ugen_write_clear_stall_callback(struct usb2_xfer *xfer)
489 struct usb2_fifo *f = xfer->priv_sc;
490 struct usb2_xfer *xfer_other = f->xfer[0];
492 if (f->flag_stall == 0) {
496 if (usb2_clear_stall_callback(xfer, xfer_other)) {
497 DPRINTFN(5, "f=%p: stall cleared\n", f);
499 usb2_transfer_start(xfer_other);
504 ugen_isoc_read_callback(struct usb2_xfer *xfer)
506 struct usb2_fifo *f = xfer->priv_sc;
507 usb2_frlength_t offset;
510 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
512 switch (USB_GET_STATE(xfer)) {
513 case USB_ST_TRANSFERRED:
515 DPRINTFN(6, "actlen=%d\n", xfer->actlen);
519 for (n = 0; n != xfer->aframes; n++) {
520 usb2_fifo_put_data(f, xfer->frbuffers, offset,
521 xfer->frlengths[n], 1);
522 offset += xfer->max_frame_size;
527 for (n = 0; n != xfer->nframes; n++) {
528 /* setup size for next transfer */
529 xfer->frlengths[n] = xfer->max_frame_size;
531 usb2_start_hardware(xfer);
535 if (xfer->error == USB_ERR_CANCELLED) {
543 ugen_isoc_write_callback(struct usb2_xfer *xfer)
545 struct usb2_fifo *f = xfer->priv_sc;
546 usb2_frlength_t actlen;
547 usb2_frlength_t offset;
550 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
552 switch (USB_GET_STATE(xfer)) {
553 case USB_ST_TRANSFERRED:
557 for (n = 0; n != xfer->nframes; n++) {
558 if (usb2_fifo_get_data(f, xfer->frbuffers, offset,
559 xfer->max_frame_size, &actlen, 1)) {
560 xfer->frlengths[n] = actlen;
567 for (; n != xfer->nframes; n++) {
568 /* fill in zero frames */
569 xfer->frlengths[n] = 0;
571 usb2_start_hardware(xfer);
575 if (xfer->error == USB_ERR_CANCELLED) {
583 ugen_set_config(struct usb2_fifo *f, uint8_t index)
585 DPRINTFN(2, "index %u\n", index);
587 if (f->udev->flags.usb2_mode != USB_MODE_HOST) {
588 /* not possible in device side mode */
591 if (f->udev->curr_config_index == index) {
592 /* no change needed */
595 /* make sure all FIFO's are gone */
596 /* else there can be a deadlock */
597 if (ugen_fs_uninit(f)) {
598 /* ignore any errors */
599 DPRINTFN(6, "no FIFOs\n");
601 /* change setting - will free generic FIFOs, if any */
602 if (usb2_set_config_index(f->udev, index)) {
605 /* probe and attach */
606 if (usb2_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) {
613 ugen_set_interface(struct usb2_fifo *f,
614 uint8_t iface_index, uint8_t alt_index)
616 DPRINTFN(2, "%u, %u\n", iface_index, alt_index);
618 if (f->udev->flags.usb2_mode != USB_MODE_HOST) {
619 /* not possible in device side mode */
622 /* make sure all FIFO's are gone */
623 /* else there can be a deadlock */
624 if (ugen_fs_uninit(f)) {
625 /* ignore any errors */
626 DPRINTFN(6, "no FIFOs\n");
628 /* change setting - will free generic FIFOs, if any */
629 if (usb2_set_alt_interface_index(f->udev, iface_index, alt_index)) {
632 /* probe and attach */
633 if (usb2_probe_and_attach(f->udev, iface_index)) {
639 /*------------------------------------------------------------------------*
642 * This function will retrieve the complete configuration descriptor
643 * at the given index.
644 *------------------------------------------------------------------------*/
646 ugen_get_cdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd)
648 struct usb2_config_descriptor *cdesc;
649 struct usb2_device *udev = f->udev;
656 if (ugd->ugd_data == NULL) {
657 /* userland pointer should not be zero */
660 if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) ||
661 (ugd->ugd_config_index == udev->curr_config_index)) {
662 cdesc = usb2_get_config_descriptor(udev);
669 if (usb2_req_get_config_desc_full(udev,
670 NULL, &cdesc, M_USBDEV,
671 ugd->ugd_config_index)) {
677 len = UGETW(cdesc->wTotalLength);
678 if (len > ugd->ugd_maxlen) {
679 len = ugd->ugd_maxlen;
681 DPRINTFN(6, "len=%u\n", len);
683 ugd->ugd_actlen = len;
686 error = copyout(cdesc, ugd->ugd_data, len);
689 free(cdesc, M_USBDEV);
695 ugen_get_sdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd)
697 void *ptr = f->udev->bus->scratch[0].data;
698 uint16_t size = sizeof(f->udev->bus->scratch[0].data);
701 if (usb2_req_get_string_desc(f->udev, NULL, ptr,
702 size, ugd->ugd_lang_id, ugd->ugd_string_index)) {
706 if (size > ((uint8_t *)ptr)[0]) {
707 size = ((uint8_t *)ptr)[0];
709 if (size > ugd->ugd_maxlen) {
710 size = ugd->ugd_maxlen;
712 ugd->ugd_actlen = size;
715 error = copyout(ptr, ugd->ugd_data, size);
720 /*------------------------------------------------------------------------*
721 * ugen_get_iface_driver
723 * This function generates an USB interface description for userland.
728 *------------------------------------------------------------------------*/
730 ugen_get_iface_driver(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd)
732 struct usb2_device *udev = f->udev;
733 struct usb2_interface *iface;
743 if ((ugd->ugd_data == NULL) || (ugd->ugd_maxlen == 0)) {
744 /* userland pointer should not be zero */
748 iface = usb2_get_iface(udev, ugd->ugd_iface_index);
749 if ((iface == NULL) || (iface->idesc == NULL)) {
750 /* invalid interface index */
754 /* read out device nameunit string, if any */
755 if ((iface->subdev != NULL) &&
756 device_is_attached(iface->subdev) &&
757 (ptr = device_get_nameunit(iface->subdev)) &&
758 (desc = device_get_desc(iface->subdev))) {
760 /* print description */
761 snprintf(buf, sizeof(buf), "%s: <%s>", ptr, desc);
764 maxlen = ugd->ugd_maxlen - 1;
769 /* update actual length, including terminating zero */
770 ugd->ugd_actlen = len + 1;
772 /* copy out interface description */
773 error = copyout(buf, ugd->ugd_data, ugd->ugd_actlen);
775 /* zero length string is default */
776 error = copyout("", ugd->ugd_data, 1);
781 /*------------------------------------------------------------------------*
782 * usb2_gen_fill_deviceinfo
784 * This function dumps information about an USB device to the
785 * structure pointed to by the "di" argument.
790 *------------------------------------------------------------------------*/
792 usb2_gen_fill_deviceinfo(struct usb2_fifo *f, struct usb2_device_info *di)
794 struct usb2_device *udev;
795 struct usb2_device *hub;
799 bzero(di, sizeof(di[0]));
801 di->udi_bus = device_get_unit(udev->bus->bdev);
802 di->udi_addr = udev->address;
803 di->udi_index = udev->device_index;
805 strlcpy(di->udi_serial, udev->serial,
806 sizeof(di->udi_serial));
807 strlcpy(di->udi_vendor, udev->manufacturer,
808 sizeof(di->udi_vendor));
809 strlcpy(di->udi_product, udev->product,
810 sizeof(di->udi_product));
812 usb2_printBCD(di->udi_release, sizeof(di->udi_release),
813 UGETW(udev->ddesc.bcdDevice));
814 di->udi_vendorNo = UGETW(udev->ddesc.idVendor);
815 di->udi_productNo = UGETW(udev->ddesc.idProduct);
816 di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice);
817 di->udi_class = udev->ddesc.bDeviceClass;
818 di->udi_subclass = udev->ddesc.bDeviceSubClass;
819 di->udi_protocol = udev->ddesc.bDeviceProtocol;
820 di->udi_config_no = udev->curr_config_no;
821 di->udi_config_index = udev->curr_config_index;
822 di->udi_power = udev->flags.self_powered ? 0 : udev->power;
823 di->udi_speed = udev->speed;
824 di->udi_mode = udev->flags.usb2_mode;
825 di->udi_power_mode = udev->power_mode;
826 if (udev->flags.suspended) {
827 di->udi_suspended = 1;
829 di->udi_suspended = 0;
832 hub = udev->parent_hub;
834 di->udi_hubaddr = hub->address;
835 di->udi_hubindex = hub->device_index;
836 di->udi_hubport = udev->port_no;
841 /*------------------------------------------------------------------------*
847 *------------------------------------------------------------------------*/
849 ugen_check_request(struct usb2_device *udev, struct usb2_device_request *req)
851 struct usb2_pipe *pipe;
855 * Avoid requests that would damage the bus integrity:
857 if (((req->bmRequestType == UT_WRITE_DEVICE) &&
858 (req->bRequest == UR_SET_ADDRESS)) ||
859 ((req->bmRequestType == UT_WRITE_DEVICE) &&
860 (req->bRequest == UR_SET_CONFIG)) ||
861 ((req->bmRequestType == UT_WRITE_INTERFACE) &&
862 (req->bRequest == UR_SET_INTERFACE))) {
864 * These requests can be useful for testing USB drivers.
866 error = priv_check(curthread, PRIV_DRIVER);
872 * Special case - handle clearing of stall
874 if (req->bmRequestType == UT_WRITE_ENDPOINT) {
876 pipe = usb2_get_pipe_by_addr(udev, req->wIndex[0]);
880 if ((req->bRequest == UR_CLEAR_FEATURE) &&
881 (UGETW(req->wValue) == UF_ENDPOINT_HALT)) {
882 usb2_clear_data_toggle(udev, pipe);
885 /* TODO: add more checks to verify the interface index */
891 ugen_do_request(struct usb2_fifo *f, struct usb2_ctl_request *ur)
897 if (ugen_check_request(f->udev, &ur->ucr_request)) {
900 len = UGETW(ur->ucr_request.wLength);
902 /* check if "ucr_data" is valid */
904 if (ur->ucr_data == NULL) {
908 /* do the USB request */
909 error = usb2_do_request_flags
910 (f->udev, NULL, &ur->ucr_request, ur->ucr_data,
911 (ur->ucr_flags & USB_SHORT_XFER_OK) |
912 USB_USER_DATA_PTR, &actlen,
913 USB_DEFAULT_TIMEOUT);
915 ur->ucr_actlen = actlen;
923 /*------------------------------------------------------------------------
925 *------------------------------------------------------------------------*/
927 ugen_re_enumerate(struct usb2_fifo *f)
929 struct usb2_device *udev = f->udev;
933 * This request can be useful for testing USB drivers:
935 error = priv_check(curthread, PRIV_DRIVER);
939 /* get the device unconfigured */
940 error = ugen_set_config(f, USB_UNCONFIG_INDEX);
945 mtx_lock(f->priv_mtx);
946 error = usb2_req_re_enumerate(udev, f->priv_mtx);
947 mtx_unlock(f->priv_mtx);
952 /* restore configuration to index 0 */
953 error = ugen_set_config(f, 0);
961 ugen_fs_uninit(struct usb2_fifo *f)
963 if (f->fs_xfer == NULL) {
966 usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max);
967 free(f->fs_xfer, M_USB);
971 f->flag_iscomplete = 0;
972 usb2_fifo_free_buffer(f);
977 ugen_fs_get_complete(struct usb2_fifo *f, uint8_t *pindex)
981 USB_IF_DEQUEUE(&f->used_q, m);
984 *pindex = *((uint8_t *)(m->cur_data_ptr));
986 USB_IF_ENQUEUE(&f->free_q, m);
988 return (0); /* success */
991 *pindex = 0; /* fix compiler warning */
993 f->flag_iscomplete = 0;
995 return (1); /* failure */
999 ugen_fs_set_complete(struct usb2_fifo *f, uint8_t index)
1001 struct usb2_mbuf *m;
1003 USB_IF_DEQUEUE(&f->free_q, m);
1006 /* can happen during close */
1007 DPRINTF("out of buffers\n");
1012 *((uint8_t *)(m->cur_data_ptr)) = index;
1014 USB_IF_ENQUEUE(&f->used_q, m);
1016 f->flag_iscomplete = 1;
1018 usb2_fifo_wakeup(f);
1022 ugen_fs_copy_in(struct usb2_fifo *f, uint8_t ep_index)
1024 struct usb2_device_request *req;
1025 struct usb2_xfer *xfer;
1026 struct usb2_fs_endpoint fs_ep;
1027 void *uaddr; /* userland pointer */
1029 usb2_frlength_t offset;
1030 usb2_frlength_t rem;
1036 if (ep_index >= f->fs_ep_max) {
1039 xfer = f->fs_xfer[ep_index];
1043 mtx_lock(f->priv_mtx);
1044 if (usb2_transfer_pending(xfer)) {
1045 mtx_unlock(f->priv_mtx);
1046 return (EBUSY); /* should not happen */
1048 mtx_unlock(f->priv_mtx);
1050 error = copyin(f->fs_ep_ptr +
1051 ep_index, &fs_ep, sizeof(fs_ep));
1055 /* security checks */
1057 if (fs_ep.nFrames > xfer->max_frame_count) {
1058 xfer->error = USB_ERR_INVAL;
1061 if (fs_ep.nFrames == 0) {
1062 xfer->error = USB_ERR_INVAL;
1065 error = copyin(fs_ep.ppBuffer,
1066 &uaddr, sizeof(uaddr));
1070 /* reset first frame */
1071 usb2_set_frame_offset(xfer, 0, 0);
1073 if (xfer->flags_int.control_xfr) {
1075 req = xfer->frbuffers[0].buffer;
1077 error = copyin(fs_ep.pLength,
1078 &length, sizeof(length));
1082 if (length >= sizeof(*req)) {
1083 xfer->error = USB_ERR_INVAL;
1087 error = copyin(uaddr, req, length);
1092 if (ugen_check_request(f->udev, req)) {
1093 xfer->error = USB_ERR_INVAL;
1096 xfer->frlengths[0] = length;
1098 /* Host mode only ! */
1099 if ((req->bmRequestType &
1100 (UT_READ | UT_WRITE)) == UT_READ) {
1106 offset = sizeof(*req);
1109 /* Device and Host mode */
1110 if (USB_GET_DATA_ISREAD(xfer)) {
1119 rem = xfer->max_data_length;
1120 xfer->nframes = fs_ep.nFrames;
1121 xfer->timeout = fs_ep.timeout;
1122 if (xfer->timeout > 65535) {
1123 xfer->timeout = 65535;
1125 if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
1126 xfer->flags.short_xfer_ok = 1;
1128 xfer->flags.short_xfer_ok = 0;
1130 if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
1131 xfer->flags.short_frames_ok = 1;
1133 xfer->flags.short_frames_ok = 0;
1135 if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
1136 xfer->flags.force_short_xfer = 1;
1138 xfer->flags.force_short_xfer = 0;
1140 if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
1141 xfer->flags.stall_pipe = 1;
1143 xfer->flags.stall_pipe = 0;
1145 for (; n != xfer->nframes; n++) {
1147 error = copyin(fs_ep.pLength + n,
1148 &length, sizeof(length));
1152 xfer->frlengths[n] = length;
1155 xfer->error = USB_ERR_INVAL;
1162 /* we need to know the source buffer */
1163 error = copyin(fs_ep.ppBuffer + n,
1164 &uaddr, sizeof(uaddr));
1168 if (xfer->flags_int.isochronous_xfr) {
1169 /* get kernel buffer address */
1170 kaddr = xfer->frbuffers[0].buffer;
1171 kaddr = USB_ADD_BYTES(kaddr, offset);
1173 /* set current frame offset */
1174 usb2_set_frame_offset(xfer, offset, n);
1176 /* get kernel buffer address */
1177 kaddr = xfer->frbuffers[n].buffer;
1181 error = copyin(uaddr, kaddr, length);
1191 mtx_lock(f->priv_mtx);
1192 ugen_fs_set_complete(f, ep_index);
1193 mtx_unlock(f->priv_mtx);
1198 ugen_fs_copy_out(struct usb2_fifo *f, uint8_t ep_index)
1200 struct usb2_device_request *req;
1201 struct usb2_xfer *xfer;
1202 struct usb2_fs_endpoint fs_ep;
1203 struct usb2_fs_endpoint *fs_ep_uptr; /* userland ptr */
1204 void *uaddr; /* userland ptr */
1206 usb2_frlength_t offset;
1207 usb2_frlength_t rem;
1214 if (ep_index >= f->fs_ep_max)
1217 xfer = f->fs_xfer[ep_index];
1221 mtx_lock(f->priv_mtx);
1222 if (usb2_transfer_pending(xfer)) {
1223 mtx_unlock(f->priv_mtx);
1224 return (EBUSY); /* should not happen */
1226 mtx_unlock(f->priv_mtx);
1228 fs_ep_uptr = f->fs_ep_ptr + ep_index;
1229 error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
1233 fs_ep.status = xfer->error;
1234 fs_ep.aFrames = xfer->aframes;
1235 fs_ep.isoc_time_complete = xfer->isoc_time_complete;
1239 if (xfer->flags_int.control_xfr) {
1240 req = xfer->frbuffers[0].buffer;
1242 /* Host mode only ! */
1243 if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
1248 if (xfer->nframes == 0)
1249 n = 0; /* should never happen */
1253 /* Device and Host mode */
1254 if (USB_GET_DATA_ISREAD(xfer)) {
1262 /* Update lengths and copy out data */
1264 rem = xfer->max_data_length;
1267 for (; n != xfer->nframes; n++) {
1269 /* get initial length into "temp" */
1270 error = copyin(fs_ep.pLength + n,
1271 &temp, sizeof(temp));
1276 /* the userland length has been corrupted */
1277 DPRINTF("corrupt userland length "
1278 "%u > %u\n", temp, rem);
1279 fs_ep.status = USB_ERR_INVAL;
1284 /* get actual transfer length */
1285 length = xfer->frlengths[n];
1286 if (length > temp) {
1288 fs_ep.status = USB_ERR_INVAL;
1289 DPRINTF("data overflow %u > %u\n",
1295 /* we need to know the destination buffer */
1296 error = copyin(fs_ep.ppBuffer + n,
1297 &uaddr, sizeof(uaddr));
1301 if (xfer->flags_int.isochronous_xfr) {
1302 /* only one frame buffer */
1303 kaddr = USB_ADD_BYTES(
1304 xfer->frbuffers[0].buffer, offset);
1306 /* multiple frame buffers */
1307 kaddr = xfer->frbuffers[n].buffer;
1311 error = copyout(kaddr, uaddr, length);
1317 * Update offset according to initial length, which is
1318 * needed by isochronous transfers!
1323 error = copyout(&length,
1324 fs_ep.pLength + n, sizeof(length));
1331 /* update "aFrames" */
1332 error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames,
1333 sizeof(fs_ep.aFrames));
1337 /* update "isoc_time_complete" */
1338 error = copyout(&fs_ep.isoc_time_complete,
1339 &fs_ep_uptr->isoc_time_complete,
1340 sizeof(fs_ep.isoc_time_complete));
1343 /* update "status" */
1344 error = copyout(&fs_ep.status, &fs_ep_uptr->status,
1345 sizeof(fs_ep.status));
1351 ugen_fifo_in_use(struct usb2_fifo *f, int fflags)
1353 struct usb2_fifo *f_rx;
1354 struct usb2_fifo *f_tx;
1356 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1357 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1359 if ((fflags & FREAD) && f_rx &&
1360 (f_rx->xfer[0] || f_rx->xfer[1])) {
1361 return (1); /* RX FIFO in use */
1363 if ((fflags & FWRITE) && f_tx &&
1364 (f_tx->xfer[0] || f_tx->xfer[1])) {
1365 return (1); /* TX FIFO in use */
1367 return (0); /* not in use */
1371 ugen_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1373 struct usb2_config usb2_config[1];
1374 struct usb2_device_request req;
1376 struct usb2_fs_complete *pcomp;
1377 struct usb2_fs_start *pstart;
1378 struct usb2_fs_stop *pstop;
1379 struct usb2_fs_open *popen;
1380 struct usb2_fs_close *pclose;
1381 struct usb2_fs_clear_stall_sync *pstall;
1384 struct usb2_pipe *pipe;
1385 struct usb2_endpoint_descriptor *ed;
1387 uint8_t iface_index;
1393 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1396 case USB_FS_COMPLETE:
1397 mtx_lock(f->priv_mtx);
1398 error = ugen_fs_get_complete(f, &ep_index);
1399 mtx_unlock(f->priv_mtx);
1405 u.pcomp->ep_index = ep_index;
1406 error = ugen_fs_copy_out(f, u.pcomp->ep_index);
1410 error = ugen_fs_copy_in(f, u.pstart->ep_index);
1414 mtx_lock(f->priv_mtx);
1415 usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]);
1416 mtx_unlock(f->priv_mtx);
1420 if (u.pstop->ep_index >= f->fs_ep_max) {
1424 mtx_lock(f->priv_mtx);
1425 usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
1426 mtx_unlock(f->priv_mtx);
1430 if (u.popen->ep_index >= f->fs_ep_max) {
1434 if (f->fs_xfer[u.popen->ep_index] != NULL) {
1438 if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) {
1439 u.popen->max_bufsize = USB_FS_MAX_BUFSIZE;
1441 if (u.popen->max_frames > USB_FS_MAX_FRAMES) {
1442 u.popen->max_frames = USB_FS_MAX_FRAMES;
1445 if (u.popen->max_frames == 0) {
1449 pipe = usb2_get_pipe_by_addr(f->udev, u.popen->ep_no);
1459 iface_index = pipe->iface_index;
1461 bzero(usb2_config, sizeof(usb2_config));
1463 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
1464 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
1465 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
1466 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL;
1467 usb2_config[0].mh.flags.proxy_buffer = 1;
1468 usb2_config[0].mh.callback = &ugen_default_fs_callback;
1469 usb2_config[0].mh.timeout = 0; /* no timeout */
1470 usb2_config[0].mh.frames = u.popen->max_frames;
1471 usb2_config[0].mh.bufsize = u.popen->max_bufsize;
1472 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */
1474 if (usb2_config[0].type == UE_CONTROL) {
1475 if (f->udev->flags.usb2_mode != USB_MODE_HOST) {
1481 isread = ((usb2_config[0].endpoint &
1482 (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
1484 if (f->udev->flags.usb2_mode != USB_MODE_HOST) {
1487 /* check permissions */
1489 if (!(fflags & FREAD)) {
1494 if (!(fflags & FWRITE)) {
1500 error = usb2_transfer_setup(f->udev, &iface_index,
1501 f->fs_xfer + u.popen->ep_index, usb2_config, 1,
1504 /* update maximums */
1505 u.popen->max_packet_length =
1506 f->fs_xfer[u.popen->ep_index]->max_frame_size;
1507 u.popen->max_bufsize =
1508 f->fs_xfer[u.popen->ep_index]->max_data_length;
1509 f->fs_xfer[u.popen->ep_index]->priv_fifo =
1510 ((uint8_t *)0) + u.popen->ep_index;
1517 if (u.pclose->ep_index >= f->fs_ep_max) {
1521 if (f->fs_xfer[u.pclose->ep_index] == NULL) {
1525 usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
1528 case USB_FS_CLEAR_STALL_SYNC:
1529 if (u.pstall->ep_index >= f->fs_ep_max) {
1533 if (f->fs_xfer[u.pstall->ep_index] == NULL) {
1537 if (f->udev->flags.usb2_mode != USB_MODE_HOST) {
1541 mtx_lock(f->priv_mtx);
1542 error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
1543 mtx_unlock(f->priv_mtx);
1548 pipe = f->fs_xfer[u.pstall->ep_index]->pipe;
1550 /* setup a clear-stall packet */
1551 req.bmRequestType = UT_WRITE_ENDPOINT;
1552 req.bRequest = UR_CLEAR_FEATURE;
1553 USETW(req.wValue, UF_ENDPOINT_HALT);
1554 req.wIndex[0] = pipe->edesc->bEndpointAddress;
1556 USETW(req.wLength, 0);
1558 error = usb2_do_request(f->udev, NULL, &req, NULL);
1560 usb2_clear_data_toggle(f->udev, pipe);
1571 DPRINTFN(6, "error=%d\n", error);
1577 ugen_set_short_xfer(struct usb2_fifo *f, void *addr)
1586 if (f->flag_short == t) {
1587 /* same value like before - accept */
1590 if (f->xfer[0] || f->xfer[1]) {
1591 /* cannot change this during transfer */
1599 ugen_set_timeout(struct usb2_fifo *f, void *addr)
1601 f->timeout = *(int *)addr;
1602 if (f->timeout > 65535) {
1603 /* limit user input */
1610 ugen_get_frame_size(struct usb2_fifo *f, void *addr)
1613 *(int *)addr = f->xfer[0]->max_frame_size;
1621 ugen_set_buffer_size(struct usb2_fifo *f, void *addr)
1625 if (*(int *)addr < 0)
1626 t = 0; /* use "wMaxPacketSize" */
1627 else if (*(int *)addr < (256 * 1024))
1632 if (f->bufsize == t) {
1633 /* same value like before - accept */
1636 if (f->xfer[0] || f->xfer[1]) {
1637 /* cannot change this during transfer */
1645 ugen_get_buffer_size(struct usb2_fifo *f, void *addr)
1647 *(int *)addr = f->bufsize;
1652 ugen_get_iface_desc(struct usb2_fifo *f,
1653 struct usb2_interface_descriptor *idesc)
1655 struct usb2_interface *iface;
1657 iface = usb2_get_iface(f->udev, f->iface_index);
1658 if (iface && iface->idesc) {
1659 *idesc = *(iface->idesc);
1667 ugen_get_endpoint_desc(struct usb2_fifo *f,
1668 struct usb2_endpoint_descriptor *ed)
1670 struct usb2_pipe *pipe;
1674 if (pipe && pipe->edesc) {
1683 ugen_set_power_mode(struct usb2_fifo *f, int mode)
1685 struct usb2_device *udev = f->udev;
1689 if ((udev == NULL) ||
1690 (udev->parent_hub == NULL)) {
1693 err = priv_check(curthread, PRIV_DRIVER);
1697 /* get old power mode */
1698 old_mode = udev->power_mode;
1700 /* if no change, then just return */
1701 if (old_mode == mode)
1705 case USB_POWER_MODE_OFF:
1706 /* get the device unconfigured */
1707 err = ugen_set_config(f, USB_UNCONFIG_INDEX);
1709 DPRINTFN(0, "Could not unconfigure "
1710 "device (ignored)\n");
1713 /* clear port enable */
1714 err = usb2_req_clear_port_feature(udev->parent_hub,
1715 NULL, udev->port_no, UHF_PORT_ENABLE);
1718 case USB_POWER_MODE_ON:
1719 case USB_POWER_MODE_SAVE:
1722 case USB_POWER_MODE_RESUME:
1723 err = usb2_req_clear_port_feature(udev->parent_hub,
1724 NULL, udev->port_no, UHF_PORT_SUSPEND);
1725 mode = USB_POWER_MODE_SAVE;
1728 case USB_POWER_MODE_SUSPEND:
1729 err = usb2_req_set_port_feature(udev->parent_hub,
1730 NULL, udev->port_no, UHF_PORT_SUSPEND);
1731 mode = USB_POWER_MODE_SAVE;
1739 return (ENXIO); /* I/O failure */
1741 /* if we are powered off we need to re-enumerate first */
1742 if (old_mode == USB_POWER_MODE_OFF) {
1743 err = ugen_re_enumerate(f);
1748 /* set new power mode */
1749 usb2_set_power_mode(udev, mode);
1751 return (0); /* success */
1755 ugen_get_power_mode(struct usb2_fifo *f)
1757 struct usb2_device *udev = f->udev;
1759 if ((udev == NULL) ||
1760 (udev->parent_hub == NULL)) {
1761 return (USB_POWER_MODE_ON);
1763 return (udev->power_mode);
1767 ugen_do_port_feature(struct usb2_fifo *f, uint8_t port_no,
1768 uint8_t set, uint16_t feature)
1770 struct usb2_device *udev = f->udev;
1771 struct usb2_hub *hub;
1774 err = priv_check(curthread, PRIV_DRIVER);
1781 if ((udev == NULL) ||
1782 (udev->hub == NULL)) {
1787 if (port_no > hub->nports) {
1791 err = usb2_req_set_port_feature(udev,
1792 NULL, port_no, feature);
1794 err = usb2_req_clear_port_feature(udev,
1795 NULL, port_no, feature);
1798 return (ENXIO); /* failure */
1800 return (0); /* success */
1804 ugen_iface_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1806 struct usb2_fifo *f_rx;
1807 struct usb2_fifo *f_tx;
1810 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1811 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1814 case USB_SET_RX_SHORT_XFER:
1815 if (fflags & FREAD) {
1816 error = ugen_set_short_xfer(f_rx, addr);
1822 case USB_SET_TX_FORCE_SHORT:
1823 if (fflags & FWRITE) {
1824 error = ugen_set_short_xfer(f_tx, addr);
1830 case USB_SET_RX_TIMEOUT:
1831 if (fflags & FREAD) {
1832 error = ugen_set_timeout(f_rx, addr);
1838 case USB_SET_TX_TIMEOUT:
1839 if (fflags & FWRITE) {
1840 error = ugen_set_timeout(f_tx, addr);
1846 case USB_GET_RX_FRAME_SIZE:
1847 if (fflags & FREAD) {
1848 error = ugen_get_frame_size(f_rx, addr);
1854 case USB_GET_TX_FRAME_SIZE:
1855 if (fflags & FWRITE) {
1856 error = ugen_get_frame_size(f_tx, addr);
1862 case USB_SET_RX_BUFFER_SIZE:
1863 if (fflags & FREAD) {
1864 error = ugen_set_buffer_size(f_rx, addr);
1870 case USB_SET_TX_BUFFER_SIZE:
1871 if (fflags & FWRITE) {
1872 error = ugen_set_buffer_size(f_tx, addr);
1878 case USB_GET_RX_BUFFER_SIZE:
1879 if (fflags & FREAD) {
1880 error = ugen_get_buffer_size(f_rx, addr);
1886 case USB_GET_TX_BUFFER_SIZE:
1887 if (fflags & FWRITE) {
1888 error = ugen_get_buffer_size(f_tx, addr);
1894 case USB_GET_RX_INTERFACE_DESC:
1895 if (fflags & FREAD) {
1896 error = ugen_get_iface_desc(f_rx, addr);
1902 case USB_GET_TX_INTERFACE_DESC:
1903 if (fflags & FWRITE) {
1904 error = ugen_get_iface_desc(f_tx, addr);
1910 case USB_GET_RX_ENDPOINT_DESC:
1911 if (fflags & FREAD) {
1912 error = ugen_get_endpoint_desc(f_rx, addr);
1918 case USB_GET_TX_ENDPOINT_DESC:
1919 if (fflags & FWRITE) {
1920 error = ugen_get_endpoint_desc(f_tx, addr);
1926 case USB_SET_RX_STALL_FLAG:
1927 if ((fflags & FREAD) && (*(int *)addr)) {
1928 f_rx->flag_stall = 1;
1932 case USB_SET_TX_STALL_FLAG:
1933 if ((fflags & FWRITE) && (*(int *)addr)) {
1934 f_tx->flag_stall = 1;
1946 ugen_ioctl_post(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1949 struct usb2_interface_descriptor *idesc;
1950 struct usb2_alt_interface *ai;
1951 struct usb2_device_descriptor *ddesc;
1952 struct usb2_config_descriptor *cdesc;
1953 struct usb2_device_stats *stat;
1954 struct usb2_fs_init *pinit;
1955 struct usb2_fs_uninit *puninit;
1960 struct usb2_device_descriptor *dtemp;
1961 struct usb2_config_descriptor *ctemp;
1962 struct usb2_interface *iface;
1968 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1972 usb2_needs_explore_all();
1976 if (!(fflags & FWRITE)) {
1980 usb2_debug = *(int *)addr;
1983 case USB_GET_CONFIG:
1984 *(int *)addr = f->udev->curr_config_index;
1987 case USB_SET_CONFIG:
1988 if (!(fflags & FWRITE)) {
1992 error = ugen_set_config(f, *(int *)addr);
1995 case USB_GET_ALTINTERFACE:
1996 iface = usb2_get_iface(f->udev,
1997 u.ai->uai_interface_index);
1998 if (iface && iface->idesc) {
1999 u.ai->uai_alt_index = iface->alt_index;
2005 case USB_SET_ALTINTERFACE:
2006 if (!(fflags & FWRITE)) {
2010 error = ugen_set_interface(f,
2011 u.ai->uai_interface_index, u.ai->uai_alt_index);
2014 case USB_GET_DEVICE_DESC:
2015 dtemp = usb2_get_device_descriptor(f->udev);
2023 case USB_GET_CONFIG_DESC:
2024 ctemp = usb2_get_config_descriptor(f->udev);
2032 case USB_GET_FULL_DESC:
2033 error = ugen_get_cdesc(f, addr);
2036 case USB_GET_STRING_DESC:
2037 error = ugen_get_sdesc(f, addr);
2040 case USB_GET_IFACE_DRIVER:
2041 error = ugen_get_iface_driver(f, addr);
2045 case USB_DO_REQUEST:
2046 if (!(fflags & FWRITE)) {
2050 error = ugen_do_request(f, addr);
2053 case USB_DEVICEINFO:
2054 case USB_GET_DEVICEINFO:
2055 error = usb2_gen_fill_deviceinfo(f, addr);
2058 case USB_DEVICESTATS:
2059 for (n = 0; n != 4; n++) {
2061 u.stat->uds_requests_fail[n] =
2062 f->udev->bus->stats_err.uds_requests[n];
2064 u.stat->uds_requests_ok[n] =
2065 f->udev->bus->stats_ok.uds_requests[n];
2069 case USB_DEVICEENUMERATE:
2070 error = ugen_re_enumerate(f);
2073 case USB_GET_PLUGTIME:
2074 *u.ptime = f->udev->plugtime;
2077 case USB_CLAIM_INTERFACE:
2078 case USB_RELEASE_INTERFACE:
2082 case USB_IFACE_DRIVER_ACTIVE:
2087 case USB_IFACE_DRIVER_DETACH:
2089 error = priv_check(curthread, PRIV_DRIVER);
2096 case USB_SET_POWER_MODE:
2097 error = ugen_set_power_mode(f, *u.pint);
2100 case USB_GET_POWER_MODE:
2101 *u.pint = ugen_get_power_mode(f);
2104 case USB_SET_PORT_ENABLE:
2105 error = ugen_do_port_feature(f,
2106 *u.pint, 1, UHF_PORT_ENABLE);
2109 case USB_SET_PORT_DISABLE:
2110 error = ugen_do_port_feature(f,
2111 *u.pint, 0, UHF_PORT_ENABLE);
2115 /* verify input parameters */
2116 if (u.pinit->pEndpoints == NULL) {
2120 if (u.pinit->ep_index_max > 127) {
2124 if (u.pinit->ep_index_max == 0) {
2128 if (f->fs_xfer != NULL) {
2132 if (f->dev_ep_index != 0) {
2136 if (ugen_fifo_in_use(f, fflags)) {
2140 error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
2144 f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) *
2145 u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO);
2146 if (f->fs_xfer == NULL) {
2147 usb2_fifo_free_buffer(f);
2151 f->fs_ep_max = u.pinit->ep_index_max;
2152 f->fs_ep_ptr = u.pinit->pEndpoints;
2156 if (u.puninit->dummy != 0) {
2160 error = ugen_fs_uninit(f);
2164 mtx_lock(f->priv_mtx);
2165 error = ugen_iface_ioctl(f, cmd, addr, fflags);
2166 mtx_unlock(f->priv_mtx);
2169 DPRINTFN(6, "error=%d\n", error);
2174 ugen_default_fs_callback(struct usb2_xfer *xfer)
2176 ; /* workaround for a bug in "indent" */
2178 DPRINTF("st=%u alen=%u aframes=%u\n",
2179 USB_GET_STATE(xfer), xfer->actlen, xfer->aframes);
2181 switch (USB_GET_STATE(xfer)) {
2183 usb2_start_hardware(xfer);
2186 ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
2190 #endif /* USB_HAVE_UGEN */