usb_generic.c revision 194659
1184610Salfred/* $FreeBSD: head/sys/dev/usb/usb_generic.c 194659 2009-06-22 21:09:52Z thompsa $ */
2184610Salfred/*-
3184610Salfred * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
4184610Salfred *
5184610Salfred * Redistribution and use in source and binary forms, with or without
6184610Salfred * modification, are permitted provided that the following conditions
7184610Salfred * are met:
8184610Salfred * 1. Redistributions of source code must retain the above copyright
9184610Salfred *    notice, this list of conditions and the following disclaimer.
10184610Salfred * 2. Redistributions in binary form must reproduce the above copyright
11184610Salfred *    notice, this list of conditions and the following disclaimer in the
12184610Salfred *    documentation and/or other materials provided with the distribution.
13184610Salfred *
14184610Salfred * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15184610Salfred * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16184610Salfred * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17184610Salfred * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18184610Salfred * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19184610Salfred * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20184610Salfred * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21184610Salfred * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22184610Salfred * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23184610Salfred * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24184610Salfred * SUCH DAMAGE.
25184610Salfred */
26184610Salfred
27188942Sthompsa#include <dev/usb/usb_mfunc.h>
28188942Sthompsa#include <dev/usb/usb.h>
29188942Sthompsa#include <dev/usb/usb_ioctl.h>
30188942Sthompsa#include <dev/usb/usb_error.h>
31184610Salfred
32184610Salfred#define	USB_DEBUG_VAR ugen_debug
33184610Salfred
34188942Sthompsa#include <dev/usb/usb_core.h>
35188942Sthompsa#include <dev/usb/usb_mbuf.h>
36188942Sthompsa#include <dev/usb/usb_dev.h>
37188942Sthompsa#include <dev/usb/usb_process.h>
38188942Sthompsa#include <dev/usb/usb_device.h>
39188942Sthompsa#include <dev/usb/usb_debug.h>
40188942Sthompsa#include <dev/usb/usb_request.h>
41188942Sthompsa#include <dev/usb/usb_busdma.h>
42188942Sthompsa#include <dev/usb/usb_util.h>
43188942Sthompsa#include <dev/usb/usb_hub.h>
44188942Sthompsa#include <dev/usb/usb_generic.h>
45188942Sthompsa#include <dev/usb/usb_transfer.h>
46184610Salfred
47188942Sthompsa#include <dev/usb/usb_controller.h>
48188942Sthompsa#include <dev/usb/usb_bus.h>
49184610Salfred
50190191Sthompsa#if USB_HAVE_UGEN
51190191Sthompsa
52184610Salfred/* defines */
53184610Salfred
54184610Salfred#define	UGEN_BULK_FS_BUFFER_SIZE	(64*32)	/* bytes */
55184610Salfred#define	UGEN_BULK_HS_BUFFER_SIZE	(1024*32)	/* bytes */
56184610Salfred#define	UGEN_HW_FRAMES	50		/* number of milliseconds per transfer */
57184610Salfred
58184610Salfred/* function prototypes */
59184610Salfred
60193045Sthompsastatic usb_callback_t ugen_read_clear_stall_callback;
61193045Sthompsastatic usb_callback_t ugen_write_clear_stall_callback;
62193045Sthompsastatic usb_callback_t ugen_default_read_callback;
63193045Sthompsastatic usb_callback_t ugen_default_write_callback;
64193045Sthompsastatic usb_callback_t ugen_isoc_read_callback;
65193045Sthompsastatic usb_callback_t ugen_isoc_write_callback;
66193045Sthompsastatic usb_callback_t ugen_default_fs_callback;
67184610Salfred
68193045Sthompsastatic usb_fifo_open_t ugen_open;
69193045Sthompsastatic usb_fifo_close_t ugen_close;
70193045Sthompsastatic usb_fifo_ioctl_t ugen_ioctl;
71193045Sthompsastatic usb_fifo_ioctl_t ugen_ioctl_post;
72193045Sthompsastatic usb_fifo_cmd_t ugen_start_read;
73193045Sthompsastatic usb_fifo_cmd_t ugen_start_write;
74193045Sthompsastatic usb_fifo_cmd_t ugen_stop_io;
75184610Salfred
76192984Sthompsastatic int	ugen_transfer_setup(struct usb_fifo *,
77192984Sthompsa		     const struct usb_config *, uint8_t);
78192984Sthompsastatic int	ugen_open_pipe_write(struct usb_fifo *);
79192984Sthompsastatic int	ugen_open_pipe_read(struct usb_fifo *);
80192984Sthompsastatic int	ugen_set_config(struct usb_fifo *, uint8_t);
81192984Sthompsastatic int	ugen_set_interface(struct usb_fifo *, uint8_t, uint8_t);
82192984Sthompsastatic int	ugen_get_cdesc(struct usb_fifo *, struct usb_gen_descriptor *);
83192984Sthompsastatic int	ugen_get_sdesc(struct usb_fifo *, struct usb_gen_descriptor *);
84192984Sthompsastatic int	ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd);
85194228Sthompsastatic int	usb_gen_fill_deviceinfo(struct usb_fifo *,
86192984Sthompsa		    struct usb_device_info *);
87192984Sthompsastatic int	ugen_re_enumerate(struct usb_fifo *);
88192984Sthompsastatic int	ugen_iface_ioctl(struct usb_fifo *, u_long, void *, int);
89192984Sthompsastatic uint8_t	ugen_fs_get_complete(struct usb_fifo *, uint8_t *);
90192984Sthompsastatic int ugen_fs_uninit(struct usb_fifo *f);
91184610Salfred
92184610Salfred/* structures */
93184610Salfred
94194228Sthompsastruct usb_fifo_methods usb_ugen_methods = {
95184610Salfred	.f_open = &ugen_open,
96184610Salfred	.f_close = &ugen_close,
97184610Salfred	.f_ioctl = &ugen_ioctl,
98185087Salfred	.f_ioctl_post = &ugen_ioctl_post,
99184610Salfred	.f_start_read = &ugen_start_read,
100184610Salfred	.f_stop_read = &ugen_stop_io,
101184610Salfred	.f_start_write = &ugen_start_write,
102184610Salfred	.f_stop_write = &ugen_stop_io,
103184610Salfred};
104184610Salfred
105184610Salfred#if USB_DEBUG
106184610Salfredstatic int ugen_debug = 0;
107184610Salfred
108192502SthompsaSYSCTL_NODE(_hw_usb, OID_AUTO, ugen, CTLFLAG_RW, 0, "USB generic");
109192502SthompsaSYSCTL_INT(_hw_usb_ugen, OID_AUTO, debug, CTLFLAG_RW, &ugen_debug,
110184610Salfred    0, "Debug level");
111184610Salfred#endif
112184610Salfred
113184610Salfred
114184610Salfred/* prototypes */
115184610Salfred
116184610Salfredstatic int
117192984Sthompsaugen_transfer_setup(struct usb_fifo *f,
118192984Sthompsa    const struct usb_config *setup, uint8_t n_setup)
119184610Salfred{
120193644Sthompsa	struct usb_endpoint *ep = f->priv_sc0;
121192984Sthompsa	struct usb_device *udev = f->udev;
122193644Sthompsa	uint8_t iface_index = ep->iface_index;
123184610Salfred	int error;
124184610Salfred
125184610Salfred	mtx_unlock(f->priv_mtx);
126184610Salfred
127184610Salfred	/*
128194228Sthompsa	 * "usbd_transfer_setup()" can sleep so one needs to make a wrapper,
129184610Salfred	 * exiting the mutex and checking things
130184610Salfred	 */
131194228Sthompsa	error = usbd_transfer_setup(udev, &iface_index, f->xfer,
132184610Salfred	    setup, n_setup, f, f->priv_mtx);
133184610Salfred	if (error == 0) {
134184610Salfred
135184610Salfred		if (f->xfer[0]->nframes == 1) {
136194228Sthompsa			error = usb_fifo_alloc_buffer(f,
137184610Salfred			    f->xfer[0]->max_data_length, 2);
138184610Salfred		} else {
139194228Sthompsa			error = usb_fifo_alloc_buffer(f,
140184610Salfred			    f->xfer[0]->max_frame_size,
141184610Salfred			    2 * f->xfer[0]->nframes);
142184610Salfred		}
143184610Salfred		if (error) {
144194228Sthompsa			usbd_transfer_unsetup(f->xfer, n_setup);
145184610Salfred		}
146184610Salfred	}
147184610Salfred	mtx_lock(f->priv_mtx);
148184610Salfred
149184610Salfred	return (error);
150184610Salfred}
151184610Salfred
152184610Salfredstatic int
153192984Sthompsaugen_open(struct usb_fifo *f, int fflags)
154184610Salfred{
155193644Sthompsa	struct usb_endpoint *ep = f->priv_sc0;
156193644Sthompsa	struct usb_endpoint_descriptor *ed = ep->edesc;
157184610Salfred	uint8_t type;
158184610Salfred
159184610Salfred	DPRINTFN(6, "flag=0x%x\n", fflags);
160184610Salfred
161184610Salfred	mtx_lock(f->priv_mtx);
162194228Sthompsa	switch (usbd_get_speed(f->udev)) {
163187180Sthompsa	case USB_SPEED_LOW:
164187180Sthompsa	case USB_SPEED_FULL:
165187180Sthompsa		f->nframes = UGEN_HW_FRAMES;
166187180Sthompsa		f->bufsize = UGEN_BULK_FS_BUFFER_SIZE;
167187180Sthompsa		break;
168187180Sthompsa	default:
169184610Salfred		f->nframes = UGEN_HW_FRAMES * 8;
170184610Salfred		f->bufsize = UGEN_BULK_HS_BUFFER_SIZE;
171187180Sthompsa		break;
172184610Salfred	}
173184610Salfred
174184610Salfred	type = ed->bmAttributes & UE_XFERTYPE;
175184610Salfred	if (type == UE_INTERRUPT) {
176184610Salfred		f->bufsize = 0;		/* use "wMaxPacketSize" */
177184610Salfred	}
178184610Salfred	f->timeout = USB_NO_TIMEOUT;
179184610Salfred	f->flag_short = 0;
180184610Salfred	f->fifo_zlp = 0;
181184610Salfred	mtx_unlock(f->priv_mtx);
182184610Salfred
183184610Salfred	return (0);
184184610Salfred}
185184610Salfred
186184610Salfredstatic void
187192984Sthompsaugen_close(struct usb_fifo *f, int fflags)
188184610Salfred{
189184610Salfred	DPRINTFN(6, "flag=0x%x\n", fflags);
190184610Salfred
191184610Salfred	/* cleanup */
192184610Salfred
193184610Salfred	mtx_lock(f->priv_mtx);
194194228Sthompsa	usbd_transfer_stop(f->xfer[0]);
195194228Sthompsa	usbd_transfer_stop(f->xfer[1]);
196184610Salfred	mtx_unlock(f->priv_mtx);
197184610Salfred
198194228Sthompsa	usbd_transfer_unsetup(f->xfer, 2);
199194228Sthompsa	usb_fifo_free_buffer(f);
200184610Salfred
201184610Salfred	if (ugen_fs_uninit(f)) {
202184610Salfred		/* ignore any errors - we are closing */
203185290Salfred		DPRINTFN(6, "no FIFOs\n");
204184610Salfred	}
205184610Salfred}
206184610Salfred
207184610Salfredstatic int
208192984Sthompsaugen_open_pipe_write(struct usb_fifo *f)
209184610Salfred{
210192984Sthompsa	struct usb_config usb_config[2];
211193644Sthompsa	struct usb_endpoint *ep = f->priv_sc0;
212193644Sthompsa	struct usb_endpoint_descriptor *ed = ep->edesc;
213184610Salfred
214184610Salfred	mtx_assert(f->priv_mtx, MA_OWNED);
215184610Salfred
216184610Salfred	if (f->xfer[0] || f->xfer[1]) {
217184610Salfred		/* transfers are already opened */
218184610Salfred		return (0);
219184610Salfred	}
220192984Sthompsa	bzero(usb_config, sizeof(usb_config));
221184610Salfred
222192984Sthompsa	usb_config[1].type = UE_CONTROL;
223192984Sthompsa	usb_config[1].endpoint = 0;
224192984Sthompsa	usb_config[1].direction = UE_DIR_ANY;
225192984Sthompsa	usb_config[1].timeout = 1000;	/* 1 second */
226192984Sthompsa	usb_config[1].interval = 50;/* 50 milliseconds */
227192984Sthompsa	usb_config[1].bufsize = sizeof(struct usb_device_request);
228192984Sthompsa	usb_config[1].callback = &ugen_write_clear_stall_callback;
229192984Sthompsa	usb_config[1].usb_mode = USB_MODE_HOST;
230184610Salfred
231192984Sthompsa	usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
232192984Sthompsa	usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
233192984Sthompsa	usb_config[0].direction = UE_DIR_TX;
234192984Sthompsa	usb_config[0].interval = USB_DEFAULT_INTERVAL;
235192984Sthompsa	usb_config[0].flags.proxy_buffer = 1;
236192984Sthompsa	usb_config[0].usb_mode = USB_MODE_DUAL;	/* both modes */
237184610Salfred
238184610Salfred	switch (ed->bmAttributes & UE_XFERTYPE) {
239184610Salfred	case UE_INTERRUPT:
240184610Salfred	case UE_BULK:
241184610Salfred		if (f->flag_short) {
242192984Sthompsa			usb_config[0].flags.force_short_xfer = 1;
243184610Salfred		}
244192984Sthompsa		usb_config[0].callback = &ugen_default_write_callback;
245192984Sthompsa		usb_config[0].timeout = f->timeout;
246192984Sthompsa		usb_config[0].frames = 1;
247192984Sthompsa		usb_config[0].bufsize = f->bufsize;
248192984Sthompsa		if (ugen_transfer_setup(f, usb_config, 2)) {
249184610Salfred			return (EIO);
250184610Salfred		}
251184610Salfred		/* first transfer does not clear stall */
252184610Salfred		f->flag_stall = 0;
253184610Salfred		break;
254184610Salfred
255184610Salfred	case UE_ISOCHRONOUS:
256192984Sthompsa		usb_config[0].flags.short_xfer_ok = 1;
257192984Sthompsa		usb_config[0].bufsize = 0;	/* use default */
258192984Sthompsa		usb_config[0].frames = f->nframes;
259192984Sthompsa		usb_config[0].callback = &ugen_isoc_write_callback;
260192984Sthompsa		usb_config[0].timeout = 0;
261184610Salfred
262184610Salfred		/* clone configuration */
263192984Sthompsa		usb_config[1] = usb_config[0];
264184610Salfred
265192984Sthompsa		if (ugen_transfer_setup(f, usb_config, 2)) {
266184610Salfred			return (EIO);
267184610Salfred		}
268184610Salfred		break;
269184610Salfred	default:
270184610Salfred		return (EINVAL);
271184610Salfred	}
272184610Salfred	return (0);
273184610Salfred}
274184610Salfred
275184610Salfredstatic int
276192984Sthompsaugen_open_pipe_read(struct usb_fifo *f)
277184610Salfred{
278192984Sthompsa	struct usb_config usb_config[2];
279193644Sthompsa	struct usb_endpoint *ep = f->priv_sc0;
280193644Sthompsa	struct usb_endpoint_descriptor *ed = ep->edesc;
281184610Salfred
282184610Salfred	mtx_assert(f->priv_mtx, MA_OWNED);
283184610Salfred
284184610Salfred	if (f->xfer[0] || f->xfer[1]) {
285184610Salfred		/* transfers are already opened */
286184610Salfred		return (0);
287184610Salfred	}
288192984Sthompsa	bzero(usb_config, sizeof(usb_config));
289184610Salfred
290192984Sthompsa	usb_config[1].type = UE_CONTROL;
291192984Sthompsa	usb_config[1].endpoint = 0;
292192984Sthompsa	usb_config[1].direction = UE_DIR_ANY;
293192984Sthompsa	usb_config[1].timeout = 1000;	/* 1 second */
294192984Sthompsa	usb_config[1].interval = 50;/* 50 milliseconds */
295192984Sthompsa	usb_config[1].bufsize = sizeof(struct usb_device_request);
296192984Sthompsa	usb_config[1].callback = &ugen_read_clear_stall_callback;
297192984Sthompsa	usb_config[1].usb_mode = USB_MODE_HOST;
298184610Salfred
299192984Sthompsa	usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
300192984Sthompsa	usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
301192984Sthompsa	usb_config[0].direction = UE_DIR_RX;
302192984Sthompsa	usb_config[0].interval = USB_DEFAULT_INTERVAL;
303192984Sthompsa	usb_config[0].flags.proxy_buffer = 1;
304192984Sthompsa	usb_config[0].usb_mode = USB_MODE_DUAL;	/* both modes */
305184610Salfred
306184610Salfred	switch (ed->bmAttributes & UE_XFERTYPE) {
307184610Salfred	case UE_INTERRUPT:
308184610Salfred	case UE_BULK:
309184610Salfred		if (f->flag_short) {
310192984Sthompsa			usb_config[0].flags.short_xfer_ok = 1;
311184610Salfred		}
312192984Sthompsa		usb_config[0].timeout = f->timeout;
313192984Sthompsa		usb_config[0].frames = 1;
314192984Sthompsa		usb_config[0].callback = &ugen_default_read_callback;
315192984Sthompsa		usb_config[0].bufsize = f->bufsize;
316184610Salfred
317192984Sthompsa		if (ugen_transfer_setup(f, usb_config, 2)) {
318184610Salfred			return (EIO);
319184610Salfred		}
320184610Salfred		/* first transfer does not clear stall */
321184610Salfred		f->flag_stall = 0;
322184610Salfred		break;
323184610Salfred
324184610Salfred	case UE_ISOCHRONOUS:
325192984Sthompsa		usb_config[0].flags.short_xfer_ok = 1;
326192984Sthompsa		usb_config[0].bufsize = 0;	/* use default */
327192984Sthompsa		usb_config[0].frames = f->nframes;
328192984Sthompsa		usb_config[0].callback = &ugen_isoc_read_callback;
329192984Sthompsa		usb_config[0].timeout = 0;
330184610Salfred
331184610Salfred		/* clone configuration */
332192984Sthompsa		usb_config[1] = usb_config[0];
333184610Salfred
334192984Sthompsa		if (ugen_transfer_setup(f, usb_config, 2)) {
335184610Salfred			return (EIO);
336184610Salfred		}
337184610Salfred		break;
338184610Salfred
339184610Salfred	default:
340184610Salfred		return (EINVAL);
341184610Salfred	}
342184610Salfred	return (0);
343184610Salfred}
344184610Salfred
345184610Salfredstatic void
346192984Sthompsaugen_start_read(struct usb_fifo *f)
347184610Salfred{
348184610Salfred	/* check that pipes are open */
349184610Salfred	if (ugen_open_pipe_read(f)) {
350184610Salfred		/* signal error */
351194228Sthompsa		usb_fifo_put_data_error(f);
352184610Salfred	}
353184610Salfred	/* start transfers */
354194228Sthompsa	usbd_transfer_start(f->xfer[0]);
355194228Sthompsa	usbd_transfer_start(f->xfer[1]);
356184610Salfred}
357184610Salfred
358184610Salfredstatic void
359192984Sthompsaugen_start_write(struct usb_fifo *f)
360184610Salfred{
361184610Salfred	/* check that pipes are open */
362184610Salfred	if (ugen_open_pipe_write(f)) {
363184610Salfred		/* signal error */
364194228Sthompsa		usb_fifo_get_data_error(f);
365184610Salfred	}
366184610Salfred	/* start transfers */
367194228Sthompsa	usbd_transfer_start(f->xfer[0]);
368194228Sthompsa	usbd_transfer_start(f->xfer[1]);
369184610Salfred}
370184610Salfred
371184610Salfredstatic void
372192984Sthompsaugen_stop_io(struct usb_fifo *f)
373184610Salfred{
374184610Salfred	/* stop transfers */
375194228Sthompsa	usbd_transfer_stop(f->xfer[0]);
376194228Sthompsa	usbd_transfer_stop(f->xfer[1]);
377184610Salfred}
378184610Salfred
379184610Salfredstatic void
380192984Sthompsaugen_default_read_callback(struct usb_xfer *xfer)
381184610Salfred{
382192984Sthompsa	struct usb_fifo *f = xfer->priv_sc;
383192984Sthompsa	struct usb_mbuf *m;
384184610Salfred
385184610Salfred	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
386184610Salfred
387184610Salfred	switch (USB_GET_STATE(xfer)) {
388184610Salfred	case USB_ST_TRANSFERRED:
389184610Salfred		if (xfer->actlen == 0) {
390184610Salfred			if (f->fifo_zlp != 4) {
391184610Salfred				f->fifo_zlp++;
392184610Salfred			} else {
393184610Salfred				/*
394184610Salfred				 * Throttle a little bit we have multiple ZLPs
395184610Salfred				 * in a row!
396184610Salfred				 */
397184610Salfred				xfer->interval = 64;	/* ms */
398184610Salfred			}
399184610Salfred		} else {
400184610Salfred			/* clear throttle */
401184610Salfred			xfer->interval = 0;
402184610Salfred			f->fifo_zlp = 0;
403184610Salfred		}
404194228Sthompsa		usb_fifo_put_data(f, xfer->frbuffers, 0,
405184610Salfred		    xfer->actlen, 1);
406184610Salfred
407184610Salfred	case USB_ST_SETUP:
408184610Salfred		if (f->flag_stall) {
409194228Sthompsa			usbd_transfer_start(f->xfer[1]);
410184610Salfred			break;
411184610Salfred		}
412184610Salfred		USB_IF_POLL(&f->free_q, m);
413184610Salfred		if (m) {
414184610Salfred			xfer->frlengths[0] = xfer->max_data_length;
415194228Sthompsa			usbd_transfer_submit(xfer);
416184610Salfred		}
417184610Salfred		break;
418184610Salfred
419184610Salfred	default:			/* Error */
420184610Salfred		if (xfer->error != USB_ERR_CANCELLED) {
421190188Sthompsa			/* send a zero length packet to userland */
422194228Sthompsa			usb_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
423184610Salfred			f->flag_stall = 1;
424184610Salfred			f->fifo_zlp = 0;
425194228Sthompsa			usbd_transfer_start(f->xfer[1]);
426184610Salfred		}
427184610Salfred		break;
428184610Salfred	}
429184610Salfred}
430184610Salfred
431184610Salfredstatic void
432192984Sthompsaugen_default_write_callback(struct usb_xfer *xfer)
433184610Salfred{
434192984Sthompsa	struct usb_fifo *f = xfer->priv_sc;
435193045Sthompsa	usb_frlength_t actlen;
436184610Salfred
437184610Salfred	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
438184610Salfred
439184610Salfred	switch (USB_GET_STATE(xfer)) {
440184610Salfred	case USB_ST_SETUP:
441184610Salfred	case USB_ST_TRANSFERRED:
442184610Salfred		/*
443184610Salfred		 * If writing is in stall, just jump to clear stall
444184610Salfred		 * callback and solve the situation.
445184610Salfred		 */
446184610Salfred		if (f->flag_stall) {
447194228Sthompsa			usbd_transfer_start(f->xfer[1]);
448184610Salfred			break;
449184610Salfred		}
450184610Salfred		/*
451184610Salfred		 * Write data, setup and perform hardware transfer.
452184610Salfred		 */
453194228Sthompsa		if (usb_fifo_get_data(f, xfer->frbuffers, 0,
454184610Salfred		    xfer->max_data_length, &actlen, 0)) {
455184610Salfred			xfer->frlengths[0] = actlen;
456194228Sthompsa			usbd_transfer_submit(xfer);
457184610Salfred		}
458184610Salfred		break;
459184610Salfred
460184610Salfred	default:			/* Error */
461184610Salfred		if (xfer->error != USB_ERR_CANCELLED) {
462184610Salfred			f->flag_stall = 1;
463194228Sthompsa			usbd_transfer_start(f->xfer[1]);
464184610Salfred		}
465184610Salfred		break;
466184610Salfred	}
467184610Salfred}
468184610Salfred
469184610Salfredstatic void
470192984Sthompsaugen_read_clear_stall_callback(struct usb_xfer *xfer)
471184610Salfred{
472192984Sthompsa	struct usb_fifo *f = xfer->priv_sc;
473192984Sthompsa	struct usb_xfer *xfer_other = f->xfer[0];
474184610Salfred
475184610Salfred	if (f->flag_stall == 0) {
476184610Salfred		/* nothing to do */
477184610Salfred		return;
478184610Salfred	}
479194228Sthompsa	if (usbd_clear_stall_callback(xfer, xfer_other)) {
480184610Salfred		DPRINTFN(5, "f=%p: stall cleared\n", f);
481184610Salfred		f->flag_stall = 0;
482194228Sthompsa		usbd_transfer_start(xfer_other);
483184610Salfred	}
484184610Salfred}
485184610Salfred
486184610Salfredstatic void
487192984Sthompsaugen_write_clear_stall_callback(struct usb_xfer *xfer)
488184610Salfred{
489192984Sthompsa	struct usb_fifo *f = xfer->priv_sc;
490192984Sthompsa	struct usb_xfer *xfer_other = f->xfer[0];
491184610Salfred
492184610Salfred	if (f->flag_stall == 0) {
493184610Salfred		/* nothing to do */
494184610Salfred		return;
495184610Salfred	}
496194228Sthompsa	if (usbd_clear_stall_callback(xfer, xfer_other)) {
497184610Salfred		DPRINTFN(5, "f=%p: stall cleared\n", f);
498184610Salfred		f->flag_stall = 0;
499194228Sthompsa		usbd_transfer_start(xfer_other);
500184610Salfred	}
501184610Salfred}
502184610Salfred
503184610Salfredstatic void
504192984Sthompsaugen_isoc_read_callback(struct usb_xfer *xfer)
505184610Salfred{
506192984Sthompsa	struct usb_fifo *f = xfer->priv_sc;
507193045Sthompsa	usb_frlength_t offset;
508193045Sthompsa	usb_frcount_t n;
509184610Salfred
510184610Salfred	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
511184610Salfred
512184610Salfred	switch (USB_GET_STATE(xfer)) {
513184610Salfred	case USB_ST_TRANSFERRED:
514184610Salfred
515184610Salfred		DPRINTFN(6, "actlen=%d\n", xfer->actlen);
516184610Salfred
517184610Salfred		offset = 0;
518184610Salfred
519184610Salfred		for (n = 0; n != xfer->aframes; n++) {
520194228Sthompsa			usb_fifo_put_data(f, xfer->frbuffers, offset,
521184610Salfred			    xfer->frlengths[n], 1);
522184610Salfred			offset += xfer->max_frame_size;
523184610Salfred		}
524184610Salfred
525184610Salfred	case USB_ST_SETUP:
526184610Salfredtr_setup:
527184610Salfred		for (n = 0; n != xfer->nframes; n++) {
528184610Salfred			/* setup size for next transfer */
529184610Salfred			xfer->frlengths[n] = xfer->max_frame_size;
530184610Salfred		}
531194228Sthompsa		usbd_transfer_submit(xfer);
532184610Salfred		break;
533184610Salfred
534184610Salfred	default:			/* Error */
535184610Salfred		if (xfer->error == USB_ERR_CANCELLED) {
536184610Salfred			break;
537184610Salfred		}
538184610Salfred		goto tr_setup;
539184610Salfred	}
540184610Salfred}
541184610Salfred
542184610Salfredstatic void
543192984Sthompsaugen_isoc_write_callback(struct usb_xfer *xfer)
544184610Salfred{
545192984Sthompsa	struct usb_fifo *f = xfer->priv_sc;
546193045Sthompsa	usb_frlength_t actlen;
547193045Sthompsa	usb_frlength_t offset;
548193045Sthompsa	usb_frcount_t n;
549184610Salfred
550184610Salfred	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
551184610Salfred
552184610Salfred	switch (USB_GET_STATE(xfer)) {
553184610Salfred	case USB_ST_TRANSFERRED:
554184610Salfred	case USB_ST_SETUP:
555184610Salfredtr_setup:
556184610Salfred		offset = 0;
557184610Salfred		for (n = 0; n != xfer->nframes; n++) {
558194228Sthompsa			if (usb_fifo_get_data(f, xfer->frbuffers, offset,
559184610Salfred			    xfer->max_frame_size, &actlen, 1)) {
560184610Salfred				xfer->frlengths[n] = actlen;
561184610Salfred				offset += actlen;
562184610Salfred			} else {
563184610Salfred				break;
564184610Salfred			}
565184610Salfred		}
566184610Salfred
567184610Salfred		for (; n != xfer->nframes; n++) {
568184610Salfred			/* fill in zero frames */
569184610Salfred			xfer->frlengths[n] = 0;
570184610Salfred		}
571194228Sthompsa		usbd_transfer_submit(xfer);
572184610Salfred		break;
573184610Salfred
574184610Salfred	default:			/* Error */
575184610Salfred		if (xfer->error == USB_ERR_CANCELLED) {
576184610Salfred			break;
577184610Salfred		}
578184610Salfred		goto tr_setup;
579184610Salfred	}
580184610Salfred}
581184610Salfred
582184610Salfredstatic int
583192984Sthompsaugen_set_config(struct usb_fifo *f, uint8_t index)
584184610Salfred{
585184610Salfred	DPRINTFN(2, "index %u\n", index);
586184610Salfred
587192499Sthompsa	if (f->udev->flags.usb_mode != USB_MODE_HOST) {
588184610Salfred		/* not possible in device side mode */
589184610Salfred		return (ENOTTY);
590184610Salfred	}
591184610Salfred	if (f->udev->curr_config_index == index) {
592184610Salfred		/* no change needed */
593184610Salfred		return (0);
594184610Salfred	}
595185290Salfred	/* make sure all FIFO's are gone */
596185290Salfred	/* else there can be a deadlock */
597185290Salfred	if (ugen_fs_uninit(f)) {
598185290Salfred		/* ignore any errors */
599185290Salfred		DPRINTFN(6, "no FIFOs\n");
600185290Salfred	}
601184610Salfred	/* change setting - will free generic FIFOs, if any */
602194228Sthompsa	if (usbd_set_config_index(f->udev, index)) {
603184610Salfred		return (EIO);
604184610Salfred	}
605184610Salfred	/* probe and attach */
606194228Sthompsa	if (usb_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) {
607184610Salfred		return (EIO);
608184610Salfred	}
609184610Salfred	return (0);
610184610Salfred}
611184610Salfred
612184610Salfredstatic int
613192984Sthompsaugen_set_interface(struct usb_fifo *f,
614184610Salfred    uint8_t iface_index, uint8_t alt_index)
615184610Salfred{
616184610Salfred	DPRINTFN(2, "%u, %u\n", iface_index, alt_index);
617184610Salfred
618192499Sthompsa	if (f->udev->flags.usb_mode != USB_MODE_HOST) {
619184610Salfred		/* not possible in device side mode */
620184610Salfred		return (ENOTTY);
621184610Salfred	}
622185290Salfred	/* make sure all FIFO's are gone */
623185290Salfred	/* else there can be a deadlock */
624185290Salfred	if (ugen_fs_uninit(f)) {
625185290Salfred		/* ignore any errors */
626185290Salfred		DPRINTFN(6, "no FIFOs\n");
627185290Salfred	}
628184610Salfred	/* change setting - will free generic FIFOs, if any */
629194228Sthompsa	if (usbd_set_alt_interface_index(f->udev, iface_index, alt_index)) {
630184610Salfred		return (EIO);
631184610Salfred	}
632184610Salfred	/* probe and attach */
633194228Sthompsa	if (usb_probe_and_attach(f->udev, iface_index)) {
634184610Salfred		return (EIO);
635184610Salfred	}
636184610Salfred	return (0);
637184610Salfred}
638184610Salfred
639184610Salfred/*------------------------------------------------------------------------*
640184610Salfred *	ugen_get_cdesc
641184610Salfred *
642184610Salfred * This function will retrieve the complete configuration descriptor
643184610Salfred * at the given index.
644184610Salfred *------------------------------------------------------------------------*/
645184610Salfredstatic int
646192984Sthompsaugen_get_cdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
647184610Salfred{
648192984Sthompsa	struct usb_config_descriptor *cdesc;
649192984Sthompsa	struct usb_device *udev = f->udev;
650184610Salfred	int error;
651184610Salfred	uint16_t len;
652184610Salfred	uint8_t free_data;
653184610Salfred
654184610Salfred	DPRINTFN(6, "\n");
655184610Salfred
656184610Salfred	if (ugd->ugd_data == NULL) {
657184610Salfred		/* userland pointer should not be zero */
658184610Salfred		return (EINVAL);
659184610Salfred	}
660184610Salfred	if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) ||
661184610Salfred	    (ugd->ugd_config_index == udev->curr_config_index)) {
662194228Sthompsa		cdesc = usbd_get_config_descriptor(udev);
663184610Salfred		if (cdesc == NULL) {
664184610Salfred			return (ENXIO);
665184610Salfred		}
666184610Salfred		free_data = 0;
667184610Salfred
668184610Salfred	} else {
669194228Sthompsa		if (usbd_req_get_config_desc_full(udev,
670188986Sthompsa		    NULL, &cdesc, M_USBDEV,
671184610Salfred		    ugd->ugd_config_index)) {
672184610Salfred			return (ENXIO);
673184610Salfred		}
674184610Salfred		free_data = 1;
675184610Salfred	}
676184610Salfred
677184610Salfred	len = UGETW(cdesc->wTotalLength);
678184610Salfred	if (len > ugd->ugd_maxlen) {
679184610Salfred		len = ugd->ugd_maxlen;
680184610Salfred	}
681184610Salfred	DPRINTFN(6, "len=%u\n", len);
682184610Salfred
683184610Salfred	ugd->ugd_actlen = len;
684184610Salfred	ugd->ugd_offset = 0;
685184610Salfred
686184610Salfred	error = copyout(cdesc, ugd->ugd_data, len);
687184610Salfred
688184610Salfred	if (free_data) {
689184610Salfred		free(cdesc, M_USBDEV);
690184610Salfred	}
691184610Salfred	return (error);
692184610Salfred}
693184610Salfred
694184610Salfredstatic int
695192984Sthompsaugen_get_sdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
696184610Salfred{
697184610Salfred	void *ptr = f->udev->bus->scratch[0].data;
698184610Salfred	uint16_t size = sizeof(f->udev->bus->scratch[0].data);
699184610Salfred	int error;
700184610Salfred
701194228Sthompsa	if (usbd_req_get_string_desc(f->udev, NULL, ptr,
702184610Salfred	    size, ugd->ugd_lang_id, ugd->ugd_string_index)) {
703184610Salfred		error = EINVAL;
704184610Salfred	} else {
705184610Salfred
706184610Salfred		if (size > ((uint8_t *)ptr)[0]) {
707184610Salfred			size = ((uint8_t *)ptr)[0];
708184610Salfred		}
709184610Salfred		if (size > ugd->ugd_maxlen) {
710184610Salfred			size = ugd->ugd_maxlen;
711184610Salfred		}
712184610Salfred		ugd->ugd_actlen = size;
713184610Salfred		ugd->ugd_offset = 0;
714184610Salfred
715184610Salfred		error = copyout(ptr, ugd->ugd_data, size);
716184610Salfred	}
717184610Salfred	return (error);
718184610Salfred}
719184610Salfred
720184610Salfred/*------------------------------------------------------------------------*
721188622Sthompsa *	ugen_get_iface_driver
722184610Salfred *
723188622Sthompsa * This function generates an USB interface description for userland.
724184610Salfred *
725184610Salfred * Returns:
726184610Salfred *    0: Success
727184610Salfred * Else: Failure
728184610Salfred *------------------------------------------------------------------------*/
729184610Salfredstatic int
730192984Sthompsaugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
731184610Salfred{
732192984Sthompsa	struct usb_device *udev = f->udev;
733192984Sthompsa	struct usb_interface *iface;
734184610Salfred	const char *ptr;
735188622Sthompsa	const char *desc;
736188622Sthompsa	unsigned int len;
737188622Sthompsa	unsigned int maxlen;
738188622Sthompsa	char buf[128];
739188622Sthompsa	int error;
740184610Salfred
741188622Sthompsa	DPRINTFN(6, "\n");
742184610Salfred
743188622Sthompsa	if ((ugd->ugd_data == NULL) || (ugd->ugd_maxlen == 0)) {
744188622Sthompsa		/* userland pointer should not be zero */
745184610Salfred		return (EINVAL);
746184610Salfred	}
747188622Sthompsa
748194228Sthompsa	iface = usbd_get_iface(udev, ugd->ugd_iface_index);
749188622Sthompsa	if ((iface == NULL) || (iface->idesc == NULL)) {
750188622Sthompsa		/* invalid interface index */
751188622Sthompsa		return (EINVAL);
752184610Salfred	}
753188622Sthompsa
754188622Sthompsa	/* read out device nameunit string, if any */
755188622Sthompsa	if ((iface->subdev != NULL) &&
756188622Sthompsa	    device_is_attached(iface->subdev) &&
757188622Sthompsa	    (ptr = device_get_nameunit(iface->subdev)) &&
758188622Sthompsa	    (desc = device_get_desc(iface->subdev))) {
759188622Sthompsa
760188622Sthompsa		/* print description */
761188622Sthompsa		snprintf(buf, sizeof(buf), "%s: <%s>", ptr, desc);
762188622Sthompsa
763188622Sthompsa		/* range checks */
764188622Sthompsa		maxlen = ugd->ugd_maxlen - 1;
765188622Sthompsa		len = strlen(buf);
766188622Sthompsa		if (len > maxlen)
767188622Sthompsa			len = maxlen;
768188622Sthompsa
769188622Sthompsa		/* update actual length, including terminating zero */
770188622Sthompsa		ugd->ugd_actlen = len + 1;
771188622Sthompsa
772188622Sthompsa		/* copy out interface description */
773188622Sthompsa		error = copyout(buf, ugd->ugd_data, ugd->ugd_actlen);
774188622Sthompsa	} else {
775188622Sthompsa		/* zero length string is default */
776188622Sthompsa		error = copyout("", ugd->ugd_data, 1);
777184610Salfred	}
778188622Sthompsa	return (error);
779184610Salfred}
780184610Salfred
781184610Salfred/*------------------------------------------------------------------------*
782194228Sthompsa *	usb_gen_fill_deviceinfo
783184610Salfred *
784184610Salfred * This function dumps information about an USB device to the
785184610Salfred * structure pointed to by the "di" argument.
786184610Salfred *
787184610Salfred * Returns:
788184610Salfred *    0: Success
789184610Salfred * Else: Failure
790184610Salfred *------------------------------------------------------------------------*/
791184610Salfredstatic int
792194228Sthompsausb_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di)
793184610Salfred{
794192984Sthompsa	struct usb_device *udev;
795192984Sthompsa	struct usb_device *hub;
796184610Salfred
797184610Salfred	udev = f->udev;
798184610Salfred
799184610Salfred	bzero(di, sizeof(di[0]));
800184610Salfred
801184610Salfred	di->udi_bus = device_get_unit(udev->bus->bdev);
802184610Salfred	di->udi_addr = udev->address;
803184610Salfred	di->udi_index = udev->device_index;
804192938Sthompsa	strlcpy(di->udi_serial, udev->serial, sizeof(di->udi_serial));
805192938Sthompsa	strlcpy(di->udi_vendor, udev->manufacturer, sizeof(di->udi_vendor));
806192938Sthompsa	strlcpy(di->udi_product, udev->product, sizeof(di->udi_product));
807194228Sthompsa	usb_printbcd(di->udi_release, sizeof(di->udi_release),
808184610Salfred	    UGETW(udev->ddesc.bcdDevice));
809184610Salfred	di->udi_vendorNo = UGETW(udev->ddesc.idVendor);
810184610Salfred	di->udi_productNo = UGETW(udev->ddesc.idProduct);
811184610Salfred	di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice);
812184610Salfred	di->udi_class = udev->ddesc.bDeviceClass;
813184610Salfred	di->udi_subclass = udev->ddesc.bDeviceSubClass;
814184610Salfred	di->udi_protocol = udev->ddesc.bDeviceProtocol;
815184610Salfred	di->udi_config_no = udev->curr_config_no;
816184610Salfred	di->udi_config_index = udev->curr_config_index;
817184610Salfred	di->udi_power = udev->flags.self_powered ? 0 : udev->power;
818184610Salfred	di->udi_speed = udev->speed;
819192499Sthompsa	di->udi_mode = udev->flags.usb_mode;
820184610Salfred	di->udi_power_mode = udev->power_mode;
821191824Sthompsa	di->udi_suspended = udev->flags.peer_suspended;
822184610Salfred
823184610Salfred	hub = udev->parent_hub;
824184610Salfred	if (hub) {
825184610Salfred		di->udi_hubaddr = hub->address;
826184610Salfred		di->udi_hubindex = hub->device_index;
827184610Salfred		di->udi_hubport = udev->port_no;
828184610Salfred	}
829184610Salfred	return (0);
830184610Salfred}
831184610Salfred
832184610Salfred/*------------------------------------------------------------------------*
833184610Salfred *	ugen_check_request
834184610Salfred *
835184610Salfred * Return values:
836184610Salfred * 0: Access allowed
837184610Salfred * Else: No access
838184610Salfred *------------------------------------------------------------------------*/
839184610Salfredstatic int
840192984Sthompsaugen_check_request(struct usb_device *udev, struct usb_device_request *req)
841184610Salfred{
842193644Sthompsa	struct usb_endpoint *ep;
843184610Salfred	int error;
844184610Salfred
845184610Salfred	/*
846184610Salfred	 * Avoid requests that would damage the bus integrity:
847184610Salfred	 */
848184610Salfred	if (((req->bmRequestType == UT_WRITE_DEVICE) &&
849184610Salfred	    (req->bRequest == UR_SET_ADDRESS)) ||
850184610Salfred	    ((req->bmRequestType == UT_WRITE_DEVICE) &&
851184610Salfred	    (req->bRequest == UR_SET_CONFIG)) ||
852184610Salfred	    ((req->bmRequestType == UT_WRITE_INTERFACE) &&
853184610Salfred	    (req->bRequest == UR_SET_INTERFACE))) {
854184610Salfred		/*
855184610Salfred		 * These requests can be useful for testing USB drivers.
856184610Salfred		 */
857184610Salfred		error = priv_check(curthread, PRIV_DRIVER);
858184610Salfred		if (error) {
859184610Salfred			return (error);
860184610Salfred		}
861184610Salfred	}
862184610Salfred	/*
863184610Salfred	 * Special case - handle clearing of stall
864184610Salfred	 */
865184610Salfred	if (req->bmRequestType == UT_WRITE_ENDPOINT) {
866184610Salfred
867194228Sthompsa		ep = usbd_get_ep_by_addr(udev, req->wIndex[0]);
868193644Sthompsa		if (ep == NULL) {
869184610Salfred			return (EINVAL);
870184610Salfred		}
871184610Salfred		if ((req->bRequest == UR_CLEAR_FEATURE) &&
872184610Salfred		    (UGETW(req->wValue) == UF_ENDPOINT_HALT)) {
873194228Sthompsa			usbd_clear_data_toggle(udev, ep);
874184610Salfred		}
875184610Salfred	}
876184610Salfred	/* TODO: add more checks to verify the interface index */
877184610Salfred
878184610Salfred	return (0);
879184610Salfred}
880184610Salfred
881184610Salfredint
882192984Sthompsaugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur)
883184610Salfred{
884184610Salfred	int error;
885184610Salfred	uint16_t len;
886184610Salfred	uint16_t actlen;
887184610Salfred
888184610Salfred	if (ugen_check_request(f->udev, &ur->ucr_request)) {
889184610Salfred		return (EPERM);
890184610Salfred	}
891184610Salfred	len = UGETW(ur->ucr_request.wLength);
892184610Salfred
893184610Salfred	/* check if "ucr_data" is valid */
894184610Salfred	if (len != 0) {
895184610Salfred		if (ur->ucr_data == NULL) {
896184610Salfred			return (EFAULT);
897184610Salfred		}
898184610Salfred	}
899184610Salfred	/* do the USB request */
900194228Sthompsa	error = usbd_do_request_flags
901184610Salfred	    (f->udev, NULL, &ur->ucr_request, ur->ucr_data,
902184610Salfred	    (ur->ucr_flags & USB_SHORT_XFER_OK) |
903184610Salfred	    USB_USER_DATA_PTR, &actlen,
904184610Salfred	    USB_DEFAULT_TIMEOUT);
905184610Salfred
906184610Salfred	ur->ucr_actlen = actlen;
907184610Salfred
908184610Salfred	if (error) {
909184610Salfred		error = EIO;
910184610Salfred	}
911184610Salfred	return (error);
912184610Salfred}
913184610Salfred
914184610Salfred/*------------------------------------------------------------------------
915184610Salfred *	ugen_re_enumerate
916184610Salfred *------------------------------------------------------------------------*/
917184610Salfredstatic int
918192984Sthompsaugen_re_enumerate(struct usb_fifo *f)
919184610Salfred{
920192984Sthompsa	struct usb_device *udev = f->udev;
921184610Salfred	int error;
922184610Salfred
923184610Salfred	/*
924184610Salfred	 * This request can be useful for testing USB drivers:
925184610Salfred	 */
926184610Salfred	error = priv_check(curthread, PRIV_DRIVER);
927184610Salfred	if (error) {
928184610Salfred		return (error);
929184610Salfred	}
930185087Salfred	/* get the device unconfigured */
931185087Salfred	error = ugen_set_config(f, USB_UNCONFIG_INDEX);
932185087Salfred	if (error) {
933185087Salfred		return (error);
934185087Salfred	}
935185087Salfred	/* do a bus-reset */
936184610Salfred	mtx_lock(f->priv_mtx);
937194228Sthompsa	error = usbd_req_re_enumerate(udev, f->priv_mtx);
938184610Salfred	mtx_unlock(f->priv_mtx);
939184610Salfred
940184610Salfred	if (error) {
941184610Salfred		return (ENXIO);
942184610Salfred	}
943185087Salfred	/* restore configuration to index 0 */
944185087Salfred	error = ugen_set_config(f, 0);
945185087Salfred	if (error) {
946185087Salfred		return (error);
947185087Salfred	}
948184610Salfred	return (0);
949184610Salfred}
950184610Salfred
951185087Salfredint
952192984Sthompsaugen_fs_uninit(struct usb_fifo *f)
953184610Salfred{
954184610Salfred	if (f->fs_xfer == NULL) {
955184610Salfred		return (EINVAL);
956184610Salfred	}
957194228Sthompsa	usbd_transfer_unsetup(f->fs_xfer, f->fs_ep_max);
958184610Salfred	free(f->fs_xfer, M_USB);
959184610Salfred	f->fs_xfer = NULL;
960184610Salfred	f->fs_ep_max = 0;
961184610Salfred	f->fs_ep_ptr = NULL;
962184610Salfred	f->flag_iscomplete = 0;
963194228Sthompsa	usb_fifo_free_buffer(f);
964184610Salfred	return (0);
965184610Salfred}
966184610Salfred
967184610Salfredstatic uint8_t
968192984Sthompsaugen_fs_get_complete(struct usb_fifo *f, uint8_t *pindex)
969184610Salfred{
970192984Sthompsa	struct usb_mbuf *m;
971184610Salfred
972184610Salfred	USB_IF_DEQUEUE(&f->used_q, m);
973184610Salfred
974184610Salfred	if (m) {
975184610Salfred		*pindex = *((uint8_t *)(m->cur_data_ptr));
976184610Salfred
977184610Salfred		USB_IF_ENQUEUE(&f->free_q, m);
978184610Salfred
979184610Salfred		return (0);		/* success */
980184610Salfred	} else {
981184610Salfred
982184610Salfred		*pindex = 0;		/* fix compiler warning */
983184610Salfred
984184610Salfred		f->flag_iscomplete = 0;
985184610Salfred	}
986184610Salfred	return (1);			/* failure */
987184610Salfred}
988184610Salfred
989184610Salfredstatic void
990192984Sthompsaugen_fs_set_complete(struct usb_fifo *f, uint8_t index)
991184610Salfred{
992192984Sthompsa	struct usb_mbuf *m;
993184610Salfred
994184610Salfred	USB_IF_DEQUEUE(&f->free_q, m);
995184610Salfred
996184610Salfred	if (m == NULL) {
997184610Salfred		/* can happen during close */
998184610Salfred		DPRINTF("out of buffers\n");
999184610Salfred		return;
1000184610Salfred	}
1001184610Salfred	USB_MBUF_RESET(m);
1002184610Salfred
1003184610Salfred	*((uint8_t *)(m->cur_data_ptr)) = index;
1004184610Salfred
1005184610Salfred	USB_IF_ENQUEUE(&f->used_q, m);
1006184610Salfred
1007184610Salfred	f->flag_iscomplete = 1;
1008184610Salfred
1009194228Sthompsa	usb_fifo_wakeup(f);
1010184610Salfred}
1011184610Salfred
1012184610Salfredstatic int
1013192984Sthompsaugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
1014184610Salfred{
1015192984Sthompsa	struct usb_device_request *req;
1016192984Sthompsa	struct usb_xfer *xfer;
1017192984Sthompsa	struct usb_fs_endpoint fs_ep;
1018184610Salfred	void *uaddr;			/* userland pointer */
1019184610Salfred	void *kaddr;
1020193045Sthompsa	usb_frlength_t offset;
1021193045Sthompsa	usb_frlength_t rem;
1022193045Sthompsa	usb_frcount_t n;
1023184610Salfred	uint32_t length;
1024184610Salfred	int error;
1025184610Salfred	uint8_t isread;
1026184610Salfred
1027184610Salfred	if (ep_index >= f->fs_ep_max) {
1028184610Salfred		return (EINVAL);
1029184610Salfred	}
1030184610Salfred	xfer = f->fs_xfer[ep_index];
1031184610Salfred	if (xfer == NULL) {
1032184610Salfred		return (EINVAL);
1033184610Salfred	}
1034184610Salfred	mtx_lock(f->priv_mtx);
1035194228Sthompsa	if (usbd_transfer_pending(xfer)) {
1036184610Salfred		mtx_unlock(f->priv_mtx);
1037184610Salfred		return (EBUSY);		/* should not happen */
1038184610Salfred	}
1039184610Salfred	mtx_unlock(f->priv_mtx);
1040184610Salfred
1041184610Salfred	error = copyin(f->fs_ep_ptr +
1042184610Salfred	    ep_index, &fs_ep, sizeof(fs_ep));
1043184610Salfred	if (error) {
1044184610Salfred		return (error);
1045184610Salfred	}
1046184610Salfred	/* security checks */
1047184610Salfred
1048184610Salfred	if (fs_ep.nFrames > xfer->max_frame_count) {
1049184610Salfred		xfer->error = USB_ERR_INVAL;
1050184610Salfred		goto complete;
1051184610Salfred	}
1052184610Salfred	if (fs_ep.nFrames == 0) {
1053184610Salfred		xfer->error = USB_ERR_INVAL;
1054184610Salfred		goto complete;
1055184610Salfred	}
1056184610Salfred	error = copyin(fs_ep.ppBuffer,
1057184610Salfred	    &uaddr, sizeof(uaddr));
1058184610Salfred	if (error) {
1059184610Salfred		return (error);
1060184610Salfred	}
1061184610Salfred	/* reset first frame */
1062194228Sthompsa	usbd_set_frame_offset(xfer, 0, 0);
1063184610Salfred
1064184610Salfred	if (xfer->flags_int.control_xfr) {
1065184610Salfred
1066184610Salfred		req = xfer->frbuffers[0].buffer;
1067184610Salfred
1068184610Salfred		error = copyin(fs_ep.pLength,
1069184610Salfred		    &length, sizeof(length));
1070184610Salfred		if (error) {
1071184610Salfred			return (error);
1072184610Salfred		}
1073194659Sthompsa		if (length != sizeof(*req)) {
1074184610Salfred			xfer->error = USB_ERR_INVAL;
1075184610Salfred			goto complete;
1076184610Salfred		}
1077184610Salfred		if (length != 0) {
1078184610Salfred			error = copyin(uaddr, req, length);
1079184610Salfred			if (error) {
1080184610Salfred				return (error);
1081184610Salfred			}
1082184610Salfred		}
1083184610Salfred		if (ugen_check_request(f->udev, req)) {
1084184610Salfred			xfer->error = USB_ERR_INVAL;
1085184610Salfred			goto complete;
1086184610Salfred		}
1087184610Salfred		xfer->frlengths[0] = length;
1088184610Salfred
1089184610Salfred		/* Host mode only ! */
1090184610Salfred		if ((req->bmRequestType &
1091184610Salfred		    (UT_READ | UT_WRITE)) == UT_READ) {
1092184610Salfred			isread = 1;
1093184610Salfred		} else {
1094184610Salfred			isread = 0;
1095184610Salfred		}
1096184610Salfred		n = 1;
1097184610Salfred		offset = sizeof(*req);
1098184610Salfred
1099184610Salfred	} else {
1100184610Salfred		/* Device and Host mode */
1101184610Salfred		if (USB_GET_DATA_ISREAD(xfer)) {
1102184610Salfred			isread = 1;
1103184610Salfred		} else {
1104184610Salfred			isread = 0;
1105184610Salfred		}
1106184610Salfred		n = 0;
1107184610Salfred		offset = 0;
1108184610Salfred	}
1109184610Salfred
1110184610Salfred	rem = xfer->max_data_length;
1111184610Salfred	xfer->nframes = fs_ep.nFrames;
1112184610Salfred	xfer->timeout = fs_ep.timeout;
1113184610Salfred	if (xfer->timeout > 65535) {
1114184610Salfred		xfer->timeout = 65535;
1115184610Salfred	}
1116184610Salfred	if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
1117184610Salfred		xfer->flags.short_xfer_ok = 1;
1118184610Salfred	else
1119184610Salfred		xfer->flags.short_xfer_ok = 0;
1120184610Salfred
1121184610Salfred	if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
1122184610Salfred		xfer->flags.short_frames_ok = 1;
1123184610Salfred	else
1124184610Salfred		xfer->flags.short_frames_ok = 0;
1125184610Salfred
1126184610Salfred	if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
1127184610Salfred		xfer->flags.force_short_xfer = 1;
1128184610Salfred	else
1129184610Salfred		xfer->flags.force_short_xfer = 0;
1130184610Salfred
1131184610Salfred	if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
1132184610Salfred		xfer->flags.stall_pipe = 1;
1133184610Salfred	else
1134184610Salfred		xfer->flags.stall_pipe = 0;
1135184610Salfred
1136184610Salfred	for (; n != xfer->nframes; n++) {
1137184610Salfred
1138184610Salfred		error = copyin(fs_ep.pLength + n,
1139184610Salfred		    &length, sizeof(length));
1140184610Salfred		if (error) {
1141184610Salfred			break;
1142184610Salfred		}
1143184610Salfred		xfer->frlengths[n] = length;
1144184610Salfred
1145184610Salfred		if (length > rem) {
1146184610Salfred			xfer->error = USB_ERR_INVAL;
1147184610Salfred			goto complete;
1148184610Salfred		}
1149184610Salfred		rem -= length;
1150184610Salfred
1151184610Salfred		if (!isread) {
1152184610Salfred
1153184610Salfred			/* we need to know the source buffer */
1154184610Salfred			error = copyin(fs_ep.ppBuffer + n,
1155184610Salfred			    &uaddr, sizeof(uaddr));
1156184610Salfred			if (error) {
1157184610Salfred				break;
1158184610Salfred			}
1159184610Salfred			if (xfer->flags_int.isochronous_xfr) {
1160184610Salfred				/* get kernel buffer address */
1161184610Salfred				kaddr = xfer->frbuffers[0].buffer;
1162184610Salfred				kaddr = USB_ADD_BYTES(kaddr, offset);
1163184610Salfred			} else {
1164184610Salfred				/* set current frame offset */
1165194228Sthompsa				usbd_set_frame_offset(xfer, offset, n);
1166184610Salfred
1167184610Salfred				/* get kernel buffer address */
1168184610Salfred				kaddr = xfer->frbuffers[n].buffer;
1169184610Salfred			}
1170184610Salfred
1171184610Salfred			/* move data */
1172184610Salfred			error = copyin(uaddr, kaddr, length);
1173184610Salfred			if (error) {
1174184610Salfred				break;
1175184610Salfred			}
1176184610Salfred		}
1177184610Salfred		offset += length;
1178184610Salfred	}
1179184610Salfred	return (error);
1180184610Salfred
1181184610Salfredcomplete:
1182184610Salfred	mtx_lock(f->priv_mtx);
1183184610Salfred	ugen_fs_set_complete(f, ep_index);
1184184610Salfred	mtx_unlock(f->priv_mtx);
1185184610Salfred	return (0);
1186184610Salfred}
1187184610Salfred
1188184610Salfredstatic int
1189192984Sthompsaugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index)
1190184610Salfred{
1191192984Sthompsa	struct usb_device_request *req;
1192192984Sthompsa	struct usb_xfer *xfer;
1193192984Sthompsa	struct usb_fs_endpoint fs_ep;
1194192984Sthompsa	struct usb_fs_endpoint *fs_ep_uptr;	/* userland ptr */
1195184610Salfred	void *uaddr;			/* userland ptr */
1196184610Salfred	void *kaddr;
1197193045Sthompsa	usb_frlength_t offset;
1198193045Sthompsa	usb_frlength_t rem;
1199193045Sthompsa	usb_frcount_t n;
1200184610Salfred	uint32_t length;
1201184610Salfred	uint32_t temp;
1202184610Salfred	int error;
1203184610Salfred	uint8_t isread;
1204184610Salfred
1205190181Sthompsa	if (ep_index >= f->fs_ep_max)
1206184610Salfred		return (EINVAL);
1207190181Sthompsa
1208184610Salfred	xfer = f->fs_xfer[ep_index];
1209190181Sthompsa	if (xfer == NULL)
1210184610Salfred		return (EINVAL);
1211190181Sthompsa
1212184610Salfred	mtx_lock(f->priv_mtx);
1213194228Sthompsa	if (usbd_transfer_pending(xfer)) {
1214184610Salfred		mtx_unlock(f->priv_mtx);
1215184610Salfred		return (EBUSY);		/* should not happen */
1216184610Salfred	}
1217184610Salfred	mtx_unlock(f->priv_mtx);
1218184610Salfred
1219184610Salfred	fs_ep_uptr = f->fs_ep_ptr + ep_index;
1220184610Salfred	error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
1221184610Salfred	if (error) {
1222184610Salfred		return (error);
1223184610Salfred	}
1224184610Salfred	fs_ep.status = xfer->error;
1225184610Salfred	fs_ep.aFrames = xfer->aframes;
1226184610Salfred	fs_ep.isoc_time_complete = xfer->isoc_time_complete;
1227184610Salfred	if (xfer->error) {
1228184610Salfred		goto complete;
1229184610Salfred	}
1230184610Salfred	if (xfer->flags_int.control_xfr) {
1231184610Salfred		req = xfer->frbuffers[0].buffer;
1232184610Salfred
1233184610Salfred		/* Host mode only ! */
1234184610Salfred		if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
1235184610Salfred			isread = 1;
1236184610Salfred		} else {
1237184610Salfred			isread = 0;
1238184610Salfred		}
1239184610Salfred		if (xfer->nframes == 0)
1240184610Salfred			n = 0;		/* should never happen */
1241184610Salfred		else
1242184610Salfred			n = 1;
1243184610Salfred	} else {
1244184610Salfred		/* Device and Host mode */
1245184610Salfred		if (USB_GET_DATA_ISREAD(xfer)) {
1246184610Salfred			isread = 1;
1247184610Salfred		} else {
1248184610Salfred			isread = 0;
1249184610Salfred		}
1250184610Salfred		n = 0;
1251184610Salfred	}
1252184610Salfred
1253184610Salfred	/* Update lengths and copy out data */
1254184610Salfred
1255184610Salfred	rem = xfer->max_data_length;
1256184610Salfred	offset = 0;
1257184610Salfred
1258184610Salfred	for (; n != xfer->nframes; n++) {
1259184610Salfred
1260184610Salfred		/* get initial length into "temp" */
1261184610Salfred		error = copyin(fs_ep.pLength + n,
1262184610Salfred		    &temp, sizeof(temp));
1263184610Salfred		if (error) {
1264184610Salfred			return (error);
1265184610Salfred		}
1266184610Salfred		if (temp > rem) {
1267184610Salfred			/* the userland length has been corrupted */
1268184610Salfred			DPRINTF("corrupt userland length "
1269184610Salfred			    "%u > %u\n", temp, rem);
1270184610Salfred			fs_ep.status = USB_ERR_INVAL;
1271184610Salfred			goto complete;
1272184610Salfred		}
1273184610Salfred		rem -= temp;
1274184610Salfred
1275184610Salfred		/* get actual transfer length */
1276184610Salfred		length = xfer->frlengths[n];
1277184610Salfred		if (length > temp) {
1278184610Salfred			/* data overflow */
1279184610Salfred			fs_ep.status = USB_ERR_INVAL;
1280184610Salfred			DPRINTF("data overflow %u > %u\n",
1281184610Salfred			    length, temp);
1282184610Salfred			goto complete;
1283184610Salfred		}
1284184610Salfred		if (isread) {
1285184610Salfred
1286184610Salfred			/* we need to know the destination buffer */
1287184610Salfred			error = copyin(fs_ep.ppBuffer + n,
1288184610Salfred			    &uaddr, sizeof(uaddr));
1289184610Salfred			if (error) {
1290184610Salfred				return (error);
1291184610Salfred			}
1292184610Salfred			if (xfer->flags_int.isochronous_xfr) {
1293184610Salfred				/* only one frame buffer */
1294184610Salfred				kaddr = USB_ADD_BYTES(
1295184610Salfred				    xfer->frbuffers[0].buffer, offset);
1296184610Salfred			} else {
1297184610Salfred				/* multiple frame buffers */
1298184610Salfred				kaddr = xfer->frbuffers[n].buffer;
1299184610Salfred			}
1300184610Salfred
1301184610Salfred			/* move data */
1302184610Salfred			error = copyout(kaddr, uaddr, length);
1303184610Salfred			if (error) {
1304184610Salfred				return (error);
1305184610Salfred			}
1306184610Salfred		}
1307184610Salfred		/*
1308184610Salfred		 * Update offset according to initial length, which is
1309184610Salfred		 * needed by isochronous transfers!
1310184610Salfred		 */
1311184610Salfred		offset += temp;
1312184610Salfred
1313184610Salfred		/* update length */
1314184610Salfred		error = copyout(&length,
1315184610Salfred		    fs_ep.pLength + n, sizeof(length));
1316184610Salfred		if (error) {
1317184610Salfred			return (error);
1318184610Salfred		}
1319184610Salfred	}
1320184610Salfred
1321184610Salfredcomplete:
1322184610Salfred	/* update "aFrames" */
1323184610Salfred	error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames,
1324184610Salfred	    sizeof(fs_ep.aFrames));
1325184610Salfred	if (error)
1326184610Salfred		goto done;
1327184610Salfred
1328184610Salfred	/* update "isoc_time_complete" */
1329184610Salfred	error = copyout(&fs_ep.isoc_time_complete,
1330184610Salfred	    &fs_ep_uptr->isoc_time_complete,
1331184610Salfred	    sizeof(fs_ep.isoc_time_complete));
1332184610Salfred	if (error)
1333184610Salfred		goto done;
1334184610Salfred	/* update "status" */
1335184610Salfred	error = copyout(&fs_ep.status, &fs_ep_uptr->status,
1336184610Salfred	    sizeof(fs_ep.status));
1337184610Salfreddone:
1338184610Salfred	return (error);
1339184610Salfred}
1340184610Salfred
1341184610Salfredstatic uint8_t
1342192984Sthompsaugen_fifo_in_use(struct usb_fifo *f, int fflags)
1343184610Salfred{
1344192984Sthompsa	struct usb_fifo *f_rx;
1345192984Sthompsa	struct usb_fifo *f_tx;
1346184610Salfred
1347184610Salfred	f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1348184610Salfred	f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1349184610Salfred
1350184610Salfred	if ((fflags & FREAD) && f_rx &&
1351184610Salfred	    (f_rx->xfer[0] || f_rx->xfer[1])) {
1352184610Salfred		return (1);		/* RX FIFO in use */
1353184610Salfred	}
1354184610Salfred	if ((fflags & FWRITE) && f_tx &&
1355184610Salfred	    (f_tx->xfer[0] || f_tx->xfer[1])) {
1356184610Salfred		return (1);		/* TX FIFO in use */
1357184610Salfred	}
1358184610Salfred	return (0);			/* not in use */
1359184610Salfred}
1360184610Salfred
1361184610Salfredstatic int
1362192984Sthompsaugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
1363184610Salfred{
1364192984Sthompsa	struct usb_config usb_config[1];
1365192984Sthompsa	struct usb_device_request req;
1366184610Salfred	union {
1367192984Sthompsa		struct usb_fs_complete *pcomp;
1368192984Sthompsa		struct usb_fs_start *pstart;
1369192984Sthompsa		struct usb_fs_stop *pstop;
1370192984Sthompsa		struct usb_fs_open *popen;
1371192984Sthompsa		struct usb_fs_close *pclose;
1372192984Sthompsa		struct usb_fs_clear_stall_sync *pstall;
1373184610Salfred		void   *addr;
1374184610Salfred	}     u;
1375193644Sthompsa	struct usb_endpoint *ep;
1376192984Sthompsa	struct usb_endpoint_descriptor *ed;
1377184610Salfred	int error = 0;
1378184610Salfred	uint8_t iface_index;
1379184610Salfred	uint8_t isread;
1380184610Salfred	uint8_t ep_index;
1381184610Salfred
1382184610Salfred	u.addr = addr;
1383184610Salfred
1384185087Salfred	DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1385185087Salfred
1386184610Salfred	switch (cmd) {
1387184610Salfred	case USB_FS_COMPLETE:
1388184610Salfred		mtx_lock(f->priv_mtx);
1389184610Salfred		error = ugen_fs_get_complete(f, &ep_index);
1390184610Salfred		mtx_unlock(f->priv_mtx);
1391184610Salfred
1392184610Salfred		if (error) {
1393184610Salfred			error = EBUSY;
1394184610Salfred			break;
1395184610Salfred		}
1396184610Salfred		u.pcomp->ep_index = ep_index;
1397184610Salfred		error = ugen_fs_copy_out(f, u.pcomp->ep_index);
1398184610Salfred		break;
1399184610Salfred
1400184610Salfred	case USB_FS_START:
1401184610Salfred		error = ugen_fs_copy_in(f, u.pstart->ep_index);
1402184610Salfred		if (error) {
1403184610Salfred			break;
1404184610Salfred		}
1405184610Salfred		mtx_lock(f->priv_mtx);
1406194228Sthompsa		usbd_transfer_start(f->fs_xfer[u.pstart->ep_index]);
1407184610Salfred		mtx_unlock(f->priv_mtx);
1408184610Salfred		break;
1409184610Salfred
1410184610Salfred	case USB_FS_STOP:
1411184610Salfred		if (u.pstop->ep_index >= f->fs_ep_max) {
1412184610Salfred			error = EINVAL;
1413184610Salfred			break;
1414184610Salfred		}
1415184610Salfred		mtx_lock(f->priv_mtx);
1416194228Sthompsa		usbd_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
1417184610Salfred		mtx_unlock(f->priv_mtx);
1418184610Salfred		break;
1419184610Salfred
1420184610Salfred	case USB_FS_OPEN:
1421184610Salfred		if (u.popen->ep_index >= f->fs_ep_max) {
1422184610Salfred			error = EINVAL;
1423184610Salfred			break;
1424184610Salfred		}
1425184610Salfred		if (f->fs_xfer[u.popen->ep_index] != NULL) {
1426184610Salfred			error = EBUSY;
1427184610Salfred			break;
1428184610Salfred		}
1429184610Salfred		if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) {
1430184610Salfred			u.popen->max_bufsize = USB_FS_MAX_BUFSIZE;
1431184610Salfred		}
1432184610Salfred		if (u.popen->max_frames > USB_FS_MAX_FRAMES) {
1433184610Salfred			u.popen->max_frames = USB_FS_MAX_FRAMES;
1434184610Salfred			break;
1435184610Salfred		}
1436184610Salfred		if (u.popen->max_frames == 0) {
1437184610Salfred			error = EINVAL;
1438184610Salfred			break;
1439184610Salfred		}
1440194228Sthompsa		ep = usbd_get_ep_by_addr(f->udev, u.popen->ep_no);
1441193644Sthompsa		if (ep == NULL) {
1442184610Salfred			error = EINVAL;
1443184610Salfred			break;
1444184610Salfred		}
1445193644Sthompsa		ed = ep->edesc;
1446184610Salfred		if (ed == NULL) {
1447184610Salfred			error = ENXIO;
1448184610Salfred			break;
1449184610Salfred		}
1450193644Sthompsa		iface_index = ep->iface_index;
1451184610Salfred
1452192984Sthompsa		bzero(usb_config, sizeof(usb_config));
1453184610Salfred
1454192984Sthompsa		usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
1455192984Sthompsa		usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
1456192984Sthompsa		usb_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
1457192984Sthompsa		usb_config[0].interval = USB_DEFAULT_INTERVAL;
1458192984Sthompsa		usb_config[0].flags.proxy_buffer = 1;
1459192984Sthompsa		usb_config[0].callback = &ugen_default_fs_callback;
1460192984Sthompsa		usb_config[0].timeout = 0;	/* no timeout */
1461192984Sthompsa		usb_config[0].frames = u.popen->max_frames;
1462192984Sthompsa		usb_config[0].bufsize = u.popen->max_bufsize;
1463192984Sthompsa		usb_config[0].usb_mode = USB_MODE_DUAL;	/* both modes */
1464184610Salfred
1465192984Sthompsa		if (usb_config[0].type == UE_CONTROL) {
1466192499Sthompsa			if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1467184610Salfred				error = EINVAL;
1468184610Salfred				break;
1469184610Salfred			}
1470184610Salfred		} else {
1471184610Salfred
1472192984Sthompsa			isread = ((usb_config[0].endpoint &
1473184610Salfred			    (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
1474184610Salfred
1475192499Sthompsa			if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1476184610Salfred				isread = !isread;
1477184610Salfred			}
1478184610Salfred			/* check permissions */
1479184610Salfred			if (isread) {
1480184610Salfred				if (!(fflags & FREAD)) {
1481184610Salfred					error = EPERM;
1482184610Salfred					break;
1483184610Salfred				}
1484184610Salfred			} else {
1485184610Salfred				if (!(fflags & FWRITE)) {
1486184610Salfred					error = EPERM;
1487184610Salfred					break;
1488184610Salfred				}
1489184610Salfred			}
1490184610Salfred		}
1491194228Sthompsa		error = usbd_transfer_setup(f->udev, &iface_index,
1492192984Sthompsa		    f->fs_xfer + u.popen->ep_index, usb_config, 1,
1493184610Salfred		    f, f->priv_mtx);
1494184610Salfred		if (error == 0) {
1495184610Salfred			/* update maximums */
1496184610Salfred			u.popen->max_packet_length =
1497184610Salfred			    f->fs_xfer[u.popen->ep_index]->max_frame_size;
1498184610Salfred			u.popen->max_bufsize =
1499184610Salfred			    f->fs_xfer[u.popen->ep_index]->max_data_length;
1500184610Salfred			f->fs_xfer[u.popen->ep_index]->priv_fifo =
1501184610Salfred			    ((uint8_t *)0) + u.popen->ep_index;
1502184610Salfred		} else {
1503184610Salfred			error = ENOMEM;
1504184610Salfred		}
1505184610Salfred		break;
1506184610Salfred
1507184610Salfred	case USB_FS_CLOSE:
1508184610Salfred		if (u.pclose->ep_index >= f->fs_ep_max) {
1509184610Salfred			error = EINVAL;
1510184610Salfred			break;
1511184610Salfred		}
1512184610Salfred		if (f->fs_xfer[u.pclose->ep_index] == NULL) {
1513184610Salfred			error = EINVAL;
1514184610Salfred			break;
1515184610Salfred		}
1516194228Sthompsa		usbd_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
1517184610Salfred		break;
1518184610Salfred
1519184610Salfred	case USB_FS_CLEAR_STALL_SYNC:
1520184610Salfred		if (u.pstall->ep_index >= f->fs_ep_max) {
1521184610Salfred			error = EINVAL;
1522184610Salfred			break;
1523184610Salfred		}
1524184610Salfred		if (f->fs_xfer[u.pstall->ep_index] == NULL) {
1525184610Salfred			error = EINVAL;
1526184610Salfred			break;
1527184610Salfred		}
1528192499Sthompsa		if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1529184610Salfred			error = EINVAL;
1530184610Salfred			break;
1531184610Salfred		}
1532184610Salfred		mtx_lock(f->priv_mtx);
1533194228Sthompsa		error = usbd_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
1534184610Salfred		mtx_unlock(f->priv_mtx);
1535184610Salfred
1536184610Salfred		if (error) {
1537184610Salfred			return (EBUSY);
1538184610Salfred		}
1539193644Sthompsa		ep = f->fs_xfer[u.pstall->ep_index]->endpoint;
1540184610Salfred
1541184610Salfred		/* setup a clear-stall packet */
1542184610Salfred		req.bmRequestType = UT_WRITE_ENDPOINT;
1543184610Salfred		req.bRequest = UR_CLEAR_FEATURE;
1544184610Salfred		USETW(req.wValue, UF_ENDPOINT_HALT);
1545193644Sthompsa		req.wIndex[0] = ep->edesc->bEndpointAddress;
1546184610Salfred		req.wIndex[1] = 0;
1547184610Salfred		USETW(req.wLength, 0);
1548184610Salfred
1549194228Sthompsa		error = usbd_do_request(f->udev, NULL, &req, NULL);
1550184610Salfred		if (error == 0) {
1551194228Sthompsa			usbd_clear_data_toggle(f->udev, ep);
1552184610Salfred		} else {
1553184610Salfred			error = ENXIO;
1554184610Salfred		}
1555184610Salfred		break;
1556184610Salfred
1557184610Salfred	default:
1558185087Salfred		error = ENOIOCTL;
1559184610Salfred		break;
1560184610Salfred	}
1561185087Salfred
1562185087Salfred	DPRINTFN(6, "error=%d\n", error);
1563185087Salfred
1564184610Salfred	return (error);
1565184610Salfred}
1566184610Salfred
1567184610Salfredstatic int
1568192984Sthompsaugen_set_short_xfer(struct usb_fifo *f, void *addr)
1569184610Salfred{
1570184610Salfred	uint8_t t;
1571184610Salfred
1572184610Salfred	if (*(int *)addr)
1573184610Salfred		t = 1;
1574184610Salfred	else
1575184610Salfred		t = 0;
1576184610Salfred
1577184610Salfred	if (f->flag_short == t) {
1578184610Salfred		/* same value like before - accept */
1579184610Salfred		return (0);
1580184610Salfred	}
1581184610Salfred	if (f->xfer[0] || f->xfer[1]) {
1582184610Salfred		/* cannot change this during transfer */
1583184610Salfred		return (EBUSY);
1584184610Salfred	}
1585184610Salfred	f->flag_short = t;
1586184610Salfred	return (0);
1587184610Salfred}
1588184610Salfred
1589184610Salfredstatic int
1590192984Sthompsaugen_set_timeout(struct usb_fifo *f, void *addr)
1591184610Salfred{
1592184610Salfred	f->timeout = *(int *)addr;
1593184610Salfred	if (f->timeout > 65535) {
1594184610Salfred		/* limit user input */
1595184610Salfred		f->timeout = 65535;
1596184610Salfred	}
1597184610Salfred	return (0);
1598184610Salfred}
1599184610Salfred
1600184610Salfredstatic int
1601192984Sthompsaugen_get_frame_size(struct usb_fifo *f, void *addr)
1602184610Salfred{
1603184610Salfred	if (f->xfer[0]) {
1604184610Salfred		*(int *)addr = f->xfer[0]->max_frame_size;
1605184610Salfred	} else {
1606184610Salfred		return (EINVAL);
1607184610Salfred	}
1608184610Salfred	return (0);
1609184610Salfred}
1610184610Salfred
1611184610Salfredstatic int
1612192984Sthompsaugen_set_buffer_size(struct usb_fifo *f, void *addr)
1613184610Salfred{
1614193045Sthompsa	usb_frlength_t t;
1615184610Salfred
1616190188Sthompsa	if (*(int *)addr < 0)
1617190188Sthompsa		t = 0;		/* use "wMaxPacketSize" */
1618184610Salfred	else if (*(int *)addr < (256 * 1024))
1619184610Salfred		t = *(int *)addr;
1620184610Salfred	else
1621184610Salfred		t = 256 * 1024;
1622184610Salfred
1623184610Salfred	if (f->bufsize == t) {
1624184610Salfred		/* same value like before - accept */
1625184610Salfred		return (0);
1626184610Salfred	}
1627184610Salfred	if (f->xfer[0] || f->xfer[1]) {
1628184610Salfred		/* cannot change this during transfer */
1629184610Salfred		return (EBUSY);
1630184610Salfred	}
1631184610Salfred	f->bufsize = t;
1632184610Salfred	return (0);
1633184610Salfred}
1634184610Salfred
1635184610Salfredstatic int
1636192984Sthompsaugen_get_buffer_size(struct usb_fifo *f, void *addr)
1637184610Salfred{
1638184610Salfred	*(int *)addr = f->bufsize;
1639184610Salfred	return (0);
1640184610Salfred}
1641184610Salfred
1642184610Salfredstatic int
1643192984Sthompsaugen_get_iface_desc(struct usb_fifo *f,
1644192984Sthompsa    struct usb_interface_descriptor *idesc)
1645184610Salfred{
1646192984Sthompsa	struct usb_interface *iface;
1647184610Salfred
1648194228Sthompsa	iface = usbd_get_iface(f->udev, f->iface_index);
1649184610Salfred	if (iface && iface->idesc) {
1650184610Salfred		*idesc = *(iface->idesc);
1651184610Salfred	} else {
1652184610Salfred		return (EIO);
1653184610Salfred	}
1654184610Salfred	return (0);
1655184610Salfred}
1656184610Salfred
1657184610Salfredstatic int
1658192984Sthompsaugen_get_endpoint_desc(struct usb_fifo *f,
1659192984Sthompsa    struct usb_endpoint_descriptor *ed)
1660184610Salfred{
1661193644Sthompsa	struct usb_endpoint *ep;
1662184610Salfred
1663193644Sthompsa	ep = f->priv_sc0;
1664184610Salfred
1665193644Sthompsa	if (ep && ep->edesc) {
1666193644Sthompsa		*ed = *ep->edesc;
1667184610Salfred	} else {
1668184610Salfred		return (EINVAL);
1669184610Salfred	}
1670184610Salfred	return (0);
1671184610Salfred}
1672184610Salfred
1673184610Salfredstatic int
1674192984Sthompsaugen_set_power_mode(struct usb_fifo *f, int mode)
1675184610Salfred{
1676192984Sthompsa	struct usb_device *udev = f->udev;
1677184610Salfred	int err;
1678187169Sthompsa	uint8_t old_mode;
1679184610Salfred
1680184610Salfred	if ((udev == NULL) ||
1681184610Salfred	    (udev->parent_hub == NULL)) {
1682184610Salfred		return (EINVAL);
1683184610Salfred	}
1684189125Sthompsa	err = priv_check(curthread, PRIV_DRIVER);
1685187169Sthompsa	if (err)
1686184610Salfred		return (err);
1687187169Sthompsa
1688187169Sthompsa	/* get old power mode */
1689187169Sthompsa	old_mode = udev->power_mode;
1690187169Sthompsa
1691187169Sthompsa	/* if no change, then just return */
1692187169Sthompsa	if (old_mode == mode)
1693187169Sthompsa		return (0);
1694187169Sthompsa
1695184610Salfred	switch (mode) {
1696184610Salfred	case USB_POWER_MODE_OFF:
1697187164Sthompsa		/* get the device unconfigured */
1698187164Sthompsa		err = ugen_set_config(f, USB_UNCONFIG_INDEX);
1699187164Sthompsa		if (err) {
1700187164Sthompsa			DPRINTFN(0, "Could not unconfigure "
1701187164Sthompsa			    "device (ignored)\n");
1702187164Sthompsa		}
1703184610Salfred
1704184610Salfred		/* clear port enable */
1705194228Sthompsa		err = usbd_req_clear_port_feature(udev->parent_hub,
1706184610Salfred		    NULL, udev->port_no, UHF_PORT_ENABLE);
1707184610Salfred		break;
1708184610Salfred
1709184610Salfred	case USB_POWER_MODE_ON:
1710186730Salfred	case USB_POWER_MODE_SAVE:
1711186730Salfred		break;
1712184610Salfred
1713184610Salfred	case USB_POWER_MODE_RESUME:
1714194228Sthompsa		err = usbd_req_clear_port_feature(udev->parent_hub,
1715184610Salfred		    NULL, udev->port_no, UHF_PORT_SUSPEND);
1716186730Salfred		mode = USB_POWER_MODE_SAVE;
1717184610Salfred		break;
1718184610Salfred
1719184610Salfred	case USB_POWER_MODE_SUSPEND:
1720194228Sthompsa		err = usbd_req_set_port_feature(udev->parent_hub,
1721184610Salfred		    NULL, udev->port_no, UHF_PORT_SUSPEND);
1722186730Salfred		mode = USB_POWER_MODE_SAVE;
1723184610Salfred		break;
1724186730Salfred
1725184610Salfred	default:
1726184610Salfred		return (EINVAL);
1727184610Salfred	}
1728184610Salfred
1729184610Salfred	if (err)
1730184610Salfred		return (ENXIO);		/* I/O failure */
1731184610Salfred
1732187169Sthompsa	/* if we are powered off we need to re-enumerate first */
1733187169Sthompsa	if (old_mode == USB_POWER_MODE_OFF) {
1734187169Sthompsa		err = ugen_re_enumerate(f);
1735187169Sthompsa		if (err)
1736187169Sthompsa			return (err);
1737187169Sthompsa	}
1738187169Sthompsa
1739186730Salfred	/* set new power mode */
1740194228Sthompsa	usbd_set_power_mode(udev, mode);
1741184610Salfred
1742184610Salfred	return (0);			/* success */
1743184610Salfred}
1744184610Salfred
1745184610Salfredstatic int
1746192984Sthompsaugen_get_power_mode(struct usb_fifo *f)
1747184610Salfred{
1748192984Sthompsa	struct usb_device *udev = f->udev;
1749184610Salfred
1750184610Salfred	if ((udev == NULL) ||
1751184610Salfred	    (udev->parent_hub == NULL)) {
1752184610Salfred		return (USB_POWER_MODE_ON);
1753184610Salfred	}
1754184610Salfred	return (udev->power_mode);
1755184610Salfred}
1756184610Salfred
1757184610Salfredstatic int
1758192984Sthompsaugen_do_port_feature(struct usb_fifo *f, uint8_t port_no,
1759184610Salfred    uint8_t set, uint16_t feature)
1760184610Salfred{
1761192984Sthompsa	struct usb_device *udev = f->udev;
1762192984Sthompsa	struct usb_hub *hub;
1763184610Salfred	int err;
1764184610Salfred
1765189125Sthompsa	err = priv_check(curthread, PRIV_DRIVER);
1766184610Salfred	if (err) {
1767184610Salfred		return (err);
1768184610Salfred	}
1769184610Salfred	if (port_no == 0) {
1770184610Salfred		return (EINVAL);
1771184610Salfred	}
1772184610Salfred	if ((udev == NULL) ||
1773184610Salfred	    (udev->hub == NULL)) {
1774184610Salfred		return (EINVAL);
1775184610Salfred	}
1776184610Salfred	hub = udev->hub;
1777184610Salfred
1778184610Salfred	if (port_no > hub->nports) {
1779184610Salfred		return (EINVAL);
1780184610Salfred	}
1781184610Salfred	if (set)
1782194228Sthompsa		err = usbd_req_set_port_feature(udev,
1783184610Salfred		    NULL, port_no, feature);
1784184610Salfred	else
1785194228Sthompsa		err = usbd_req_clear_port_feature(udev,
1786184610Salfred		    NULL, port_no, feature);
1787184610Salfred
1788184610Salfred	if (err)
1789184610Salfred		return (ENXIO);		/* failure */
1790184610Salfred
1791184610Salfred	return (0);			/* success */
1792184610Salfred}
1793184610Salfred
1794184610Salfredstatic int
1795192984Sthompsaugen_iface_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
1796184610Salfred{
1797192984Sthompsa	struct usb_fifo *f_rx;
1798192984Sthompsa	struct usb_fifo *f_tx;
1799184610Salfred	int error = 0;
1800184610Salfred
1801184610Salfred	f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1802184610Salfred	f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1803184610Salfred
1804184610Salfred	switch (cmd) {
1805184610Salfred	case USB_SET_RX_SHORT_XFER:
1806184610Salfred		if (fflags & FREAD) {
1807184610Salfred			error = ugen_set_short_xfer(f_rx, addr);
1808184610Salfred		} else {
1809184610Salfred			error = EINVAL;
1810184610Salfred		}
1811184610Salfred		break;
1812184610Salfred
1813184610Salfred	case USB_SET_TX_FORCE_SHORT:
1814184610Salfred		if (fflags & FWRITE) {
1815184610Salfred			error = ugen_set_short_xfer(f_tx, addr);
1816184610Salfred		} else {
1817184610Salfred			error = EINVAL;
1818184610Salfred		}
1819184610Salfred		break;
1820184610Salfred
1821184610Salfred	case USB_SET_RX_TIMEOUT:
1822184610Salfred		if (fflags & FREAD) {
1823184610Salfred			error = ugen_set_timeout(f_rx, addr);
1824184610Salfred		} else {
1825184610Salfred			error = EINVAL;
1826184610Salfred		}
1827184610Salfred		break;
1828184610Salfred
1829184610Salfred	case USB_SET_TX_TIMEOUT:
1830184610Salfred		if (fflags & FWRITE) {
1831184610Salfred			error = ugen_set_timeout(f_tx, addr);
1832184610Salfred		} else {
1833184610Salfred			error = EINVAL;
1834184610Salfred		}
1835184610Salfred		break;
1836184610Salfred
1837184610Salfred	case USB_GET_RX_FRAME_SIZE:
1838184610Salfred		if (fflags & FREAD) {
1839184610Salfred			error = ugen_get_frame_size(f_rx, addr);
1840184610Salfred		} else {
1841184610Salfred			error = EINVAL;
1842184610Salfred		}
1843184610Salfred		break;
1844184610Salfred
1845184610Salfred	case USB_GET_TX_FRAME_SIZE:
1846184610Salfred		if (fflags & FWRITE) {
1847184610Salfred			error = ugen_get_frame_size(f_tx, addr);
1848184610Salfred		} else {
1849184610Salfred			error = EINVAL;
1850184610Salfred		}
1851184610Salfred		break;
1852184610Salfred
1853184610Salfred	case USB_SET_RX_BUFFER_SIZE:
1854184610Salfred		if (fflags & FREAD) {
1855184610Salfred			error = ugen_set_buffer_size(f_rx, addr);
1856184610Salfred		} else {
1857184610Salfred			error = EINVAL;
1858184610Salfred		}
1859184610Salfred		break;
1860184610Salfred
1861184610Salfred	case USB_SET_TX_BUFFER_SIZE:
1862184610Salfred		if (fflags & FWRITE) {
1863184610Salfred			error = ugen_set_buffer_size(f_tx, addr);
1864184610Salfred		} else {
1865184610Salfred			error = EINVAL;
1866184610Salfred		}
1867184610Salfred		break;
1868184610Salfred
1869184610Salfred	case USB_GET_RX_BUFFER_SIZE:
1870184610Salfred		if (fflags & FREAD) {
1871184610Salfred			error = ugen_get_buffer_size(f_rx, addr);
1872184610Salfred		} else {
1873184610Salfred			error = EINVAL;
1874184610Salfred		}
1875184610Salfred		break;
1876184610Salfred
1877184610Salfred	case USB_GET_TX_BUFFER_SIZE:
1878184610Salfred		if (fflags & FWRITE) {
1879184610Salfred			error = ugen_get_buffer_size(f_tx, addr);
1880184610Salfred		} else {
1881184610Salfred			error = EINVAL;
1882184610Salfred		}
1883184610Salfred		break;
1884184610Salfred
1885184610Salfred	case USB_GET_RX_INTERFACE_DESC:
1886184610Salfred		if (fflags & FREAD) {
1887184610Salfred			error = ugen_get_iface_desc(f_rx, addr);
1888184610Salfred		} else {
1889184610Salfred			error = EINVAL;
1890184610Salfred		}
1891184610Salfred		break;
1892184610Salfred
1893184610Salfred	case USB_GET_TX_INTERFACE_DESC:
1894184610Salfred		if (fflags & FWRITE) {
1895184610Salfred			error = ugen_get_iface_desc(f_tx, addr);
1896184610Salfred		} else {
1897184610Salfred			error = EINVAL;
1898184610Salfred		}
1899184610Salfred		break;
1900184610Salfred
1901184610Salfred	case USB_GET_RX_ENDPOINT_DESC:
1902184610Salfred		if (fflags & FREAD) {
1903184610Salfred			error = ugen_get_endpoint_desc(f_rx, addr);
1904184610Salfred		} else {
1905184610Salfred			error = EINVAL;
1906184610Salfred		}
1907184610Salfred		break;
1908184610Salfred
1909184610Salfred	case USB_GET_TX_ENDPOINT_DESC:
1910184610Salfred		if (fflags & FWRITE) {
1911184610Salfred			error = ugen_get_endpoint_desc(f_tx, addr);
1912184610Salfred		} else {
1913184610Salfred			error = EINVAL;
1914184610Salfred		}
1915184610Salfred		break;
1916184610Salfred
1917184610Salfred	case USB_SET_RX_STALL_FLAG:
1918184610Salfred		if ((fflags & FREAD) && (*(int *)addr)) {
1919184610Salfred			f_rx->flag_stall = 1;
1920184610Salfred		}
1921184610Salfred		break;
1922184610Salfred
1923184610Salfred	case USB_SET_TX_STALL_FLAG:
1924184610Salfred		if ((fflags & FWRITE) && (*(int *)addr)) {
1925184610Salfred			f_tx->flag_stall = 1;
1926184610Salfred		}
1927184610Salfred		break;
1928184610Salfred
1929184610Salfred	default:
1930185087Salfred		error = ENOIOCTL;
1931184610Salfred		break;
1932184610Salfred	}
1933184610Salfred	return (error);
1934184610Salfred}
1935184610Salfred
1936184610Salfredstatic int
1937192984Sthompsaugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
1938184610Salfred{
1939184610Salfred	union {
1940192984Sthompsa		struct usb_interface_descriptor *idesc;
1941192984Sthompsa		struct usb_alt_interface *ai;
1942192984Sthompsa		struct usb_device_descriptor *ddesc;
1943192984Sthompsa		struct usb_config_descriptor *cdesc;
1944192984Sthompsa		struct usb_device_stats *stat;
1945192984Sthompsa		struct usb_fs_init *pinit;
1946192984Sthompsa		struct usb_fs_uninit *puninit;
1947184610Salfred		uint32_t *ptime;
1948184610Salfred		void   *addr;
1949184610Salfred		int    *pint;
1950184610Salfred	}     u;
1951192984Sthompsa	struct usb_device_descriptor *dtemp;
1952192984Sthompsa	struct usb_config_descriptor *ctemp;
1953192984Sthompsa	struct usb_interface *iface;
1954184610Salfred	int error = 0;
1955184610Salfred	uint8_t n;
1956184610Salfred
1957184610Salfred	u.addr = addr;
1958184610Salfred
1959185087Salfred	DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1960185087Salfred
1961184610Salfred	switch (cmd) {
1962184610Salfred	case USB_DISCOVER:
1963194228Sthompsa		usb_needs_explore_all();
1964184610Salfred		break;
1965184610Salfred
1966184610Salfred	case USB_SETDEBUG:
1967184610Salfred		if (!(fflags & FWRITE)) {
1968184610Salfred			error = EPERM;
1969184610Salfred			break;
1970184610Salfred		}
1971194228Sthompsa		usb_debug = *(int *)addr;
1972184610Salfred		break;
1973184610Salfred
1974184610Salfred	case USB_GET_CONFIG:
1975184610Salfred		*(int *)addr = f->udev->curr_config_index;
1976184610Salfred		break;
1977184610Salfred
1978184610Salfred	case USB_SET_CONFIG:
1979184610Salfred		if (!(fflags & FWRITE)) {
1980184610Salfred			error = EPERM;
1981184610Salfred			break;
1982184610Salfred		}
1983184610Salfred		error = ugen_set_config(f, *(int *)addr);
1984184610Salfred		break;
1985184610Salfred
1986184610Salfred	case USB_GET_ALTINTERFACE:
1987194228Sthompsa		iface = usbd_get_iface(f->udev,
1988184610Salfred		    u.ai->uai_interface_index);
1989184610Salfred		if (iface && iface->idesc) {
1990184610Salfred			u.ai->uai_alt_index = iface->alt_index;
1991184610Salfred		} else {
1992184610Salfred			error = EINVAL;
1993184610Salfred		}
1994184610Salfred		break;
1995184610Salfred
1996184610Salfred	case USB_SET_ALTINTERFACE:
1997184610Salfred		if (!(fflags & FWRITE)) {
1998184610Salfred			error = EPERM;
1999184610Salfred			break;
2000184610Salfred		}
2001184610Salfred		error = ugen_set_interface(f,
2002184610Salfred		    u.ai->uai_interface_index, u.ai->uai_alt_index);
2003184610Salfred		break;
2004184610Salfred
2005184610Salfred	case USB_GET_DEVICE_DESC:
2006194228Sthompsa		dtemp = usbd_get_device_descriptor(f->udev);
2007184610Salfred		if (!dtemp) {
2008184610Salfred			error = EIO;
2009184610Salfred			break;
2010184610Salfred		}
2011184610Salfred		*u.ddesc = *dtemp;
2012184610Salfred		break;
2013184610Salfred
2014184610Salfred	case USB_GET_CONFIG_DESC:
2015194228Sthompsa		ctemp = usbd_get_config_descriptor(f->udev);
2016184610Salfred		if (!ctemp) {
2017184610Salfred			error = EIO;
2018184610Salfred			break;
2019184610Salfred		}
2020184610Salfred		*u.cdesc = *ctemp;
2021184610Salfred		break;
2022184610Salfred
2023184610Salfred	case USB_GET_FULL_DESC:
2024184610Salfred		error = ugen_get_cdesc(f, addr);
2025184610Salfred		break;
2026184610Salfred
2027184610Salfred	case USB_GET_STRING_DESC:
2028184610Salfred		error = ugen_get_sdesc(f, addr);
2029184610Salfred		break;
2030184610Salfred
2031188622Sthompsa	case USB_GET_IFACE_DRIVER:
2032188622Sthompsa		error = ugen_get_iface_driver(f, addr);
2033188622Sthompsa		break;
2034188622Sthompsa
2035184610Salfred	case USB_REQUEST:
2036184610Salfred	case USB_DO_REQUEST:
2037184610Salfred		if (!(fflags & FWRITE)) {
2038184610Salfred			error = EPERM;
2039184610Salfred			break;
2040184610Salfred		}
2041184610Salfred		error = ugen_do_request(f, addr);
2042184610Salfred		break;
2043184610Salfred
2044184610Salfred	case USB_DEVICEINFO:
2045184610Salfred	case USB_GET_DEVICEINFO:
2046194228Sthompsa		error = usb_gen_fill_deviceinfo(f, addr);
2047184610Salfred		break;
2048184610Salfred
2049184610Salfred	case USB_DEVICESTATS:
2050184610Salfred		for (n = 0; n != 4; n++) {
2051184610Salfred
2052184610Salfred			u.stat->uds_requests_fail[n] =
2053184610Salfred			    f->udev->bus->stats_err.uds_requests[n];
2054184610Salfred
2055184610Salfred			u.stat->uds_requests_ok[n] =
2056184610Salfred			    f->udev->bus->stats_ok.uds_requests[n];
2057184610Salfred		}
2058184610Salfred		break;
2059184610Salfred
2060184610Salfred	case USB_DEVICEENUMERATE:
2061184610Salfred		error = ugen_re_enumerate(f);
2062184610Salfred		break;
2063184610Salfred
2064184610Salfred	case USB_GET_PLUGTIME:
2065184610Salfred		*u.ptime = f->udev->plugtime;
2066184610Salfred		break;
2067184610Salfred
2068184610Salfred	case USB_CLAIM_INTERFACE:
2069184610Salfred	case USB_RELEASE_INTERFACE:
2070184610Salfred		/* TODO */
2071184610Salfred		break;
2072184610Salfred
2073184610Salfred	case USB_IFACE_DRIVER_ACTIVE:
2074184610Salfred		/* TODO */
2075184610Salfred		*u.pint = 0;
2076184610Salfred		break;
2077184610Salfred
2078184610Salfred	case USB_IFACE_DRIVER_DETACH:
2079184610Salfred		/* TODO */
2080184610Salfred		error = priv_check(curthread, PRIV_DRIVER);
2081184610Salfred		if (error) {
2082184610Salfred			break;
2083184610Salfred		}
2084184610Salfred		error = EINVAL;
2085184610Salfred		break;
2086184610Salfred
2087184610Salfred	case USB_SET_POWER_MODE:
2088184610Salfred		error = ugen_set_power_mode(f, *u.pint);
2089184610Salfred		break;
2090184610Salfred
2091184610Salfred	case USB_GET_POWER_MODE:
2092184610Salfred		*u.pint = ugen_get_power_mode(f);
2093184610Salfred		break;
2094184610Salfred
2095184610Salfred	case USB_SET_PORT_ENABLE:
2096184610Salfred		error = ugen_do_port_feature(f,
2097184610Salfred		    *u.pint, 1, UHF_PORT_ENABLE);
2098184610Salfred		break;
2099184610Salfred
2100184610Salfred	case USB_SET_PORT_DISABLE:
2101184610Salfred		error = ugen_do_port_feature(f,
2102184610Salfred		    *u.pint, 0, UHF_PORT_ENABLE);
2103184610Salfred		break;
2104184610Salfred
2105185087Salfred	case USB_FS_INIT:
2106185087Salfred		/* verify input parameters */
2107185087Salfred		if (u.pinit->pEndpoints == NULL) {
2108185087Salfred			error = EINVAL;
2109185087Salfred			break;
2110185087Salfred		}
2111185087Salfred		if (u.pinit->ep_index_max > 127) {
2112185087Salfred			error = EINVAL;
2113185087Salfred			break;
2114185087Salfred		}
2115185087Salfred		if (u.pinit->ep_index_max == 0) {
2116185087Salfred			error = EINVAL;
2117185087Salfred			break;
2118185087Salfred		}
2119185087Salfred		if (f->fs_xfer != NULL) {
2120185087Salfred			error = EBUSY;
2121185087Salfred			break;
2122185087Salfred		}
2123185087Salfred		if (f->dev_ep_index != 0) {
2124185087Salfred			error = EINVAL;
2125185087Salfred			break;
2126185087Salfred		}
2127185087Salfred		if (ugen_fifo_in_use(f, fflags)) {
2128185087Salfred			error = EBUSY;
2129185087Salfred			break;
2130185087Salfred		}
2131194228Sthompsa		error = usb_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
2132185087Salfred		if (error) {
2133185087Salfred			break;
2134185087Salfred		}
2135185087Salfred		f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) *
2136185087Salfred		    u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO);
2137185087Salfred		if (f->fs_xfer == NULL) {
2138194228Sthompsa			usb_fifo_free_buffer(f);
2139185087Salfred			error = ENOMEM;
2140185087Salfred			break;
2141185087Salfred		}
2142185087Salfred		f->fs_ep_max = u.pinit->ep_index_max;
2143185087Salfred		f->fs_ep_ptr = u.pinit->pEndpoints;
2144184610Salfred		break;
2145184610Salfred
2146185087Salfred	case USB_FS_UNINIT:
2147185087Salfred		if (u.puninit->dummy != 0) {
2148185087Salfred			error = EINVAL;
2149185087Salfred			break;
2150185087Salfred		}
2151185087Salfred		error = ugen_fs_uninit(f);
2152185087Salfred		break;
2153184610Salfred
2154185087Salfred	default:
2155185087Salfred		mtx_lock(f->priv_mtx);
2156185087Salfred		error = ugen_iface_ioctl(f, cmd, addr, fflags);
2157185087Salfred		mtx_unlock(f->priv_mtx);
2158185087Salfred		break;
2159184610Salfred	}
2160184610Salfred	DPRINTFN(6, "error=%d\n", error);
2161184610Salfred	return (error);
2162184610Salfred}
2163184610Salfred
2164184610Salfredstatic void
2165192984Sthompsaugen_default_fs_callback(struct usb_xfer *xfer)
2166184610Salfred{
2167184610Salfred	;				/* workaround for a bug in "indent" */
2168184610Salfred
2169184610Salfred	DPRINTF("st=%u alen=%u aframes=%u\n",
2170184610Salfred	    USB_GET_STATE(xfer), xfer->actlen, xfer->aframes);
2171184610Salfred
2172184610Salfred	switch (USB_GET_STATE(xfer)) {
2173184610Salfred	case USB_ST_SETUP:
2174194228Sthompsa		usbd_transfer_submit(xfer);
2175184610Salfred		break;
2176184610Salfred	default:
2177184610Salfred		ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
2178184610Salfred		break;
2179184610Salfred	}
2180184610Salfred}
2181190191Sthompsa#endif	/* USB_HAVE_UGEN */
2182