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