xref: /freebsd/lib/libusb/libusb10.c (revision 1323ec57) 
1 /* $FreeBSD$ */
2 /*-
3  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4  *
5  * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
6  * Copyright (c) 2009 Hans Petter Selasky. All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE
31 #include LIBUSB_GLOBAL_INCLUDE_FILE
32 #else
33 #include <assert.h>
34 #include <errno.h>
35 #include <poll.h>
36 #include <pthread.h>
37 #include <signal.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <unistd.h>
42 #include <time.h>
43 #include <sys/fcntl.h>
44 #include <sys/ioctl.h>
45 #include <sys/queue.h>
46 #include <sys/endian.h>
47 #endif
48 
49 #define	libusb_device_handle libusb20_device
50 
51 #include "libusb20.h"
52 #include "libusb20_desc.h"
53 #include "libusb20_int.h"
54 #include "libusb.h"
55 #include "libusb10.h"
56 
57 #define	LIBUSB_NUM_SW_ENDPOINTS	(16 * 4)
58 
59 static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER;
60 struct libusb_context *usbi_default_context = NULL;
61 
62 /* Prototypes */
63 
64 static struct libusb20_transfer *libusb10_get_transfer(struct libusb20_device *, uint8_t, uint8_t);
65 static int libusb10_get_buffsize(struct libusb20_device *, libusb_transfer *);
66 static int libusb10_convert_error(uint8_t status);
67 static void libusb10_complete_transfer(struct libusb20_transfer *, struct libusb_super_transfer *, int);
68 static void libusb10_isoc_proxy(struct libusb20_transfer *);
69 static void libusb10_bulk_intr_proxy(struct libusb20_transfer *);
70 static void libusb10_ctrl_proxy(struct libusb20_transfer *);
71 static void libusb10_submit_transfer_sub(struct libusb20_device *, uint8_t);
72 
73 /*  Library initialisation / deinitialisation */
74 
75 static const struct libusb_version libusb_version = {
76 	.major = 1,
77 	.minor = 0,
78 	.micro = 0,
79 	.nano = 2016,
80 	.rc = "",
81 	.describe = "https://www.freebsd.org"
82 };
83 
84 const struct libusb_version *
85 libusb_get_version(void)
86 {
87 
88 	return (&libusb_version);
89 }
90 
91 void
92 libusb_set_debug(libusb_context *ctx, int level)
93 {
94 	ctx = GET_CONTEXT(ctx);
95 	/* debug_fixed is set when the environment overrides libusb_set_debug */
96 	if (ctx && ctx->debug_fixed == 0)
97 		ctx->debug = level;
98 }
99 
100 static void
101 libusb_set_nonblocking(int f)
102 {
103 	int flags;
104 
105 	/*
106 	 * We ignore any failures in this function, hence the
107 	 * non-blocking flag is not critical to the operation of
108 	 * libUSB. We use F_GETFL and F_SETFL to be compatible with
109 	 * Linux.
110 	 */
111 
112 	flags = fcntl(f, F_GETFL, NULL);
113 	if (flags == -1)
114 		return;
115 	flags |= O_NONBLOCK;
116 	fcntl(f, F_SETFL, flags);
117 }
118 
119 static void
120 libusb10_wakeup_event_loop(libusb_context *ctx)
121 {
122 	uint8_t dummy = 0;
123 	int err;
124 
125 	err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
126 	if (err < (int)sizeof(dummy)) {
127 		/* ignore error, if any */
128 		DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "Waking up event loop failed!");
129 	}
130 }
131 
132 int
133 libusb_init(libusb_context **context)
134 {
135 	struct libusb_context *ctx;
136 	pthread_condattr_t attr;
137 	char *debug, *ep;
138 	int ret;
139 
140 	ctx = malloc(sizeof(*ctx));
141 	if (!ctx)
142 		return (LIBUSB_ERROR_INVALID_PARAM);
143 
144 	memset(ctx, 0, sizeof(*ctx));
145 
146 	debug = getenv("LIBUSB_DEBUG");
147 	if (debug != NULL) {
148 		/*
149 		 * If LIBUSB_DEBUG is set, we'll honor that and use it to
150 		 * override libusb_set_debug calls.
151 		 */
152 		errno = 0;
153 		ctx->debug = strtol(debug, &ep, 10);
154 		if (errno == 0 && *ep == '\0') {
155 			ctx->debug_fixed = 1;
156 		} else {
157 			/*
158 			 * LIBUSB_DEBUG conversion failed for some reason, but
159 			 * we don't care about the specifics all that much.  We
160 			 * can't use it either way.  Force it to the default,
161 			 * 0, in case we had a partial number.
162 			 */
163 			ctx->debug = 0;
164 		}
165 	}
166 	TAILQ_INIT(&ctx->pollfds);
167 	TAILQ_INIT(&ctx->tr_done);
168 	TAILQ_INIT(&ctx->hotplug_cbh);
169 	TAILQ_INIT(&ctx->hotplug_devs);
170 
171 	if (pthread_mutex_init(&ctx->ctx_lock, NULL) != 0) {
172 		free(ctx);
173 		return (LIBUSB_ERROR_NO_MEM);
174 	}
175 	if (pthread_mutex_init(&ctx->hotplug_lock, NULL) != 0) {
176 		pthread_mutex_destroy(&ctx->ctx_lock);
177 		free(ctx);
178 		return (LIBUSB_ERROR_NO_MEM);
179 	}
180 	if (pthread_condattr_init(&attr) != 0) {
181 		pthread_mutex_destroy(&ctx->ctx_lock);
182 		pthread_mutex_destroy(&ctx->hotplug_lock);
183 		free(ctx);
184 		return (LIBUSB_ERROR_NO_MEM);
185 	}
186 	if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) != 0) {
187 		pthread_mutex_destroy(&ctx->ctx_lock);
188 		pthread_mutex_destroy(&ctx->hotplug_lock);
189 		pthread_condattr_destroy(&attr);
190 		free(ctx);
191 		return (LIBUSB_ERROR_OTHER);
192 	}
193 	if (pthread_cond_init(&ctx->ctx_cond, &attr) != 0) {
194 		pthread_mutex_destroy(&ctx->ctx_lock);
195 		pthread_mutex_destroy(&ctx->hotplug_lock);
196 		pthread_condattr_destroy(&attr);
197 		free(ctx);
198 		return (LIBUSB_ERROR_NO_MEM);
199 	}
200 	pthread_condattr_destroy(&attr);
201 
202 	ctx->ctx_handler = NO_THREAD;
203 	ctx->hotplug_handler = NO_THREAD;
204 
205 	ret = pipe(ctx->ctrl_pipe);
206 	if (ret < 0) {
207 		pthread_mutex_destroy(&ctx->ctx_lock);
208 		pthread_mutex_destroy(&ctx->hotplug_lock);
209 		pthread_cond_destroy(&ctx->ctx_cond);
210 		free(ctx);
211 		return (LIBUSB_ERROR_OTHER);
212 	}
213 	/* set non-blocking mode on the control pipe to avoid deadlock */
214 	libusb_set_nonblocking(ctx->ctrl_pipe[0]);
215 	libusb_set_nonblocking(ctx->ctrl_pipe[1]);
216 
217 	libusb10_add_pollfd(ctx, &ctx->ctx_poll, NULL, ctx->ctrl_pipe[0], POLLIN);
218 
219 	pthread_mutex_lock(&default_context_lock);
220 	if (usbi_default_context == NULL) {
221 		usbi_default_context = ctx;
222 	}
223 	pthread_mutex_unlock(&default_context_lock);
224 
225 	if (context)
226 		*context = ctx;
227 
228 	DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_init complete");
229 
230 	signal(SIGPIPE, SIG_IGN);
231 
232 	return (0);
233 }
234 
235 void
236 libusb_exit(libusb_context *ctx)
237 {
238 	ctx = GET_CONTEXT(ctx);
239 
240 	if (ctx == NULL)
241 		return;
242 
243 	/* stop hotplug thread, if any */
244 
245 	if (ctx->hotplug_handler != NO_THREAD) {
246 		pthread_t td;
247 		void *ptr;
248 
249 		HOTPLUG_LOCK(ctx);
250 		td = ctx->hotplug_handler;
251 		ctx->hotplug_handler = NO_THREAD;
252 		HOTPLUG_UNLOCK(ctx);
253 
254 		pthread_join(td, &ptr);
255 	}
256 
257 	/* XXX cleanup devices */
258 
259 	libusb10_remove_pollfd(ctx, &ctx->ctx_poll);
260 	close(ctx->ctrl_pipe[0]);
261 	close(ctx->ctrl_pipe[1]);
262 	pthread_mutex_destroy(&ctx->ctx_lock);
263 	pthread_mutex_destroy(&ctx->hotplug_lock);
264 	pthread_cond_destroy(&ctx->ctx_cond);
265 
266 	pthread_mutex_lock(&default_context_lock);
267 	if (ctx == usbi_default_context) {
268 		usbi_default_context = NULL;
269 	}
270 	pthread_mutex_unlock(&default_context_lock);
271 
272 	free(ctx);
273 }
274 
275 /* Device handling and initialisation. */
276 
277 ssize_t
278 libusb_get_device_list(libusb_context *ctx, libusb_device ***list)
279 {
280 	struct libusb20_backend *usb_backend;
281 	struct libusb20_device *pdev;
282 	struct libusb_device *dev;
283 	int i;
284 
285 	ctx = GET_CONTEXT(ctx);
286 
287 	if (ctx == NULL)
288 		return (LIBUSB_ERROR_INVALID_PARAM);
289 
290 	if (list == NULL)
291 		return (LIBUSB_ERROR_INVALID_PARAM);
292 
293 	usb_backend = libusb20_be_alloc_default();
294 	if (usb_backend == NULL)
295 		return (LIBUSB_ERROR_NO_MEM);
296 
297 	/* figure out how many USB devices are present */
298 	pdev = NULL;
299 	i = 0;
300 	while ((pdev = libusb20_be_device_foreach(usb_backend, pdev)))
301 		i++;
302 
303 	/* allocate device pointer list */
304 	*list = malloc((i + 1) * sizeof(void *));
305 	if (*list == NULL) {
306 		libusb20_be_free(usb_backend);
307 		return (LIBUSB_ERROR_NO_MEM);
308 	}
309 	/* create libusb v1.0 compliant devices */
310 	i = 0;
311 	while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
312 
313 		dev = malloc(sizeof(*dev));
314 		if (dev == NULL) {
315 			while (i != 0) {
316 				libusb_unref_device((*list)[i - 1]);
317 				i--;
318 			}
319 			free(*list);
320 			*list = NULL;
321 			libusb20_be_free(usb_backend);
322 			return (LIBUSB_ERROR_NO_MEM);
323 		}
324 		/* get device into libUSB v1.0 list */
325 		libusb20_be_dequeue_device(usb_backend, pdev);
326 
327 		memset(dev, 0, sizeof(*dev));
328 
329 		/* init transfer queues */
330 		TAILQ_INIT(&dev->tr_head);
331 
332 		/* set context we belong to */
333 		dev->ctx = ctx;
334 
335 		/* link together the two structures */
336 		dev->os_priv = pdev;
337 		pdev->privLuData = dev;
338 
339 		(*list)[i] = libusb_ref_device(dev);
340 		i++;
341 	}
342 	(*list)[i] = NULL;
343 
344 	libusb20_be_free(usb_backend);
345 	return (i);
346 }
347 
348 void
349 libusb_free_device_list(libusb_device **list, int unref_devices)
350 {
351 	int i;
352 
353 	if (list == NULL)
354 		return;			/* be NULL safe */
355 
356 	if (unref_devices) {
357 		for (i = 0; list[i] != NULL; i++)
358 			libusb_unref_device(list[i]);
359 	}
360 	free(list);
361 }
362 
363 uint8_t
364 libusb_get_bus_number(libusb_device *dev)
365 {
366 	if (dev == NULL)
367 		return (0);		/* should not happen */
368 	return (libusb20_dev_get_bus_number(dev->os_priv));
369 }
370 
371 uint8_t
372 libusb_get_port_number(libusb_device *dev)
373 {
374 	if (dev == NULL)
375 		return (0);		/* should not happen */
376 	return (libusb20_dev_get_parent_port(dev->os_priv));
377 }
378 
379 int
380 libusb_get_port_numbers(libusb_device *dev, uint8_t *buf, uint8_t bufsize)
381 {
382 	return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
383 }
384 
385 int
386 libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t *buf,
387     uint8_t bufsize)
388 {
389 	return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
390 }
391 
392 uint8_t
393 libusb_get_device_address(libusb_device *dev)
394 {
395 	if (dev == NULL)
396 		return (0);		/* should not happen */
397 	return (libusb20_dev_get_address(dev->os_priv));
398 }
399 
400 enum libusb_speed
401 libusb_get_device_speed(libusb_device *dev)
402 {
403 	if (dev == NULL)
404 		return (LIBUSB_SPEED_UNKNOWN);	/* should not happen */
405 
406 	switch (libusb20_dev_get_speed(dev->os_priv)) {
407 	case LIBUSB20_SPEED_LOW:
408 		return (LIBUSB_SPEED_LOW);
409 	case LIBUSB20_SPEED_FULL:
410 		return (LIBUSB_SPEED_FULL);
411 	case LIBUSB20_SPEED_HIGH:
412 		return (LIBUSB_SPEED_HIGH);
413 	case LIBUSB20_SPEED_SUPER:
414 		return (LIBUSB_SPEED_SUPER);
415 	default:
416 		break;
417 	}
418 	return (LIBUSB_SPEED_UNKNOWN);
419 }
420 
421 int
422 libusb_get_max_packet_size(libusb_device *dev, uint8_t endpoint)
423 {
424 	struct libusb_config_descriptor *pdconf;
425 	struct libusb_interface *pinf;
426 	struct libusb_interface_descriptor *pdinf;
427 	struct libusb_endpoint_descriptor *pdend;
428 	int i;
429 	int j;
430 	int k;
431 	int ret;
432 
433 	if (dev == NULL)
434 		return (LIBUSB_ERROR_NO_DEVICE);
435 
436 	ret = libusb_get_active_config_descriptor(dev, &pdconf);
437 	if (ret < 0)
438 		return (ret);
439 
440 	ret = LIBUSB_ERROR_NOT_FOUND;
441 	for (i = 0; i < pdconf->bNumInterfaces; i++) {
442 		pinf = &pdconf->interface[i];
443 		for (j = 0; j < pinf->num_altsetting; j++) {
444 			pdinf = &pinf->altsetting[j];
445 			for (k = 0; k < pdinf->bNumEndpoints; k++) {
446 				pdend = &pdinf->endpoint[k];
447 				if (pdend->bEndpointAddress == endpoint) {
448 					ret = pdend->wMaxPacketSize;
449 					goto out;
450 				}
451 			}
452 		}
453 	}
454 
455 out:
456 	libusb_free_config_descriptor(pdconf);
457 	return (ret);
458 }
459 
460 int
461 libusb_get_max_iso_packet_size(libusb_device *dev, uint8_t endpoint)
462 {
463 	int multiplier;
464 	int ret;
465 
466 	ret = libusb_get_max_packet_size(dev, endpoint);
467 
468 	switch (libusb20_dev_get_speed(dev->os_priv)) {
469 	case LIBUSB20_SPEED_LOW:
470 	case LIBUSB20_SPEED_FULL:
471 		break;
472 	default:
473 		if (ret > -1) {
474 			multiplier = (1 + ((ret >> 11) & 3));
475 			if (multiplier > 3)
476 				multiplier = 3;
477 			ret = (ret & 0x7FF) * multiplier;
478 		}
479 		break;
480 	}
481 	return (ret);
482 }
483 
484 libusb_device *
485 libusb_ref_device(libusb_device *dev)
486 {
487 	if (dev == NULL)
488 		return (NULL);		/* be NULL safe */
489 
490 	CTX_LOCK(dev->ctx);
491 	dev->refcnt++;
492 	CTX_UNLOCK(dev->ctx);
493 
494 	return (dev);
495 }
496 
497 void
498 libusb_unref_device(libusb_device *dev)
499 {
500 	if (dev == NULL)
501 		return;			/* be NULL safe */
502 
503 	CTX_LOCK(dev->ctx);
504 	dev->refcnt--;
505 	CTX_UNLOCK(dev->ctx);
506 
507 	if (dev->refcnt == 0) {
508 		libusb20_dev_free(dev->os_priv);
509 		free(dev);
510 	}
511 }
512 
513 int
514 libusb_open(libusb_device *dev, libusb_device_handle **devh)
515 {
516 	libusb_context *ctx = dev->ctx;
517 	struct libusb20_device *pdev = dev->os_priv;
518 	int err;
519 
520 	if (devh == NULL)
521 		return (LIBUSB_ERROR_INVALID_PARAM);
522 
523 	/* set default device handle value */
524 	*devh = NULL;
525 
526 	dev = libusb_ref_device(dev);
527 	if (dev == NULL)
528 		return (LIBUSB_ERROR_INVALID_PARAM);
529 
530 	err = libusb20_dev_open(pdev, LIBUSB_NUM_SW_ENDPOINTS);
531 	if (err) {
532 		libusb_unref_device(dev);
533 		return (LIBUSB_ERROR_NO_MEM);
534 	}
535 
536 	/*
537 	 * Clear the device gone flag, in case the device was opened
538 	 * after a re-attach, to allow new transaction:
539 	 */
540 	CTX_LOCK(ctx);
541 	dev->device_is_gone = 0;
542 	CTX_UNLOCK(ctx);
543 
544 	libusb10_add_pollfd(ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
545 	    POLLOUT | POLLRDNORM | POLLWRNORM);
546 
547 	/* make sure our event loop detects the new device */
548 	libusb10_wakeup_event_loop(ctx);
549 
550 	*devh = pdev;
551 
552 	return (0);
553 }
554 
555 libusb_device_handle *
556 libusb_open_device_with_vid_pid(libusb_context *ctx, uint16_t vendor_id,
557     uint16_t product_id)
558 {
559 	struct libusb_device **devs;
560 	struct libusb20_device *pdev;
561 	struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
562 	int i;
563 	int j;
564 
565 	ctx = GET_CONTEXT(ctx);
566 	if (ctx == NULL)
567 		return (NULL);		/* be NULL safe */
568 
569 	DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_with_vid_pid enter");
570 
571 	if ((i = libusb_get_device_list(ctx, &devs)) < 0)
572 		return (NULL);
573 
574 	pdev = NULL;
575 	for (j = 0; j < i; j++) {
576 		struct libusb20_device *tdev;
577 
578 		tdev = devs[j]->os_priv;
579 		pdesc = libusb20_dev_get_device_desc(tdev);
580 		/*
581 		 * NOTE: The USB library will automatically swap the
582 		 * fields in the device descriptor to be of host
583 		 * endian type!
584 		 */
585 		if (pdesc->idVendor == vendor_id &&
586 		    pdesc->idProduct == product_id) {
587 			libusb_open(devs[j], &pdev);
588 			break;
589 		}
590 	}
591 
592 	libusb_free_device_list(devs, 1);
593 	DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_with_vid_pid leave");
594 	return (pdev);
595 }
596 
597 void
598 libusb_close(struct libusb20_device *pdev)
599 {
600 	libusb_context *ctx;
601 	struct libusb_device *dev;
602 
603 	if (pdev == NULL)
604 		return;			/* be NULL safe */
605 
606 	dev = libusb_get_device(pdev);
607 	ctx = dev->ctx;
608 
609 	libusb10_remove_pollfd(ctx, &dev->dev_poll);
610 
611 	libusb20_dev_close(pdev);
612 
613 	/* unref will free the "pdev" when the refcount reaches zero */
614 	libusb_unref_device(dev);
615 
616 	/* make sure our event loop detects the closed device */
617 	libusb10_wakeup_event_loop(ctx);
618 }
619 
620 libusb_device *
621 libusb_get_device(struct libusb20_device *pdev)
622 {
623 	if (pdev == NULL)
624 		return (NULL);
625 	return ((libusb_device *)pdev->privLuData);
626 }
627 
628 int
629 libusb_get_configuration(struct libusb20_device *pdev, int *config)
630 {
631 	struct libusb20_config *pconf;
632 
633 	if (pdev == NULL || config == NULL)
634 		return (LIBUSB_ERROR_INVALID_PARAM);
635 
636 	pconf = libusb20_dev_alloc_config(pdev, libusb20_dev_get_config_index(pdev));
637 	if (pconf == NULL)
638 		return (LIBUSB_ERROR_NO_MEM);
639 
640 	*config = pconf->desc.bConfigurationValue;
641 
642 	free(pconf);
643 
644 	return (0);
645 }
646 
647 int
648 libusb_set_configuration(struct libusb20_device *pdev, int configuration)
649 {
650 	struct libusb20_config *pconf;
651 	struct libusb_device *dev;
652 	int err;
653 	uint8_t i;
654 
655 	dev = libusb_get_device(pdev);
656 	if (dev == NULL)
657 		return (LIBUSB_ERROR_INVALID_PARAM);
658 
659 	if (configuration < 1) {
660 		/* unconfigure */
661 		i = 255;
662 	} else {
663 		for (i = 0; i != 255; i++) {
664 			uint8_t found;
665 
666 			pconf = libusb20_dev_alloc_config(pdev, i);
667 			if (pconf == NULL)
668 				return (LIBUSB_ERROR_INVALID_PARAM);
669 			found = (pconf->desc.bConfigurationValue
670 			    == configuration);
671 			free(pconf);
672 
673 			if (found)
674 				goto set_config;
675 		}
676 		return (LIBUSB_ERROR_INVALID_PARAM);
677 	}
678 
679 set_config:
680 
681 	libusb10_cancel_all_transfer(dev);
682 
683 	libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
684 
685 	err = libusb20_dev_set_config_index(pdev, i);
686 
687 	libusb10_add_pollfd(dev->ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
688 	    POLLOUT | POLLRDNORM | POLLWRNORM);
689 
690 	return (err ? LIBUSB_ERROR_INVALID_PARAM : 0);
691 }
692 
693 int
694 libusb_claim_interface(struct libusb20_device *pdev, int interface_number)
695 {
696 	libusb_device *dev;
697 	int err = 0;
698 
699 	dev = libusb_get_device(pdev);
700 	if (dev == NULL)
701 		return (LIBUSB_ERROR_INVALID_PARAM);
702 
703 	if (interface_number < 0 || interface_number > 31)
704 		return (LIBUSB_ERROR_INVALID_PARAM);
705 
706 	if (pdev->auto_detach != 0) {
707 		err = libusb_detach_kernel_driver(pdev, interface_number);
708 		if (err != 0)
709 			goto done;
710 	}
711 
712 	CTX_LOCK(dev->ctx);
713 	dev->claimed_interfaces |= (1 << interface_number);
714 	CTX_UNLOCK(dev->ctx);
715 done:
716 	return (err);
717 }
718 
719 int
720 libusb_release_interface(struct libusb20_device *pdev, int interface_number)
721 {
722 	libusb_device *dev;
723 	int err = 0;
724 
725 	dev = libusb_get_device(pdev);
726 	if (dev == NULL)
727 		return (LIBUSB_ERROR_INVALID_PARAM);
728 
729 	if (interface_number < 0 || interface_number > 31)
730 		return (LIBUSB_ERROR_INVALID_PARAM);
731 
732 	if (pdev->auto_detach != 0) {
733 		err = libusb_attach_kernel_driver(pdev, interface_number);
734 		if (err != 0)
735 			goto done;
736 	}
737 
738 	CTX_LOCK(dev->ctx);
739 	if (!(dev->claimed_interfaces & (1 << interface_number)))
740 		err = LIBUSB_ERROR_NOT_FOUND;
741 	else
742 		dev->claimed_interfaces &= ~(1 << interface_number);
743 	CTX_UNLOCK(dev->ctx);
744 done:
745 	return (err);
746 }
747 
748 int
749 libusb_set_interface_alt_setting(struct libusb20_device *pdev,
750     int interface_number, int alternate_setting)
751 {
752 	libusb_device *dev;
753 	int err = 0;
754 
755 	dev = libusb_get_device(pdev);
756 	if (dev == NULL)
757 		return (LIBUSB_ERROR_INVALID_PARAM);
758 
759 	if (interface_number < 0 || interface_number > 31)
760 		return (LIBUSB_ERROR_INVALID_PARAM);
761 
762 	CTX_LOCK(dev->ctx);
763 	if (!(dev->claimed_interfaces & (1 << interface_number)))
764 		err = LIBUSB_ERROR_NOT_FOUND;
765 	CTX_UNLOCK(dev->ctx);
766 
767 	if (err)
768 		return (err);
769 
770 	libusb10_cancel_all_transfer(dev);
771 
772 	libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
773 
774 	err = libusb20_dev_set_alt_index(pdev,
775 	    interface_number, alternate_setting);
776 
777 	libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
778 	    pdev, libusb20_dev_get_fd(pdev),
779 	    POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
780 
781 	return (err ? LIBUSB_ERROR_OTHER : 0);
782 }
783 
784 static struct libusb20_transfer *
785 libusb10_get_transfer(struct libusb20_device *pdev,
786     uint8_t endpoint, uint8_t xfer_index)
787 {
788 	xfer_index &= 1;	/* double buffering */
789 
790 	xfer_index |= (endpoint & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 4;
791 
792 	if (endpoint & LIBUSB20_ENDPOINT_DIR_MASK) {
793 		/* this is an IN endpoint */
794 		xfer_index |= 2;
795 	}
796 	return (libusb20_tr_get_pointer(pdev, xfer_index));
797 }
798 
799 int
800 libusb_clear_halt(struct libusb20_device *pdev, uint8_t endpoint)
801 {
802 	struct libusb20_transfer *xfer;
803 	struct libusb_device *dev;
804 	int err;
805 
806 	xfer = libusb10_get_transfer(pdev, endpoint, 0);
807 	if (xfer == NULL)
808 		return (LIBUSB_ERROR_INVALID_PARAM);
809 
810 	dev = libusb_get_device(pdev);
811 	if (dev == NULL)
812 		return (LIBUSB_ERROR_INVALID_PARAM);
813 
814 	CTX_LOCK(dev->ctx);
815 	err = libusb20_tr_open(xfer, 0, 1, endpoint);
816 	CTX_UNLOCK(dev->ctx);
817 
818 	if (err != 0 && err != LIBUSB20_ERROR_BUSY)
819 		return (LIBUSB_ERROR_OTHER);
820 
821 	libusb20_tr_clear_stall_sync(xfer);
822 
823 	/* check if we opened the transfer */
824 	if (err == 0) {
825 		CTX_LOCK(dev->ctx);
826 		libusb20_tr_close(xfer);
827 		CTX_UNLOCK(dev->ctx);
828 	}
829 	return (0);			/* success */
830 }
831 
832 int
833 libusb_reset_device(struct libusb20_device *pdev)
834 {
835 	libusb_device *dev;
836 	int err;
837 
838 	dev = libusb_get_device(pdev);
839 	if (dev == NULL)
840 		return (LIBUSB_ERROR_INVALID_PARAM);
841 
842 	libusb10_cancel_all_transfer(dev);
843 
844 	libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
845 
846 	err = libusb20_dev_reset(pdev);
847 
848 	libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
849 	    pdev, libusb20_dev_get_fd(pdev),
850 	    POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
851 
852 	return (err ? LIBUSB_ERROR_OTHER : 0);
853 }
854 
855 int
856 libusb_check_connected(struct libusb20_device *pdev)
857 {
858 	libusb_device *dev;
859 	int err;
860 
861 	dev = libusb_get_device(pdev);
862 	if (dev == NULL)
863 		return (LIBUSB_ERROR_INVALID_PARAM);
864 
865 	err = libusb20_dev_check_connected(pdev);
866 
867 	return (err ? LIBUSB_ERROR_NO_DEVICE : 0);
868 }
869 
870 int
871 libusb_kernel_driver_active(struct libusb20_device *pdev, int interface)
872 {
873 	if (pdev == NULL)
874 		return (LIBUSB_ERROR_INVALID_PARAM);
875 
876 	if (libusb20_dev_kernel_driver_active(pdev, interface))
877 		return (0);		/* no kernel driver is active */
878 	else
879 		return (1);		/* kernel driver is active */
880 }
881 
882 int
883 libusb_get_driver_np(struct libusb20_device *pdev, int interface,
884     char *name, int namelen)
885 {
886 	return (libusb_get_driver(pdev, interface, name, namelen));
887 }
888 
889 int
890 libusb_get_driver(struct libusb20_device *pdev, int interface,
891     char *name, int namelen)
892 {
893 	char *ptr;
894 	int err;
895 
896 	if (pdev == NULL)
897 		return (LIBUSB_ERROR_INVALID_PARAM);
898 	if (namelen < 1)
899 		return (LIBUSB_ERROR_INVALID_PARAM);
900 	if (namelen > 255)
901 		namelen = 255;
902 
903 	err = libusb20_dev_get_iface_desc(
904 	    pdev, interface, name, namelen);
905 
906 	if (err != 0)
907 		return (LIBUSB_ERROR_OTHER);
908 
909 	/* we only want the driver name */
910 	ptr = strstr(name, ":");
911 	if (ptr != NULL)
912 		*ptr = 0;
913 
914 	return (0);
915 }
916 
917 int
918 libusb_detach_kernel_driver_np(struct libusb20_device *pdev, int interface)
919 {
920 	return (libusb_detach_kernel_driver(pdev, interface));
921 }
922 
923 int
924 libusb_detach_kernel_driver(struct libusb20_device *pdev, int interface)
925 {
926 	int err;
927 
928 	if (pdev == NULL)
929 		return (LIBUSB_ERROR_INVALID_PARAM);
930 
931 	err = libusb20_dev_detach_kernel_driver(
932 	    pdev, interface);
933 
934 	return (err ? LIBUSB_ERROR_OTHER : 0);
935 }
936 
937 int
938 libusb_attach_kernel_driver(struct libusb20_device *pdev, int interface)
939 {
940 	if (pdev == NULL)
941 		return (LIBUSB_ERROR_INVALID_PARAM);
942 	/* stub - currently not supported by libusb20 */
943 	return (0);
944 }
945 
946 int
947 libusb_set_auto_detach_kernel_driver(libusb_device_handle *dev, int enable)
948 {
949 	dev->auto_detach = (enable ? 1 : 0);
950 	return (0);
951 }
952 
953 /* Asynchronous device I/O */
954 
955 struct libusb_transfer *
956 libusb_alloc_transfer(int iso_packets)
957 {
958 	struct libusb_transfer *uxfer;
959 	struct libusb_super_transfer *sxfer;
960 	int len;
961 
962 	len = sizeof(struct libusb_transfer) +
963 	    sizeof(struct libusb_super_transfer) +
964 	    (iso_packets * sizeof(libusb_iso_packet_descriptor));
965 
966 	sxfer = malloc(len);
967 	if (sxfer == NULL)
968 		return (NULL);
969 
970 	memset(sxfer, 0, len);
971 
972 	uxfer = (struct libusb_transfer *)(
973 	    ((uint8_t *)sxfer) + sizeof(*sxfer));
974 
975 	/* set default value */
976 	uxfer->num_iso_packets = iso_packets;
977 
978 	return (uxfer);
979 }
980 
981 void
982 libusb_free_transfer(struct libusb_transfer *uxfer)
983 {
984 	struct libusb_super_transfer *sxfer;
985 
986 	if (uxfer == NULL)
987 		return;			/* be NULL safe */
988 
989 	/* check if we should free the transfer buffer */
990 	if (uxfer->flags & LIBUSB_TRANSFER_FREE_BUFFER)
991 		free(uxfer->buffer);
992 
993 	sxfer = (struct libusb_super_transfer *)(
994 	    (uint8_t *)uxfer - sizeof(*sxfer));
995 
996 	free(sxfer);
997 }
998 
999 static uint32_t
1000 libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer)
1001 {
1002 	uint32_t ret;
1003 
1004 	switch (xfer->type) {
1005 	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1006 		ret = 60 | LIBUSB20_MAX_FRAME_PRE_SCALE;	/* 60ms */
1007 		break;
1008 	case LIBUSB_TRANSFER_TYPE_CONTROL:
1009 		ret = 2;
1010 		break;
1011 	default:
1012 		ret = 1;
1013 		break;
1014 	}
1015 	return (ret);
1016 }
1017 
1018 static int
1019 libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer)
1020 {
1021 	int ret;
1022 	int usb_speed;
1023 
1024 	usb_speed = libusb20_dev_get_speed(pdev);
1025 
1026 	switch (xfer->type) {
1027 	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1028 		ret = 0;		/* kernel will auto-select */
1029 		break;
1030 	case LIBUSB_TRANSFER_TYPE_CONTROL:
1031 		ret = 1024;
1032 		break;
1033 	default:
1034 		switch (usb_speed) {
1035 		case LIBUSB20_SPEED_LOW:
1036 			ret = 256;
1037 			break;
1038 		case LIBUSB20_SPEED_FULL:
1039 			ret = 4096;
1040 			break;
1041 		case LIBUSB20_SPEED_SUPER:
1042 			ret = 65536;
1043 			break;
1044 		default:
1045 			ret = 16384;
1046 			break;
1047 		}
1048 		break;
1049 	}
1050 	return (ret);
1051 }
1052 
1053 static int
1054 libusb10_convert_error(uint8_t status)
1055 {
1056 	;				/* indent fix */
1057 
1058 	switch (status) {
1059 	case LIBUSB20_TRANSFER_START:
1060 	case LIBUSB20_TRANSFER_COMPLETED:
1061 		return (LIBUSB_TRANSFER_COMPLETED);
1062 	case LIBUSB20_TRANSFER_OVERFLOW:
1063 		return (LIBUSB_TRANSFER_OVERFLOW);
1064 	case LIBUSB20_TRANSFER_NO_DEVICE:
1065 		return (LIBUSB_TRANSFER_NO_DEVICE);
1066 	case LIBUSB20_TRANSFER_STALL:
1067 		return (LIBUSB_TRANSFER_STALL);
1068 	case LIBUSB20_TRANSFER_CANCELLED:
1069 		return (LIBUSB_TRANSFER_CANCELLED);
1070 	case LIBUSB20_TRANSFER_TIMED_OUT:
1071 		return (LIBUSB_TRANSFER_TIMED_OUT);
1072 	default:
1073 		return (LIBUSB_TRANSFER_ERROR);
1074 	}
1075 }
1076 
1077 /* This function must be called locked */
1078 
1079 static void
1080 libusb10_complete_transfer(struct libusb20_transfer *pxfer,
1081     struct libusb_super_transfer *sxfer, int status)
1082 {
1083 	struct libusb_transfer *uxfer;
1084 	struct libusb_device *dev;
1085 
1086 	uxfer = (struct libusb_transfer *)(
1087 	    ((uint8_t *)sxfer) + sizeof(*sxfer));
1088 
1089 	if (pxfer != NULL)
1090 		libusb20_tr_set_priv_sc1(pxfer, NULL);
1091 
1092 	/* set transfer status */
1093 	uxfer->status = status;
1094 
1095 	/* update super transfer state */
1096 	sxfer->state = LIBUSB_SUPER_XFER_ST_NONE;
1097 
1098 	dev = libusb_get_device(uxfer->dev_handle);
1099 
1100 	TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry);
1101 }
1102 
1103 /* This function must be called locked */
1104 
1105 static void
1106 libusb10_isoc_proxy(struct libusb20_transfer *pxfer)
1107 {
1108 	struct libusb_super_transfer *sxfer;
1109 	struct libusb_transfer *uxfer;
1110 	uint32_t actlen;
1111 	uint16_t iso_packets;
1112 	uint16_t i;
1113 	uint8_t status;
1114 
1115 	status = libusb20_tr_get_status(pxfer);
1116 	sxfer = libusb20_tr_get_priv_sc1(pxfer);
1117 	actlen = libusb20_tr_get_actual_length(pxfer);
1118 	iso_packets = libusb20_tr_get_max_frames(pxfer);
1119 
1120 	if (sxfer == NULL)
1121 		return; /* cancelled - nothing to do */
1122 
1123 	uxfer = (struct libusb_transfer *)(
1124 	    ((uint8_t *)sxfer) + sizeof(*sxfer));
1125 
1126 	if (iso_packets > uxfer->num_iso_packets)
1127 		iso_packets = uxfer->num_iso_packets;
1128 
1129 	if (iso_packets == 0)
1130 		return; /* nothing to do */
1131 
1132 	/* make sure that the number of ISOCHRONOUS packets is valid */
1133 	uxfer->num_iso_packets = iso_packets;
1134 
1135 	switch (status) {
1136 	case LIBUSB20_TRANSFER_COMPLETED:
1137 		/* update actual length */
1138 		uxfer->actual_length = actlen;
1139 		for (i = 0; i != iso_packets; i++) {
1140 			uxfer->iso_packet_desc[i].actual_length =
1141 			    libusb20_tr_get_length(pxfer, i);
1142 		}
1143 		libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1144 		break;
1145 	case LIBUSB20_TRANSFER_START:
1146 		/* setup length(s) */
1147 		actlen = 0;
1148 		for (i = 0; i != iso_packets; i++) {
1149 			libusb20_tr_setup_isoc(pxfer,
1150 			    &uxfer->buffer[actlen],
1151 			    uxfer->iso_packet_desc[i].length, i);
1152 			actlen += uxfer->iso_packet_desc[i].length;
1153 		}
1154 
1155 		/* no remainder */
1156 		sxfer->rem_len = 0;
1157 
1158 		libusb20_tr_set_total_frames(pxfer, iso_packets);
1159 		libusb20_tr_submit(pxfer);
1160 
1161 		/* fork another USB transfer, if any */
1162 		libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1163 		break;
1164 	default:
1165 		libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1166 		break;
1167 	}
1168 }
1169 
1170 /* This function must be called locked */
1171 
1172 static void
1173 libusb10_bulk_intr_proxy(struct libusb20_transfer *pxfer)
1174 {
1175 	struct libusb_super_transfer *sxfer;
1176 	struct libusb_transfer *uxfer;
1177 	uint32_t max_bulk;
1178 	uint32_t actlen;
1179 	uint8_t status;
1180 	uint8_t flags;
1181 
1182 	status = libusb20_tr_get_status(pxfer);
1183 	sxfer = libusb20_tr_get_priv_sc1(pxfer);
1184 	max_bulk = libusb20_tr_get_max_total_length(pxfer);
1185 	actlen = libusb20_tr_get_actual_length(pxfer);
1186 
1187 	if (sxfer == NULL)
1188 		return;			/* cancelled - nothing to do */
1189 
1190 	uxfer = (struct libusb_transfer *)(
1191 	    ((uint8_t *)sxfer) + sizeof(*sxfer));
1192 
1193 	flags = uxfer->flags;
1194 
1195 	switch (status) {
1196 	case LIBUSB20_TRANSFER_COMPLETED:
1197 
1198 		uxfer->actual_length += actlen;
1199 
1200 		/* check for short packet */
1201 		if (sxfer->last_len != actlen) {
1202 			if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1203 				libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1204 			} else {
1205 				libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1206 			}
1207 			break;
1208 		}
1209 		/* check for end of data */
1210 		if (sxfer->rem_len == 0) {
1211 			libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1212 			break;
1213 		}
1214 		/* FALLTHROUGH */
1215 
1216 	case LIBUSB20_TRANSFER_START:
1217 		if (max_bulk > sxfer->rem_len) {
1218 			max_bulk = sxfer->rem_len;
1219 		}
1220 		/* setup new BULK or INTERRUPT transaction */
1221 		libusb20_tr_setup_bulk(pxfer,
1222 		    sxfer->curr_data, max_bulk, uxfer->timeout);
1223 
1224 		/* update counters */
1225 		sxfer->last_len = max_bulk;
1226 		sxfer->curr_data += max_bulk;
1227 		sxfer->rem_len -= max_bulk;
1228 
1229 		libusb20_tr_submit(pxfer);
1230 
1231 		/* check if we can fork another USB transfer */
1232 		if (sxfer->rem_len == 0)
1233 			libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1234 		break;
1235 
1236 	default:
1237 		libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1238 		break;
1239 	}
1240 }
1241 
1242 /* This function must be called locked */
1243 
1244 static void
1245 libusb10_ctrl_proxy(struct libusb20_transfer *pxfer)
1246 {
1247 	struct libusb_super_transfer *sxfer;
1248 	struct libusb_transfer *uxfer;
1249 	uint32_t max_bulk;
1250 	uint32_t actlen;
1251 	uint8_t status;
1252 	uint8_t flags;
1253 
1254 	status = libusb20_tr_get_status(pxfer);
1255 	sxfer = libusb20_tr_get_priv_sc1(pxfer);
1256 	max_bulk = libusb20_tr_get_max_total_length(pxfer);
1257 	actlen = libusb20_tr_get_actual_length(pxfer);
1258 
1259 	if (sxfer == NULL)
1260 		return;			/* cancelled - nothing to do */
1261 
1262 	uxfer = (struct libusb_transfer *)(
1263 	    ((uint8_t *)sxfer) + sizeof(*sxfer));
1264 
1265 	flags = uxfer->flags;
1266 
1267 	switch (status) {
1268 	case LIBUSB20_TRANSFER_COMPLETED:
1269 
1270 		uxfer->actual_length += actlen;
1271 
1272 		/* subtract length of SETUP packet, if any */
1273 		actlen -= libusb20_tr_get_length(pxfer, 0);
1274 
1275 		/* check for short packet */
1276 		if (sxfer->last_len != actlen) {
1277 			if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1278 				libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1279 			} else {
1280 				libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1281 			}
1282 			break;
1283 		}
1284 		/* check for end of data */
1285 		if (sxfer->rem_len == 0) {
1286 			libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1287 			break;
1288 		}
1289 		/* FALLTHROUGH */
1290 
1291 	case LIBUSB20_TRANSFER_START:
1292 		if (max_bulk > sxfer->rem_len) {
1293 			max_bulk = sxfer->rem_len;
1294 		}
1295 		/* setup new CONTROL transaction */
1296 		if (status == LIBUSB20_TRANSFER_COMPLETED) {
1297 			/* next fragment - don't send SETUP packet */
1298 			libusb20_tr_set_length(pxfer, 0, 0);
1299 		} else {
1300 			/* first fragment - send SETUP packet */
1301 			libusb20_tr_set_length(pxfer, 8, 0);
1302 			libusb20_tr_set_buffer(pxfer, uxfer->buffer, 0);
1303 		}
1304 
1305 		if (max_bulk != 0) {
1306 			libusb20_tr_set_length(pxfer, max_bulk, 1);
1307 			libusb20_tr_set_buffer(pxfer, sxfer->curr_data, 1);
1308 			libusb20_tr_set_total_frames(pxfer, 2);
1309 		} else {
1310 			libusb20_tr_set_total_frames(pxfer, 1);
1311 		}
1312 
1313 		/* update counters */
1314 		sxfer->last_len = max_bulk;
1315 		sxfer->curr_data += max_bulk;
1316 		sxfer->rem_len -= max_bulk;
1317 
1318 		libusb20_tr_submit(pxfer);
1319 
1320 		/* check if we can fork another USB transfer */
1321 		if (sxfer->rem_len == 0)
1322 			libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1323 		break;
1324 
1325 	default:
1326 		libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1327 		break;
1328 	}
1329 }
1330 
1331 /* The following function must be called locked */
1332 
1333 static void
1334 libusb10_submit_transfer_sub(struct libusb20_device *pdev, uint8_t endpoint)
1335 {
1336 	struct libusb20_transfer *pxfer0;
1337 	struct libusb20_transfer *pxfer1;
1338 	struct libusb_super_transfer *sxfer;
1339 	struct libusb_transfer *uxfer;
1340 	struct libusb_device *dev;
1341 	int err;
1342 	int buffsize;
1343 	int maxframe;
1344 	int temp;
1345 
1346 	dev = libusb_get_device(pdev);
1347 
1348 	pxfer0 = libusb10_get_transfer(pdev, endpoint, 0);
1349 	pxfer1 = libusb10_get_transfer(pdev, endpoint, 1);
1350 
1351 	if (pxfer0 == NULL || pxfer1 == NULL)
1352 		return;			/* shouldn't happen */
1353 
1354 	temp = 0;
1355 	if (libusb20_tr_pending(pxfer0))
1356 		temp |= 1;
1357 	if (libusb20_tr_pending(pxfer1))
1358 		temp |= 2;
1359 
1360 	switch (temp) {
1361 	case 3:
1362 		/* wait till one of the transfers complete */
1363 		return;
1364 	case 2:
1365 		sxfer = libusb20_tr_get_priv_sc1(pxfer1);
1366 		if (sxfer == NULL)
1367 			return;		/* cancelling */
1368 		if (sxfer->rem_len)
1369 			return;		/* cannot queue another one */
1370 		/* swap transfers */
1371 		pxfer1 = pxfer0;
1372 		break;
1373 	case 1:
1374 		sxfer = libusb20_tr_get_priv_sc1(pxfer0);
1375 		if (sxfer == NULL)
1376 			return;		/* cancelling */
1377 		if (sxfer->rem_len)
1378 			return;		/* cannot queue another one */
1379 		/* swap transfers */
1380 		pxfer0 = pxfer1;
1381 		break;
1382 	default:
1383 		break;
1384 	}
1385 
1386 	/* find next transfer on same endpoint */
1387 	TAILQ_FOREACH(sxfer, &dev->tr_head, entry) {
1388 
1389 		uxfer = (struct libusb_transfer *)(
1390 		    ((uint8_t *)sxfer) + sizeof(*sxfer));
1391 
1392 		if (uxfer->endpoint == endpoint) {
1393 			TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1394 			sxfer->entry.tqe_prev = NULL;
1395 			goto found;
1396 		}
1397 	}
1398 	return;				/* success */
1399 
1400 found:
1401 
1402 	libusb20_tr_set_priv_sc0(pxfer0, pdev);
1403 	libusb20_tr_set_priv_sc1(pxfer0, sxfer);
1404 
1405 	/* reset super transfer state */
1406 	sxfer->rem_len = uxfer->length;
1407 	sxfer->curr_data = uxfer->buffer;
1408 	uxfer->actual_length = 0;
1409 
1410 	switch (uxfer->type) {
1411 	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1412 		libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy);
1413 		break;
1414 	case LIBUSB_TRANSFER_TYPE_BULK:
1415 	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1416 		libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy);
1417 		break;
1418 	case LIBUSB_TRANSFER_TYPE_CONTROL:
1419 		libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy);
1420 		if (sxfer->rem_len < 8)
1421 			goto failure;
1422 
1423 		/* remove SETUP packet from data */
1424 		sxfer->rem_len -= 8;
1425 		sxfer->curr_data += 8;
1426 		break;
1427 	default:
1428 		goto failure;
1429 	}
1430 
1431 	buffsize = libusb10_get_buffsize(pdev, uxfer);
1432 	maxframe = libusb10_get_maxframe(pdev, uxfer);
1433 
1434 	/* make sure the transfer is opened */
1435 	err = libusb20_tr_open_stream(pxfer0, buffsize, maxframe,
1436 	    endpoint, sxfer->stream_id);
1437 	if (err && (err != LIBUSB20_ERROR_BUSY)) {
1438 		goto failure;
1439 	}
1440 	libusb20_tr_start(pxfer0);
1441 	return;
1442 
1443 failure:
1444 	libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR);
1445 	/* make sure our event loop spins the done handler */
1446 	libusb10_wakeup_event_loop(dev->ctx);
1447 }
1448 
1449 /* The following function must be called unlocked */
1450 
1451 int
1452 libusb_submit_transfer(struct libusb_transfer *uxfer)
1453 {
1454 	struct libusb20_transfer *pxfer0;
1455 	struct libusb20_transfer *pxfer1;
1456 	struct libusb_super_transfer *sxfer;
1457 	struct libusb_device *dev;
1458 	uint8_t endpoint;
1459 	int err;
1460 
1461 	if (uxfer == NULL)
1462 		return (LIBUSB_ERROR_INVALID_PARAM);
1463 
1464 	if (uxfer->dev_handle == NULL)
1465 		return (LIBUSB_ERROR_INVALID_PARAM);
1466 
1467 	endpoint = uxfer->endpoint;
1468 
1469 	dev = libusb_get_device(uxfer->dev_handle);
1470 
1471 	DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter");
1472 
1473 	sxfer = (struct libusb_super_transfer *)(
1474 	    (uint8_t *)uxfer - sizeof(*sxfer));
1475 
1476 	CTX_LOCK(dev->ctx);
1477 
1478 	pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1479 	pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1480 
1481 	if (pxfer0 == NULL || pxfer1 == NULL) {
1482 		err = LIBUSB_ERROR_OTHER;
1483 	} else if ((sxfer->entry.tqe_prev != NULL) ||
1484 	    (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) ||
1485 	    (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) {
1486 		err = LIBUSB_ERROR_BUSY;
1487 	} else if (dev->device_is_gone != 0) {
1488 		err = LIBUSB_ERROR_NO_DEVICE;
1489 	} else {
1490 
1491 		/* set pending state */
1492 		sxfer->state = LIBUSB_SUPER_XFER_ST_PEND;
1493 
1494 		/* insert transfer into transfer head list */
1495 		TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry);
1496 
1497 		/* start work transfers */
1498 		libusb10_submit_transfer_sub(
1499 		    uxfer->dev_handle, endpoint);
1500 
1501 		err = 0;		/* success */
1502 	}
1503 
1504 	CTX_UNLOCK(dev->ctx);
1505 
1506 	DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err);
1507 
1508 	return (err);
1509 }
1510 
1511 /* Asynchronous transfer cancel */
1512 
1513 int
1514 libusb_cancel_transfer(struct libusb_transfer *uxfer)
1515 {
1516 	struct libusb20_transfer *pxfer0;
1517 	struct libusb20_transfer *pxfer1;
1518 	struct libusb_super_transfer *sxfer;
1519 	struct libusb_device *dev;
1520 	struct libusb_device_handle *devh;
1521 	uint8_t endpoint;
1522 	int retval;
1523 
1524 	if (uxfer == NULL)
1525 		return (LIBUSB_ERROR_INVALID_PARAM);
1526 
1527 	/* check if not initialised */
1528 	if ((devh = uxfer->dev_handle) == NULL)
1529 		return (LIBUSB_ERROR_NOT_FOUND);
1530 
1531 	endpoint = uxfer->endpoint;
1532 
1533 	dev = libusb_get_device(devh);
1534 
1535 	DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter");
1536 
1537 	sxfer = (struct libusb_super_transfer *)(
1538 	    (uint8_t *)uxfer - sizeof(*sxfer));
1539 
1540 	retval = 0;
1541 
1542 	CTX_LOCK(dev->ctx);
1543 
1544 	pxfer0 = libusb10_get_transfer(devh, endpoint, 0);
1545 	pxfer1 = libusb10_get_transfer(devh, endpoint, 1);
1546 
1547 	if (sxfer->state != LIBUSB_SUPER_XFER_ST_PEND) {
1548 		/* only update the transfer status */
1549 		uxfer->status = LIBUSB_TRANSFER_CANCELLED;
1550 		retval = LIBUSB_ERROR_NOT_FOUND;
1551 	} else if (sxfer->entry.tqe_prev != NULL) {
1552 		/* we are lucky - transfer is on a queue */
1553 		TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1554 		sxfer->entry.tqe_prev = NULL;
1555 		libusb10_complete_transfer(NULL,
1556 		    sxfer, LIBUSB_TRANSFER_CANCELLED);
1557 		/* make sure our event loop spins the done handler */
1558 		libusb10_wakeup_event_loop(dev->ctx);
1559 	} else if (pxfer0 == NULL || pxfer1 == NULL) {
1560 		/* not started */
1561 		retval = LIBUSB_ERROR_NOT_FOUND;
1562 	} else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) {
1563 		libusb10_complete_transfer(pxfer0,
1564 		    sxfer, LIBUSB_TRANSFER_CANCELLED);
1565 		if (dev->device_is_gone != 0) {
1566 			/* clear transfer pointer */
1567 			libusb20_tr_set_priv_sc1(pxfer0, NULL);
1568 			/* make sure our event loop spins the done handler */
1569 			libusb10_wakeup_event_loop(dev->ctx);
1570 		} else {
1571 			libusb20_tr_stop(pxfer0);
1572 			/* make sure the queue doesn't stall */
1573 			libusb10_submit_transfer_sub(devh, endpoint);
1574 		}
1575 	} else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) {
1576 		libusb10_complete_transfer(pxfer1,
1577 		    sxfer, LIBUSB_TRANSFER_CANCELLED);
1578 		/* check if handle is still active */
1579 		if (dev->device_is_gone != 0) {
1580 			/* clear transfer pointer */
1581 			libusb20_tr_set_priv_sc1(pxfer1, NULL);
1582 			/* make sure our event loop spins the done handler */
1583 			libusb10_wakeup_event_loop(dev->ctx);
1584 		} else {
1585 			libusb20_tr_stop(pxfer1);
1586 			/* make sure the queue doesn't stall */
1587 			libusb10_submit_transfer_sub(devh, endpoint);
1588 		}
1589 	} else {
1590 		/* not started */
1591 		retval = LIBUSB_ERROR_NOT_FOUND;
1592 	}
1593 
1594 	CTX_UNLOCK(dev->ctx);
1595 
1596 	DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave");
1597 
1598 	return (retval);
1599 }
1600 
1601 UNEXPORTED void
1602 libusb10_cancel_all_transfer(libusb_device *dev)
1603 {
1604 	struct libusb20_device *pdev = dev->os_priv;
1605 	unsigned x;
1606 
1607 	for (x = 0; x != LIBUSB_NUM_SW_ENDPOINTS; x++) {
1608 		struct libusb20_transfer *xfer;
1609 
1610 		xfer = libusb20_tr_get_pointer(pdev, x);
1611 		if (xfer == NULL)
1612 			continue;
1613 		libusb20_tr_close(xfer);
1614 	}
1615 }
1616 
1617 UNEXPORTED void
1618 libusb10_cancel_all_transfer_locked(struct libusb20_device *pdev, struct libusb_device *dev)
1619 {
1620 	struct libusb_super_transfer *sxfer;
1621 	unsigned x;
1622 
1623 	for (x = 0; x != LIBUSB_NUM_SW_ENDPOINTS; x++) {
1624 		struct libusb20_transfer *xfer;
1625 
1626 		xfer = libusb20_tr_get_pointer(pdev, x);
1627 		if (xfer == NULL)
1628 			continue;
1629 		if (libusb20_tr_pending(xfer) == 0)
1630 			continue;
1631 		sxfer = libusb20_tr_get_priv_sc1(xfer);
1632 		if (sxfer == NULL)
1633 			continue;
1634 		/* complete pending transfer */
1635 		libusb10_complete_transfer(xfer, sxfer, LIBUSB_TRANSFER_ERROR);
1636 	}
1637 
1638 	while ((sxfer = TAILQ_FIRST(&dev->tr_head))) {
1639 		TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1640 
1641 		/* complete pending transfer */
1642 		libusb10_complete_transfer(NULL, sxfer, LIBUSB_TRANSFER_ERROR);
1643 	}
1644 }
1645 
1646 uint16_t
1647 libusb_cpu_to_le16(uint16_t x)
1648 {
1649 	return (htole16(x));
1650 }
1651 
1652 uint16_t
1653 libusb_le16_to_cpu(uint16_t x)
1654 {
1655 	return (le16toh(x));
1656 }
1657 
1658 const char *
1659 libusb_strerror(int code)
1660 {
1661 	switch (code) {
1662 	case LIBUSB_SUCCESS:
1663 		return ("Success");
1664 	case LIBUSB_ERROR_IO:
1665 		return ("I/O error");
1666 	case LIBUSB_ERROR_INVALID_PARAM:
1667 		return ("Invalid parameter");
1668 	case LIBUSB_ERROR_ACCESS:
1669 		return ("Permissions error");
1670 	case LIBUSB_ERROR_NO_DEVICE:
1671 		return ("No device");
1672 	case LIBUSB_ERROR_NOT_FOUND:
1673 		return ("Not found");
1674 	case LIBUSB_ERROR_BUSY:
1675 		return ("Device busy");
1676 	case LIBUSB_ERROR_TIMEOUT:
1677 		return ("Timeout");
1678 	case LIBUSB_ERROR_OVERFLOW:
1679 		return ("Overflow");
1680 	case LIBUSB_ERROR_PIPE:
1681 		return ("Pipe error");
1682 	case LIBUSB_ERROR_INTERRUPTED:
1683 		return ("Interrupted");
1684 	case LIBUSB_ERROR_NO_MEM:
1685 		return ("Out of memory");
1686 	case LIBUSB_ERROR_NOT_SUPPORTED:
1687 		return ("Not supported");
1688 	case LIBUSB_ERROR_OTHER:
1689 		return ("Other error");
1690 	default:
1691 		return ("Unknown error");
1692 	}
1693 }
1694 
1695 const char *
1696 libusb_error_name(int code)
1697 {
1698 	switch (code) {
1699 	case LIBUSB_SUCCESS:
1700 		return ("LIBUSB_SUCCESS");
1701 	case LIBUSB_ERROR_IO:
1702 		return ("LIBUSB_ERROR_IO");
1703 	case LIBUSB_ERROR_INVALID_PARAM:
1704 		return ("LIBUSB_ERROR_INVALID_PARAM");
1705 	case LIBUSB_ERROR_ACCESS:
1706 		return ("LIBUSB_ERROR_ACCESS");
1707 	case LIBUSB_ERROR_NO_DEVICE:
1708 		return ("LIBUSB_ERROR_NO_DEVICE");
1709 	case LIBUSB_ERROR_NOT_FOUND:
1710 		return ("LIBUSB_ERROR_NOT_FOUND");
1711 	case LIBUSB_ERROR_BUSY:
1712 		return ("LIBUSB_ERROR_BUSY");
1713 	case LIBUSB_ERROR_TIMEOUT:
1714 		return ("LIBUSB_ERROR_TIMEOUT");
1715 	case LIBUSB_ERROR_OVERFLOW:
1716 		return ("LIBUSB_ERROR_OVERFLOW");
1717 	case LIBUSB_ERROR_PIPE:
1718 		return ("LIBUSB_ERROR_PIPE");
1719 	case LIBUSB_ERROR_INTERRUPTED:
1720 		return ("LIBUSB_ERROR_INTERRUPTED");
1721 	case LIBUSB_ERROR_NO_MEM:
1722 		return ("LIBUSB_ERROR_NO_MEM");
1723 	case LIBUSB_ERROR_NOT_SUPPORTED:
1724 		return ("LIBUSB_ERROR_NOT_SUPPORTED");
1725 	case LIBUSB_ERROR_OTHER:
1726 		return ("LIBUSB_ERROR_OTHER");
1727 	default:
1728 		return ("LIBUSB_ERROR_UNKNOWN");
1729 	}
1730 }
1731 
1732 int
1733 libusb_has_capability(uint32_t capability)
1734 {
1735 
1736 	switch (capability) {
1737 	case LIBUSB_CAP_HAS_CAPABILITY:
1738 	case LIBUSB_CAP_HAS_HOTPLUG:
1739 	case LIBUSB_CAP_HAS_HID_ACCESS:
1740 	case LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER:
1741 		return (1);
1742 	default:
1743 		return (0);
1744 	}
1745 }
1746