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