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