1 /* $FreeBSD: head/sys/dev/usb/usb_generic.c 277417 2015-01-20 11:43:16Z hselasky $ */
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 <sys/stdint.h>
28 #include <sys/param.h>
29 #include <sys/queue.h>
30 #include <sys/types.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
34 #include <sys/module.h>
36 #include <sys/condvar.h>
37 #include <sys/sysctl.h>
38 #include <sys/unistd.h>
39 #include <sys/callout.h>
40 #include <sys/malloc.h>
43 #include <sys/fcntl.h>
45 #include <bus/u4b/usb.h>
46 #include <bus/u4b/usb_ioctl.h>
47 #include <bus/u4b/usbdi.h>
48 #include <bus/u4b/usbdi_util.h>
50 #define USB_DEBUG_VAR ugen_debug
52 #include <bus/u4b/usb_core.h>
53 #include <bus/u4b/usb_dev.h>
54 #include <bus/u4b/usb_mbuf.h>
55 #include <bus/u4b/usb_process.h>
56 #include <bus/u4b/usb_device.h>
57 #include <bus/u4b/usb_debug.h>
58 #include <bus/u4b/usb_request.h>
59 #include <bus/u4b/usb_busdma.h>
60 #include <bus/u4b/usb_util.h>
61 #include <bus/u4b/usb_hub.h>
62 #include <bus/u4b/usb_generic.h>
63 #include <bus/u4b/usb_transfer.h>
65 #include <bus/u4b/usb_controller.h>
66 #include <bus/u4b/usb_bus.h>
72 #define UGEN_BULK_FS_BUFFER_SIZE (64*32) /* bytes */
73 #define UGEN_BULK_HS_BUFFER_SIZE (1024*32) /* bytes */
74 #define UGEN_HW_FRAMES 50 /* number of milliseconds per transfer */
76 /* function prototypes */
78 static usb_callback_t ugen_read_clear_stall_callback
;
79 static usb_callback_t ugen_write_clear_stall_callback
;
80 static usb_callback_t ugen_ctrl_read_callback
;
81 static usb_callback_t ugen_ctrl_write_callback
;
82 static usb_callback_t ugen_isoc_read_callback
;
83 static usb_callback_t ugen_isoc_write_callback
;
84 static usb_callback_t ugen_ctrl_fs_callback
;
86 static usb_fifo_open_t ugen_open
;
87 static usb_fifo_close_t ugen_close
;
88 static usb_fifo_ioctl_t ugen_ioctl
;
89 static usb_fifo_ioctl_t ugen_ioctl_post
;
90 static usb_fifo_cmd_t ugen_start_read
;
91 static usb_fifo_cmd_t ugen_start_write
;
92 static usb_fifo_cmd_t ugen_stop_io
;
94 static int ugen_transfer_setup(struct usb_fifo
*,
95 const struct usb_config
*, uint8_t);
96 static int ugen_open_pipe_write(struct usb_fifo
*);
97 static int ugen_open_pipe_read(struct usb_fifo
*);
98 static int ugen_set_config(struct usb_fifo
*, uint8_t);
99 static int ugen_set_interface(struct usb_fifo
*, uint8_t, uint8_t);
100 static int ugen_get_cdesc(struct usb_fifo
*, struct usb_gen_descriptor
*);
101 static int ugen_get_sdesc(struct usb_fifo
*, struct usb_gen_descriptor
*);
102 static int ugen_get_iface_driver(struct usb_fifo
*f
, struct usb_gen_descriptor
*ugd
);
103 static int usb_gen_fill_deviceinfo(struct usb_fifo
*,
104 struct usb_device_info
*);
105 static int ugen_re_enumerate(struct usb_fifo
*);
106 static int ugen_iface_ioctl(struct usb_fifo
*, u_long
, void *, int);
107 static uint8_t ugen_fs_get_complete(struct usb_fifo
*, uint8_t *);
108 static int ugen_fs_uninit(struct usb_fifo
*f
);
112 struct usb_fifo_methods usb_ugen_methods
= {
113 .f_open
= &ugen_open
,
114 .f_close
= &ugen_close
,
115 .f_ioctl
= &ugen_ioctl
,
116 .f_ioctl_post
= &ugen_ioctl_post
,
117 .f_start_read
= &ugen_start_read
,
118 .f_stop_read
= &ugen_stop_io
,
119 .f_start_write
= &ugen_start_write
,
120 .f_stop_write
= &ugen_stop_io
,
124 static int ugen_debug
= 0;
126 static SYSCTL_NODE(_hw_usb
, OID_AUTO
, ugen
, CTLFLAG_RW
, 0, "USB generic");
127 SYSCTL_INT(_hw_usb_ugen
, OID_AUTO
, debug
, CTLFLAG_RW
, &ugen_debug
,
130 TUNABLE_INT("hw.usb.ugen.debug", &ugen_debug
);
137 ugen_transfer_setup(struct usb_fifo
*f
,
138 const struct usb_config
*setup
, uint8_t n_setup
)
140 struct usb_endpoint
*ep
= usb_fifo_softc(f
);
141 struct usb_device
*udev
= f
->udev
;
142 uint8_t iface_index
= ep
->iface_index
;
145 lockmgr(f
->priv_lock
, LK_RELEASE
);
148 * "usbd_transfer_setup()" can sleep so one needs to make a wrapper,
149 * exiting the mutex and checking things
151 error
= usbd_transfer_setup(udev
, &iface_index
, f
->xfer
,
152 setup
, n_setup
, f
, f
->priv_lock
);
155 if (f
->xfer
[0]->nframes
== 1) {
156 error
= usb_fifo_alloc_buffer(f
,
157 f
->xfer
[0]->max_data_length
, 2);
159 error
= usb_fifo_alloc_buffer(f
,
160 f
->xfer
[0]->max_frame_size
,
161 2 * f
->xfer
[0]->nframes
);
164 usbd_transfer_unsetup(f
->xfer
, n_setup
);
167 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
173 ugen_open(struct usb_fifo
*f
, int fflags
)
175 struct usb_endpoint
*ep
= usb_fifo_softc(f
);
176 struct usb_endpoint_descriptor
*ed
= ep
->edesc
;
179 DPRINTFN(6, "flag=0x%x\n", fflags
);
181 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
182 switch (usbd_get_speed(f
->udev
)) {
185 f
->nframes
= UGEN_HW_FRAMES
;
186 f
->bufsize
= UGEN_BULK_FS_BUFFER_SIZE
;
189 f
->nframes
= UGEN_HW_FRAMES
* 8;
190 f
->bufsize
= UGEN_BULK_HS_BUFFER_SIZE
;
194 type
= ed
->bmAttributes
& UE_XFERTYPE
;
195 if (type
== UE_INTERRUPT
) {
196 f
->bufsize
= 0; /* use "wMaxPacketSize" */
198 f
->timeout
= USB_NO_TIMEOUT
;
201 lockmgr(f
->priv_lock
, LK_RELEASE
);
207 ugen_close(struct usb_fifo
*f
, int fflags
)
209 DPRINTFN(6, "flag=0x%x\n", fflags
);
213 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
214 usbd_transfer_stop(f
->xfer
[0]);
215 usbd_transfer_stop(f
->xfer
[1]);
216 lockmgr(f
->priv_lock
, LK_RELEASE
);
218 usbd_transfer_unsetup(f
->xfer
, 2);
219 usb_fifo_free_buffer(f
);
221 if (ugen_fs_uninit(f
)) {
222 /* ignore any errors - we are closing */
223 DPRINTFN(6, "no FIFOs\n");
228 ugen_open_pipe_write(struct usb_fifo
*f
)
230 struct usb_config usb_config
[2];
231 struct usb_endpoint
*ep
= usb_fifo_softc(f
);
232 struct usb_endpoint_descriptor
*ed
= ep
->edesc
;
234 KKASSERT(lockowned(f
->priv_lock
));
236 if (f
->xfer
[0] || f
->xfer
[1]) {
237 /* transfers are already opened */
240 memset(usb_config
, 0, sizeof(usb_config
));
242 usb_config
[1].type
= UE_CONTROL
;
243 usb_config
[1].endpoint
= 0;
244 usb_config
[1].direction
= UE_DIR_ANY
;
245 usb_config
[1].timeout
= 1000; /* 1 second */
246 usb_config
[1].interval
= 50;/* 50 milliseconds */
247 usb_config
[1].bufsize
= sizeof(struct usb_device_request
);
248 usb_config
[1].callback
= &ugen_write_clear_stall_callback
;
249 usb_config
[1].usb_mode
= USB_MODE_HOST
;
251 usb_config
[0].type
= ed
->bmAttributes
& UE_XFERTYPE
;
252 usb_config
[0].endpoint
= ed
->bEndpointAddress
& UE_ADDR
;
253 usb_config
[0].stream_id
= 0; /* XXX support more stream ID's */
254 usb_config
[0].direction
= UE_DIR_TX
;
255 usb_config
[0].interval
= USB_DEFAULT_INTERVAL
;
256 usb_config
[0].flags
.proxy_buffer
= 1;
257 usb_config
[0].usb_mode
= USB_MODE_DUAL
; /* both modes */
259 switch (ed
->bmAttributes
& UE_XFERTYPE
) {
263 usb_config
[0].flags
.force_short_xfer
= 1;
265 usb_config
[0].callback
= &ugen_ctrl_write_callback
;
266 usb_config
[0].timeout
= f
->timeout
;
267 usb_config
[0].frames
= 1;
268 usb_config
[0].bufsize
= f
->bufsize
;
269 if (ugen_transfer_setup(f
, usb_config
, 2)) {
272 /* first transfer does not clear stall */
277 usb_config
[0].flags
.short_xfer_ok
= 1;
278 usb_config
[0].bufsize
= 0; /* use default */
279 usb_config
[0].frames
= f
->nframes
;
280 usb_config
[0].callback
= &ugen_isoc_write_callback
;
281 usb_config
[0].timeout
= 0;
283 /* clone configuration */
284 usb_config
[1] = usb_config
[0];
286 if (ugen_transfer_setup(f
, usb_config
, 2)) {
297 ugen_open_pipe_read(struct usb_fifo
*f
)
299 struct usb_config usb_config
[2];
300 struct usb_endpoint
*ep
= usb_fifo_softc(f
);
301 struct usb_endpoint_descriptor
*ed
= ep
->edesc
;
303 KKASSERT(lockowned(f
->priv_lock
));
305 if (f
->xfer
[0] || f
->xfer
[1]) {
306 /* transfers are already opened */
309 memset(usb_config
, 0, sizeof(usb_config
));
311 usb_config
[1].type
= UE_CONTROL
;
312 usb_config
[1].endpoint
= 0;
313 usb_config
[1].direction
= UE_DIR_ANY
;
314 usb_config
[1].timeout
= 1000; /* 1 second */
315 usb_config
[1].interval
= 50;/* 50 milliseconds */
316 usb_config
[1].bufsize
= sizeof(struct usb_device_request
);
317 usb_config
[1].callback
= &ugen_read_clear_stall_callback
;
318 usb_config
[1].usb_mode
= USB_MODE_HOST
;
320 usb_config
[0].type
= ed
->bmAttributes
& UE_XFERTYPE
;
321 usb_config
[0].endpoint
= ed
->bEndpointAddress
& UE_ADDR
;
322 usb_config
[0].stream_id
= 0; /* XXX support more stream ID's */
323 usb_config
[0].direction
= UE_DIR_RX
;
324 usb_config
[0].interval
= USB_DEFAULT_INTERVAL
;
325 usb_config
[0].flags
.proxy_buffer
= 1;
326 usb_config
[0].usb_mode
= USB_MODE_DUAL
; /* both modes */
328 switch (ed
->bmAttributes
& UE_XFERTYPE
) {
332 usb_config
[0].flags
.short_xfer_ok
= 1;
334 usb_config
[0].timeout
= f
->timeout
;
335 usb_config
[0].frames
= 1;
336 usb_config
[0].callback
= &ugen_ctrl_read_callback
;
337 usb_config
[0].bufsize
= f
->bufsize
;
339 if (ugen_transfer_setup(f
, usb_config
, 2)) {
342 /* first transfer does not clear stall */
347 usb_config
[0].flags
.short_xfer_ok
= 1;
348 usb_config
[0].bufsize
= 0; /* use default */
349 usb_config
[0].frames
= f
->nframes
;
350 usb_config
[0].callback
= &ugen_isoc_read_callback
;
351 usb_config
[0].timeout
= 0;
353 /* clone configuration */
354 usb_config
[1] = usb_config
[0];
356 if (ugen_transfer_setup(f
, usb_config
, 2)) {
368 ugen_start_read(struct usb_fifo
*f
)
370 /* check that pipes are open */
371 if (ugen_open_pipe_read(f
)) {
373 usb_fifo_put_data_error(f
);
375 /* start transfers */
376 usbd_transfer_start(f
->xfer
[0]);
377 usbd_transfer_start(f
->xfer
[1]);
381 ugen_start_write(struct usb_fifo
*f
)
383 /* check that pipes are open */
384 if (ugen_open_pipe_write(f
)) {
386 usb_fifo_get_data_error(f
);
388 /* start transfers */
389 usbd_transfer_start(f
->xfer
[0]);
390 usbd_transfer_start(f
->xfer
[1]);
394 ugen_stop_io(struct usb_fifo
*f
)
397 usbd_transfer_stop(f
->xfer
[0]);
398 usbd_transfer_stop(f
->xfer
[1]);
402 ugen_ctrl_read_callback(struct usb_xfer
*xfer
, usb_error_t error
)
404 struct usb_fifo
*f
= usbd_xfer_softc(xfer
);
407 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer
->actlen
, xfer
->aframes
);
409 switch (USB_GET_STATE(xfer
)) {
410 case USB_ST_TRANSFERRED
:
411 if (xfer
->actlen
== 0) {
412 if (f
->fifo_zlp
!= 4) {
416 * Throttle a little bit we have multiple ZLPs
419 xfer
->interval
= 64; /* ms */
426 usb_fifo_put_data(f
, xfer
->frbuffers
, 0,
431 usbd_transfer_start(f
->xfer
[1]);
434 USB_IF_POLL(&f
->free_q
, m
);
436 usbd_xfer_set_frame_len(xfer
, 0, usbd_xfer_max_len(xfer
));
437 usbd_transfer_submit(xfer
);
442 if (xfer
->error
!= USB_ERR_CANCELLED
) {
443 /* send a zero length packet to userland */
444 usb_fifo_put_data(f
, xfer
->frbuffers
, 0, 0, 1);
447 usbd_transfer_start(f
->xfer
[1]);
454 ugen_ctrl_write_callback(struct usb_xfer
*xfer
, usb_error_t error
)
456 struct usb_fifo
*f
= usbd_xfer_softc(xfer
);
457 usb_frlength_t actlen
;
459 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer
->actlen
, xfer
->aframes
);
461 switch (USB_GET_STATE(xfer
)) {
463 case USB_ST_TRANSFERRED
:
465 * If writing is in stall, just jump to clear stall
466 * callback and solve the situation.
469 usbd_transfer_start(f
->xfer
[1]);
473 * Write data, setup and perform hardware transfer.
475 if (usb_fifo_get_data(f
, xfer
->frbuffers
, 0,
476 xfer
->max_data_length
, &actlen
, 0)) {
477 usbd_xfer_set_frame_len(xfer
, 0, actlen
);
478 usbd_transfer_submit(xfer
);
483 if (xfer
->error
!= USB_ERR_CANCELLED
) {
485 usbd_transfer_start(f
->xfer
[1]);
492 ugen_read_clear_stall_callback(struct usb_xfer
*xfer
, usb_error_t error
)
494 struct usb_fifo
*f
= usbd_xfer_softc(xfer
);
495 struct usb_xfer
*xfer_other
= f
->xfer
[0];
497 if (f
->flag_stall
== 0) {
501 if (usbd_clear_stall_callback(xfer
, xfer_other
)) {
502 DPRINTFN(5, "f=%p: stall cleared\n", f
);
504 usbd_transfer_start(xfer_other
);
509 ugen_write_clear_stall_callback(struct usb_xfer
*xfer
, usb_error_t error
)
511 struct usb_fifo
*f
= usbd_xfer_softc(xfer
);
512 struct usb_xfer
*xfer_other
= f
->xfer
[0];
514 if (f
->flag_stall
== 0) {
518 if (usbd_clear_stall_callback(xfer
, xfer_other
)) {
519 DPRINTFN(5, "f=%p: stall cleared\n", f
);
521 usbd_transfer_start(xfer_other
);
526 ugen_isoc_read_callback(struct usb_xfer
*xfer
, usb_error_t error
)
528 struct usb_fifo
*f
= usbd_xfer_softc(xfer
);
529 usb_frlength_t offset
;
532 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer
->actlen
, xfer
->aframes
);
534 switch (USB_GET_STATE(xfer
)) {
535 case USB_ST_TRANSFERRED
:
537 DPRINTFN(6, "actlen=%d\n", xfer
->actlen
);
541 for (n
= 0; n
!= xfer
->aframes
; n
++) {
542 usb_fifo_put_data(f
, xfer
->frbuffers
, offset
,
543 xfer
->frlengths
[n
], 1);
544 offset
+= xfer
->max_frame_size
;
549 for (n
= 0; n
!= xfer
->nframes
; n
++) {
550 /* setup size for next transfer */
551 usbd_xfer_set_frame_len(xfer
, n
, xfer
->max_frame_size
);
553 usbd_transfer_submit(xfer
);
557 if (xfer
->error
== USB_ERR_CANCELLED
) {
565 ugen_isoc_write_callback(struct usb_xfer
*xfer
, usb_error_t error
)
567 struct usb_fifo
*f
= usbd_xfer_softc(xfer
);
568 usb_frlength_t actlen
;
569 usb_frlength_t offset
;
572 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer
->actlen
, xfer
->aframes
);
574 switch (USB_GET_STATE(xfer
)) {
575 case USB_ST_TRANSFERRED
:
579 for (n
= 0; n
!= xfer
->nframes
; n
++) {
580 if (usb_fifo_get_data(f
, xfer
->frbuffers
, offset
,
581 xfer
->max_frame_size
, &actlen
, 1)) {
582 usbd_xfer_set_frame_len(xfer
, n
, actlen
);
589 for (; n
!= xfer
->nframes
; n
++) {
590 /* fill in zero frames */
591 usbd_xfer_set_frame_len(xfer
, n
, 0);
593 usbd_transfer_submit(xfer
);
597 if (xfer
->error
== USB_ERR_CANCELLED
) {
605 ugen_set_config(struct usb_fifo
*f
, uint8_t index
)
607 DPRINTFN(2, "index %u\n", index
);
609 if (f
->udev
->flags
.usb_mode
!= USB_MODE_HOST
) {
610 /* not possible in device side mode */
614 /* make sure all FIFO's are gone */
615 /* else there can be a deadlock */
616 if (ugen_fs_uninit(f
)) {
617 /* ignore any errors */
618 DPRINTFN(6, "no FIFOs\n");
621 if (usbd_start_set_config(f
->udev
, index
) != 0)
628 ugen_set_interface(struct usb_fifo
*f
,
629 uint8_t iface_index
, uint8_t alt_index
)
631 DPRINTFN(2, "%u, %u\n", iface_index
, alt_index
);
633 if (f
->udev
->flags
.usb_mode
!= USB_MODE_HOST
) {
634 /* not possible in device side mode */
637 /* make sure all FIFO's are gone */
638 /* else there can be a deadlock */
639 if (ugen_fs_uninit(f
)) {
640 /* ignore any errors */
641 DPRINTFN(6, "no FIFOs\n");
643 /* change setting - will free generic FIFOs, if any */
644 if (usbd_set_alt_interface_index(f
->udev
, iface_index
, alt_index
)) {
647 /* probe and attach */
648 if (usb_probe_and_attach(f
->udev
, iface_index
)) {
654 /*------------------------------------------------------------------------*
657 * This function will retrieve the complete configuration descriptor
658 * at the given index.
659 *------------------------------------------------------------------------*/
661 ugen_get_cdesc(struct usb_fifo
*f
, struct usb_gen_descriptor
*ugd
)
663 struct usb_config_descriptor
*cdesc
;
664 struct usb_device
*udev
= f
->udev
;
671 if (ugd
->ugd_data
== NULL
) {
672 /* userland pointer should not be zero */
675 if ((ugd
->ugd_config_index
== USB_UNCONFIG_INDEX
) ||
676 (ugd
->ugd_config_index
== udev
->curr_config_index
)) {
677 cdesc
= usbd_get_config_descriptor(udev
);
684 #if (USB_HAVE_FIXED_CONFIG == 0)
685 if (usbd_req_get_config_desc_full(udev
,
686 NULL
, &cdesc
, ugd
->ugd_config_index
)) {
691 /* configuration descriptor data is shared */
696 len
= UGETW(cdesc
->wTotalLength
);
697 if (len
> ugd
->ugd_maxlen
) {
698 len
= ugd
->ugd_maxlen
;
700 DPRINTFN(6, "len=%u\n", len
);
702 ugd
->ugd_actlen
= len
;
705 error
= copyout(cdesc
, ugd
->ugd_data
, len
);
708 usbd_free_config_desc(udev
, cdesc
);
714 * This function is called having the enumeration SX locked which
715 * protects the scratch area used.
718 ugen_get_sdesc(struct usb_fifo
*f
, struct usb_gen_descriptor
*ugd
)
724 ptr
= f
->udev
->scratch
.data
;
725 size
= sizeof(f
->udev
->scratch
.data
);
727 if (usbd_req_get_string_desc(f
->udev
, NULL
, ptr
,
728 size
, ugd
->ugd_lang_id
, ugd
->ugd_string_index
)) {
732 if (size
> ((uint8_t *)ptr
)[0]) {
733 size
= ((uint8_t *)ptr
)[0];
735 if (size
> ugd
->ugd_maxlen
) {
736 size
= ugd
->ugd_maxlen
;
738 ugd
->ugd_actlen
= size
;
741 error
= copyout(ptr
, ugd
->ugd_data
, size
);
746 /*------------------------------------------------------------------------*
747 * ugen_get_iface_driver
749 * This function generates an USB interface description for userland.
754 *------------------------------------------------------------------------*/
756 ugen_get_iface_driver(struct usb_fifo
*f
, struct usb_gen_descriptor
*ugd
)
758 struct usb_device
*udev
= f
->udev
;
759 struct usb_interface
*iface
;
769 if ((ugd
->ugd_data
== NULL
) || (ugd
->ugd_maxlen
== 0)) {
770 /* userland pointer should not be zero */
774 iface
= usbd_get_iface(udev
, ugd
->ugd_iface_index
);
775 if ((iface
== NULL
) || (iface
->idesc
== NULL
)) {
776 /* invalid interface index */
780 /* read out device nameunit string, if any */
781 if ((iface
->subdev
!= NULL
) &&
782 device_is_attached(iface
->subdev
) &&
783 (ptr
= device_get_nameunit(iface
->subdev
)) &&
784 (desc
= device_get_desc(iface
->subdev
))) {
786 /* print description */
787 ksnprintf(buf
, sizeof(buf
), "%s: <%s>", ptr
, desc
);
790 maxlen
= ugd
->ugd_maxlen
- 1;
795 /* update actual length, including terminating zero */
796 ugd
->ugd_actlen
= len
+ 1;
798 /* copy out interface description */
799 error
= copyout(buf
, ugd
->ugd_data
, ugd
->ugd_actlen
);
801 /* zero length string is default */
802 error
= copyout("", ugd
->ugd_data
, 1);
807 /*------------------------------------------------------------------------*
808 * usb_gen_fill_deviceinfo
810 * This function dumps information about an USB device to the
811 * structure pointed to by the "di" argument.
816 *------------------------------------------------------------------------*/
818 usb_gen_fill_deviceinfo(struct usb_fifo
*f
, struct usb_device_info
*di
)
820 struct usb_device
*udev
;
821 struct usb_device
*hub
;
825 bzero(di
, sizeof(di
[0]));
827 di
->udi_bus
= device_get_unit(udev
->bus
->bdev
);
828 di
->udi_addr
= udev
->address
;
829 di
->udi_index
= udev
->device_index
;
830 strlcpy(di
->udi_serial
, usb_get_serial(udev
), sizeof(di
->udi_serial
));
831 strlcpy(di
->udi_vendor
, usb_get_manufacturer(udev
), sizeof(di
->udi_vendor
));
832 strlcpy(di
->udi_product
, usb_get_product(udev
), sizeof(di
->udi_product
));
833 usb_printbcd(di
->udi_release
, sizeof(di
->udi_release
),
834 UGETW(udev
->ddesc
.bcdDevice
));
835 di
->udi_vendorNo
= UGETW(udev
->ddesc
.idVendor
);
836 di
->udi_productNo
= UGETW(udev
->ddesc
.idProduct
);
837 di
->udi_releaseNo
= UGETW(udev
->ddesc
.bcdDevice
);
838 di
->udi_class
= udev
->ddesc
.bDeviceClass
;
839 di
->udi_subclass
= udev
->ddesc
.bDeviceSubClass
;
840 di
->udi_protocol
= udev
->ddesc
.bDeviceProtocol
;
841 di
->udi_config_no
= udev
->curr_config_no
;
842 di
->udi_config_index
= udev
->curr_config_index
;
843 di
->udi_power
= udev
->flags
.self_powered
? 0 : udev
->power
;
844 di
->udi_speed
= udev
->speed
;
845 di
->udi_mode
= udev
->flags
.usb_mode
;
846 di
->udi_power_mode
= udev
->power_mode
;
847 di
->udi_suspended
= udev
->flags
.peer_suspended
;
849 hub
= udev
->parent_hub
;
851 di
->udi_hubaddr
= hub
->address
;
852 di
->udi_hubindex
= hub
->device_index
;
853 di
->udi_hubport
= udev
->port_no
;
858 /*------------------------------------------------------------------------*
864 *------------------------------------------------------------------------*/
866 ugen_check_request(struct usb_device
*udev
, struct usb_device_request
*req
)
868 struct usb_endpoint
*ep
;
872 * Avoid requests that would damage the bus integrity:
874 if (((req
->bmRequestType
== UT_WRITE_DEVICE
) &&
875 (req
->bRequest
== UR_SET_ADDRESS
)) ||
876 ((req
->bmRequestType
== UT_WRITE_DEVICE
) &&
877 (req
->bRequest
== UR_SET_CONFIG
)) ||
878 ((req
->bmRequestType
== UT_WRITE_INTERFACE
) &&
879 (req
->bRequest
== UR_SET_INTERFACE
))) {
881 * These requests can be useful for testing USB drivers.
883 error
= priv_check(curthread
, PRIV_DRIVER
);
889 * Special case - handle clearing of stall
891 if (req
->bmRequestType
== UT_WRITE_ENDPOINT
) {
893 ep
= usbd_get_ep_by_addr(udev
, req
->wIndex
[0]);
897 if ((req
->bRequest
== UR_CLEAR_FEATURE
) &&
898 (UGETW(req
->wValue
) == UF_ENDPOINT_HALT
)) {
899 usbd_clear_data_toggle(udev
, ep
);
902 /* TODO: add more checks to verify the interface index */
908 ugen_do_request(struct usb_fifo
*f
, struct usb_ctl_request
*ur
)
914 if (ugen_check_request(f
->udev
, &ur
->ucr_request
)) {
917 len
= UGETW(ur
->ucr_request
.wLength
);
919 /* check if "ucr_data" is valid */
921 if (ur
->ucr_data
== NULL
) {
925 /* do the USB request */
926 error
= usbd_do_request_flags
927 (f
->udev
, NULL
, &ur
->ucr_request
, ur
->ucr_data
,
928 (ur
->ucr_flags
& USB_SHORT_XFER_OK
) |
929 USB_USER_DATA_PTR
, &actlen
,
930 USB_DEFAULT_TIMEOUT
);
932 ur
->ucr_actlen
= actlen
;
940 /*------------------------------------------------------------------------
942 *------------------------------------------------------------------------*/
944 ugen_re_enumerate(struct usb_fifo
*f
)
946 struct usb_device
*udev
= f
->udev
;
950 * This request can be useful for testing USB drivers:
952 error
= priv_check(curthread
, PRIV_DRIVER
);
956 if (udev
->flags
.usb_mode
!= USB_MODE_HOST
) {
957 /* not possible in device side mode */
958 DPRINTFN(6, "device mode\n");
961 /* make sure all FIFO's are gone */
962 /* else there can be a deadlock */
963 if (ugen_fs_uninit(f
)) {
964 /* ignore any errors */
965 DPRINTFN(6, "no FIFOs\n");
967 /* start re-enumeration of device */
968 usbd_start_re_enumerate(udev
);
973 ugen_fs_uninit(struct usb_fifo
*f
)
975 if (f
->fs_xfer
== NULL
) {
978 usbd_transfer_unsetup(f
->fs_xfer
, f
->fs_ep_max
);
979 kfree(f
->fs_xfer
, M_USB
);
983 f
->flag_iscomplete
= 0;
984 usb_fifo_free_buffer(f
);
989 ugen_fs_get_complete(struct usb_fifo
*f
, uint8_t *pindex
)
993 USB_IF_DEQUEUE(&f
->used_q
, m
);
996 *pindex
= *((uint8_t *)(m
->cur_data_ptr
));
998 USB_IF_ENQUEUE(&f
->free_q
, m
);
1000 return (0); /* success */
1003 *pindex
= 0; /* fix compiler warning */
1005 f
->flag_iscomplete
= 0;
1007 return (1); /* failure */
1011 ugen_fs_set_complete(struct usb_fifo
*f
, uint8_t index
)
1015 USB_IF_DEQUEUE(&f
->free_q
, m
);
1018 /* can happen during close */
1019 DPRINTF("out of buffers\n");
1024 *((uint8_t *)(m
->cur_data_ptr
)) = index
;
1026 USB_IF_ENQUEUE(&f
->used_q
, m
);
1028 f
->flag_iscomplete
= 1;
1034 ugen_fs_copy_in(struct usb_fifo
*f
, uint8_t ep_index
)
1036 struct usb_device_request
*req
;
1037 struct usb_xfer
*xfer
;
1038 struct usb_fs_endpoint fs_ep
;
1039 void *uaddr
; /* userland pointer */
1041 usb_frlength_t offset
;
1048 if (ep_index
>= f
->fs_ep_max
) {
1051 xfer
= f
->fs_xfer
[ep_index
];
1055 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
1056 if (usbd_transfer_pending(xfer
)) {
1057 lockmgr(f
->priv_lock
, LK_RELEASE
);
1058 return (EBUSY
); /* should not happen */
1060 lockmgr(f
->priv_lock
, LK_RELEASE
);
1062 error
= copyin(f
->fs_ep_ptr
+
1063 ep_index
, &fs_ep
, sizeof(fs_ep
));
1067 /* security checks */
1069 if (fs_ep
.nFrames
> xfer
->max_frame_count
) {
1070 xfer
->error
= USB_ERR_INVAL
;
1073 if (fs_ep
.nFrames
== 0) {
1074 xfer
->error
= USB_ERR_INVAL
;
1077 error
= copyin(fs_ep
.ppBuffer
,
1078 &uaddr
, sizeof(uaddr
));
1082 /* reset first frame */
1083 usbd_xfer_set_frame_offset(xfer
, 0, 0);
1085 if (xfer
->flags_int
.control_xfr
) {
1087 req
= xfer
->frbuffers
[0].buffer
;
1089 error
= copyin(fs_ep
.pLength
,
1090 &length
, sizeof(length
));
1094 if (length
!= sizeof(*req
)) {
1095 xfer
->error
= USB_ERR_INVAL
;
1099 error
= copyin(uaddr
, req
, length
);
1104 if (ugen_check_request(f
->udev
, req
)) {
1105 xfer
->error
= USB_ERR_INVAL
;
1108 usbd_xfer_set_frame_len(xfer
, 0, length
);
1110 /* Host mode only ! */
1111 if ((req
->bmRequestType
&
1112 (UT_READ
| UT_WRITE
)) == UT_READ
) {
1118 offset
= sizeof(*req
);
1121 /* Device and Host mode */
1122 if (USB_GET_DATA_ISREAD(xfer
)) {
1131 rem
= usbd_xfer_max_len(xfer
);
1132 xfer
->nframes
= fs_ep
.nFrames
;
1133 xfer
->timeout
= fs_ep
.timeout
;
1134 if (xfer
->timeout
> 65535) {
1135 xfer
->timeout
= 65535;
1137 if (fs_ep
.flags
& USB_FS_FLAG_SINGLE_SHORT_OK
)
1138 xfer
->flags
.short_xfer_ok
= 1;
1140 xfer
->flags
.short_xfer_ok
= 0;
1142 if (fs_ep
.flags
& USB_FS_FLAG_MULTI_SHORT_OK
)
1143 xfer
->flags
.short_frames_ok
= 1;
1145 xfer
->flags
.short_frames_ok
= 0;
1147 if (fs_ep
.flags
& USB_FS_FLAG_FORCE_SHORT
)
1148 xfer
->flags
.force_short_xfer
= 1;
1150 xfer
->flags
.force_short_xfer
= 0;
1152 if (fs_ep
.flags
& USB_FS_FLAG_CLEAR_STALL
)
1153 usbd_xfer_set_stall(xfer
);
1155 xfer
->flags
.stall_pipe
= 0;
1157 for (; n
!= xfer
->nframes
; n
++) {
1159 error
= copyin(fs_ep
.pLength
+ n
,
1160 &length
, sizeof(length
));
1164 usbd_xfer_set_frame_len(xfer
, n
, length
);
1167 xfer
->error
= USB_ERR_INVAL
;
1174 /* we need to know the source buffer */
1175 error
= copyin(fs_ep
.ppBuffer
+ n
,
1176 &uaddr
, sizeof(uaddr
));
1180 if (xfer
->flags_int
.isochronous_xfr
) {
1181 /* get kernel buffer address */
1182 kaddr
= xfer
->frbuffers
[0].buffer
;
1183 kaddr
= USB_ADD_BYTES(kaddr
, offset
);
1185 /* set current frame offset */
1186 usbd_xfer_set_frame_offset(xfer
, offset
, n
);
1188 /* get kernel buffer address */
1189 kaddr
= xfer
->frbuffers
[n
].buffer
;
1193 error
= copyin(uaddr
, kaddr
, length
);
1203 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
1204 ugen_fs_set_complete(f
, ep_index
);
1205 lockmgr(f
->priv_lock
, LK_RELEASE
);
1210 ugen_fs_copy_out(struct usb_fifo
*f
, uint8_t ep_index
)
1212 struct usb_device_request
*req
;
1213 struct usb_xfer
*xfer
;
1214 struct usb_fs_endpoint fs_ep
;
1215 struct usb_fs_endpoint
*fs_ep_uptr
; /* userland ptr */
1216 void *uaddr
; /* userland ptr */
1218 usb_frlength_t offset
;
1226 if (ep_index
>= f
->fs_ep_max
)
1229 xfer
= f
->fs_xfer
[ep_index
];
1233 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
1234 if (usbd_transfer_pending(xfer
)) {
1235 lockmgr(f
->priv_lock
, LK_RELEASE
);
1236 return (EBUSY
); /* should not happen */
1238 lockmgr(f
->priv_lock
, LK_RELEASE
);
1240 fs_ep_uptr
= f
->fs_ep_ptr
+ ep_index
;
1241 error
= copyin(fs_ep_uptr
, &fs_ep
, sizeof(fs_ep
));
1245 fs_ep
.status
= xfer
->error
;
1246 fs_ep
.aFrames
= xfer
->aframes
;
1247 fs_ep
.isoc_time_complete
= xfer
->isoc_time_complete
;
1251 if (xfer
->flags_int
.control_xfr
) {
1252 req
= xfer
->frbuffers
[0].buffer
;
1254 /* Host mode only ! */
1255 if ((req
->bmRequestType
& (UT_READ
| UT_WRITE
)) == UT_READ
) {
1260 if (xfer
->nframes
== 0)
1261 n
= 0; /* should never happen */
1265 /* Device and Host mode */
1266 if (USB_GET_DATA_ISREAD(xfer
)) {
1274 /* Update lengths and copy out data */
1276 rem
= usbd_xfer_max_len(xfer
);
1279 for (; n
!= xfer
->nframes
; n
++) {
1281 /* get initial length into "temp" */
1282 error
= copyin(fs_ep
.pLength
+ n
,
1283 &temp
, sizeof(temp
));
1288 /* the userland length has been corrupted */
1289 DPRINTF("corrupt userland length "
1290 "%u > %u\n", temp
, rem
);
1291 fs_ep
.status
= USB_ERR_INVAL
;
1296 /* get actual transfer length */
1297 length
= xfer
->frlengths
[n
];
1298 if (length
> temp
) {
1300 fs_ep
.status
= USB_ERR_INVAL
;
1301 DPRINTF("data overflow %u > %u\n",
1307 /* we need to know the destination buffer */
1308 error
= copyin(fs_ep
.ppBuffer
+ n
,
1309 &uaddr
, sizeof(uaddr
));
1313 if (xfer
->flags_int
.isochronous_xfr
) {
1314 /* only one frame buffer */
1315 kaddr
= USB_ADD_BYTES(
1316 xfer
->frbuffers
[0].buffer
, offset
);
1318 /* multiple frame buffers */
1319 kaddr
= xfer
->frbuffers
[n
].buffer
;
1323 error
= copyout(kaddr
, uaddr
, length
);
1329 * Update offset according to initial length, which is
1330 * needed by isochronous transfers!
1335 error
= copyout(&length
,
1336 fs_ep
.pLength
+ n
, sizeof(length
));
1343 /* update "aFrames" */
1344 error
= copyout(&fs_ep
.aFrames
, &fs_ep_uptr
->aFrames
,
1345 sizeof(fs_ep
.aFrames
));
1349 /* update "isoc_time_complete" */
1350 error
= copyout(&fs_ep
.isoc_time_complete
,
1351 &fs_ep_uptr
->isoc_time_complete
,
1352 sizeof(fs_ep
.isoc_time_complete
));
1355 /* update "status" */
1356 error
= copyout(&fs_ep
.status
, &fs_ep_uptr
->status
,
1357 sizeof(fs_ep
.status
));
1363 ugen_fifo_in_use(struct usb_fifo
*f
, int fflags
)
1365 struct usb_fifo
*f_rx
;
1366 struct usb_fifo
*f_tx
;
1368 f_rx
= f
->udev
->fifo
[(f
->fifo_index
& ~1) + USB_FIFO_RX
];
1369 f_tx
= f
->udev
->fifo
[(f
->fifo_index
& ~1) + USB_FIFO_TX
];
1371 if ((fflags
& FREAD
) && f_rx
&&
1372 (f_rx
->xfer
[0] || f_rx
->xfer
[1])) {
1373 return (1); /* RX FIFO in use */
1375 if ((fflags
& FWRITE
) && f_tx
&&
1376 (f_tx
->xfer
[0] || f_tx
->xfer
[1])) {
1377 return (1); /* TX FIFO in use */
1379 return (0); /* not in use */
1383 ugen_ioctl(struct usb_fifo
*f
, u_long cmd
, void *addr
, int fflags
)
1385 struct usb_config usb_config
[1];
1386 struct usb_device_request req
;
1388 struct usb_fs_complete
*pcomp
;
1389 struct usb_fs_start
*pstart
;
1390 struct usb_fs_stop
*pstop
;
1391 struct usb_fs_open
*popen
;
1392 struct usb_fs_open_stream
*popen_stream
;
1393 struct usb_fs_close
*pclose
;
1394 struct usb_fs_clear_stall_sync
*pstall
;
1397 struct usb_endpoint
*ep
;
1398 struct usb_endpoint_descriptor
*ed
;
1399 struct usb_xfer
*xfer
;
1401 uint8_t iface_index
;
1408 DPRINTFN(6, "cmd=0x%08lx\n", cmd
);
1411 case USB_FS_COMPLETE
:
1412 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
1413 error
= ugen_fs_get_complete(f
, &ep_index
);
1414 lockmgr(f
->priv_lock
, LK_RELEASE
);
1420 u
.pcomp
->ep_index
= ep_index
;
1421 error
= ugen_fs_copy_out(f
, u
.pcomp
->ep_index
);
1425 error
= ugen_fs_copy_in(f
, u
.pstart
->ep_index
);
1428 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
1429 xfer
= f
->fs_xfer
[u
.pstart
->ep_index
];
1430 usbd_transfer_start(xfer
);
1431 lockmgr(f
->priv_lock
, LK_RELEASE
);
1435 if (u
.pstop
->ep_index
>= f
->fs_ep_max
) {
1439 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
1440 xfer
= f
->fs_xfer
[u
.pstart
->ep_index
];
1441 if (usbd_transfer_pending(xfer
)) {
1442 usbd_transfer_stop(xfer
);
1444 * Check if the USB transfer was stopped
1445 * before it was even started. Else a cancel
1446 * callback will be pending.
1448 if (!xfer
->flags_int
.transferring
) {
1449 ugen_fs_set_complete(xfer
->priv_sc
,
1450 USB_P2U(xfer
->priv_fifo
));
1453 lockmgr(f
->priv_lock
, LK_RELEASE
);
1457 case USB_FS_OPEN_STREAM
:
1458 if (u
.popen
->ep_index
>= f
->fs_ep_max
) {
1462 if (f
->fs_xfer
[u
.popen
->ep_index
] != NULL
) {
1466 if (u
.popen
->max_bufsize
> USB_FS_MAX_BUFSIZE
) {
1467 u
.popen
->max_bufsize
= USB_FS_MAX_BUFSIZE
;
1469 if (u
.popen
->max_frames
& USB_FS_MAX_FRAMES_PRE_SCALE
) {
1471 u
.popen
->max_frames
&= ~USB_FS_MAX_FRAMES_PRE_SCALE
;
1475 if (u
.popen
->max_frames
> USB_FS_MAX_FRAMES
) {
1476 u
.popen
->max_frames
= USB_FS_MAX_FRAMES
;
1479 if (u
.popen
->max_frames
== 0) {
1483 ep
= usbd_get_ep_by_addr(f
->udev
, u
.popen
->ep_no
);
1493 iface_index
= ep
->iface_index
;
1495 memset(usb_config
, 0, sizeof(usb_config
));
1497 usb_config
[0].type
= ed
->bmAttributes
& UE_XFERTYPE
;
1498 usb_config
[0].endpoint
= ed
->bEndpointAddress
& UE_ADDR
;
1499 usb_config
[0].direction
= ed
->bEndpointAddress
& (UE_DIR_OUT
| UE_DIR_IN
);
1500 usb_config
[0].interval
= USB_DEFAULT_INTERVAL
;
1501 usb_config
[0].flags
.proxy_buffer
= 1;
1503 usb_config
[0].flags
.pre_scale_frames
= 1;
1504 usb_config
[0].callback
= &ugen_ctrl_fs_callback
;
1505 usb_config
[0].timeout
= 0; /* no timeout */
1506 usb_config
[0].frames
= u
.popen
->max_frames
;
1507 usb_config
[0].bufsize
= u
.popen
->max_bufsize
;
1508 usb_config
[0].usb_mode
= USB_MODE_DUAL
; /* both modes */
1509 if (cmd
== USB_FS_OPEN_STREAM
)
1510 usb_config
[0].stream_id
= u
.popen_stream
->stream_id
;
1512 if (usb_config
[0].type
== UE_CONTROL
) {
1513 if (f
->udev
->flags
.usb_mode
!= USB_MODE_HOST
) {
1519 isread
= ((usb_config
[0].endpoint
&
1520 (UE_DIR_IN
| UE_DIR_OUT
)) == UE_DIR_IN
);
1522 if (f
->udev
->flags
.usb_mode
!= USB_MODE_HOST
) {
1525 /* check permissions */
1527 if (!(fflags
& FREAD
)) {
1532 if (!(fflags
& FWRITE
)) {
1538 error
= usbd_transfer_setup(f
->udev
, &iface_index
,
1539 f
->fs_xfer
+ u
.popen
->ep_index
, usb_config
, 1,
1542 /* update maximums */
1543 u
.popen
->max_packet_length
=
1544 f
->fs_xfer
[u
.popen
->ep_index
]->max_frame_size
;
1545 u
.popen
->max_bufsize
=
1546 f
->fs_xfer
[u
.popen
->ep_index
]->max_data_length
;
1547 /* update number of frames */
1548 u
.popen
->max_frames
=
1549 f
->fs_xfer
[u
.popen
->ep_index
]->nframes
;
1550 /* store index of endpoint */
1551 f
->fs_xfer
[u
.popen
->ep_index
]->priv_fifo
=
1552 ((uint8_t *)0) + u
.popen
->ep_index
;
1559 if (u
.pclose
->ep_index
>= f
->fs_ep_max
) {
1563 if (f
->fs_xfer
[u
.pclose
->ep_index
] == NULL
) {
1567 usbd_transfer_unsetup(f
->fs_xfer
+ u
.pclose
->ep_index
, 1);
1570 case USB_FS_CLEAR_STALL_SYNC
:
1571 if (u
.pstall
->ep_index
>= f
->fs_ep_max
) {
1575 if (f
->fs_xfer
[u
.pstall
->ep_index
] == NULL
) {
1579 if (f
->udev
->flags
.usb_mode
!= USB_MODE_HOST
) {
1583 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
1584 error
= usbd_transfer_pending(f
->fs_xfer
[u
.pstall
->ep_index
]);
1585 lockmgr(f
->priv_lock
, LK_RELEASE
);
1590 ep
= f
->fs_xfer
[u
.pstall
->ep_index
]->endpoint
;
1592 /* setup a clear-stall packet */
1593 req
.bmRequestType
= UT_WRITE_ENDPOINT
;
1594 req
.bRequest
= UR_CLEAR_FEATURE
;
1595 USETW(req
.wValue
, UF_ENDPOINT_HALT
);
1596 req
.wIndex
[0] = ep
->edesc
->bEndpointAddress
;
1598 USETW(req
.wLength
, 0);
1600 error
= usbd_do_request(f
->udev
, NULL
, &req
, NULL
);
1602 usbd_clear_data_toggle(f
->udev
, ep
);
1613 DPRINTFN(6, "error=%d\n", error
);
1619 ugen_set_short_xfer(struct usb_fifo
*f
, void *addr
)
1628 if (f
->flag_short
== t
) {
1629 /* same value like before - accept */
1632 if (f
->xfer
[0] || f
->xfer
[1]) {
1633 /* cannot change this during transfer */
1641 ugen_set_timeout(struct usb_fifo
*f
, void *addr
)
1643 f
->timeout
= *(int *)addr
;
1644 if (f
->timeout
> 65535) {
1645 /* limit user input */
1652 ugen_get_frame_size(struct usb_fifo
*f
, void *addr
)
1655 *(int *)addr
= f
->xfer
[0]->max_frame_size
;
1663 ugen_set_buffer_size(struct usb_fifo
*f
, void *addr
)
1667 if (*(int *)addr
< 0)
1668 t
= 0; /* use "wMaxPacketSize" */
1669 else if (*(int *)addr
< (256 * 1024))
1674 if (f
->bufsize
== t
) {
1675 /* same value like before - accept */
1678 if (f
->xfer
[0] || f
->xfer
[1]) {
1679 /* cannot change this during transfer */
1687 ugen_get_buffer_size(struct usb_fifo
*f
, void *addr
)
1689 *(int *)addr
= f
->bufsize
;
1694 ugen_get_iface_desc(struct usb_fifo
*f
,
1695 struct usb_interface_descriptor
*idesc
)
1697 struct usb_interface
*iface
;
1699 iface
= usbd_get_iface(f
->udev
, f
->iface_index
);
1700 if (iface
&& iface
->idesc
) {
1701 *idesc
= *(iface
->idesc
);
1709 ugen_get_endpoint_desc(struct usb_fifo
*f
,
1710 struct usb_endpoint_descriptor
*ed
)
1712 struct usb_endpoint
*ep
;
1714 ep
= usb_fifo_softc(f
);
1716 if (ep
&& ep
->edesc
) {
1725 ugen_set_power_mode(struct usb_fifo
*f
, int mode
)
1727 struct usb_device
*udev
= f
->udev
;
1731 if ((udev
== NULL
) ||
1732 (udev
->parent_hub
== NULL
)) {
1735 err
= priv_check(curthread
, PRIV_DRIVER
);
1739 /* get old power mode */
1740 old_mode
= udev
->power_mode
;
1742 /* if no change, then just return */
1743 if (old_mode
== mode
)
1747 case USB_POWER_MODE_OFF
:
1748 if (udev
->flags
.usb_mode
== USB_MODE_HOST
&&
1749 udev
->re_enumerate_wait
== USB_RE_ENUM_DONE
) {
1750 udev
->re_enumerate_wait
= USB_RE_ENUM_PWR_OFF
;
1752 /* set power mode will wake up the explore thread */
1755 case USB_POWER_MODE_ON
:
1756 case USB_POWER_MODE_SAVE
:
1759 case USB_POWER_MODE_RESUME
:
1761 /* let USB-powerd handle resume */
1762 USB_BUS_LOCK(udev
->bus
);
1763 udev
->pwr_save
.write_refs
++;
1764 udev
->pwr_save
.last_xfer_time
= ticks
;
1765 USB_BUS_UNLOCK(udev
->bus
);
1767 /* set new power mode */
1768 usbd_set_power_mode(udev
, USB_POWER_MODE_SAVE
);
1770 /* wait for resume to complete */
1771 usb_pause_mtx(NULL
, hz
/ 4);
1773 /* clear write reference */
1774 USB_BUS_LOCK(udev
->bus
);
1775 udev
->pwr_save
.write_refs
--;
1776 USB_BUS_UNLOCK(udev
->bus
);
1778 mode
= USB_POWER_MODE_SAVE
;
1781 case USB_POWER_MODE_SUSPEND
:
1783 /* let USB-powerd handle suspend */
1784 USB_BUS_LOCK(udev
->bus
);
1785 udev
->pwr_save
.last_xfer_time
= ticks
- (256 * hz
);
1786 USB_BUS_UNLOCK(udev
->bus
);
1788 mode
= USB_POWER_MODE_SAVE
;
1796 return (ENXIO
); /* I/O failure */
1798 /* if we are powered off we need to re-enumerate first */
1799 if (old_mode
== USB_POWER_MODE_OFF
) {
1800 if (udev
->flags
.usb_mode
== USB_MODE_HOST
&&
1801 udev
->re_enumerate_wait
== USB_RE_ENUM_DONE
) {
1802 udev
->re_enumerate_wait
= USB_RE_ENUM_START
;
1804 /* set power mode will wake up the explore thread */
1807 /* set new power mode */
1808 usbd_set_power_mode(udev
, mode
);
1810 return (0); /* success */
1814 ugen_get_power_mode(struct usb_fifo
*f
)
1816 struct usb_device
*udev
= f
->udev
;
1819 return (USB_POWER_MODE_ON
);
1821 return (udev
->power_mode
);
1825 ugen_get_port_path(struct usb_fifo
*f
, struct usb_device_port_path
*dpp
)
1827 struct usb_device
*udev
= f
->udev
;
1828 struct usb_device
*next
;
1829 unsigned int nlevel
= 0;
1834 dpp
->udp_bus
= device_get_unit(udev
->bus
->bdev
);
1835 dpp
->udp_index
= udev
->device_index
;
1837 /* count port levels */
1839 while (next
->parent_hub
!= NULL
) {
1841 next
= next
->parent_hub
;
1844 /* check if too many levels */
1845 if (nlevel
> USB_DEVICE_PORT_PATH_MAX
)
1848 /* store total level of ports */
1849 dpp
->udp_port_level
= nlevel
;
1851 /* store port index array */
1853 while (next
->parent_hub
!= NULL
) {
1854 dpp
->udp_port_no
[--nlevel
] = next
->port_no
;
1855 next
= next
->parent_hub
;
1857 return (0); /* success */
1860 return (EINVAL
); /* failure */
1864 ugen_get_power_usage(struct usb_fifo
*f
)
1866 struct usb_device
*udev
= f
->udev
;
1871 return (udev
->power
);
1875 ugen_do_port_feature(struct usb_fifo
*f
, uint8_t port_no
,
1876 uint8_t set
, uint16_t feature
)
1878 struct usb_device
*udev
= f
->udev
;
1879 struct usb_hub
*hub
;
1882 err
= priv_check(curthread
, PRIV_DRIVER
);
1889 if ((udev
== NULL
) ||
1890 (udev
->hub
== NULL
)) {
1895 if (port_no
> hub
->nports
) {
1899 err
= usbd_req_set_port_feature(udev
,
1900 NULL
, port_no
, feature
);
1902 err
= usbd_req_clear_port_feature(udev
,
1903 NULL
, port_no
, feature
);
1906 return (ENXIO
); /* failure */
1908 return (0); /* success */
1912 ugen_iface_ioctl(struct usb_fifo
*f
, u_long cmd
, void *addr
, int fflags
)
1914 struct usb_fifo
*f_rx
;
1915 struct usb_fifo
*f_tx
;
1918 f_rx
= f
->udev
->fifo
[(f
->fifo_index
& ~1) + USB_FIFO_RX
];
1919 f_tx
= f
->udev
->fifo
[(f
->fifo_index
& ~1) + USB_FIFO_TX
];
1922 case USB_SET_RX_SHORT_XFER
:
1923 if (fflags
& FREAD
) {
1924 error
= ugen_set_short_xfer(f_rx
, addr
);
1930 case USB_SET_TX_FORCE_SHORT
:
1931 if (fflags
& FWRITE
) {
1932 error
= ugen_set_short_xfer(f_tx
, addr
);
1938 case USB_SET_RX_TIMEOUT
:
1939 if (fflags
& FREAD
) {
1940 error
= ugen_set_timeout(f_rx
, addr
);
1946 case USB_SET_TX_TIMEOUT
:
1947 if (fflags
& FWRITE
) {
1948 error
= ugen_set_timeout(f_tx
, addr
);
1954 case USB_GET_RX_FRAME_SIZE
:
1955 if (fflags
& FREAD
) {
1956 error
= ugen_get_frame_size(f_rx
, addr
);
1962 case USB_GET_TX_FRAME_SIZE
:
1963 if (fflags
& FWRITE
) {
1964 error
= ugen_get_frame_size(f_tx
, addr
);
1970 case USB_SET_RX_BUFFER_SIZE
:
1971 if (fflags
& FREAD
) {
1972 error
= ugen_set_buffer_size(f_rx
, addr
);
1978 case USB_SET_TX_BUFFER_SIZE
:
1979 if (fflags
& FWRITE
) {
1980 error
= ugen_set_buffer_size(f_tx
, addr
);
1986 case USB_GET_RX_BUFFER_SIZE
:
1987 if (fflags
& FREAD
) {
1988 error
= ugen_get_buffer_size(f_rx
, addr
);
1994 case USB_GET_TX_BUFFER_SIZE
:
1995 if (fflags
& FWRITE
) {
1996 error
= ugen_get_buffer_size(f_tx
, addr
);
2002 case USB_GET_RX_INTERFACE_DESC
:
2003 if (fflags
& FREAD
) {
2004 error
= ugen_get_iface_desc(f_rx
, addr
);
2010 case USB_GET_TX_INTERFACE_DESC
:
2011 if (fflags
& FWRITE
) {
2012 error
= ugen_get_iface_desc(f_tx
, addr
);
2018 case USB_GET_RX_ENDPOINT_DESC
:
2019 if (fflags
& FREAD
) {
2020 error
= ugen_get_endpoint_desc(f_rx
, addr
);
2026 case USB_GET_TX_ENDPOINT_DESC
:
2027 if (fflags
& FWRITE
) {
2028 error
= ugen_get_endpoint_desc(f_tx
, addr
);
2034 case USB_SET_RX_STALL_FLAG
:
2035 if ((fflags
& FREAD
) && (*(int *)addr
)) {
2036 f_rx
->flag_stall
= 1;
2040 case USB_SET_TX_STALL_FLAG
:
2041 if ((fflags
& FWRITE
) && (*(int *)addr
)) {
2042 f_tx
->flag_stall
= 1;
2054 ugen_ioctl_post(struct usb_fifo
*f
, u_long cmd
, void *addr
, int fflags
)
2057 struct usb_interface_descriptor
*idesc
;
2058 struct usb_alt_interface
*ai
;
2059 struct usb_device_descriptor
*ddesc
;
2060 struct usb_config_descriptor
*cdesc
;
2061 struct usb_device_stats
*stat
;
2062 struct usb_fs_init
*pinit
;
2063 struct usb_fs_uninit
*puninit
;
2064 struct usb_device_port_path
*dpp
;
2069 struct usb_device_descriptor
*dtemp
;
2070 struct usb_config_descriptor
*ctemp
;
2071 struct usb_interface
*iface
;
2077 DPRINTFN(6, "cmd=0x%08lx\n", cmd
);
2081 usb_needs_explore_all();
2085 if (!(fflags
& FWRITE
)) {
2089 usb_debug
= *(int *)addr
;
2092 case USB_GET_CONFIG
:
2093 *(int *)addr
= f
->udev
->curr_config_index
;
2096 case USB_SET_CONFIG
:
2097 if (!(fflags
& FWRITE
)) {
2101 error
= ugen_set_config(f
, *(int *)addr
);
2104 case USB_GET_ALTINTERFACE
:
2105 iface
= usbd_get_iface(f
->udev
,
2106 u
.ai
->uai_interface_index
);
2107 if (iface
&& iface
->idesc
) {
2108 u
.ai
->uai_alt_index
= iface
->alt_index
;
2114 case USB_SET_ALTINTERFACE
:
2115 if (!(fflags
& FWRITE
)) {
2119 error
= ugen_set_interface(f
,
2120 u
.ai
->uai_interface_index
, u
.ai
->uai_alt_index
);
2123 case USB_GET_DEVICE_DESC
:
2124 dtemp
= usbd_get_device_descriptor(f
->udev
);
2132 case USB_GET_CONFIG_DESC
:
2133 ctemp
= usbd_get_config_descriptor(f
->udev
);
2141 case USB_GET_FULL_DESC
:
2142 error
= ugen_get_cdesc(f
, addr
);
2145 case USB_GET_STRING_DESC
:
2146 error
= ugen_get_sdesc(f
, addr
);
2149 case USB_GET_IFACE_DRIVER
:
2150 error
= ugen_get_iface_driver(f
, addr
);
2154 case USB_DO_REQUEST
:
2155 if (!(fflags
& FWRITE
)) {
2159 error
= ugen_do_request(f
, addr
);
2162 case USB_DEVICEINFO
:
2163 case USB_GET_DEVICEINFO
:
2164 error
= usb_gen_fill_deviceinfo(f
, addr
);
2167 case USB_DEVICESTATS
:
2168 for (n
= 0; n
!= 4; n
++) {
2170 u
.stat
->uds_requests_fail
[n
] =
2171 f
->udev
->bus
->stats_err
.uds_requests
[n
];
2173 u
.stat
->uds_requests_ok
[n
] =
2174 f
->udev
->bus
->stats_ok
.uds_requests
[n
];
2178 case USB_DEVICEENUMERATE
:
2179 error
= ugen_re_enumerate(f
);
2182 case USB_GET_PLUGTIME
:
2183 *u
.ptime
= f
->udev
->plugtime
;
2186 case USB_CLAIM_INTERFACE
:
2187 case USB_RELEASE_INTERFACE
:
2191 case USB_IFACE_DRIVER_ACTIVE
:
2195 iface
= usbd_get_iface(f
->udev
, n
);
2197 if (iface
&& iface
->subdev
)
2203 case USB_IFACE_DRIVER_DETACH
:
2205 error
= priv_check(curthread
, PRIV_DRIVER
);
2212 if (n
== USB_IFACE_INDEX_ANY
) {
2218 * Detach the currently attached driver.
2220 usb_detach_device(f
->udev
, n
, 0);
2223 * Set parent to self, this should keep attach away
2224 * until the next set configuration event.
2226 usbd_set_parent_iface(f
->udev
, n
, n
);
2229 case USB_SET_POWER_MODE
:
2230 error
= ugen_set_power_mode(f
, *u
.pint
);
2233 case USB_GET_POWER_MODE
:
2234 *u
.pint
= ugen_get_power_mode(f
);
2237 case USB_GET_DEV_PORT_PATH
:
2238 error
= ugen_get_port_path(f
, u
.dpp
);
2241 case USB_GET_POWER_USAGE
:
2242 *u
.pint
= ugen_get_power_usage(f
);
2245 case USB_SET_PORT_ENABLE
:
2246 error
= ugen_do_port_feature(f
,
2247 *u
.pint
, 1, UHF_PORT_ENABLE
);
2250 case USB_SET_PORT_DISABLE
:
2251 error
= ugen_do_port_feature(f
,
2252 *u
.pint
, 0, UHF_PORT_ENABLE
);
2256 /* verify input parameters */
2257 if (u
.pinit
->pEndpoints
== NULL
) {
2261 if (u
.pinit
->ep_index_max
> 127) {
2265 if (u
.pinit
->ep_index_max
== 0) {
2269 if (f
->fs_xfer
!= NULL
) {
2273 if (f
->dev_ep_index
!= 0) {
2277 if (ugen_fifo_in_use(f
, fflags
)) {
2281 error
= usb_fifo_alloc_buffer(f
, 1, u
.pinit
->ep_index_max
);
2285 f
->fs_xfer
= kmalloc(sizeof(f
->fs_xfer
[0]) *
2286 u
.pinit
->ep_index_max
, M_USB
, M_WAITOK
| M_ZERO
);
2287 if (f
->fs_xfer
== NULL
) {
2288 usb_fifo_free_buffer(f
);
2292 f
->fs_ep_max
= u
.pinit
->ep_index_max
;
2293 f
->fs_ep_ptr
= u
.pinit
->pEndpoints
;
2297 if (u
.puninit
->dummy
!= 0) {
2301 error
= ugen_fs_uninit(f
);
2305 lockmgr(f
->priv_lock
, LK_EXCLUSIVE
);
2306 error
= ugen_iface_ioctl(f
, cmd
, addr
, fflags
);
2307 lockmgr(f
->priv_lock
, LK_RELEASE
);
2310 DPRINTFN(6, "error=%d\n", error
);
2315 ugen_ctrl_fs_callback(struct usb_xfer
*xfer
, usb_error_t error
)
2317 ; /* workaround for a bug in "indent" */
2319 DPRINTF("st=%u alen=%u aframes=%u\n",
2320 USB_GET_STATE(xfer
), xfer
->actlen
, xfer
->aframes
);
2322 switch (USB_GET_STATE(xfer
)) {
2324 usbd_transfer_submit(xfer
);
2327 ugen_fs_set_complete(xfer
->priv_sc
, USB_P2U(xfer
->priv_fifo
));
2331 #endif /* USB_HAVE_UGEN */