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_usb, OID_AUTO, ugen, CTLFLAG_RW, 0, "USB generic");
109 SYSCTL_INT(_hw_usb_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].timeout = 1000; /* 1 second */
226 usb2_config[1].interval = 50;/* 50 milliseconds */
227 usb2_config[1].bufsize = sizeof(struct usb2_device_request);
228 usb2_config[1].callback = &ugen_write_clear_stall_callback;
229 usb2_config[1].usb_mode = USB_MODE_HOST;
231 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
232 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
233 usb2_config[0].direction = UE_DIR_TX;
234 usb2_config[0].interval = USB_DEFAULT_INTERVAL;
235 usb2_config[0].flags.proxy_buffer = 1;
236 usb2_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
238 switch (ed->bmAttributes & UE_XFERTYPE) {
242 usb2_config[0].flags.force_short_xfer = 1;
244 usb2_config[0].callback = &ugen_default_write_callback;
245 usb2_config[0].timeout = f->timeout;
246 usb2_config[0].frames = 1;
247 usb2_config[0].bufsize = f->bufsize;
248 if (ugen_transfer_setup(f, usb2_config, 2)) {
251 /* first transfer does not clear stall */
256 usb2_config[0].flags.short_xfer_ok = 1;
257 usb2_config[0].bufsize = 0; /* use default */
258 usb2_config[0].frames = f->nframes;
259 usb2_config[0].callback = &ugen_isoc_write_callback;
260 usb2_config[0].timeout = 0;
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].timeout = 1000; /* 1 second */
294 usb2_config[1].interval = 50;/* 50 milliseconds */
295 usb2_config[1].bufsize = sizeof(struct usb2_device_request);
296 usb2_config[1].callback = &ugen_read_clear_stall_callback;
297 usb2_config[1].usb_mode = USB_MODE_HOST;
299 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
300 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
301 usb2_config[0].direction = UE_DIR_RX;
302 usb2_config[0].interval = USB_DEFAULT_INTERVAL;
303 usb2_config[0].flags.proxy_buffer = 1;
304 usb2_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
306 switch (ed->bmAttributes & UE_XFERTYPE) {
310 usb2_config[0].flags.short_xfer_ok = 1;
312 usb2_config[0].timeout = f->timeout;
313 usb2_config[0].frames = 1;
314 usb2_config[0].callback = &ugen_default_read_callback;
315 usb2_config[0].bufsize = f->bufsize;
317 if (ugen_transfer_setup(f, usb2_config, 2)) {
320 /* first transfer does not clear stall */
325 usb2_config[0].flags.short_xfer_ok = 1;
326 usb2_config[0].bufsize = 0; /* use default */
327 usb2_config[0].frames = f->nframes;
328 usb2_config[0].callback = &ugen_isoc_read_callback;
329 usb2_config[0].timeout = 0;
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.usb_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.usb_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.usb_mode;
825 di->udi_power_mode = udev->power_mode;
826 di->udi_suspended = udev->flags.peer_suspended;
828 hub = udev->parent_hub;
830 di->udi_hubaddr = hub->address;
831 di->udi_hubindex = hub->device_index;
832 di->udi_hubport = udev->port_no;
837 /*------------------------------------------------------------------------*
843 *------------------------------------------------------------------------*/
845 ugen_check_request(struct usb2_device *udev, struct usb2_device_request *req)
847 struct usb2_pipe *pipe;
851 * Avoid requests that would damage the bus integrity:
853 if (((req->bmRequestType == UT_WRITE_DEVICE) &&
854 (req->bRequest == UR_SET_ADDRESS)) ||
855 ((req->bmRequestType == UT_WRITE_DEVICE) &&
856 (req->bRequest == UR_SET_CONFIG)) ||
857 ((req->bmRequestType == UT_WRITE_INTERFACE) &&
858 (req->bRequest == UR_SET_INTERFACE))) {
860 * These requests can be useful for testing USB drivers.
862 error = priv_check(curthread, PRIV_DRIVER);
868 * Special case - handle clearing of stall
870 if (req->bmRequestType == UT_WRITE_ENDPOINT) {
872 pipe = usb2_get_pipe_by_addr(udev, req->wIndex[0]);
876 if ((req->bRequest == UR_CLEAR_FEATURE) &&
877 (UGETW(req->wValue) == UF_ENDPOINT_HALT)) {
878 usb2_clear_data_toggle(udev, pipe);
881 /* TODO: add more checks to verify the interface index */
887 ugen_do_request(struct usb2_fifo *f, struct usb2_ctl_request *ur)
893 if (ugen_check_request(f->udev, &ur->ucr_request)) {
896 len = UGETW(ur->ucr_request.wLength);
898 /* check if "ucr_data" is valid */
900 if (ur->ucr_data == NULL) {
904 /* do the USB request */
905 error = usb2_do_request_flags
906 (f->udev, NULL, &ur->ucr_request, ur->ucr_data,
907 (ur->ucr_flags & USB_SHORT_XFER_OK) |
908 USB_USER_DATA_PTR, &actlen,
909 USB_DEFAULT_TIMEOUT);
911 ur->ucr_actlen = actlen;
919 /*------------------------------------------------------------------------
921 *------------------------------------------------------------------------*/
923 ugen_re_enumerate(struct usb2_fifo *f)
925 struct usb2_device *udev = f->udev;
929 * This request can be useful for testing USB drivers:
931 error = priv_check(curthread, PRIV_DRIVER);
935 /* get the device unconfigured */
936 error = ugen_set_config(f, USB_UNCONFIG_INDEX);
941 mtx_lock(f->priv_mtx);
942 error = usb2_req_re_enumerate(udev, f->priv_mtx);
943 mtx_unlock(f->priv_mtx);
948 /* restore configuration to index 0 */
949 error = ugen_set_config(f, 0);
957 ugen_fs_uninit(struct usb2_fifo *f)
959 if (f->fs_xfer == NULL) {
962 usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max);
963 free(f->fs_xfer, M_USB);
967 f->flag_iscomplete = 0;
968 usb2_fifo_free_buffer(f);
973 ugen_fs_get_complete(struct usb2_fifo *f, uint8_t *pindex)
977 USB_IF_DEQUEUE(&f->used_q, m);
980 *pindex = *((uint8_t *)(m->cur_data_ptr));
982 USB_IF_ENQUEUE(&f->free_q, m);
984 return (0); /* success */
987 *pindex = 0; /* fix compiler warning */
989 f->flag_iscomplete = 0;
991 return (1); /* failure */
995 ugen_fs_set_complete(struct usb2_fifo *f, uint8_t index)
999 USB_IF_DEQUEUE(&f->free_q, m);
1002 /* can happen during close */
1003 DPRINTF("out of buffers\n");
1008 *((uint8_t *)(m->cur_data_ptr)) = index;
1010 USB_IF_ENQUEUE(&f->used_q, m);
1012 f->flag_iscomplete = 1;
1014 usb2_fifo_wakeup(f);
1018 ugen_fs_copy_in(struct usb2_fifo *f, uint8_t ep_index)
1020 struct usb2_device_request *req;
1021 struct usb2_xfer *xfer;
1022 struct usb2_fs_endpoint fs_ep;
1023 void *uaddr; /* userland pointer */
1025 usb2_frlength_t offset;
1026 usb2_frlength_t rem;
1032 if (ep_index >= f->fs_ep_max) {
1035 xfer = f->fs_xfer[ep_index];
1039 mtx_lock(f->priv_mtx);
1040 if (usb2_transfer_pending(xfer)) {
1041 mtx_unlock(f->priv_mtx);
1042 return (EBUSY); /* should not happen */
1044 mtx_unlock(f->priv_mtx);
1046 error = copyin(f->fs_ep_ptr +
1047 ep_index, &fs_ep, sizeof(fs_ep));
1051 /* security checks */
1053 if (fs_ep.nFrames > xfer->max_frame_count) {
1054 xfer->error = USB_ERR_INVAL;
1057 if (fs_ep.nFrames == 0) {
1058 xfer->error = USB_ERR_INVAL;
1061 error = copyin(fs_ep.ppBuffer,
1062 &uaddr, sizeof(uaddr));
1066 /* reset first frame */
1067 usb2_set_frame_offset(xfer, 0, 0);
1069 if (xfer->flags_int.control_xfr) {
1071 req = xfer->frbuffers[0].buffer;
1073 error = copyin(fs_ep.pLength,
1074 &length, sizeof(length));
1078 if (length >= sizeof(*req)) {
1079 xfer->error = USB_ERR_INVAL;
1083 error = copyin(uaddr, req, length);
1088 if (ugen_check_request(f->udev, req)) {
1089 xfer->error = USB_ERR_INVAL;
1092 xfer->frlengths[0] = length;
1094 /* Host mode only ! */
1095 if ((req->bmRequestType &
1096 (UT_READ | UT_WRITE)) == UT_READ) {
1102 offset = sizeof(*req);
1105 /* Device and Host mode */
1106 if (USB_GET_DATA_ISREAD(xfer)) {
1115 rem = xfer->max_data_length;
1116 xfer->nframes = fs_ep.nFrames;
1117 xfer->timeout = fs_ep.timeout;
1118 if (xfer->timeout > 65535) {
1119 xfer->timeout = 65535;
1121 if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
1122 xfer->flags.short_xfer_ok = 1;
1124 xfer->flags.short_xfer_ok = 0;
1126 if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
1127 xfer->flags.short_frames_ok = 1;
1129 xfer->flags.short_frames_ok = 0;
1131 if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
1132 xfer->flags.force_short_xfer = 1;
1134 xfer->flags.force_short_xfer = 0;
1136 if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
1137 xfer->flags.stall_pipe = 1;
1139 xfer->flags.stall_pipe = 0;
1141 for (; n != xfer->nframes; n++) {
1143 error = copyin(fs_ep.pLength + n,
1144 &length, sizeof(length));
1148 xfer->frlengths[n] = length;
1151 xfer->error = USB_ERR_INVAL;
1158 /* we need to know the source buffer */
1159 error = copyin(fs_ep.ppBuffer + n,
1160 &uaddr, sizeof(uaddr));
1164 if (xfer->flags_int.isochronous_xfr) {
1165 /* get kernel buffer address */
1166 kaddr = xfer->frbuffers[0].buffer;
1167 kaddr = USB_ADD_BYTES(kaddr, offset);
1169 /* set current frame offset */
1170 usb2_set_frame_offset(xfer, offset, n);
1172 /* get kernel buffer address */
1173 kaddr = xfer->frbuffers[n].buffer;
1177 error = copyin(uaddr, kaddr, length);
1187 mtx_lock(f->priv_mtx);
1188 ugen_fs_set_complete(f, ep_index);
1189 mtx_unlock(f->priv_mtx);
1194 ugen_fs_copy_out(struct usb2_fifo *f, uint8_t ep_index)
1196 struct usb2_device_request *req;
1197 struct usb2_xfer *xfer;
1198 struct usb2_fs_endpoint fs_ep;
1199 struct usb2_fs_endpoint *fs_ep_uptr; /* userland ptr */
1200 void *uaddr; /* userland ptr */
1202 usb2_frlength_t offset;
1203 usb2_frlength_t rem;
1210 if (ep_index >= f->fs_ep_max)
1213 xfer = f->fs_xfer[ep_index];
1217 mtx_lock(f->priv_mtx);
1218 if (usb2_transfer_pending(xfer)) {
1219 mtx_unlock(f->priv_mtx);
1220 return (EBUSY); /* should not happen */
1222 mtx_unlock(f->priv_mtx);
1224 fs_ep_uptr = f->fs_ep_ptr + ep_index;
1225 error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
1229 fs_ep.status = xfer->error;
1230 fs_ep.aFrames = xfer->aframes;
1231 fs_ep.isoc_time_complete = xfer->isoc_time_complete;
1235 if (xfer->flags_int.control_xfr) {
1236 req = xfer->frbuffers[0].buffer;
1238 /* Host mode only ! */
1239 if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
1244 if (xfer->nframes == 0)
1245 n = 0; /* should never happen */
1249 /* Device and Host mode */
1250 if (USB_GET_DATA_ISREAD(xfer)) {
1258 /* Update lengths and copy out data */
1260 rem = xfer->max_data_length;
1263 for (; n != xfer->nframes; n++) {
1265 /* get initial length into "temp" */
1266 error = copyin(fs_ep.pLength + n,
1267 &temp, sizeof(temp));
1272 /* the userland length has been corrupted */
1273 DPRINTF("corrupt userland length "
1274 "%u > %u\n", temp, rem);
1275 fs_ep.status = USB_ERR_INVAL;
1280 /* get actual transfer length */
1281 length = xfer->frlengths[n];
1282 if (length > temp) {
1284 fs_ep.status = USB_ERR_INVAL;
1285 DPRINTF("data overflow %u > %u\n",
1291 /* we need to know the destination buffer */
1292 error = copyin(fs_ep.ppBuffer + n,
1293 &uaddr, sizeof(uaddr));
1297 if (xfer->flags_int.isochronous_xfr) {
1298 /* only one frame buffer */
1299 kaddr = USB_ADD_BYTES(
1300 xfer->frbuffers[0].buffer, offset);
1302 /* multiple frame buffers */
1303 kaddr = xfer->frbuffers[n].buffer;
1307 error = copyout(kaddr, uaddr, length);
1313 * Update offset according to initial length, which is
1314 * needed by isochronous transfers!
1319 error = copyout(&length,
1320 fs_ep.pLength + n, sizeof(length));
1327 /* update "aFrames" */
1328 error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames,
1329 sizeof(fs_ep.aFrames));
1333 /* update "isoc_time_complete" */
1334 error = copyout(&fs_ep.isoc_time_complete,
1335 &fs_ep_uptr->isoc_time_complete,
1336 sizeof(fs_ep.isoc_time_complete));
1339 /* update "status" */
1340 error = copyout(&fs_ep.status, &fs_ep_uptr->status,
1341 sizeof(fs_ep.status));
1347 ugen_fifo_in_use(struct usb2_fifo *f, int fflags)
1349 struct usb2_fifo *f_rx;
1350 struct usb2_fifo *f_tx;
1352 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1353 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1355 if ((fflags & FREAD) && f_rx &&
1356 (f_rx->xfer[0] || f_rx->xfer[1])) {
1357 return (1); /* RX FIFO in use */
1359 if ((fflags & FWRITE) && f_tx &&
1360 (f_tx->xfer[0] || f_tx->xfer[1])) {
1361 return (1); /* TX FIFO in use */
1363 return (0); /* not in use */
1367 ugen_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1369 struct usb2_config usb2_config[1];
1370 struct usb2_device_request req;
1372 struct usb2_fs_complete *pcomp;
1373 struct usb2_fs_start *pstart;
1374 struct usb2_fs_stop *pstop;
1375 struct usb2_fs_open *popen;
1376 struct usb2_fs_close *pclose;
1377 struct usb2_fs_clear_stall_sync *pstall;
1380 struct usb2_pipe *pipe;
1381 struct usb2_endpoint_descriptor *ed;
1383 uint8_t iface_index;
1389 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1392 case USB_FS_COMPLETE:
1393 mtx_lock(f->priv_mtx);
1394 error = ugen_fs_get_complete(f, &ep_index);
1395 mtx_unlock(f->priv_mtx);
1401 u.pcomp->ep_index = ep_index;
1402 error = ugen_fs_copy_out(f, u.pcomp->ep_index);
1406 error = ugen_fs_copy_in(f, u.pstart->ep_index);
1410 mtx_lock(f->priv_mtx);
1411 usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]);
1412 mtx_unlock(f->priv_mtx);
1416 if (u.pstop->ep_index >= f->fs_ep_max) {
1420 mtx_lock(f->priv_mtx);
1421 usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
1422 mtx_unlock(f->priv_mtx);
1426 if (u.popen->ep_index >= f->fs_ep_max) {
1430 if (f->fs_xfer[u.popen->ep_index] != NULL) {
1434 if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) {
1435 u.popen->max_bufsize = USB_FS_MAX_BUFSIZE;
1437 if (u.popen->max_frames > USB_FS_MAX_FRAMES) {
1438 u.popen->max_frames = USB_FS_MAX_FRAMES;
1441 if (u.popen->max_frames == 0) {
1445 pipe = usb2_get_pipe_by_addr(f->udev, u.popen->ep_no);
1455 iface_index = pipe->iface_index;
1457 bzero(usb2_config, sizeof(usb2_config));
1459 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
1460 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
1461 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
1462 usb2_config[0].interval = USB_DEFAULT_INTERVAL;
1463 usb2_config[0].flags.proxy_buffer = 1;
1464 usb2_config[0].callback = &ugen_default_fs_callback;
1465 usb2_config[0].timeout = 0; /* no timeout */
1466 usb2_config[0].frames = u.popen->max_frames;
1467 usb2_config[0].bufsize = u.popen->max_bufsize;
1468 usb2_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
1470 if (usb2_config[0].type == UE_CONTROL) {
1471 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1477 isread = ((usb2_config[0].endpoint &
1478 (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
1480 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1483 /* check permissions */
1485 if (!(fflags & FREAD)) {
1490 if (!(fflags & FWRITE)) {
1496 error = usb2_transfer_setup(f->udev, &iface_index,
1497 f->fs_xfer + u.popen->ep_index, usb2_config, 1,
1500 /* update maximums */
1501 u.popen->max_packet_length =
1502 f->fs_xfer[u.popen->ep_index]->max_frame_size;
1503 u.popen->max_bufsize =
1504 f->fs_xfer[u.popen->ep_index]->max_data_length;
1505 f->fs_xfer[u.popen->ep_index]->priv_fifo =
1506 ((uint8_t *)0) + u.popen->ep_index;
1513 if (u.pclose->ep_index >= f->fs_ep_max) {
1517 if (f->fs_xfer[u.pclose->ep_index] == NULL) {
1521 usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
1524 case USB_FS_CLEAR_STALL_SYNC:
1525 if (u.pstall->ep_index >= f->fs_ep_max) {
1529 if (f->fs_xfer[u.pstall->ep_index] == NULL) {
1533 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1537 mtx_lock(f->priv_mtx);
1538 error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
1539 mtx_unlock(f->priv_mtx);
1544 pipe = f->fs_xfer[u.pstall->ep_index]->pipe;
1546 /* setup a clear-stall packet */
1547 req.bmRequestType = UT_WRITE_ENDPOINT;
1548 req.bRequest = UR_CLEAR_FEATURE;
1549 USETW(req.wValue, UF_ENDPOINT_HALT);
1550 req.wIndex[0] = pipe->edesc->bEndpointAddress;
1552 USETW(req.wLength, 0);
1554 error = usb2_do_request(f->udev, NULL, &req, NULL);
1556 usb2_clear_data_toggle(f->udev, pipe);
1567 DPRINTFN(6, "error=%d\n", error);
1573 ugen_set_short_xfer(struct usb2_fifo *f, void *addr)
1582 if (f->flag_short == t) {
1583 /* same value like before - accept */
1586 if (f->xfer[0] || f->xfer[1]) {
1587 /* cannot change this during transfer */
1595 ugen_set_timeout(struct usb2_fifo *f, void *addr)
1597 f->timeout = *(int *)addr;
1598 if (f->timeout > 65535) {
1599 /* limit user input */
1606 ugen_get_frame_size(struct usb2_fifo *f, void *addr)
1609 *(int *)addr = f->xfer[0]->max_frame_size;
1617 ugen_set_buffer_size(struct usb2_fifo *f, void *addr)
1621 if (*(int *)addr < 0)
1622 t = 0; /* use "wMaxPacketSize" */
1623 else if (*(int *)addr < (256 * 1024))
1628 if (f->bufsize == t) {
1629 /* same value like before - accept */
1632 if (f->xfer[0] || f->xfer[1]) {
1633 /* cannot change this during transfer */
1641 ugen_get_buffer_size(struct usb2_fifo *f, void *addr)
1643 *(int *)addr = f->bufsize;
1648 ugen_get_iface_desc(struct usb2_fifo *f,
1649 struct usb2_interface_descriptor *idesc)
1651 struct usb2_interface *iface;
1653 iface = usb2_get_iface(f->udev, f->iface_index);
1654 if (iface && iface->idesc) {
1655 *idesc = *(iface->idesc);
1663 ugen_get_endpoint_desc(struct usb2_fifo *f,
1664 struct usb2_endpoint_descriptor *ed)
1666 struct usb2_pipe *pipe;
1670 if (pipe && pipe->edesc) {
1679 ugen_set_power_mode(struct usb2_fifo *f, int mode)
1681 struct usb2_device *udev = f->udev;
1685 if ((udev == NULL) ||
1686 (udev->parent_hub == NULL)) {
1689 err = priv_check(curthread, PRIV_DRIVER);
1693 /* get old power mode */
1694 old_mode = udev->power_mode;
1696 /* if no change, then just return */
1697 if (old_mode == mode)
1701 case USB_POWER_MODE_OFF:
1702 /* get the device unconfigured */
1703 err = ugen_set_config(f, USB_UNCONFIG_INDEX);
1705 DPRINTFN(0, "Could not unconfigure "
1706 "device (ignored)\n");
1709 /* clear port enable */
1710 err = usb2_req_clear_port_feature(udev->parent_hub,
1711 NULL, udev->port_no, UHF_PORT_ENABLE);
1714 case USB_POWER_MODE_ON:
1715 case USB_POWER_MODE_SAVE:
1718 case USB_POWER_MODE_RESUME:
1719 err = usb2_req_clear_port_feature(udev->parent_hub,
1720 NULL, udev->port_no, UHF_PORT_SUSPEND);
1721 mode = USB_POWER_MODE_SAVE;
1724 case USB_POWER_MODE_SUSPEND:
1725 err = usb2_req_set_port_feature(udev->parent_hub,
1726 NULL, udev->port_no, UHF_PORT_SUSPEND);
1727 mode = USB_POWER_MODE_SAVE;
1735 return (ENXIO); /* I/O failure */
1737 /* if we are powered off we need to re-enumerate first */
1738 if (old_mode == USB_POWER_MODE_OFF) {
1739 err = ugen_re_enumerate(f);
1744 /* set new power mode */
1745 usb2_set_power_mode(udev, mode);
1747 return (0); /* success */
1751 ugen_get_power_mode(struct usb2_fifo *f)
1753 struct usb2_device *udev = f->udev;
1755 if ((udev == NULL) ||
1756 (udev->parent_hub == NULL)) {
1757 return (USB_POWER_MODE_ON);
1759 return (udev->power_mode);
1763 ugen_do_port_feature(struct usb2_fifo *f, uint8_t port_no,
1764 uint8_t set, uint16_t feature)
1766 struct usb2_device *udev = f->udev;
1767 struct usb2_hub *hub;
1770 err = priv_check(curthread, PRIV_DRIVER);
1777 if ((udev == NULL) ||
1778 (udev->hub == NULL)) {
1783 if (port_no > hub->nports) {
1787 err = usb2_req_set_port_feature(udev,
1788 NULL, port_no, feature);
1790 err = usb2_req_clear_port_feature(udev,
1791 NULL, port_no, feature);
1794 return (ENXIO); /* failure */
1796 return (0); /* success */
1800 ugen_iface_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1802 struct usb2_fifo *f_rx;
1803 struct usb2_fifo *f_tx;
1806 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1807 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1810 case USB_SET_RX_SHORT_XFER:
1811 if (fflags & FREAD) {
1812 error = ugen_set_short_xfer(f_rx, addr);
1818 case USB_SET_TX_FORCE_SHORT:
1819 if (fflags & FWRITE) {
1820 error = ugen_set_short_xfer(f_tx, addr);
1826 case USB_SET_RX_TIMEOUT:
1827 if (fflags & FREAD) {
1828 error = ugen_set_timeout(f_rx, addr);
1834 case USB_SET_TX_TIMEOUT:
1835 if (fflags & FWRITE) {
1836 error = ugen_set_timeout(f_tx, addr);
1842 case USB_GET_RX_FRAME_SIZE:
1843 if (fflags & FREAD) {
1844 error = ugen_get_frame_size(f_rx, addr);
1850 case USB_GET_TX_FRAME_SIZE:
1851 if (fflags & FWRITE) {
1852 error = ugen_get_frame_size(f_tx, addr);
1858 case USB_SET_RX_BUFFER_SIZE:
1859 if (fflags & FREAD) {
1860 error = ugen_set_buffer_size(f_rx, addr);
1866 case USB_SET_TX_BUFFER_SIZE:
1867 if (fflags & FWRITE) {
1868 error = ugen_set_buffer_size(f_tx, addr);
1874 case USB_GET_RX_BUFFER_SIZE:
1875 if (fflags & FREAD) {
1876 error = ugen_get_buffer_size(f_rx, addr);
1882 case USB_GET_TX_BUFFER_SIZE:
1883 if (fflags & FWRITE) {
1884 error = ugen_get_buffer_size(f_tx, addr);
1890 case USB_GET_RX_INTERFACE_DESC:
1891 if (fflags & FREAD) {
1892 error = ugen_get_iface_desc(f_rx, addr);
1898 case USB_GET_TX_INTERFACE_DESC:
1899 if (fflags & FWRITE) {
1900 error = ugen_get_iface_desc(f_tx, addr);
1906 case USB_GET_RX_ENDPOINT_DESC:
1907 if (fflags & FREAD) {
1908 error = ugen_get_endpoint_desc(f_rx, addr);
1914 case USB_GET_TX_ENDPOINT_DESC:
1915 if (fflags & FWRITE) {
1916 error = ugen_get_endpoint_desc(f_tx, addr);
1922 case USB_SET_RX_STALL_FLAG:
1923 if ((fflags & FREAD) && (*(int *)addr)) {
1924 f_rx->flag_stall = 1;
1928 case USB_SET_TX_STALL_FLAG:
1929 if ((fflags & FWRITE) && (*(int *)addr)) {
1930 f_tx->flag_stall = 1;
1942 ugen_ioctl_post(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1945 struct usb2_interface_descriptor *idesc;
1946 struct usb2_alt_interface *ai;
1947 struct usb2_device_descriptor *ddesc;
1948 struct usb2_config_descriptor *cdesc;
1949 struct usb2_device_stats *stat;
1950 struct usb2_fs_init *pinit;
1951 struct usb2_fs_uninit *puninit;
1956 struct usb2_device_descriptor *dtemp;
1957 struct usb2_config_descriptor *ctemp;
1958 struct usb2_interface *iface;
1964 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1968 usb2_needs_explore_all();
1972 if (!(fflags & FWRITE)) {
1976 usb2_debug = *(int *)addr;
1979 case USB_GET_CONFIG:
1980 *(int *)addr = f->udev->curr_config_index;
1983 case USB_SET_CONFIG:
1984 if (!(fflags & FWRITE)) {
1988 error = ugen_set_config(f, *(int *)addr);
1991 case USB_GET_ALTINTERFACE:
1992 iface = usb2_get_iface(f->udev,
1993 u.ai->uai_interface_index);
1994 if (iface && iface->idesc) {
1995 u.ai->uai_alt_index = iface->alt_index;
2001 case USB_SET_ALTINTERFACE:
2002 if (!(fflags & FWRITE)) {
2006 error = ugen_set_interface(f,
2007 u.ai->uai_interface_index, u.ai->uai_alt_index);
2010 case USB_GET_DEVICE_DESC:
2011 dtemp = usb2_get_device_descriptor(f->udev);
2019 case USB_GET_CONFIG_DESC:
2020 ctemp = usb2_get_config_descriptor(f->udev);
2028 case USB_GET_FULL_DESC:
2029 error = ugen_get_cdesc(f, addr);
2032 case USB_GET_STRING_DESC:
2033 error = ugen_get_sdesc(f, addr);
2036 case USB_GET_IFACE_DRIVER:
2037 error = ugen_get_iface_driver(f, addr);
2041 case USB_DO_REQUEST:
2042 if (!(fflags & FWRITE)) {
2046 error = ugen_do_request(f, addr);
2049 case USB_DEVICEINFO:
2050 case USB_GET_DEVICEINFO:
2051 error = usb2_gen_fill_deviceinfo(f, addr);
2054 case USB_DEVICESTATS:
2055 for (n = 0; n != 4; n++) {
2057 u.stat->uds_requests_fail[n] =
2058 f->udev->bus->stats_err.uds_requests[n];
2060 u.stat->uds_requests_ok[n] =
2061 f->udev->bus->stats_ok.uds_requests[n];
2065 case USB_DEVICEENUMERATE:
2066 error = ugen_re_enumerate(f);
2069 case USB_GET_PLUGTIME:
2070 *u.ptime = f->udev->plugtime;
2073 case USB_CLAIM_INTERFACE:
2074 case USB_RELEASE_INTERFACE:
2078 case USB_IFACE_DRIVER_ACTIVE:
2083 case USB_IFACE_DRIVER_DETACH:
2085 error = priv_check(curthread, PRIV_DRIVER);
2092 case USB_SET_POWER_MODE:
2093 error = ugen_set_power_mode(f, *u.pint);
2096 case USB_GET_POWER_MODE:
2097 *u.pint = ugen_get_power_mode(f);
2100 case USB_SET_PORT_ENABLE:
2101 error = ugen_do_port_feature(f,
2102 *u.pint, 1, UHF_PORT_ENABLE);
2105 case USB_SET_PORT_DISABLE:
2106 error = ugen_do_port_feature(f,
2107 *u.pint, 0, UHF_PORT_ENABLE);
2111 /* verify input parameters */
2112 if (u.pinit->pEndpoints == NULL) {
2116 if (u.pinit->ep_index_max > 127) {
2120 if (u.pinit->ep_index_max == 0) {
2124 if (f->fs_xfer != NULL) {
2128 if (f->dev_ep_index != 0) {
2132 if (ugen_fifo_in_use(f, fflags)) {
2136 error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
2140 f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) *
2141 u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO);
2142 if (f->fs_xfer == NULL) {
2143 usb2_fifo_free_buffer(f);
2147 f->fs_ep_max = u.pinit->ep_index_max;
2148 f->fs_ep_ptr = u.pinit->pEndpoints;
2152 if (u.puninit->dummy != 0) {
2156 error = ugen_fs_uninit(f);
2160 mtx_lock(f->priv_mtx);
2161 error = ugen_iface_ioctl(f, cmd, addr, fflags);
2162 mtx_unlock(f->priv_mtx);
2165 DPRINTFN(6, "error=%d\n", error);
2170 ugen_default_fs_callback(struct usb2_xfer *xfer)
2172 ; /* workaround for a bug in "indent" */
2174 DPRINTF("st=%u alen=%u aframes=%u\n",
2175 USB_GET_STATE(xfer), xfer->actlen, xfer->aframes);
2177 switch (USB_GET_STATE(xfer)) {
2179 usb2_start_hardware(xfer);
2182 ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
2186 #endif /* USB_HAVE_UGEN */