1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2008 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/*
29 * This file contains the emulation layer for LibUSB v0.1 from sourceforge.
30 */
31
32#ifdef LIBUSB_GLOBAL_INCLUDE_FILE
33#include LIBUSB_GLOBAL_INCLUDE_FILE
34#else
35#include <errno.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39#include <time.h>
40#include <sys/queue.h>
41#endif
42
43#include "libusb20.h"
44#include "libusb20_desc.h"
45#include "libusb20_int.h"
46#include "usb.h"
47
48/*
49 * The two following macros were taken from the original LibUSB v0.1
50 * for sake of compatibility:
51 */
52#define	LIST_ADD(begin, ent)	   \
53  do {				   \
54    if (begin) {		   \
55      ent->next = begin;	   \
56      ent->next->prev = ent;	   \
57    } else {			   \
58      ent->next = NULL;		   \
59    }				   \
60    ent->prev = NULL;		   \
61    begin = ent;		   \
62  } while(0)
63
64#define	LIST_DEL(begin, ent)		 \
65  do {					 \
66    if (ent->prev) {			 \
67      ent->prev->next = ent->next;	 \
68    } else {				 \
69      begin = ent->next;		 \
70    }					 \
71    if (ent->next) {			 \
72      ent->next->prev = ent->prev;	 \
73    }					 \
74    ent->prev = NULL;			 \
75    ent->next = NULL;			 \
76  } while (0)
77
78struct usb_bus *usb_busses = NULL;
79
80static struct usb_bus usb_global_bus = {
81	.dirname = {"/dev/usb"},
82	.root_dev = NULL,
83	.devices = NULL,
84};
85
86static struct libusb20_backend *usb_backend = NULL;
87
88struct usb_parse_state {
89
90	struct {
91		struct libusb20_endpoint *currep;
92		struct libusb20_interface *currifc;
93		struct libusb20_config *currcfg;
94		struct libusb20_me_struct *currextra;
95	}	a;
96
97	struct {
98		struct usb_config_descriptor *currcfg;
99		struct usb_interface_descriptor *currifc;
100		struct usb_endpoint_descriptor *currep;
101		struct usb_interface *currifcw;
102		uint8_t *currextra;
103	}	b;
104
105	uint8_t	preparse;
106};
107
108static struct libusb20_transfer *
109usb_get_transfer_by_ep_no(usb_dev_handle * dev, uint8_t ep_no)
110{
111	struct libusb20_device *pdev = (void *)dev;
112	struct libusb20_transfer *xfer;
113	int err;
114	uint32_t bufsize;
115	uint8_t x;
116	uint8_t speed;
117
118	x = (ep_no & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 2;
119
120	if (ep_no & LIBUSB20_ENDPOINT_DIR_MASK) {
121		/* this is an IN endpoint */
122		x |= 1;
123	}
124	speed = libusb20_dev_get_speed(pdev);
125
126	/* select a sensible buffer size */
127	if (speed == LIBUSB20_SPEED_LOW) {
128		bufsize = 256;
129	} else if (speed == LIBUSB20_SPEED_FULL) {
130		bufsize = 4096;
131	} else if (speed == LIBUSB20_SPEED_SUPER) {
132		bufsize = 65536;
133	} else {
134		bufsize = 16384;
135	}
136
137	xfer = libusb20_tr_get_pointer(pdev, x);
138
139	if (xfer == NULL)
140		return (xfer);
141
142	err = libusb20_tr_open(xfer, bufsize, 1, ep_no);
143	if (err == LIBUSB20_ERROR_BUSY) {
144		/* already opened */
145		return (xfer);
146	} else if (err) {
147		return (NULL);
148	}
149	/* success */
150	return (xfer);
151}
152
153usb_dev_handle *
154usb_open(struct usb_device *dev)
155{
156	int err;
157
158	err = libusb20_dev_open(dev->dev, 16 * 2);
159	if (err == LIBUSB20_ERROR_BUSY) {
160		/*
161		 * Workaround buggy USB applications which open the USB
162		 * device multiple times:
163		 */
164		return (dev->dev);
165	}
166	if (err)
167		return (NULL);
168
169	/*
170	 * Dequeue USB device from backend queue so that it does not get
171	 * freed when the backend is re-scanned:
172	 */
173	libusb20_be_dequeue_device(usb_backend, dev->dev);
174
175	return (dev->dev);
176}
177
178int
179usb_close(usb_dev_handle * udev)
180{
181	struct usb_device *dev;
182	int err;
183
184	err = libusb20_dev_close((void *)udev);
185
186	if (err)
187		return (-1);
188
189	if (usb_backend != NULL) {
190		/*
191		 * Enqueue USB device to backend queue so that it gets freed
192		 * when the backend is re-scanned:
193		 */
194		libusb20_be_enqueue_device(usb_backend, (void *)udev);
195	} else {
196		/*
197		 * The backend is gone. Free device data so that we
198		 * don't start leaking memory!
199		 */
200		dev = usb_device(udev);
201		libusb20_dev_free((void *)udev);
202		LIST_DEL(usb_global_bus.devices, dev);
203		free(dev);
204	}
205	return (0);
206}
207
208int
209usb_get_string(usb_dev_handle * dev, int strindex,
210    int langid, char *buf, size_t buflen)
211{
212	int err;
213
214	if (dev == NULL)
215		return (-1);
216
217	if (buflen > 65535)
218		buflen = 65535;
219
220	err = libusb20_dev_req_string_sync((void *)dev,
221	    strindex, langid, buf, buflen);
222
223	if (err)
224		return (-1);
225
226	return (0);
227}
228
229int
230usb_get_string_simple(usb_dev_handle * dev, int strindex,
231    char *buf, size_t buflen)
232{
233	int err;
234
235	if (dev == NULL)
236		return (-1);
237
238	if (buflen > 65535)
239		buflen = 65535;
240
241	err = libusb20_dev_req_string_simple_sync((void *)dev,
242	    strindex, buf, buflen);
243
244	if (err)
245		return (-1);
246
247	return (strlen(buf));
248}
249
250int
251usb_get_descriptor_by_endpoint(usb_dev_handle * udev, int ep, uint8_t type,
252    uint8_t ep_index, void *buf, int size)
253{
254	memset(buf, 0, size);
255
256	if (udev == NULL)
257		return (-1);
258
259	if (size > 65535)
260		size = 65535;
261
262	return (usb_control_msg(udev, ep | USB_ENDPOINT_IN,
263	    USB_REQ_GET_DESCRIPTOR, (type << 8) + ep_index, 0,
264	    buf, size, 1000));
265}
266
267int
268usb_get_descriptor(usb_dev_handle * udev, uint8_t type, uint8_t desc_index,
269    void *buf, int size)
270{
271	memset(buf, 0, size);
272
273	if (udev == NULL)
274		return (-1);
275
276	if (size > 65535)
277		size = 65535;
278
279	return (usb_control_msg(udev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
280	    (type << 8) + desc_index, 0, buf, size, 1000));
281}
282
283int
284usb_parse_descriptor(uint8_t *source, char *description, void *dest)
285{
286	uint8_t *sp = source;
287	uint8_t *dp = dest;
288	uint16_t w;
289	uint32_t d;
290	char *cp;
291
292	for (cp = description; *cp; cp++) {
293		switch (*cp) {
294		case 'b':		/* 8-bit byte */
295			*dp++ = *sp++;
296			break;
297			/*
298			 * 16-bit word, convert from little endian to CPU
299			 */
300		case 'w':
301			w = (sp[1] << 8) | sp[0];
302			sp += 2;
303			/* Align to word boundary */
304			dp += ((dp - (uint8_t *)0) & 1);
305			*((uint16_t *)dp) = w;
306			dp += 2;
307			break;
308			/*
309			 * 32-bit dword, convert from little endian to CPU
310			 */
311		case 'd':
312			d = (sp[3] << 24) | (sp[2] << 16) |
313			    (sp[1] << 8) | sp[0];
314			sp += 4;
315			/* Align to word boundary */
316			dp += ((dp - (uint8_t *)0) & 1);
317			/* Align to double word boundary */
318			dp += ((dp - (uint8_t *)0) & 2);
319			*((uint32_t *)dp) = d;
320			dp += 4;
321			break;
322		}
323	}
324	return (sp - source);
325}
326
327static void
328usb_parse_extra(struct usb_parse_state *ps, uint8_t **pptr, int *plen)
329{
330	void *ptr;
331	uint16_t len;
332
333	ptr = ps->a.currextra->ptr;
334	len = ps->a.currextra->len;
335
336	if (ps->preparse == 0) {
337		memcpy(ps->b.currextra, ptr, len);
338		*pptr = ps->b.currextra;
339		*plen = len;
340	}
341	ps->b.currextra += len;
342	return;
343}
344
345static void
346usb_parse_endpoint(struct usb_parse_state *ps)
347{
348	struct usb_endpoint_descriptor *bep;
349	struct libusb20_endpoint *aep;
350
351	aep = ps->a.currep;
352	bep = ps->b.currep++;
353
354	if (ps->preparse == 0) {
355		/* copy descriptor fields */
356		bep->bLength = aep->desc.bLength;
357		bep->bDescriptorType = aep->desc.bDescriptorType;
358		bep->bEndpointAddress = aep->desc.bEndpointAddress;
359		bep->bmAttributes = aep->desc.bmAttributes;
360		bep->wMaxPacketSize = aep->desc.wMaxPacketSize;
361		bep->bInterval = aep->desc.bInterval;
362		bep->bRefresh = aep->desc.bRefresh;
363		bep->bSynchAddress = aep->desc.bSynchAddress;
364	}
365	ps->a.currextra = &aep->extra;
366	usb_parse_extra(ps, &bep->extra, &bep->extralen);
367	return;
368}
369
370static void
371usb_parse_iface_sub(struct usb_parse_state *ps)
372{
373	struct libusb20_interface *aifc;
374	struct usb_interface_descriptor *bifc;
375	uint8_t x;
376
377	aifc = ps->a.currifc;
378	bifc = ps->b.currifc++;
379
380	if (ps->preparse == 0) {
381		/* copy descriptor fields */
382		bifc->bLength = aifc->desc.bLength;
383		bifc->bDescriptorType = aifc->desc.bDescriptorType;
384		bifc->bInterfaceNumber = aifc->desc.bInterfaceNumber;
385		bifc->bAlternateSetting = aifc->desc.bAlternateSetting;
386		bifc->bNumEndpoints = aifc->num_endpoints;
387		bifc->bInterfaceClass = aifc->desc.bInterfaceClass;
388		bifc->bInterfaceSubClass = aifc->desc.bInterfaceSubClass;
389		bifc->bInterfaceProtocol = aifc->desc.bInterfaceProtocol;
390		bifc->iInterface = aifc->desc.iInterface;
391		bifc->endpoint = ps->b.currep;
392	}
393	for (x = 0; x != aifc->num_endpoints; x++) {
394		ps->a.currep = aifc->endpoints + x;
395		usb_parse_endpoint(ps);
396	}
397
398	ps->a.currextra = &aifc->extra;
399	usb_parse_extra(ps, &bifc->extra, &bifc->extralen);
400	return;
401}
402
403static void
404usb_parse_iface(struct usb_parse_state *ps)
405{
406	struct libusb20_interface *aifc;
407	struct usb_interface *bifc;
408	uint8_t x;
409
410	aifc = ps->a.currifc;
411	bifc = ps->b.currifcw++;
412
413	if (ps->preparse == 0) {
414		/* initialise interface wrapper */
415		bifc->altsetting = ps->b.currifc;
416		bifc->num_altsetting = aifc->num_altsetting + 1;
417	}
418	usb_parse_iface_sub(ps);
419
420	for (x = 0; x != aifc->num_altsetting; x++) {
421		ps->a.currifc = aifc->altsetting + x;
422		usb_parse_iface_sub(ps);
423	}
424	return;
425}
426
427static void
428usb_parse_config(struct usb_parse_state *ps)
429{
430	struct libusb20_config *acfg;
431	struct usb_config_descriptor *bcfg;
432	uint8_t x;
433
434	acfg = ps->a.currcfg;
435	bcfg = ps->b.currcfg;
436
437	if (ps->preparse == 0) {
438		/* initialise config wrapper */
439		bcfg->bLength = acfg->desc.bLength;
440		bcfg->bDescriptorType = acfg->desc.bDescriptorType;
441		bcfg->wTotalLength = acfg->desc.wTotalLength;
442		bcfg->bNumInterfaces = acfg->num_interface;
443		bcfg->bConfigurationValue = acfg->desc.bConfigurationValue;
444		bcfg->iConfiguration = acfg->desc.iConfiguration;
445		bcfg->bmAttributes = acfg->desc.bmAttributes;
446		bcfg->MaxPower = acfg->desc.bMaxPower;
447		bcfg->interface = ps->b.currifcw;
448	}
449	for (x = 0; x != acfg->num_interface; x++) {
450		ps->a.currifc = acfg->interface + x;
451		usb_parse_iface(ps);
452	}
453
454	ps->a.currextra = &acfg->extra;
455	usb_parse_extra(ps, &bcfg->extra, &bcfg->extralen);
456	return;
457}
458
459int
460usb_parse_configuration(struct usb_config_descriptor *config,
461    uint8_t *buffer)
462{
463	struct usb_parse_state ps;
464	uint8_t *ptr;
465	uint32_t a;
466	uint32_t b;
467	uint32_t c;
468	uint32_t d;
469
470	if ((buffer == NULL) || (config == NULL)) {
471		return (-1);
472	}
473	memset(&ps, 0, sizeof(ps));
474
475	ps.a.currcfg = libusb20_parse_config_desc(buffer);
476	ps.b.currcfg = config;
477	if (ps.a.currcfg == NULL) {
478		/* could not parse config or out of memory */
479		return (-1);
480	}
481	/* do the pre-parse */
482	ps.preparse = 1;
483	usb_parse_config(&ps);
484
485	a = ((uint8_t *)(ps.b.currifcw) - ((uint8_t *)0));
486	b = ((uint8_t *)(ps.b.currifc) - ((uint8_t *)0));
487	c = ((uint8_t *)(ps.b.currep) - ((uint8_t *)0));
488	d = ((uint8_t *)(ps.b.currextra) - ((uint8_t *)0));
489
490	/* allocate memory for our configuration */
491	ptr = malloc(a + b + c + d);
492	if (ptr == NULL) {
493		/* free config structure */
494		free(ps.a.currcfg);
495		return (-1);
496	}
497
498	/* "currifcw" must be first, hence this pointer is freed */
499	ps.b.currifcw = (void *)(ptr);
500	ps.b.currifc = (void *)(ptr + a);
501	ps.b.currep = (void *)(ptr + a + b);
502	ps.b.currextra = (void *)(ptr + a + b + c);
503
504	/* generate a libusb v0.1 compatible structure */
505	ps.preparse = 0;
506	usb_parse_config(&ps);
507
508	/* free config structure */
509	free(ps.a.currcfg);
510
511	return (0);			/* success */
512}
513
514void
515usb_destroy_configuration(struct usb_device *dev)
516{
517	uint8_t c;
518
519	if (dev->config == NULL) {
520		return;
521	}
522	for (c = 0; c != dev->descriptor.bNumConfigurations; c++) {
523		struct usb_config_descriptor *cf = &dev->config[c];
524
525		if (cf->interface != NULL) {
526			free(cf->interface);
527			cf->interface = NULL;
528		}
529	}
530
531	free(dev->config);
532	dev->config = NULL;
533	return;
534}
535
536void
537usb_fetch_and_parse_descriptors(usb_dev_handle * udev)
538{
539	struct usb_device *dev;
540	struct libusb20_device *pdev;
541	uint8_t *ptr;
542	int error;
543	uint32_t size;
544	uint16_t len;
545	uint8_t x;
546
547	if (udev == NULL) {
548		/* be NULL safe */
549		return;
550	}
551	dev = usb_device(udev);
552	pdev = (void *)udev;
553
554	if (dev->descriptor.bNumConfigurations == 0) {
555		/* invalid device */
556		return;
557	}
558	size = dev->descriptor.bNumConfigurations *
559	    sizeof(struct usb_config_descriptor);
560
561	dev->config = malloc(size);
562	if (dev->config == NULL) {
563		/* out of memory */
564		return;
565	}
566	memset(dev->config, 0, size);
567
568	for (x = 0; x != dev->descriptor.bNumConfigurations; x++) {
569
570		error = (pdev->methods->get_config_desc_full) (
571		    pdev, &ptr, &len, x);
572
573		if (error) {
574			usb_destroy_configuration(dev);
575			return;
576		}
577		usb_parse_configuration(dev->config + x, ptr);
578
579		/* free config buffer */
580		free(ptr);
581	}
582	return;
583}
584
585static int
586usb_std_io(usb_dev_handle * dev, int ep, char *bytes, int size,
587    int timeout, int is_intr)
588{
589	struct libusb20_transfer *xfer;
590	uint32_t temp;
591	uint32_t maxsize;
592	uint32_t actlen;
593	char *oldbytes;
594
595	xfer = usb_get_transfer_by_ep_no(dev, ep);
596	if (xfer == NULL)
597		return (-1);
598
599	if (libusb20_tr_pending(xfer)) {
600		/* there is already a transfer ongoing */
601		return (-1);
602	}
603	maxsize = libusb20_tr_get_max_total_length(xfer);
604	oldbytes = bytes;
605
606	/*
607	 * We allow transferring zero bytes which is the same
608	 * equivalent to a zero length USB packet.
609	 */
610	do {
611
612		temp = size;
613		if (temp > maxsize) {
614			/* find maximum possible length */
615			temp = maxsize;
616		}
617		if (is_intr)
618			libusb20_tr_setup_intr(xfer, bytes, temp, timeout);
619		else
620			libusb20_tr_setup_bulk(xfer, bytes, temp, timeout);
621
622		libusb20_tr_start(xfer);
623
624		while (1) {
625
626			if (libusb20_dev_process((void *)dev) != 0) {
627				/* device detached */
628				return (-1);
629			}
630			if (libusb20_tr_pending(xfer) == 0) {
631				/* transfer complete */
632				break;
633			}
634			/* wait for USB event from kernel */
635			libusb20_dev_wait_process((void *)dev, -1);
636		}
637
638		switch (libusb20_tr_get_status(xfer)) {
639		case 0:
640			/* success */
641			break;
642		case LIBUSB20_TRANSFER_TIMED_OUT:
643			/* transfer timeout */
644			return (-ETIMEDOUT);
645		default:
646			/* other transfer error */
647			return (-ENXIO);
648		}
649		actlen = libusb20_tr_get_actual_length(xfer);
650
651		bytes += actlen;
652		size -= actlen;
653
654		if (actlen != temp) {
655			/* short transfer */
656			break;
657		}
658	} while (size > 0);
659
660	return (bytes - oldbytes);
661}
662
663int
664usb_bulk_write(usb_dev_handle * dev, int ep, char *bytes,
665    int size, int timeout)
666{
667	return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK,
668	    bytes, size, timeout, 0));
669}
670
671int
672usb_bulk_read(usb_dev_handle * dev, int ep, char *bytes,
673    int size, int timeout)
674{
675	return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK,
676	    bytes, size, timeout, 0));
677}
678
679int
680usb_interrupt_write(usb_dev_handle * dev, int ep, char *bytes,
681    int size, int timeout)
682{
683	return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK,
684	    bytes, size, timeout, 1));
685}
686
687int
688usb_interrupt_read(usb_dev_handle * dev, int ep, char *bytes,
689    int size, int timeout)
690{
691	return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK,
692	    bytes, size, timeout, 1));
693}
694
695int
696usb_control_msg(usb_dev_handle * dev, int requesttype, int request,
697    int value, int wIndex, char *bytes, int size, int timeout)
698{
699	struct LIBUSB20_CONTROL_SETUP_DECODED req;
700	int err;
701	uint16_t actlen;
702
703	LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
704
705	req.bmRequestType = requesttype;
706	req.bRequest = request;
707	req.wValue = value;
708	req.wIndex = wIndex;
709	req.wLength = size;
710
711	err = libusb20_dev_request_sync((void *)dev, &req, bytes,
712	    &actlen, timeout, 0);
713
714	if (err)
715		return (-1);
716
717	return (actlen);
718}
719
720int
721usb_set_configuration(usb_dev_handle * udev, int bConfigurationValue)
722{
723	struct usb_device *dev;
724	int err;
725	uint8_t i;
726
727	/*
728	 * Need to translate from "bConfigurationValue" to
729	 * configuration index:
730	 */
731
732	if (bConfigurationValue == 0) {
733		/* unconfigure */
734		i = 255;
735	} else {
736		/* lookup configuration index */
737		dev = usb_device(udev);
738
739		/* check if the configuration array is not there */
740		if (dev->config == NULL) {
741			return (-1);
742		}
743		for (i = 0;; i++) {
744			if (i == dev->descriptor.bNumConfigurations) {
745				/* "bConfigurationValue" not found */
746				return (-1);
747			}
748			if ((dev->config + i)->bConfigurationValue ==
749			    bConfigurationValue) {
750				break;
751			}
752		}
753	}
754
755	err = libusb20_dev_set_config_index((void *)udev, i);
756
757	if (err)
758		return (-1);
759
760	return (0);
761}
762
763int
764usb_claim_interface(usb_dev_handle * dev, int interface)
765{
766	struct libusb20_device *pdev = (void *)dev;
767
768	pdev->claimed_interface = interface;
769
770	return (0);
771}
772
773int
774usb_release_interface(usb_dev_handle * dev, int interface)
775{
776	/* do nothing */
777	return (0);
778}
779
780int
781usb_set_altinterface(usb_dev_handle * dev, int alternate)
782{
783	struct libusb20_device *pdev = (void *)dev;
784	int err;
785	uint8_t iface;
786
787	iface = pdev->claimed_interface;
788
789	err = libusb20_dev_set_alt_index((void *)dev, iface, alternate);
790
791	if (err)
792		return (-1);
793
794	return (0);
795}
796
797int
798usb_resetep(usb_dev_handle * dev, unsigned int ep)
799{
800	/* emulate an endpoint reset through clear-STALL */
801	return (usb_clear_halt(dev, ep));
802}
803
804int
805usb_clear_halt(usb_dev_handle * dev, unsigned int ep)
806{
807	struct libusb20_transfer *xfer;
808
809	xfer = usb_get_transfer_by_ep_no(dev, ep);
810	if (xfer == NULL)
811		return (-1);
812
813	libusb20_tr_clear_stall_sync(xfer);
814
815	return (0);
816}
817
818int
819usb_reset(usb_dev_handle * dev)
820{
821	int err;
822
823	err = libusb20_dev_reset((void *)dev);
824
825	if (err)
826		return (-1);
827
828	/*
829	 * Be compatible with LibUSB from sourceforge and close the
830	 * handle after reset!
831	 */
832	return (usb_close(dev));
833}
834
835int
836usb_check_connected(usb_dev_handle * dev)
837{
838	int err;
839
840	err = libusb20_dev_check_connected((void *)dev);
841
842	if (err)
843		return (-1);
844
845	return (0);
846}
847
848const char *
849usb_strerror(void)
850{
851	/* TODO */
852	return ("Unknown error");
853}
854
855void
856usb_init(void)
857{
858	/* nothing to do */
859	return;
860}
861
862void
863usb_set_debug(int level)
864{
865	/* use kernel UGEN debugging if you need to see what is going on */
866	return;
867}
868
869int
870usb_find_busses(void)
871{
872	usb_busses = &usb_global_bus;
873	return (1);
874}
875
876int
877usb_find_devices(void)
878{
879	struct libusb20_device *pdev;
880	struct usb_device *udev;
881	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
882	int devnum;
883	int err;
884
885	/* cleanup after last device search */
886	/* close all opened devices, if any */
887
888	while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
889		udev = pdev->privLuData;
890		libusb20_be_dequeue_device(usb_backend, pdev);
891		libusb20_dev_free(pdev);
892		if (udev != NULL) {
893			LIST_DEL(usb_global_bus.devices, udev);
894			free(udev);
895		}
896	}
897
898	/* free old USB backend, if any */
899
900	libusb20_be_free(usb_backend);
901
902	/* do a new backend device search */
903	usb_backend = libusb20_be_alloc_default();
904	if (usb_backend == NULL) {
905		return (-1);
906	}
907	/* iterate all devices */
908
909	devnum = 1;
910	pdev = NULL;
911	while ((pdev = libusb20_be_device_foreach(usb_backend, pdev))) {
912		udev = malloc(sizeof(*udev));
913		if (udev == NULL)
914			break;
915
916		memset(udev, 0, sizeof(*udev));
917
918		udev->bus = &usb_global_bus;
919
920		snprintf(udev->filename, sizeof(udev->filename),
921		    "/dev/ugen%u.%u",
922		    libusb20_dev_get_bus_number(pdev),
923		    libusb20_dev_get_address(pdev));
924
925		ddesc = libusb20_dev_get_device_desc(pdev);
926
927		udev->descriptor.bLength = sizeof(udev->descriptor);
928		udev->descriptor.bDescriptorType = ddesc->bDescriptorType;
929		udev->descriptor.bcdUSB = ddesc->bcdUSB;
930		udev->descriptor.bDeviceClass = ddesc->bDeviceClass;
931		udev->descriptor.bDeviceSubClass = ddesc->bDeviceSubClass;
932		udev->descriptor.bDeviceProtocol = ddesc->bDeviceProtocol;
933		udev->descriptor.bMaxPacketSize0 = ddesc->bMaxPacketSize0;
934		udev->descriptor.idVendor = ddesc->idVendor;
935		udev->descriptor.idProduct = ddesc->idProduct;
936		udev->descriptor.bcdDevice = ddesc->bcdDevice;
937		udev->descriptor.iManufacturer = ddesc->iManufacturer;
938		udev->descriptor.iProduct = ddesc->iProduct;
939		udev->descriptor.iSerialNumber = ddesc->iSerialNumber;
940		udev->descriptor.bNumConfigurations =
941		    ddesc->bNumConfigurations;
942		if (udev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
943			/* truncate number of configurations */
944			udev->descriptor.bNumConfigurations = USB_MAXCONFIG;
945		}
946		udev->devnum = devnum++;
947		/* link together the two structures */
948		udev->dev = pdev;
949		pdev->privLuData = udev;
950
951		err = libusb20_dev_open(pdev, 0);
952		if (err == 0) {
953			/* XXX get all config descriptors by default */
954			usb_fetch_and_parse_descriptors((void *)pdev);
955			libusb20_dev_close(pdev);
956		}
957		LIST_ADD(usb_global_bus.devices, udev);
958	}
959
960	return (devnum - 1);			/* success */
961}
962
963struct usb_device *
964usb_device(usb_dev_handle * dev)
965{
966	struct libusb20_device *pdev;
967
968	pdev = (void *)dev;
969
970	return (pdev->privLuData);
971}
972
973struct usb_bus *
974usb_get_busses(void)
975{
976	return (usb_busses);
977}
978
979int
980usb_get_driver_np(usb_dev_handle * dev, int interface, char *name, int namelen)
981{
982	struct libusb20_device *pdev;
983	char *ptr;
984	int err;
985
986	pdev = (void *)dev;
987
988	if (pdev == NULL)
989		return (-1);
990	if (namelen < 1)
991		return (-1);
992	if (namelen > 255)
993		namelen = 255;
994
995	err = libusb20_dev_get_iface_desc(pdev, interface, name, namelen);
996	if (err != 0)
997		return (-1);
998
999	/* we only want the driver name */
1000	ptr = strstr(name, ":");
1001	if (ptr != NULL)
1002		*ptr = 0;
1003
1004	return (0);
1005}
1006
1007int
1008usb_detach_kernel_driver_np(usb_dev_handle * dev, int interface)
1009{
1010	struct libusb20_device *pdev;
1011	int err;
1012
1013	pdev = (void *)dev;
1014
1015	if (pdev == NULL)
1016		return (-1);
1017
1018	err = libusb20_dev_detach_kernel_driver(pdev, interface);
1019	if (err != 0)
1020		return (-1);
1021
1022	return (0);
1023}
1024