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