usb_generic.c revision 193644
1/* $FreeBSD: head/sys/dev/usb/usb_generic.c 193644 2009-06-07 19:41:11Z thompsa $ */
2/*-
3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
13 *
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
24 * SUCH DAMAGE.
25 */
26
27#include <dev/usb/usb_mfunc.h>
28#include <dev/usb/usb.h>
29#include <dev/usb/usb_ioctl.h>
30#include <dev/usb/usb_error.h>
31
32#define	USB_DEBUG_VAR ugen_debug
33
34#include <dev/usb/usb_core.h>
35#include <dev/usb/usb_mbuf.h>
36#include <dev/usb/usb_dev.h>
37#include <dev/usb/usb_process.h>
38#include <dev/usb/usb_device.h>
39#include <dev/usb/usb_debug.h>
40#include <dev/usb/usb_request.h>
41#include <dev/usb/usb_busdma.h>
42#include <dev/usb/usb_util.h>
43#include <dev/usb/usb_hub.h>
44#include <dev/usb/usb_generic.h>
45#include <dev/usb/usb_transfer.h>
46
47#include <dev/usb/usb_controller.h>
48#include <dev/usb/usb_bus.h>
49
50#if USB_HAVE_UGEN
51
52/* defines */
53
54#define	UGEN_BULK_FS_BUFFER_SIZE	(64*32)	/* bytes */
55#define	UGEN_BULK_HS_BUFFER_SIZE	(1024*32)	/* bytes */
56#define	UGEN_HW_FRAMES	50		/* number of milliseconds per transfer */
57
58/* function prototypes */
59
60static usb_callback_t ugen_read_clear_stall_callback;
61static usb_callback_t ugen_write_clear_stall_callback;
62static usb_callback_t ugen_default_read_callback;
63static usb_callback_t ugen_default_write_callback;
64static usb_callback_t ugen_isoc_read_callback;
65static usb_callback_t ugen_isoc_write_callback;
66static usb_callback_t ugen_default_fs_callback;
67
68static usb_fifo_open_t ugen_open;
69static usb_fifo_close_t ugen_close;
70static usb_fifo_ioctl_t ugen_ioctl;
71static usb_fifo_ioctl_t ugen_ioctl_post;
72static usb_fifo_cmd_t ugen_start_read;
73static usb_fifo_cmd_t ugen_start_write;
74static usb_fifo_cmd_t ugen_stop_io;
75
76static int	ugen_transfer_setup(struct usb_fifo *,
77		     const struct usb_config *, uint8_t);
78static int	ugen_open_pipe_write(struct usb_fifo *);
79static int	ugen_open_pipe_read(struct usb_fifo *);
80static int	ugen_set_config(struct usb_fifo *, uint8_t);
81static int	ugen_set_interface(struct usb_fifo *, uint8_t, uint8_t);
82static int	ugen_get_cdesc(struct usb_fifo *, struct usb_gen_descriptor *);
83static int	ugen_get_sdesc(struct usb_fifo *, struct usb_gen_descriptor *);
84static int	ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd);
85static int	usb2_gen_fill_deviceinfo(struct usb_fifo *,
86		    struct usb_device_info *);
87static int	ugen_re_enumerate(struct usb_fifo *);
88static int	ugen_iface_ioctl(struct usb_fifo *, u_long, void *, int);
89static uint8_t	ugen_fs_get_complete(struct usb_fifo *, uint8_t *);
90static int ugen_fs_uninit(struct usb_fifo *f);
91
92/* structures */
93
94struct usb_fifo_methods usb2_ugen_methods = {
95	.f_open = &ugen_open,
96	.f_close = &ugen_close,
97	.f_ioctl = &ugen_ioctl,
98	.f_ioctl_post = &ugen_ioctl_post,
99	.f_start_read = &ugen_start_read,
100	.f_stop_read = &ugen_stop_io,
101	.f_start_write = &ugen_start_write,
102	.f_stop_write = &ugen_stop_io,
103};
104
105#if USB_DEBUG
106static int ugen_debug = 0;
107
108SYSCTL_NODE(_hw_usb, OID_AUTO, ugen, CTLFLAG_RW, 0, "USB generic");
109SYSCTL_INT(_hw_usb_ugen, OID_AUTO, debug, CTLFLAG_RW, &ugen_debug,
110    0, "Debug level");
111#endif
112
113
114/* prototypes */
115
116static int
117ugen_transfer_setup(struct usb_fifo *f,
118    const struct usb_config *setup, uint8_t n_setup)
119{
120	struct usb_endpoint *ep = f->priv_sc0;
121	struct usb_device *udev = f->udev;
122	uint8_t iface_index = ep->iface_index;
123	int error;
124
125	mtx_unlock(f->priv_mtx);
126
127	/*
128	 * "usb2_transfer_setup()" can sleep so one needs to make a wrapper,
129	 * exiting the mutex and checking things
130	 */
131	error = usb2_transfer_setup(udev, &iface_index, f->xfer,
132	    setup, n_setup, f, f->priv_mtx);
133	if (error == 0) {
134
135		if (f->xfer[0]->nframes == 1) {
136			error = usb2_fifo_alloc_buffer(f,
137			    f->xfer[0]->max_data_length, 2);
138		} else {
139			error = usb2_fifo_alloc_buffer(f,
140			    f->xfer[0]->max_frame_size,
141			    2 * f->xfer[0]->nframes);
142		}
143		if (error) {
144			usb2_transfer_unsetup(f->xfer, n_setup);
145		}
146	}
147	mtx_lock(f->priv_mtx);
148
149	return (error);
150}
151
152static int
153ugen_open(struct usb_fifo *f, int fflags)
154{
155	struct usb_endpoint *ep = f->priv_sc0;
156	struct usb_endpoint_descriptor *ed = ep->edesc;
157	uint8_t type;
158
159	DPRINTFN(6, "flag=0x%x\n", fflags);
160
161	mtx_lock(f->priv_mtx);
162	switch (usb2_get_speed(f->udev)) {
163	case USB_SPEED_LOW:
164	case USB_SPEED_FULL:
165		f->nframes = UGEN_HW_FRAMES;
166		f->bufsize = UGEN_BULK_FS_BUFFER_SIZE;
167		break;
168	default:
169		f->nframes = UGEN_HW_FRAMES * 8;
170		f->bufsize = UGEN_BULK_HS_BUFFER_SIZE;
171		break;
172	}
173
174	type = ed->bmAttributes & UE_XFERTYPE;
175	if (type == UE_INTERRUPT) {
176		f->bufsize = 0;		/* use "wMaxPacketSize" */
177	}
178	f->timeout = USB_NO_TIMEOUT;
179	f->flag_short = 0;
180	f->fifo_zlp = 0;
181	mtx_unlock(f->priv_mtx);
182
183	return (0);
184}
185
186static void
187ugen_close(struct usb_fifo *f, int fflags)
188{
189	DPRINTFN(6, "flag=0x%x\n", fflags);
190
191	/* cleanup */
192
193	mtx_lock(f->priv_mtx);
194	usb2_transfer_stop(f->xfer[0]);
195	usb2_transfer_stop(f->xfer[1]);
196	mtx_unlock(f->priv_mtx);
197
198	usb2_transfer_unsetup(f->xfer, 2);
199	usb2_fifo_free_buffer(f);
200
201	if (ugen_fs_uninit(f)) {
202		/* ignore any errors - we are closing */
203		DPRINTFN(6, "no FIFOs\n");
204	}
205}
206
207static int
208ugen_open_pipe_write(struct usb_fifo *f)
209{
210	struct usb_config usb_config[2];
211	struct usb_endpoint *ep = f->priv_sc0;
212	struct usb_endpoint_descriptor *ed = ep->edesc;
213
214	mtx_assert(f->priv_mtx, MA_OWNED);
215
216	if (f->xfer[0] || f->xfer[1]) {
217		/* transfers are already opened */
218		return (0);
219	}
220	bzero(usb_config, sizeof(usb_config));
221
222	usb_config[1].type = UE_CONTROL;
223	usb_config[1].endpoint = 0;
224	usb_config[1].direction = UE_DIR_ANY;
225	usb_config[1].timeout = 1000;	/* 1 second */
226	usb_config[1].interval = 50;/* 50 milliseconds */
227	usb_config[1].bufsize = sizeof(struct usb_device_request);
228	usb_config[1].callback = &ugen_write_clear_stall_callback;
229	usb_config[1].usb_mode = USB_MODE_HOST;
230
231	usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
232	usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
233	usb_config[0].direction = UE_DIR_TX;
234	usb_config[0].interval = USB_DEFAULT_INTERVAL;
235	usb_config[0].flags.proxy_buffer = 1;
236	usb_config[0].usb_mode = USB_MODE_DUAL;	/* both modes */
237
238	switch (ed->bmAttributes & UE_XFERTYPE) {
239	case UE_INTERRUPT:
240	case UE_BULK:
241		if (f->flag_short) {
242			usb_config[0].flags.force_short_xfer = 1;
243		}
244		usb_config[0].callback = &ugen_default_write_callback;
245		usb_config[0].timeout = f->timeout;
246		usb_config[0].frames = 1;
247		usb_config[0].bufsize = f->bufsize;
248		if (ugen_transfer_setup(f, usb_config, 2)) {
249			return (EIO);
250		}
251		/* first transfer does not clear stall */
252		f->flag_stall = 0;
253		break;
254
255	case UE_ISOCHRONOUS:
256		usb_config[0].flags.short_xfer_ok = 1;
257		usb_config[0].bufsize = 0;	/* use default */
258		usb_config[0].frames = f->nframes;
259		usb_config[0].callback = &ugen_isoc_write_callback;
260		usb_config[0].timeout = 0;
261
262		/* clone configuration */
263		usb_config[1] = usb_config[0];
264
265		if (ugen_transfer_setup(f, usb_config, 2)) {
266			return (EIO);
267		}
268		break;
269	default:
270		return (EINVAL);
271	}
272	return (0);
273}
274
275static int
276ugen_open_pipe_read(struct usb_fifo *f)
277{
278	struct usb_config usb_config[2];
279	struct usb_endpoint *ep = f->priv_sc0;
280	struct usb_endpoint_descriptor *ed = ep->edesc;
281
282	mtx_assert(f->priv_mtx, MA_OWNED);
283
284	if (f->xfer[0] || f->xfer[1]) {
285		/* transfers are already opened */
286		return (0);
287	}
288	bzero(usb_config, sizeof(usb_config));
289
290	usb_config[1].type = UE_CONTROL;
291	usb_config[1].endpoint = 0;
292	usb_config[1].direction = UE_DIR_ANY;
293	usb_config[1].timeout = 1000;	/* 1 second */
294	usb_config[1].interval = 50;/* 50 milliseconds */
295	usb_config[1].bufsize = sizeof(struct usb_device_request);
296	usb_config[1].callback = &ugen_read_clear_stall_callback;
297	usb_config[1].usb_mode = USB_MODE_HOST;
298
299	usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
300	usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
301	usb_config[0].direction = UE_DIR_RX;
302	usb_config[0].interval = USB_DEFAULT_INTERVAL;
303	usb_config[0].flags.proxy_buffer = 1;
304	usb_config[0].usb_mode = USB_MODE_DUAL;	/* both modes */
305
306	switch (ed->bmAttributes & UE_XFERTYPE) {
307	case UE_INTERRUPT:
308	case UE_BULK:
309		if (f->flag_short) {
310			usb_config[0].flags.short_xfer_ok = 1;
311		}
312		usb_config[0].timeout = f->timeout;
313		usb_config[0].frames = 1;
314		usb_config[0].callback = &ugen_default_read_callback;
315		usb_config[0].bufsize = f->bufsize;
316
317		if (ugen_transfer_setup(f, usb_config, 2)) {
318			return (EIO);
319		}
320		/* first transfer does not clear stall */
321		f->flag_stall = 0;
322		break;
323
324	case UE_ISOCHRONOUS:
325		usb_config[0].flags.short_xfer_ok = 1;
326		usb_config[0].bufsize = 0;	/* use default */
327		usb_config[0].frames = f->nframes;
328		usb_config[0].callback = &ugen_isoc_read_callback;
329		usb_config[0].timeout = 0;
330
331		/* clone configuration */
332		usb_config[1] = usb_config[0];
333
334		if (ugen_transfer_setup(f, usb_config, 2)) {
335			return (EIO);
336		}
337		break;
338
339	default:
340		return (EINVAL);
341	}
342	return (0);
343}
344
345static void
346ugen_start_read(struct usb_fifo *f)
347{
348	/* check that pipes are open */
349	if (ugen_open_pipe_read(f)) {
350		/* signal error */
351		usb2_fifo_put_data_error(f);
352	}
353	/* start transfers */
354	usb2_transfer_start(f->xfer[0]);
355	usb2_transfer_start(f->xfer[1]);
356}
357
358static void
359ugen_start_write(struct usb_fifo *f)
360{
361	/* check that pipes are open */
362	if (ugen_open_pipe_write(f)) {
363		/* signal error */
364		usb2_fifo_get_data_error(f);
365	}
366	/* start transfers */
367	usb2_transfer_start(f->xfer[0]);
368	usb2_transfer_start(f->xfer[1]);
369}
370
371static void
372ugen_stop_io(struct usb_fifo *f)
373{
374	/* stop transfers */
375	usb2_transfer_stop(f->xfer[0]);
376	usb2_transfer_stop(f->xfer[1]);
377}
378
379static void
380ugen_default_read_callback(struct usb_xfer *xfer)
381{
382	struct usb_fifo *f = xfer->priv_sc;
383	struct usb_mbuf *m;
384
385	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
386
387	switch (USB_GET_STATE(xfer)) {
388	case USB_ST_TRANSFERRED:
389		if (xfer->actlen == 0) {
390			if (f->fifo_zlp != 4) {
391				f->fifo_zlp++;
392			} else {
393				/*
394				 * Throttle a little bit we have multiple ZLPs
395				 * in a row!
396				 */
397				xfer->interval = 64;	/* ms */
398			}
399		} else {
400			/* clear throttle */
401			xfer->interval = 0;
402			f->fifo_zlp = 0;
403		}
404		usb2_fifo_put_data(f, xfer->frbuffers, 0,
405		    xfer->actlen, 1);
406
407	case USB_ST_SETUP:
408		if (f->flag_stall) {
409			usb2_transfer_start(f->xfer[1]);
410			break;
411		}
412		USB_IF_POLL(&f->free_q, m);
413		if (m) {
414			xfer->frlengths[0] = xfer->max_data_length;
415			usb2_start_hardware(xfer);
416		}
417		break;
418
419	default:			/* Error */
420		if (xfer->error != USB_ERR_CANCELLED) {
421			/* send a zero length packet to userland */
422			usb2_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
423			f->flag_stall = 1;
424			f->fifo_zlp = 0;
425			usb2_transfer_start(f->xfer[1]);
426		}
427		break;
428	}
429}
430
431static void
432ugen_default_write_callback(struct usb_xfer *xfer)
433{
434	struct usb_fifo *f = xfer->priv_sc;
435	usb_frlength_t actlen;
436
437	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
438
439	switch (USB_GET_STATE(xfer)) {
440	case USB_ST_SETUP:
441	case USB_ST_TRANSFERRED:
442		/*
443		 * If writing is in stall, just jump to clear stall
444		 * callback and solve the situation.
445		 */
446		if (f->flag_stall) {
447			usb2_transfer_start(f->xfer[1]);
448			break;
449		}
450		/*
451		 * Write data, setup and perform hardware transfer.
452		 */
453		if (usb2_fifo_get_data(f, xfer->frbuffers, 0,
454		    xfer->max_data_length, &actlen, 0)) {
455			xfer->frlengths[0] = actlen;
456			usb2_start_hardware(xfer);
457		}
458		break;
459
460	default:			/* Error */
461		if (xfer->error != USB_ERR_CANCELLED) {
462			f->flag_stall = 1;
463			usb2_transfer_start(f->xfer[1]);
464		}
465		break;
466	}
467}
468
469static void
470ugen_read_clear_stall_callback(struct usb_xfer *xfer)
471{
472	struct usb_fifo *f = xfer->priv_sc;
473	struct usb_xfer *xfer_other = f->xfer[0];
474
475	if (f->flag_stall == 0) {
476		/* nothing to do */
477		return;
478	}
479	if (usb2_clear_stall_callback(xfer, xfer_other)) {
480		DPRINTFN(5, "f=%p: stall cleared\n", f);
481		f->flag_stall = 0;
482		usb2_transfer_start(xfer_other);
483	}
484}
485
486static void
487ugen_write_clear_stall_callback(struct usb_xfer *xfer)
488{
489	struct usb_fifo *f = xfer->priv_sc;
490	struct usb_xfer *xfer_other = f->xfer[0];
491
492	if (f->flag_stall == 0) {
493		/* nothing to do */
494		return;
495	}
496	if (usb2_clear_stall_callback(xfer, xfer_other)) {
497		DPRINTFN(5, "f=%p: stall cleared\n", f);
498		f->flag_stall = 0;
499		usb2_transfer_start(xfer_other);
500	}
501}
502
503static void
504ugen_isoc_read_callback(struct usb_xfer *xfer)
505{
506	struct usb_fifo *f = xfer->priv_sc;
507	usb_frlength_t offset;
508	usb_frcount_t n;
509
510	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
511
512	switch (USB_GET_STATE(xfer)) {
513	case USB_ST_TRANSFERRED:
514
515		DPRINTFN(6, "actlen=%d\n", xfer->actlen);
516
517		offset = 0;
518
519		for (n = 0; n != xfer->aframes; n++) {
520			usb2_fifo_put_data(f, xfer->frbuffers, offset,
521			    xfer->frlengths[n], 1);
522			offset += xfer->max_frame_size;
523		}
524
525	case USB_ST_SETUP:
526tr_setup:
527		for (n = 0; n != xfer->nframes; n++) {
528			/* setup size for next transfer */
529			xfer->frlengths[n] = xfer->max_frame_size;
530		}
531		usb2_start_hardware(xfer);
532		break;
533
534	default:			/* Error */
535		if (xfer->error == USB_ERR_CANCELLED) {
536			break;
537		}
538		goto tr_setup;
539	}
540}
541
542static void
543ugen_isoc_write_callback(struct usb_xfer *xfer)
544{
545	struct usb_fifo *f = xfer->priv_sc;
546	usb_frlength_t actlen;
547	usb_frlength_t offset;
548	usb_frcount_t n;
549
550	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
551
552	switch (USB_GET_STATE(xfer)) {
553	case USB_ST_TRANSFERRED:
554	case USB_ST_SETUP:
555tr_setup:
556		offset = 0;
557		for (n = 0; n != xfer->nframes; n++) {
558			if (usb2_fifo_get_data(f, xfer->frbuffers, offset,
559			    xfer->max_frame_size, &actlen, 1)) {
560				xfer->frlengths[n] = actlen;
561				offset += actlen;
562			} else {
563				break;
564			}
565		}
566
567		for (; n != xfer->nframes; n++) {
568			/* fill in zero frames */
569			xfer->frlengths[n] = 0;
570		}
571		usb2_start_hardware(xfer);
572		break;
573
574	default:			/* Error */
575		if (xfer->error == USB_ERR_CANCELLED) {
576			break;
577		}
578		goto tr_setup;
579	}
580}
581
582static int
583ugen_set_config(struct usb_fifo *f, uint8_t index)
584{
585	DPRINTFN(2, "index %u\n", index);
586
587	if (f->udev->flags.usb_mode != USB_MODE_HOST) {
588		/* not possible in device side mode */
589		return (ENOTTY);
590	}
591	if (f->udev->curr_config_index == index) {
592		/* no change needed */
593		return (0);
594	}
595	/* make sure all FIFO's are gone */
596	/* else there can be a deadlock */
597	if (ugen_fs_uninit(f)) {
598		/* ignore any errors */
599		DPRINTFN(6, "no FIFOs\n");
600	}
601	/* change setting - will free generic FIFOs, if any */
602	if (usb2_set_config_index(f->udev, index)) {
603		return (EIO);
604	}
605	/* probe and attach */
606	if (usb2_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) {
607		return (EIO);
608	}
609	return (0);
610}
611
612static int
613ugen_set_interface(struct usb_fifo *f,
614    uint8_t iface_index, uint8_t alt_index)
615{
616	DPRINTFN(2, "%u, %u\n", iface_index, alt_index);
617
618	if (f->udev->flags.usb_mode != USB_MODE_HOST) {
619		/* not possible in device side mode */
620		return (ENOTTY);
621	}
622	/* make sure all FIFO's are gone */
623	/* else there can be a deadlock */
624	if (ugen_fs_uninit(f)) {
625		/* ignore any errors */
626		DPRINTFN(6, "no FIFOs\n");
627	}
628	/* change setting - will free generic FIFOs, if any */
629	if (usb2_set_alt_interface_index(f->udev, iface_index, alt_index)) {
630		return (EIO);
631	}
632	/* probe and attach */
633	if (usb2_probe_and_attach(f->udev, iface_index)) {
634		return (EIO);
635	}
636	return (0);
637}
638
639/*------------------------------------------------------------------------*
640 *	ugen_get_cdesc
641 *
642 * This function will retrieve the complete configuration descriptor
643 * at the given index.
644 *------------------------------------------------------------------------*/
645static int
646ugen_get_cdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
647{
648	struct usb_config_descriptor *cdesc;
649	struct usb_device *udev = f->udev;
650	int error;
651	uint16_t len;
652	uint8_t free_data;
653
654	DPRINTFN(6, "\n");
655
656	if (ugd->ugd_data == NULL) {
657		/* userland pointer should not be zero */
658		return (EINVAL);
659	}
660	if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) ||
661	    (ugd->ugd_config_index == udev->curr_config_index)) {
662		cdesc = usb2_get_config_descriptor(udev);
663		if (cdesc == NULL) {
664			return (ENXIO);
665		}
666		free_data = 0;
667
668	} else {
669		if (usb2_req_get_config_desc_full(udev,
670		    NULL, &cdesc, M_USBDEV,
671		    ugd->ugd_config_index)) {
672			return (ENXIO);
673		}
674		free_data = 1;
675	}
676
677	len = UGETW(cdesc->wTotalLength);
678	if (len > ugd->ugd_maxlen) {
679		len = ugd->ugd_maxlen;
680	}
681	DPRINTFN(6, "len=%u\n", len);
682
683	ugd->ugd_actlen = len;
684	ugd->ugd_offset = 0;
685
686	error = copyout(cdesc, ugd->ugd_data, len);
687
688	if (free_data) {
689		free(cdesc, M_USBDEV);
690	}
691	return (error);
692}
693
694static int
695ugen_get_sdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
696{
697	void *ptr = f->udev->bus->scratch[0].data;
698	uint16_t size = sizeof(f->udev->bus->scratch[0].data);
699	int error;
700
701	if (usb2_req_get_string_desc(f->udev, NULL, ptr,
702	    size, ugd->ugd_lang_id, ugd->ugd_string_index)) {
703		error = EINVAL;
704	} else {
705
706		if (size > ((uint8_t *)ptr)[0]) {
707			size = ((uint8_t *)ptr)[0];
708		}
709		if (size > ugd->ugd_maxlen) {
710			size = ugd->ugd_maxlen;
711		}
712		ugd->ugd_actlen = size;
713		ugd->ugd_offset = 0;
714
715		error = copyout(ptr, ugd->ugd_data, size);
716	}
717	return (error);
718}
719
720/*------------------------------------------------------------------------*
721 *	ugen_get_iface_driver
722 *
723 * This function generates an USB interface description for userland.
724 *
725 * Returns:
726 *    0: Success
727 * Else: Failure
728 *------------------------------------------------------------------------*/
729static int
730ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
731{
732	struct usb_device *udev = f->udev;
733	struct usb_interface *iface;
734	const char *ptr;
735	const char *desc;
736	unsigned int len;
737	unsigned int maxlen;
738	char buf[128];
739	int error;
740
741	DPRINTFN(6, "\n");
742
743	if ((ugd->ugd_data == NULL) || (ugd->ugd_maxlen == 0)) {
744		/* userland pointer should not be zero */
745		return (EINVAL);
746	}
747
748	iface = usb2_get_iface(udev, ugd->ugd_iface_index);
749	if ((iface == NULL) || (iface->idesc == NULL)) {
750		/* invalid interface index */
751		return (EINVAL);
752	}
753
754	/* read out device nameunit string, if any */
755	if ((iface->subdev != NULL) &&
756	    device_is_attached(iface->subdev) &&
757	    (ptr = device_get_nameunit(iface->subdev)) &&
758	    (desc = device_get_desc(iface->subdev))) {
759
760		/* print description */
761		snprintf(buf, sizeof(buf), "%s: <%s>", ptr, desc);
762
763		/* range checks */
764		maxlen = ugd->ugd_maxlen - 1;
765		len = strlen(buf);
766		if (len > maxlen)
767			len = maxlen;
768
769		/* update actual length, including terminating zero */
770		ugd->ugd_actlen = len + 1;
771
772		/* copy out interface description */
773		error = copyout(buf, ugd->ugd_data, ugd->ugd_actlen);
774	} else {
775		/* zero length string is default */
776		error = copyout("", ugd->ugd_data, 1);
777	}
778	return (error);
779}
780
781/*------------------------------------------------------------------------*
782 *	usb2_gen_fill_deviceinfo
783 *
784 * This function dumps information about an USB device to the
785 * structure pointed to by the "di" argument.
786 *
787 * Returns:
788 *    0: Success
789 * Else: Failure
790 *------------------------------------------------------------------------*/
791static int
792usb2_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di)
793{
794	struct usb_device *udev;
795	struct usb_device *hub;
796
797	udev = f->udev;
798
799	bzero(di, sizeof(di[0]));
800
801	di->udi_bus = device_get_unit(udev->bus->bdev);
802	di->udi_addr = udev->address;
803	di->udi_index = udev->device_index;
804	strlcpy(di->udi_serial, udev->serial, sizeof(di->udi_serial));
805	strlcpy(di->udi_vendor, udev->manufacturer, sizeof(di->udi_vendor));
806	strlcpy(di->udi_product, udev->product, sizeof(di->udi_product));
807	usb2_printBCD(di->udi_release, sizeof(di->udi_release),
808	    UGETW(udev->ddesc.bcdDevice));
809	di->udi_vendorNo = UGETW(udev->ddesc.idVendor);
810	di->udi_productNo = UGETW(udev->ddesc.idProduct);
811	di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice);
812	di->udi_class = udev->ddesc.bDeviceClass;
813	di->udi_subclass = udev->ddesc.bDeviceSubClass;
814	di->udi_protocol = udev->ddesc.bDeviceProtocol;
815	di->udi_config_no = udev->curr_config_no;
816	di->udi_config_index = udev->curr_config_index;
817	di->udi_power = udev->flags.self_powered ? 0 : udev->power;
818	di->udi_speed = udev->speed;
819	di->udi_mode = udev->flags.usb_mode;
820	di->udi_power_mode = udev->power_mode;
821	di->udi_suspended = udev->flags.peer_suspended;
822
823	hub = udev->parent_hub;
824	if (hub) {
825		di->udi_hubaddr = hub->address;
826		di->udi_hubindex = hub->device_index;
827		di->udi_hubport = udev->port_no;
828	}
829	return (0);
830}
831
832/*------------------------------------------------------------------------*
833 *	ugen_check_request
834 *
835 * Return values:
836 * 0: Access allowed
837 * Else: No access
838 *------------------------------------------------------------------------*/
839static int
840ugen_check_request(struct usb_device *udev, struct usb_device_request *req)
841{
842	struct usb_endpoint *ep;
843	int error;
844
845	/*
846	 * Avoid requests that would damage the bus integrity:
847	 */
848	if (((req->bmRequestType == UT_WRITE_DEVICE) &&
849	    (req->bRequest == UR_SET_ADDRESS)) ||
850	    ((req->bmRequestType == UT_WRITE_DEVICE) &&
851	    (req->bRequest == UR_SET_CONFIG)) ||
852	    ((req->bmRequestType == UT_WRITE_INTERFACE) &&
853	    (req->bRequest == UR_SET_INTERFACE))) {
854		/*
855		 * These requests can be useful for testing USB drivers.
856		 */
857		error = priv_check(curthread, PRIV_DRIVER);
858		if (error) {
859			return (error);
860		}
861	}
862	/*
863	 * Special case - handle clearing of stall
864	 */
865	if (req->bmRequestType == UT_WRITE_ENDPOINT) {
866
867		ep = usb2_get_ep_by_addr(udev, req->wIndex[0]);
868		if (ep == NULL) {
869			return (EINVAL);
870		}
871		if ((req->bRequest == UR_CLEAR_FEATURE) &&
872		    (UGETW(req->wValue) == UF_ENDPOINT_HALT)) {
873			usb2_clear_data_toggle(udev, ep);
874		}
875	}
876	/* TODO: add more checks to verify the interface index */
877
878	return (0);
879}
880
881int
882ugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur)
883{
884	int error;
885	uint16_t len;
886	uint16_t actlen;
887
888	if (ugen_check_request(f->udev, &ur->ucr_request)) {
889		return (EPERM);
890	}
891	len = UGETW(ur->ucr_request.wLength);
892
893	/* check if "ucr_data" is valid */
894	if (len != 0) {
895		if (ur->ucr_data == NULL) {
896			return (EFAULT);
897		}
898	}
899	/* do the USB request */
900	error = usb2_do_request_flags
901	    (f->udev, NULL, &ur->ucr_request, ur->ucr_data,
902	    (ur->ucr_flags & USB_SHORT_XFER_OK) |
903	    USB_USER_DATA_PTR, &actlen,
904	    USB_DEFAULT_TIMEOUT);
905
906	ur->ucr_actlen = actlen;
907
908	if (error) {
909		error = EIO;
910	}
911	return (error);
912}
913
914/*------------------------------------------------------------------------
915 *	ugen_re_enumerate
916 *------------------------------------------------------------------------*/
917static int
918ugen_re_enumerate(struct usb_fifo *f)
919{
920	struct usb_device *udev = f->udev;
921	int error;
922
923	/*
924	 * This request can be useful for testing USB drivers:
925	 */
926	error = priv_check(curthread, PRIV_DRIVER);
927	if (error) {
928		return (error);
929	}
930	/* get the device unconfigured */
931	error = ugen_set_config(f, USB_UNCONFIG_INDEX);
932	if (error) {
933		return (error);
934	}
935	/* do a bus-reset */
936	mtx_lock(f->priv_mtx);
937	error = usb2_req_re_enumerate(udev, f->priv_mtx);
938	mtx_unlock(f->priv_mtx);
939
940	if (error) {
941		return (ENXIO);
942	}
943	/* restore configuration to index 0 */
944	error = ugen_set_config(f, 0);
945	if (error) {
946		return (error);
947	}
948	return (0);
949}
950
951int
952ugen_fs_uninit(struct usb_fifo *f)
953{
954	if (f->fs_xfer == NULL) {
955		return (EINVAL);
956	}
957	usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max);
958	free(f->fs_xfer, M_USB);
959	f->fs_xfer = NULL;
960	f->fs_ep_max = 0;
961	f->fs_ep_ptr = NULL;
962	f->flag_iscomplete = 0;
963	usb2_fifo_free_buffer(f);
964	return (0);
965}
966
967static uint8_t
968ugen_fs_get_complete(struct usb_fifo *f, uint8_t *pindex)
969{
970	struct usb_mbuf *m;
971
972	USB_IF_DEQUEUE(&f->used_q, m);
973
974	if (m) {
975		*pindex = *((uint8_t *)(m->cur_data_ptr));
976
977		USB_IF_ENQUEUE(&f->free_q, m);
978
979		return (0);		/* success */
980	} else {
981
982		*pindex = 0;		/* fix compiler warning */
983
984		f->flag_iscomplete = 0;
985	}
986	return (1);			/* failure */
987}
988
989static void
990ugen_fs_set_complete(struct usb_fifo *f, uint8_t index)
991{
992	struct usb_mbuf *m;
993
994	USB_IF_DEQUEUE(&f->free_q, m);
995
996	if (m == NULL) {
997		/* can happen during close */
998		DPRINTF("out of buffers\n");
999		return;
1000	}
1001	USB_MBUF_RESET(m);
1002
1003	*((uint8_t *)(m->cur_data_ptr)) = index;
1004
1005	USB_IF_ENQUEUE(&f->used_q, m);
1006
1007	f->flag_iscomplete = 1;
1008
1009	usb2_fifo_wakeup(f);
1010}
1011
1012static int
1013ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
1014{
1015	struct usb_device_request *req;
1016	struct usb_xfer *xfer;
1017	struct usb_fs_endpoint fs_ep;
1018	void *uaddr;			/* userland pointer */
1019	void *kaddr;
1020	usb_frlength_t offset;
1021	usb_frlength_t rem;
1022	usb_frcount_t n;
1023	uint32_t length;
1024	int error;
1025	uint8_t isread;
1026
1027	if (ep_index >= f->fs_ep_max) {
1028		return (EINVAL);
1029	}
1030	xfer = f->fs_xfer[ep_index];
1031	if (xfer == NULL) {
1032		return (EINVAL);
1033	}
1034	mtx_lock(f->priv_mtx);
1035	if (usb2_transfer_pending(xfer)) {
1036		mtx_unlock(f->priv_mtx);
1037		return (EBUSY);		/* should not happen */
1038	}
1039	mtx_unlock(f->priv_mtx);
1040
1041	error = copyin(f->fs_ep_ptr +
1042	    ep_index, &fs_ep, sizeof(fs_ep));
1043	if (error) {
1044		return (error);
1045	}
1046	/* security checks */
1047
1048	if (fs_ep.nFrames > xfer->max_frame_count) {
1049		xfer->error = USB_ERR_INVAL;
1050		goto complete;
1051	}
1052	if (fs_ep.nFrames == 0) {
1053		xfer->error = USB_ERR_INVAL;
1054		goto complete;
1055	}
1056	error = copyin(fs_ep.ppBuffer,
1057	    &uaddr, sizeof(uaddr));
1058	if (error) {
1059		return (error);
1060	}
1061	/* reset first frame */
1062	usb2_set_frame_offset(xfer, 0, 0);
1063
1064	if (xfer->flags_int.control_xfr) {
1065
1066		req = xfer->frbuffers[0].buffer;
1067
1068		error = copyin(fs_ep.pLength,
1069		    &length, sizeof(length));
1070		if (error) {
1071			return (error);
1072		}
1073		if (length >= sizeof(*req)) {
1074			xfer->error = USB_ERR_INVAL;
1075			goto complete;
1076		}
1077		if (length != 0) {
1078			error = copyin(uaddr, req, length);
1079			if (error) {
1080				return (error);
1081			}
1082		}
1083		if (ugen_check_request(f->udev, req)) {
1084			xfer->error = USB_ERR_INVAL;
1085			goto complete;
1086		}
1087		xfer->frlengths[0] = length;
1088
1089		/* Host mode only ! */
1090		if ((req->bmRequestType &
1091		    (UT_READ | UT_WRITE)) == UT_READ) {
1092			isread = 1;
1093		} else {
1094			isread = 0;
1095		}
1096		n = 1;
1097		offset = sizeof(*req);
1098
1099	} else {
1100		/* Device and Host mode */
1101		if (USB_GET_DATA_ISREAD(xfer)) {
1102			isread = 1;
1103		} else {
1104			isread = 0;
1105		}
1106		n = 0;
1107		offset = 0;
1108	}
1109
1110	rem = xfer->max_data_length;
1111	xfer->nframes = fs_ep.nFrames;
1112	xfer->timeout = fs_ep.timeout;
1113	if (xfer->timeout > 65535) {
1114		xfer->timeout = 65535;
1115	}
1116	if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
1117		xfer->flags.short_xfer_ok = 1;
1118	else
1119		xfer->flags.short_xfer_ok = 0;
1120
1121	if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
1122		xfer->flags.short_frames_ok = 1;
1123	else
1124		xfer->flags.short_frames_ok = 0;
1125
1126	if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
1127		xfer->flags.force_short_xfer = 1;
1128	else
1129		xfer->flags.force_short_xfer = 0;
1130
1131	if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
1132		xfer->flags.stall_pipe = 1;
1133	else
1134		xfer->flags.stall_pipe = 0;
1135
1136	for (; n != xfer->nframes; n++) {
1137
1138		error = copyin(fs_ep.pLength + n,
1139		    &length, sizeof(length));
1140		if (error) {
1141			break;
1142		}
1143		xfer->frlengths[n] = length;
1144
1145		if (length > rem) {
1146			xfer->error = USB_ERR_INVAL;
1147			goto complete;
1148		}
1149		rem -= length;
1150
1151		if (!isread) {
1152
1153			/* we need to know the source buffer */
1154			error = copyin(fs_ep.ppBuffer + n,
1155			    &uaddr, sizeof(uaddr));
1156			if (error) {
1157				break;
1158			}
1159			if (xfer->flags_int.isochronous_xfr) {
1160				/* get kernel buffer address */
1161				kaddr = xfer->frbuffers[0].buffer;
1162				kaddr = USB_ADD_BYTES(kaddr, offset);
1163			} else {
1164				/* set current frame offset */
1165				usb2_set_frame_offset(xfer, offset, n);
1166
1167				/* get kernel buffer address */
1168				kaddr = xfer->frbuffers[n].buffer;
1169			}
1170
1171			/* move data */
1172			error = copyin(uaddr, kaddr, length);
1173			if (error) {
1174				break;
1175			}
1176		}
1177		offset += length;
1178	}
1179	return (error);
1180
1181complete:
1182	mtx_lock(f->priv_mtx);
1183	ugen_fs_set_complete(f, ep_index);
1184	mtx_unlock(f->priv_mtx);
1185	return (0);
1186}
1187
1188static int
1189ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index)
1190{
1191	struct usb_device_request *req;
1192	struct usb_xfer *xfer;
1193	struct usb_fs_endpoint fs_ep;
1194	struct usb_fs_endpoint *fs_ep_uptr;	/* userland ptr */
1195	void *uaddr;			/* userland ptr */
1196	void *kaddr;
1197	usb_frlength_t offset;
1198	usb_frlength_t rem;
1199	usb_frcount_t n;
1200	uint32_t length;
1201	uint32_t temp;
1202	int error;
1203	uint8_t isread;
1204
1205	if (ep_index >= f->fs_ep_max)
1206		return (EINVAL);
1207
1208	xfer = f->fs_xfer[ep_index];
1209	if (xfer == NULL)
1210		return (EINVAL);
1211
1212	mtx_lock(f->priv_mtx);
1213	if (usb2_transfer_pending(xfer)) {
1214		mtx_unlock(f->priv_mtx);
1215		return (EBUSY);		/* should not happen */
1216	}
1217	mtx_unlock(f->priv_mtx);
1218
1219	fs_ep_uptr = f->fs_ep_ptr + ep_index;
1220	error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
1221	if (error) {
1222		return (error);
1223	}
1224	fs_ep.status = xfer->error;
1225	fs_ep.aFrames = xfer->aframes;
1226	fs_ep.isoc_time_complete = xfer->isoc_time_complete;
1227	if (xfer->error) {
1228		goto complete;
1229	}
1230	if (xfer->flags_int.control_xfr) {
1231		req = xfer->frbuffers[0].buffer;
1232
1233		/* Host mode only ! */
1234		if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
1235			isread = 1;
1236		} else {
1237			isread = 0;
1238		}
1239		if (xfer->nframes == 0)
1240			n = 0;		/* should never happen */
1241		else
1242			n = 1;
1243	} else {
1244		/* Device and Host mode */
1245		if (USB_GET_DATA_ISREAD(xfer)) {
1246			isread = 1;
1247		} else {
1248			isread = 0;
1249		}
1250		n = 0;
1251	}
1252
1253	/* Update lengths and copy out data */
1254
1255	rem = xfer->max_data_length;
1256	offset = 0;
1257
1258	for (; n != xfer->nframes; n++) {
1259
1260		/* get initial length into "temp" */
1261		error = copyin(fs_ep.pLength + n,
1262		    &temp, sizeof(temp));
1263		if (error) {
1264			return (error);
1265		}
1266		if (temp > rem) {
1267			/* the userland length has been corrupted */
1268			DPRINTF("corrupt userland length "
1269			    "%u > %u\n", temp, rem);
1270			fs_ep.status = USB_ERR_INVAL;
1271			goto complete;
1272		}
1273		rem -= temp;
1274
1275		/* get actual transfer length */
1276		length = xfer->frlengths[n];
1277		if (length > temp) {
1278			/* data overflow */
1279			fs_ep.status = USB_ERR_INVAL;
1280			DPRINTF("data overflow %u > %u\n",
1281			    length, temp);
1282			goto complete;
1283		}
1284		if (isread) {
1285
1286			/* we need to know the destination buffer */
1287			error = copyin(fs_ep.ppBuffer + n,
1288			    &uaddr, sizeof(uaddr));
1289			if (error) {
1290				return (error);
1291			}
1292			if (xfer->flags_int.isochronous_xfr) {
1293				/* only one frame buffer */
1294				kaddr = USB_ADD_BYTES(
1295				    xfer->frbuffers[0].buffer, offset);
1296			} else {
1297				/* multiple frame buffers */
1298				kaddr = xfer->frbuffers[n].buffer;
1299			}
1300
1301			/* move data */
1302			error = copyout(kaddr, uaddr, length);
1303			if (error) {
1304				return (error);
1305			}
1306		}
1307		/*
1308		 * Update offset according to initial length, which is
1309		 * needed by isochronous transfers!
1310		 */
1311		offset += temp;
1312
1313		/* update length */
1314		error = copyout(&length,
1315		    fs_ep.pLength + n, sizeof(length));
1316		if (error) {
1317			return (error);
1318		}
1319	}
1320
1321complete:
1322	/* update "aFrames" */
1323	error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames,
1324	    sizeof(fs_ep.aFrames));
1325	if (error)
1326		goto done;
1327
1328	/* update "isoc_time_complete" */
1329	error = copyout(&fs_ep.isoc_time_complete,
1330	    &fs_ep_uptr->isoc_time_complete,
1331	    sizeof(fs_ep.isoc_time_complete));
1332	if (error)
1333		goto done;
1334	/* update "status" */
1335	error = copyout(&fs_ep.status, &fs_ep_uptr->status,
1336	    sizeof(fs_ep.status));
1337done:
1338	return (error);
1339}
1340
1341static uint8_t
1342ugen_fifo_in_use(struct usb_fifo *f, int fflags)
1343{
1344	struct usb_fifo *f_rx;
1345	struct usb_fifo *f_tx;
1346
1347	f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1348	f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1349
1350	if ((fflags & FREAD) && f_rx &&
1351	    (f_rx->xfer[0] || f_rx->xfer[1])) {
1352		return (1);		/* RX FIFO in use */
1353	}
1354	if ((fflags & FWRITE) && f_tx &&
1355	    (f_tx->xfer[0] || f_tx->xfer[1])) {
1356		return (1);		/* TX FIFO in use */
1357	}
1358	return (0);			/* not in use */
1359}
1360
1361static int
1362ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
1363{
1364	struct usb_config usb_config[1];
1365	struct usb_device_request req;
1366	union {
1367		struct usb_fs_complete *pcomp;
1368		struct usb_fs_start *pstart;
1369		struct usb_fs_stop *pstop;
1370		struct usb_fs_open *popen;
1371		struct usb_fs_close *pclose;
1372		struct usb_fs_clear_stall_sync *pstall;
1373		void   *addr;
1374	}     u;
1375	struct usb_endpoint *ep;
1376	struct usb_endpoint_descriptor *ed;
1377	int error = 0;
1378	uint8_t iface_index;
1379	uint8_t isread;
1380	uint8_t ep_index;
1381
1382	u.addr = addr;
1383
1384	DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1385
1386	switch (cmd) {
1387	case USB_FS_COMPLETE:
1388		mtx_lock(f->priv_mtx);
1389		error = ugen_fs_get_complete(f, &ep_index);
1390		mtx_unlock(f->priv_mtx);
1391
1392		if (error) {
1393			error = EBUSY;
1394			break;
1395		}
1396		u.pcomp->ep_index = ep_index;
1397		error = ugen_fs_copy_out(f, u.pcomp->ep_index);
1398		break;
1399
1400	case USB_FS_START:
1401		error = ugen_fs_copy_in(f, u.pstart->ep_index);
1402		if (error) {
1403			break;
1404		}
1405		mtx_lock(f->priv_mtx);
1406		usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]);
1407		mtx_unlock(f->priv_mtx);
1408		break;
1409
1410	case USB_FS_STOP:
1411		if (u.pstop->ep_index >= f->fs_ep_max) {
1412			error = EINVAL;
1413			break;
1414		}
1415		mtx_lock(f->priv_mtx);
1416		usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
1417		mtx_unlock(f->priv_mtx);
1418		break;
1419
1420	case USB_FS_OPEN:
1421		if (u.popen->ep_index >= f->fs_ep_max) {
1422			error = EINVAL;
1423			break;
1424		}
1425		if (f->fs_xfer[u.popen->ep_index] != NULL) {
1426			error = EBUSY;
1427			break;
1428		}
1429		if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) {
1430			u.popen->max_bufsize = USB_FS_MAX_BUFSIZE;
1431		}
1432		if (u.popen->max_frames > USB_FS_MAX_FRAMES) {
1433			u.popen->max_frames = USB_FS_MAX_FRAMES;
1434			break;
1435		}
1436		if (u.popen->max_frames == 0) {
1437			error = EINVAL;
1438			break;
1439		}
1440		ep = usb2_get_ep_by_addr(f->udev, u.popen->ep_no);
1441		if (ep == NULL) {
1442			error = EINVAL;
1443			break;
1444		}
1445		ed = ep->edesc;
1446		if (ed == NULL) {
1447			error = ENXIO;
1448			break;
1449		}
1450		iface_index = ep->iface_index;
1451
1452		bzero(usb_config, sizeof(usb_config));
1453
1454		usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
1455		usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
1456		usb_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
1457		usb_config[0].interval = USB_DEFAULT_INTERVAL;
1458		usb_config[0].flags.proxy_buffer = 1;
1459		usb_config[0].callback = &ugen_default_fs_callback;
1460		usb_config[0].timeout = 0;	/* no timeout */
1461		usb_config[0].frames = u.popen->max_frames;
1462		usb_config[0].bufsize = u.popen->max_bufsize;
1463		usb_config[0].usb_mode = USB_MODE_DUAL;	/* both modes */
1464
1465		if (usb_config[0].type == UE_CONTROL) {
1466			if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1467				error = EINVAL;
1468				break;
1469			}
1470		} else {
1471
1472			isread = ((usb_config[0].endpoint &
1473			    (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
1474
1475			if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1476				isread = !isread;
1477			}
1478			/* check permissions */
1479			if (isread) {
1480				if (!(fflags & FREAD)) {
1481					error = EPERM;
1482					break;
1483				}
1484			} else {
1485				if (!(fflags & FWRITE)) {
1486					error = EPERM;
1487					break;
1488				}
1489			}
1490		}
1491		error = usb2_transfer_setup(f->udev, &iface_index,
1492		    f->fs_xfer + u.popen->ep_index, usb_config, 1,
1493		    f, f->priv_mtx);
1494		if (error == 0) {
1495			/* update maximums */
1496			u.popen->max_packet_length =
1497			    f->fs_xfer[u.popen->ep_index]->max_frame_size;
1498			u.popen->max_bufsize =
1499			    f->fs_xfer[u.popen->ep_index]->max_data_length;
1500			f->fs_xfer[u.popen->ep_index]->priv_fifo =
1501			    ((uint8_t *)0) + u.popen->ep_index;
1502		} else {
1503			error = ENOMEM;
1504		}
1505		break;
1506
1507	case USB_FS_CLOSE:
1508		if (u.pclose->ep_index >= f->fs_ep_max) {
1509			error = EINVAL;
1510			break;
1511		}
1512		if (f->fs_xfer[u.pclose->ep_index] == NULL) {
1513			error = EINVAL;
1514			break;
1515		}
1516		usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
1517		break;
1518
1519	case USB_FS_CLEAR_STALL_SYNC:
1520		if (u.pstall->ep_index >= f->fs_ep_max) {
1521			error = EINVAL;
1522			break;
1523		}
1524		if (f->fs_xfer[u.pstall->ep_index] == NULL) {
1525			error = EINVAL;
1526			break;
1527		}
1528		if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1529			error = EINVAL;
1530			break;
1531		}
1532		mtx_lock(f->priv_mtx);
1533		error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
1534		mtx_unlock(f->priv_mtx);
1535
1536		if (error) {
1537			return (EBUSY);
1538		}
1539		ep = f->fs_xfer[u.pstall->ep_index]->endpoint;
1540
1541		/* setup a clear-stall packet */
1542		req.bmRequestType = UT_WRITE_ENDPOINT;
1543		req.bRequest = UR_CLEAR_FEATURE;
1544		USETW(req.wValue, UF_ENDPOINT_HALT);
1545		req.wIndex[0] = ep->edesc->bEndpointAddress;
1546		req.wIndex[1] = 0;
1547		USETW(req.wLength, 0);
1548
1549		error = usb2_do_request(f->udev, NULL, &req, NULL);
1550		if (error == 0) {
1551			usb2_clear_data_toggle(f->udev, ep);
1552		} else {
1553			error = ENXIO;
1554		}
1555		break;
1556
1557	default:
1558		error = ENOIOCTL;
1559		break;
1560	}
1561
1562	DPRINTFN(6, "error=%d\n", error);
1563
1564	return (error);
1565}
1566
1567static int
1568ugen_set_short_xfer(struct usb_fifo *f, void *addr)
1569{
1570	uint8_t t;
1571
1572	if (*(int *)addr)
1573		t = 1;
1574	else
1575		t = 0;
1576
1577	if (f->flag_short == t) {
1578		/* same value like before - accept */
1579		return (0);
1580	}
1581	if (f->xfer[0] || f->xfer[1]) {
1582		/* cannot change this during transfer */
1583		return (EBUSY);
1584	}
1585	f->flag_short = t;
1586	return (0);
1587}
1588
1589static int
1590ugen_set_timeout(struct usb_fifo *f, void *addr)
1591{
1592	f->timeout = *(int *)addr;
1593	if (f->timeout > 65535) {
1594		/* limit user input */
1595		f->timeout = 65535;
1596	}
1597	return (0);
1598}
1599
1600static int
1601ugen_get_frame_size(struct usb_fifo *f, void *addr)
1602{
1603	if (f->xfer[0]) {
1604		*(int *)addr = f->xfer[0]->max_frame_size;
1605	} else {
1606		return (EINVAL);
1607	}
1608	return (0);
1609}
1610
1611static int
1612ugen_set_buffer_size(struct usb_fifo *f, void *addr)
1613{
1614	usb_frlength_t t;
1615
1616	if (*(int *)addr < 0)
1617		t = 0;		/* use "wMaxPacketSize" */
1618	else if (*(int *)addr < (256 * 1024))
1619		t = *(int *)addr;
1620	else
1621		t = 256 * 1024;
1622
1623	if (f->bufsize == t) {
1624		/* same value like before - accept */
1625		return (0);
1626	}
1627	if (f->xfer[0] || f->xfer[1]) {
1628		/* cannot change this during transfer */
1629		return (EBUSY);
1630	}
1631	f->bufsize = t;
1632	return (0);
1633}
1634
1635static int
1636ugen_get_buffer_size(struct usb_fifo *f, void *addr)
1637{
1638	*(int *)addr = f->bufsize;
1639	return (0);
1640}
1641
1642static int
1643ugen_get_iface_desc(struct usb_fifo *f,
1644    struct usb_interface_descriptor *idesc)
1645{
1646	struct usb_interface *iface;
1647
1648	iface = usb2_get_iface(f->udev, f->iface_index);
1649	if (iface && iface->idesc) {
1650		*idesc = *(iface->idesc);
1651	} else {
1652		return (EIO);
1653	}
1654	return (0);
1655}
1656
1657static int
1658ugen_get_endpoint_desc(struct usb_fifo *f,
1659    struct usb_endpoint_descriptor *ed)
1660{
1661	struct usb_endpoint *ep;
1662
1663	ep = f->priv_sc0;
1664
1665	if (ep && ep->edesc) {
1666		*ed = *ep->edesc;
1667	} else {
1668		return (EINVAL);
1669	}
1670	return (0);
1671}
1672
1673static int
1674ugen_set_power_mode(struct usb_fifo *f, int mode)
1675{
1676	struct usb_device *udev = f->udev;
1677	int err;
1678	uint8_t old_mode;
1679
1680	if ((udev == NULL) ||
1681	    (udev->parent_hub == NULL)) {
1682		return (EINVAL);
1683	}
1684	err = priv_check(curthread, PRIV_DRIVER);
1685	if (err)
1686		return (err);
1687
1688	/* get old power mode */
1689	old_mode = udev->power_mode;
1690
1691	/* if no change, then just return */
1692	if (old_mode == mode)
1693		return (0);
1694
1695	switch (mode) {
1696	case USB_POWER_MODE_OFF:
1697		/* get the device unconfigured */
1698		err = ugen_set_config(f, USB_UNCONFIG_INDEX);
1699		if (err) {
1700			DPRINTFN(0, "Could not unconfigure "
1701			    "device (ignored)\n");
1702		}
1703
1704		/* clear port enable */
1705		err = usb2_req_clear_port_feature(udev->parent_hub,
1706		    NULL, udev->port_no, UHF_PORT_ENABLE);
1707		break;
1708
1709	case USB_POWER_MODE_ON:
1710	case USB_POWER_MODE_SAVE:
1711		break;
1712
1713	case USB_POWER_MODE_RESUME:
1714		err = usb2_req_clear_port_feature(udev->parent_hub,
1715		    NULL, udev->port_no, UHF_PORT_SUSPEND);
1716		mode = USB_POWER_MODE_SAVE;
1717		break;
1718
1719	case USB_POWER_MODE_SUSPEND:
1720		err = usb2_req_set_port_feature(udev->parent_hub,
1721		    NULL, udev->port_no, UHF_PORT_SUSPEND);
1722		mode = USB_POWER_MODE_SAVE;
1723		break;
1724
1725	default:
1726		return (EINVAL);
1727	}
1728
1729	if (err)
1730		return (ENXIO);		/* I/O failure */
1731
1732	/* if we are powered off we need to re-enumerate first */
1733	if (old_mode == USB_POWER_MODE_OFF) {
1734		err = ugen_re_enumerate(f);
1735		if (err)
1736			return (err);
1737	}
1738
1739	/* set new power mode */
1740	usb2_set_power_mode(udev, mode);
1741
1742	return (0);			/* success */
1743}
1744
1745static int
1746ugen_get_power_mode(struct usb_fifo *f)
1747{
1748	struct usb_device *udev = f->udev;
1749
1750	if ((udev == NULL) ||
1751	    (udev->parent_hub == NULL)) {
1752		return (USB_POWER_MODE_ON);
1753	}
1754	return (udev->power_mode);
1755}
1756
1757static int
1758ugen_do_port_feature(struct usb_fifo *f, uint8_t port_no,
1759    uint8_t set, uint16_t feature)
1760{
1761	struct usb_device *udev = f->udev;
1762	struct usb_hub *hub;
1763	int err;
1764
1765	err = priv_check(curthread, PRIV_DRIVER);
1766	if (err) {
1767		return (err);
1768	}
1769	if (port_no == 0) {
1770		return (EINVAL);
1771	}
1772	if ((udev == NULL) ||
1773	    (udev->hub == NULL)) {
1774		return (EINVAL);
1775	}
1776	hub = udev->hub;
1777
1778	if (port_no > hub->nports) {
1779		return (EINVAL);
1780	}
1781	if (set)
1782		err = usb2_req_set_port_feature(udev,
1783		    NULL, port_no, feature);
1784	else
1785		err = usb2_req_clear_port_feature(udev,
1786		    NULL, port_no, feature);
1787
1788	if (err)
1789		return (ENXIO);		/* failure */
1790
1791	return (0);			/* success */
1792}
1793
1794static int
1795ugen_iface_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
1796{
1797	struct usb_fifo *f_rx;
1798	struct usb_fifo *f_tx;
1799	int error = 0;
1800
1801	f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1802	f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1803
1804	switch (cmd) {
1805	case USB_SET_RX_SHORT_XFER:
1806		if (fflags & FREAD) {
1807			error = ugen_set_short_xfer(f_rx, addr);
1808		} else {
1809			error = EINVAL;
1810		}
1811		break;
1812
1813	case USB_SET_TX_FORCE_SHORT:
1814		if (fflags & FWRITE) {
1815			error = ugen_set_short_xfer(f_tx, addr);
1816		} else {
1817			error = EINVAL;
1818		}
1819		break;
1820
1821	case USB_SET_RX_TIMEOUT:
1822		if (fflags & FREAD) {
1823			error = ugen_set_timeout(f_rx, addr);
1824		} else {
1825			error = EINVAL;
1826		}
1827		break;
1828
1829	case USB_SET_TX_TIMEOUT:
1830		if (fflags & FWRITE) {
1831			error = ugen_set_timeout(f_tx, addr);
1832		} else {
1833			error = EINVAL;
1834		}
1835		break;
1836
1837	case USB_GET_RX_FRAME_SIZE:
1838		if (fflags & FREAD) {
1839			error = ugen_get_frame_size(f_rx, addr);
1840		} else {
1841			error = EINVAL;
1842		}
1843		break;
1844
1845	case USB_GET_TX_FRAME_SIZE:
1846		if (fflags & FWRITE) {
1847			error = ugen_get_frame_size(f_tx, addr);
1848		} else {
1849			error = EINVAL;
1850		}
1851		break;
1852
1853	case USB_SET_RX_BUFFER_SIZE:
1854		if (fflags & FREAD) {
1855			error = ugen_set_buffer_size(f_rx, addr);
1856		} else {
1857			error = EINVAL;
1858		}
1859		break;
1860
1861	case USB_SET_TX_BUFFER_SIZE:
1862		if (fflags & FWRITE) {
1863			error = ugen_set_buffer_size(f_tx, addr);
1864		} else {
1865			error = EINVAL;
1866		}
1867		break;
1868
1869	case USB_GET_RX_BUFFER_SIZE:
1870		if (fflags & FREAD) {
1871			error = ugen_get_buffer_size(f_rx, addr);
1872		} else {
1873			error = EINVAL;
1874		}
1875		break;
1876
1877	case USB_GET_TX_BUFFER_SIZE:
1878		if (fflags & FWRITE) {
1879			error = ugen_get_buffer_size(f_tx, addr);
1880		} else {
1881			error = EINVAL;
1882		}
1883		break;
1884
1885	case USB_GET_RX_INTERFACE_DESC:
1886		if (fflags & FREAD) {
1887			error = ugen_get_iface_desc(f_rx, addr);
1888		} else {
1889			error = EINVAL;
1890		}
1891		break;
1892
1893	case USB_GET_TX_INTERFACE_DESC:
1894		if (fflags & FWRITE) {
1895			error = ugen_get_iface_desc(f_tx, addr);
1896		} else {
1897			error = EINVAL;
1898		}
1899		break;
1900
1901	case USB_GET_RX_ENDPOINT_DESC:
1902		if (fflags & FREAD) {
1903			error = ugen_get_endpoint_desc(f_rx, addr);
1904		} else {
1905			error = EINVAL;
1906		}
1907		break;
1908
1909	case USB_GET_TX_ENDPOINT_DESC:
1910		if (fflags & FWRITE) {
1911			error = ugen_get_endpoint_desc(f_tx, addr);
1912		} else {
1913			error = EINVAL;
1914		}
1915		break;
1916
1917	case USB_SET_RX_STALL_FLAG:
1918		if ((fflags & FREAD) && (*(int *)addr)) {
1919			f_rx->flag_stall = 1;
1920		}
1921		break;
1922
1923	case USB_SET_TX_STALL_FLAG:
1924		if ((fflags & FWRITE) && (*(int *)addr)) {
1925			f_tx->flag_stall = 1;
1926		}
1927		break;
1928
1929	default:
1930		error = ENOIOCTL;
1931		break;
1932	}
1933	return (error);
1934}
1935
1936static int
1937ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
1938{
1939	union {
1940		struct usb_interface_descriptor *idesc;
1941		struct usb_alt_interface *ai;
1942		struct usb_device_descriptor *ddesc;
1943		struct usb_config_descriptor *cdesc;
1944		struct usb_device_stats *stat;
1945		struct usb_fs_init *pinit;
1946		struct usb_fs_uninit *puninit;
1947		uint32_t *ptime;
1948		void   *addr;
1949		int    *pint;
1950	}     u;
1951	struct usb_device_descriptor *dtemp;
1952	struct usb_config_descriptor *ctemp;
1953	struct usb_interface *iface;
1954	int error = 0;
1955	uint8_t n;
1956
1957	u.addr = addr;
1958
1959	DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1960
1961	switch (cmd) {
1962	case USB_DISCOVER:
1963		usb2_needs_explore_all();
1964		break;
1965
1966	case USB_SETDEBUG:
1967		if (!(fflags & FWRITE)) {
1968			error = EPERM;
1969			break;
1970		}
1971		usb2_debug = *(int *)addr;
1972		break;
1973
1974	case USB_GET_CONFIG:
1975		*(int *)addr = f->udev->curr_config_index;
1976		break;
1977
1978	case USB_SET_CONFIG:
1979		if (!(fflags & FWRITE)) {
1980			error = EPERM;
1981			break;
1982		}
1983		error = ugen_set_config(f, *(int *)addr);
1984		break;
1985
1986	case USB_GET_ALTINTERFACE:
1987		iface = usb2_get_iface(f->udev,
1988		    u.ai->uai_interface_index);
1989		if (iface && iface->idesc) {
1990			u.ai->uai_alt_index = iface->alt_index;
1991		} else {
1992			error = EINVAL;
1993		}
1994		break;
1995
1996	case USB_SET_ALTINTERFACE:
1997		if (!(fflags & FWRITE)) {
1998			error = EPERM;
1999			break;
2000		}
2001		error = ugen_set_interface(f,
2002		    u.ai->uai_interface_index, u.ai->uai_alt_index);
2003		break;
2004
2005	case USB_GET_DEVICE_DESC:
2006		dtemp = usb2_get_device_descriptor(f->udev);
2007		if (!dtemp) {
2008			error = EIO;
2009			break;
2010		}
2011		*u.ddesc = *dtemp;
2012		break;
2013
2014	case USB_GET_CONFIG_DESC:
2015		ctemp = usb2_get_config_descriptor(f->udev);
2016		if (!ctemp) {
2017			error = EIO;
2018			break;
2019		}
2020		*u.cdesc = *ctemp;
2021		break;
2022
2023	case USB_GET_FULL_DESC:
2024		error = ugen_get_cdesc(f, addr);
2025		break;
2026
2027	case USB_GET_STRING_DESC:
2028		error = ugen_get_sdesc(f, addr);
2029		break;
2030
2031	case USB_GET_IFACE_DRIVER:
2032		error = ugen_get_iface_driver(f, addr);
2033		break;
2034
2035	case USB_REQUEST:
2036	case USB_DO_REQUEST:
2037		if (!(fflags & FWRITE)) {
2038			error = EPERM;
2039			break;
2040		}
2041		error = ugen_do_request(f, addr);
2042		break;
2043
2044	case USB_DEVICEINFO:
2045	case USB_GET_DEVICEINFO:
2046		error = usb2_gen_fill_deviceinfo(f, addr);
2047		break;
2048
2049	case USB_DEVICESTATS:
2050		for (n = 0; n != 4; n++) {
2051
2052			u.stat->uds_requests_fail[n] =
2053			    f->udev->bus->stats_err.uds_requests[n];
2054
2055			u.stat->uds_requests_ok[n] =
2056			    f->udev->bus->stats_ok.uds_requests[n];
2057		}
2058		break;
2059
2060	case USB_DEVICEENUMERATE:
2061		error = ugen_re_enumerate(f);
2062		break;
2063
2064	case USB_GET_PLUGTIME:
2065		*u.ptime = f->udev->plugtime;
2066		break;
2067
2068	case USB_CLAIM_INTERFACE:
2069	case USB_RELEASE_INTERFACE:
2070		/* TODO */
2071		break;
2072
2073	case USB_IFACE_DRIVER_ACTIVE:
2074		/* TODO */
2075		*u.pint = 0;
2076		break;
2077
2078	case USB_IFACE_DRIVER_DETACH:
2079		/* TODO */
2080		error = priv_check(curthread, PRIV_DRIVER);
2081		if (error) {
2082			break;
2083		}
2084		error = EINVAL;
2085		break;
2086
2087	case USB_SET_POWER_MODE:
2088		error = ugen_set_power_mode(f, *u.pint);
2089		break;
2090
2091	case USB_GET_POWER_MODE:
2092		*u.pint = ugen_get_power_mode(f);
2093		break;
2094
2095	case USB_SET_PORT_ENABLE:
2096		error = ugen_do_port_feature(f,
2097		    *u.pint, 1, UHF_PORT_ENABLE);
2098		break;
2099
2100	case USB_SET_PORT_DISABLE:
2101		error = ugen_do_port_feature(f,
2102		    *u.pint, 0, UHF_PORT_ENABLE);
2103		break;
2104
2105	case USB_FS_INIT:
2106		/* verify input parameters */
2107		if (u.pinit->pEndpoints == NULL) {
2108			error = EINVAL;
2109			break;
2110		}
2111		if (u.pinit->ep_index_max > 127) {
2112			error = EINVAL;
2113			break;
2114		}
2115		if (u.pinit->ep_index_max == 0) {
2116			error = EINVAL;
2117			break;
2118		}
2119		if (f->fs_xfer != NULL) {
2120			error = EBUSY;
2121			break;
2122		}
2123		if (f->dev_ep_index != 0) {
2124			error = EINVAL;
2125			break;
2126		}
2127		if (ugen_fifo_in_use(f, fflags)) {
2128			error = EBUSY;
2129			break;
2130		}
2131		error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
2132		if (error) {
2133			break;
2134		}
2135		f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) *
2136		    u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO);
2137		if (f->fs_xfer == NULL) {
2138			usb2_fifo_free_buffer(f);
2139			error = ENOMEM;
2140			break;
2141		}
2142		f->fs_ep_max = u.pinit->ep_index_max;
2143		f->fs_ep_ptr = u.pinit->pEndpoints;
2144		break;
2145
2146	case USB_FS_UNINIT:
2147		if (u.puninit->dummy != 0) {
2148			error = EINVAL;
2149			break;
2150		}
2151		error = ugen_fs_uninit(f);
2152		break;
2153
2154	default:
2155		mtx_lock(f->priv_mtx);
2156		error = ugen_iface_ioctl(f, cmd, addr, fflags);
2157		mtx_unlock(f->priv_mtx);
2158		break;
2159	}
2160	DPRINTFN(6, "error=%d\n", error);
2161	return (error);
2162}
2163
2164static void
2165ugen_default_fs_callback(struct usb_xfer *xfer)
2166{
2167	;				/* workaround for a bug in "indent" */
2168
2169	DPRINTF("st=%u alen=%u aframes=%u\n",
2170	    USB_GET_STATE(xfer), xfer->actlen, xfer->aframes);
2171
2172	switch (USB_GET_STATE(xfer)) {
2173	case USB_ST_SETUP:
2174		usb2_start_hardware(xfer);
2175		break;
2176	default:
2177		ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
2178		break;
2179	}
2180}
2181#endif	/* USB_HAVE_UGEN */
2182