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