- Add a new API function to check the connected status of the USB handle in the LibUSB v1.0 and LibUSB v0.1 interfaces. Approved by: thompsa (mentor)
941 lines
20 KiB
C
941 lines
20 KiB
C
/* $FreeBSD$ */
|
|
/*-
|
|
* Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* This file contains the emulation layer for LibUSB v0.1 from sourceforge.
|
|
*/
|
|
|
|
#include <sys/queue.h>
|
|
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "libusb20.h"
|
|
#include "libusb20_desc.h"
|
|
#include "libusb20_int.h"
|
|
#include "usb.h"
|
|
|
|
/*
|
|
* The two following macros were taken from the original LibUSB v0.1
|
|
* for sake of compatibility:
|
|
*/
|
|
#define LIST_ADD(begin, ent) \
|
|
do { \
|
|
if (begin) { \
|
|
ent->next = begin; \
|
|
ent->next->prev = ent; \
|
|
} else { \
|
|
ent->next = NULL; \
|
|
} \
|
|
ent->prev = NULL; \
|
|
begin = ent; \
|
|
} while(0)
|
|
|
|
#define LIST_DEL(begin, ent) \
|
|
do { \
|
|
if (ent->prev) { \
|
|
ent->prev->next = ent->next; \
|
|
} else { \
|
|
begin = ent->next; \
|
|
} \
|
|
if (ent->next) { \
|
|
ent->next->prev = ent->prev; \
|
|
} \
|
|
ent->prev = NULL; \
|
|
ent->next = NULL; \
|
|
} while (0)
|
|
|
|
struct usb_bus *usb_busses = NULL;
|
|
|
|
static struct usb_bus usb_global_bus = {
|
|
.dirname = {"/dev/usb"},
|
|
.root_dev = NULL,
|
|
.devices = NULL,
|
|
};
|
|
|
|
static struct libusb20_backend *usb_backend = NULL;
|
|
|
|
struct usb_parse_state {
|
|
|
|
struct {
|
|
struct libusb20_endpoint *currep;
|
|
struct libusb20_interface *currifc;
|
|
struct libusb20_config *currcfg;
|
|
struct libusb20_me_struct *currextra;
|
|
} a;
|
|
|
|
struct {
|
|
struct usb_config_descriptor *currcfg;
|
|
struct usb_interface_descriptor *currifc;
|
|
struct usb_endpoint_descriptor *currep;
|
|
struct usb_interface *currifcw;
|
|
uint8_t *currextra;
|
|
} b;
|
|
|
|
uint8_t preparse;
|
|
};
|
|
|
|
static struct libusb20_transfer *
|
|
usb_get_transfer_by_ep_no(usb_dev_handle * dev, uint8_t ep_no)
|
|
{
|
|
struct libusb20_device *pdev = (void *)dev;
|
|
struct libusb20_transfer *xfer;
|
|
int err;
|
|
uint32_t bufsize;
|
|
uint8_t x;
|
|
uint8_t speed;
|
|
|
|
x = (ep_no & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 2;
|
|
|
|
if (ep_no & LIBUSB20_ENDPOINT_DIR_MASK) {
|
|
/* this is an IN endpoint */
|
|
x |= 1;
|
|
}
|
|
speed = libusb20_dev_get_speed(pdev);
|
|
|
|
/* select a sensible buffer size */
|
|
if (speed == LIBUSB20_SPEED_LOW) {
|
|
bufsize = 256;
|
|
} else if (speed == LIBUSB20_SPEED_FULL) {
|
|
bufsize = 4096;
|
|
} else {
|
|
bufsize = 16384;
|
|
}
|
|
|
|
xfer = libusb20_tr_get_pointer(pdev, x);
|
|
|
|
if (xfer == NULL)
|
|
return (xfer);
|
|
|
|
err = libusb20_tr_open(xfer, bufsize, 1, ep_no);
|
|
if (err == LIBUSB20_ERROR_BUSY) {
|
|
/* already opened */
|
|
return (xfer);
|
|
} else if (err) {
|
|
return (NULL);
|
|
}
|
|
/* success */
|
|
return (xfer);
|
|
}
|
|
|
|
usb_dev_handle *
|
|
usb_open(struct usb_device *dev)
|
|
{
|
|
int err;
|
|
|
|
err = libusb20_dev_open(dev->dev, 16 * 2);
|
|
if (err == LIBUSB20_ERROR_BUSY) {
|
|
/*
|
|
* Workaround buggy USB applications which open the USB
|
|
* device multiple times:
|
|
*/
|
|
return (dev->dev);
|
|
}
|
|
if (err)
|
|
return (NULL);
|
|
|
|
/*
|
|
* Dequeue USB device from backend queue so that it does not get
|
|
* freed when the backend is re-scanned:
|
|
*/
|
|
libusb20_be_dequeue_device(usb_backend, dev->dev);
|
|
|
|
return (dev->dev);
|
|
}
|
|
|
|
int
|
|
usb_close(usb_dev_handle * udev)
|
|
{
|
|
struct usb_device *dev;
|
|
int err;
|
|
|
|
err = libusb20_dev_close((void *)udev);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
if (usb_backend != NULL) {
|
|
/*
|
|
* Enqueue USB device to backend queue so that it gets freed
|
|
* when the backend is re-scanned:
|
|
*/
|
|
libusb20_be_enqueue_device(usb_backend, (void *)udev);
|
|
} else {
|
|
/*
|
|
* The backend is gone. Free device data so that we
|
|
* don't start leaking memory!
|
|
*/
|
|
dev = usb_device(udev);
|
|
libusb20_dev_free((void *)udev);
|
|
LIST_DEL(usb_global_bus.devices, dev);
|
|
free(dev);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
usb_get_string(usb_dev_handle * dev, int strindex,
|
|
int langid, char *buf, size_t buflen)
|
|
{
|
|
int err;
|
|
|
|
err = libusb20_dev_req_string_sync((void *)dev,
|
|
strindex, langid, buf, buflen);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
usb_get_string_simple(usb_dev_handle * dev, int strindex,
|
|
char *buf, size_t buflen)
|
|
{
|
|
int err;
|
|
|
|
err = libusb20_dev_req_string_simple_sync((void *)dev,
|
|
strindex, buf, buflen);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
return (strlen(buf));
|
|
}
|
|
|
|
int
|
|
usb_get_descriptor_by_endpoint(usb_dev_handle * udev, int ep, uint8_t type,
|
|
uint8_t ep_index, void *buf, int size)
|
|
{
|
|
memset(buf, 0, size);
|
|
|
|
return (usb_control_msg(udev, ep | USB_ENDPOINT_IN,
|
|
USB_REQ_GET_DESCRIPTOR, (type << 8) + ep_index, 0,
|
|
buf, size, 1000));
|
|
}
|
|
|
|
int
|
|
usb_get_descriptor(usb_dev_handle * udev, uint8_t type, uint8_t desc_index,
|
|
void *buf, int size)
|
|
{
|
|
memset(buf, 0, size);
|
|
|
|
return (usb_control_msg(udev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
|
|
(type << 8) + desc_index, 0, buf, size, 1000));
|
|
}
|
|
|
|
int
|
|
usb_parse_descriptor(uint8_t *source, char *description, void *dest)
|
|
{
|
|
uint8_t *sp = source;
|
|
uint8_t *dp = dest;
|
|
uint16_t w;
|
|
uint32_t d;
|
|
char *cp;
|
|
|
|
for (cp = description; *cp; cp++) {
|
|
switch (*cp) {
|
|
case 'b': /* 8-bit byte */
|
|
*dp++ = *sp++;
|
|
break;
|
|
/*
|
|
* 16-bit word, convert from little endian to CPU
|
|
*/
|
|
case 'w':
|
|
w = (sp[1] << 8) | sp[0];
|
|
sp += 2;
|
|
/* Align to word boundary */
|
|
dp += ((dp - (uint8_t *)0) & 1);
|
|
*((uint16_t *)dp) = w;
|
|
dp += 2;
|
|
break;
|
|
/*
|
|
* 32-bit dword, convert from little endian to CPU
|
|
*/
|
|
case 'd':
|
|
d = (sp[3] << 24) | (sp[2] << 16) |
|
|
(sp[1] << 8) | sp[0];
|
|
sp += 4;
|
|
/* Align to word boundary */
|
|
dp += ((dp - (uint8_t *)0) & 1);
|
|
/* Align to double word boundary */
|
|
dp += ((dp - (uint8_t *)0) & 2);
|
|
*((uint32_t *)dp) = d;
|
|
dp += 4;
|
|
break;
|
|
}
|
|
}
|
|
return (sp - source);
|
|
}
|
|
|
|
static void
|
|
usb_parse_extra(struct usb_parse_state *ps, uint8_t **pptr, int *plen)
|
|
{
|
|
void *ptr;
|
|
uint16_t len;
|
|
|
|
ptr = ps->a.currextra->ptr;
|
|
len = ps->a.currextra->len;
|
|
|
|
if (ps->preparse == 0) {
|
|
memcpy(ps->b.currextra, ptr, len);
|
|
*pptr = ps->b.currextra;
|
|
*plen = len;
|
|
}
|
|
ps->b.currextra += len;
|
|
return;
|
|
}
|
|
|
|
static void
|
|
usb_parse_endpoint(struct usb_parse_state *ps)
|
|
{
|
|
struct usb_endpoint_descriptor *bep;
|
|
struct libusb20_endpoint *aep;
|
|
|
|
aep = ps->a.currep;
|
|
bep = ps->b.currep++;
|
|
|
|
if (ps->preparse == 0) {
|
|
/* copy descriptor fields */
|
|
bep->bLength = aep->desc.bLength;
|
|
bep->bDescriptorType = aep->desc.bDescriptorType;
|
|
bep->bEndpointAddress = aep->desc.bEndpointAddress;
|
|
bep->bmAttributes = aep->desc.bmAttributes;
|
|
bep->wMaxPacketSize = aep->desc.wMaxPacketSize;
|
|
bep->bInterval = aep->desc.bInterval;
|
|
bep->bRefresh = aep->desc.bRefresh;
|
|
bep->bSynchAddress = aep->desc.bSynchAddress;
|
|
}
|
|
ps->a.currextra = &aep->extra;
|
|
usb_parse_extra(ps, &bep->extra, &bep->extralen);
|
|
return;
|
|
}
|
|
|
|
static void
|
|
usb_parse_iface_sub(struct usb_parse_state *ps)
|
|
{
|
|
struct libusb20_interface *aifc;
|
|
struct usb_interface_descriptor *bifc;
|
|
uint8_t x;
|
|
|
|
aifc = ps->a.currifc;
|
|
bifc = ps->b.currifc++;
|
|
|
|
if (ps->preparse == 0) {
|
|
/* copy descriptor fields */
|
|
bifc->bLength = aifc->desc.bLength;
|
|
bifc->bDescriptorType = aifc->desc.bDescriptorType;
|
|
bifc->bInterfaceNumber = aifc->desc.bInterfaceNumber;
|
|
bifc->bAlternateSetting = aifc->desc.bAlternateSetting;
|
|
bifc->bNumEndpoints = aifc->num_endpoints;
|
|
bifc->bInterfaceClass = aifc->desc.bInterfaceClass;
|
|
bifc->bInterfaceSubClass = aifc->desc.bInterfaceSubClass;
|
|
bifc->bInterfaceProtocol = aifc->desc.bInterfaceProtocol;
|
|
bifc->iInterface = aifc->desc.iInterface;
|
|
bifc->endpoint = ps->b.currep;
|
|
}
|
|
for (x = 0; x != aifc->num_endpoints; x++) {
|
|
ps->a.currep = aifc->endpoints + x;
|
|
usb_parse_endpoint(ps);
|
|
}
|
|
|
|
ps->a.currextra = &aifc->extra;
|
|
usb_parse_extra(ps, &bifc->extra, &bifc->extralen);
|
|
return;
|
|
}
|
|
|
|
static void
|
|
usb_parse_iface(struct usb_parse_state *ps)
|
|
{
|
|
struct libusb20_interface *aifc;
|
|
struct usb_interface *bifc;
|
|
uint8_t x;
|
|
|
|
aifc = ps->a.currifc;
|
|
bifc = ps->b.currifcw++;
|
|
|
|
if (ps->preparse == 0) {
|
|
/* initialise interface wrapper */
|
|
bifc->altsetting = ps->b.currifc;
|
|
bifc->num_altsetting = aifc->num_altsetting + 1;
|
|
}
|
|
usb_parse_iface_sub(ps);
|
|
|
|
for (x = 0; x != aifc->num_altsetting; x++) {
|
|
ps->a.currifc = aifc->altsetting + x;
|
|
usb_parse_iface_sub(ps);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void
|
|
usb_parse_config(struct usb_parse_state *ps)
|
|
{
|
|
struct libusb20_config *acfg;
|
|
struct usb_config_descriptor *bcfg;
|
|
uint8_t x;
|
|
|
|
acfg = ps->a.currcfg;
|
|
bcfg = ps->b.currcfg;
|
|
|
|
if (ps->preparse == 0) {
|
|
/* initialise config wrapper */
|
|
bcfg->bLength = acfg->desc.bLength;
|
|
bcfg->bDescriptorType = acfg->desc.bDescriptorType;
|
|
bcfg->wTotalLength = acfg->desc.wTotalLength;
|
|
bcfg->bNumInterfaces = acfg->num_interface;
|
|
bcfg->bConfigurationValue = acfg->desc.bConfigurationValue;
|
|
bcfg->iConfiguration = acfg->desc.iConfiguration;
|
|
bcfg->bmAttributes = acfg->desc.bmAttributes;
|
|
bcfg->MaxPower = acfg->desc.bMaxPower;
|
|
bcfg->interface = ps->b.currifcw;
|
|
}
|
|
for (x = 0; x != acfg->num_interface; x++) {
|
|
ps->a.currifc = acfg->interface + x;
|
|
usb_parse_iface(ps);
|
|
}
|
|
|
|
ps->a.currextra = &acfg->extra;
|
|
usb_parse_extra(ps, &bcfg->extra, &bcfg->extralen);
|
|
return;
|
|
}
|
|
|
|
int
|
|
usb_parse_configuration(struct usb_config_descriptor *config,
|
|
uint8_t *buffer)
|
|
{
|
|
struct usb_parse_state ps;
|
|
uint8_t *ptr;
|
|
uint32_t a;
|
|
uint32_t b;
|
|
uint32_t c;
|
|
uint32_t d;
|
|
|
|
if ((buffer == NULL) || (config == NULL)) {
|
|
return (-1);
|
|
}
|
|
memset(&ps, 0, sizeof(ps));
|
|
|
|
ps.a.currcfg = libusb20_parse_config_desc(buffer);
|
|
ps.b.currcfg = config;
|
|
if (ps.a.currcfg == NULL) {
|
|
/* could not parse config or out of memory */
|
|
return (-1);
|
|
}
|
|
/* do the pre-parse */
|
|
ps.preparse = 1;
|
|
usb_parse_config(&ps);
|
|
|
|
a = ((uint8_t *)(ps.b.currifcw) - ((uint8_t *)0));
|
|
b = ((uint8_t *)(ps.b.currifc) - ((uint8_t *)0));
|
|
c = ((uint8_t *)(ps.b.currep) - ((uint8_t *)0));
|
|
d = ((uint8_t *)(ps.b.currextra) - ((uint8_t *)0));
|
|
|
|
/* allocate memory for our configuration */
|
|
ptr = malloc(a + b + c + d);
|
|
|
|
/* "currifcw" must be first, hence this pointer is freed */
|
|
ps.b.currifcw = (void *)(ptr);
|
|
ps.b.currifc = (void *)(ptr + a);
|
|
ps.b.currep = (void *)(ptr + a + b);
|
|
ps.b.currextra = (void *)(ptr + a + b + c);
|
|
|
|
/* generate a libusb v0.1 compatible structure */
|
|
ps.preparse = 0;
|
|
usb_parse_config(&ps);
|
|
|
|
/* free config structure */
|
|
free(ps.a.currcfg);
|
|
|
|
return (0); /* success */
|
|
}
|
|
|
|
void
|
|
usb_destroy_configuration(struct usb_device *dev)
|
|
{
|
|
uint8_t c;
|
|
|
|
if (dev->config == NULL) {
|
|
return;
|
|
}
|
|
for (c = 0; c != dev->descriptor.bNumConfigurations; c++) {
|
|
struct usb_config_descriptor *cf = &dev->config[c];
|
|
|
|
if (cf->interface != NULL) {
|
|
free(cf->interface);
|
|
cf->interface = NULL;
|
|
}
|
|
}
|
|
|
|
free(dev->config);
|
|
dev->config = NULL;
|
|
return;
|
|
}
|
|
|
|
void
|
|
usb_fetch_and_parse_descriptors(usb_dev_handle * udev)
|
|
{
|
|
struct usb_device *dev;
|
|
struct libusb20_device *pdev;
|
|
uint8_t *ptr;
|
|
int error;
|
|
uint32_t size;
|
|
uint16_t len;
|
|
uint8_t x;
|
|
|
|
if (udev == NULL) {
|
|
/* be NULL safe */
|
|
return;
|
|
}
|
|
dev = usb_device(udev);
|
|
pdev = (void *)udev;
|
|
|
|
if (dev->descriptor.bNumConfigurations == 0) {
|
|
/* invalid device */
|
|
return;
|
|
}
|
|
size = dev->descriptor.bNumConfigurations *
|
|
sizeof(struct usb_config_descriptor);
|
|
|
|
dev->config = malloc(size);
|
|
if (dev->config == NULL) {
|
|
/* out of memory */
|
|
return;
|
|
}
|
|
memset(dev->config, 0, size);
|
|
|
|
for (x = 0; x != dev->descriptor.bNumConfigurations; x++) {
|
|
|
|
error = (pdev->methods->get_config_desc_full) (
|
|
pdev, &ptr, &len, x);
|
|
|
|
if (error) {
|
|
usb_destroy_configuration(dev);
|
|
return;
|
|
}
|
|
usb_parse_configuration(dev->config + x, ptr);
|
|
|
|
/* free config buffer */
|
|
free(ptr);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static int
|
|
usb_std_io(usb_dev_handle * dev, int ep, char *bytes, int size,
|
|
int timeout, int is_intr)
|
|
{
|
|
struct libusb20_transfer *xfer;
|
|
uint32_t temp;
|
|
uint32_t maxsize;
|
|
uint32_t actlen;
|
|
char *oldbytes;
|
|
|
|
xfer = usb_get_transfer_by_ep_no(dev, ep);
|
|
if (xfer == NULL)
|
|
return (-1);
|
|
|
|
if (libusb20_tr_pending(xfer)) {
|
|
/* there is already a transfer ongoing */
|
|
return (-1);
|
|
}
|
|
maxsize = libusb20_tr_get_max_total_length(xfer);
|
|
oldbytes = bytes;
|
|
|
|
/*
|
|
* We allow transferring zero bytes which is the same
|
|
* equivalent to a zero length USB packet.
|
|
*/
|
|
do {
|
|
|
|
temp = size;
|
|
if (temp > maxsize) {
|
|
/* find maximum possible length */
|
|
temp = maxsize;
|
|
}
|
|
if (is_intr)
|
|
libusb20_tr_setup_intr(xfer, bytes, temp, timeout);
|
|
else
|
|
libusb20_tr_setup_bulk(xfer, bytes, temp, timeout);
|
|
|
|
libusb20_tr_start(xfer);
|
|
|
|
while (1) {
|
|
|
|
if (libusb20_dev_process((void *)dev) != 0) {
|
|
/* device detached */
|
|
return (-1);
|
|
}
|
|
if (libusb20_tr_pending(xfer) == 0) {
|
|
/* transfer complete */
|
|
break;
|
|
}
|
|
/* wait for USB event from kernel */
|
|
libusb20_dev_wait_process((void *)dev, -1);
|
|
}
|
|
|
|
switch (libusb20_tr_get_status(xfer)) {
|
|
case 0:
|
|
/* success */
|
|
break;
|
|
case LIBUSB20_TRANSFER_TIMED_OUT:
|
|
/* transfer timeout */
|
|
return (-ETIMEDOUT);
|
|
default:
|
|
/* other transfer error */
|
|
return (-ENXIO);
|
|
}
|
|
actlen = libusb20_tr_get_actual_length(xfer);
|
|
|
|
bytes += actlen;
|
|
size -= actlen;
|
|
|
|
if (actlen != temp) {
|
|
/* short transfer */
|
|
break;
|
|
}
|
|
} while (size > 0);
|
|
|
|
return (bytes - oldbytes);
|
|
}
|
|
|
|
int
|
|
usb_bulk_write(usb_dev_handle * dev, int ep, char *bytes,
|
|
int size, int timeout)
|
|
{
|
|
return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK,
|
|
bytes, size, timeout, 0));
|
|
}
|
|
|
|
int
|
|
usb_bulk_read(usb_dev_handle * dev, int ep, char *bytes,
|
|
int size, int timeout)
|
|
{
|
|
return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK,
|
|
bytes, size, timeout, 0));
|
|
}
|
|
|
|
int
|
|
usb_interrupt_write(usb_dev_handle * dev, int ep, char *bytes,
|
|
int size, int timeout)
|
|
{
|
|
return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK,
|
|
bytes, size, timeout, 1));
|
|
}
|
|
|
|
int
|
|
usb_interrupt_read(usb_dev_handle * dev, int ep, char *bytes,
|
|
int size, int timeout)
|
|
{
|
|
return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK,
|
|
bytes, size, timeout, 1));
|
|
}
|
|
|
|
int
|
|
usb_control_msg(usb_dev_handle * dev, int requesttype, int request,
|
|
int value, int wIndex, char *bytes, int size, int timeout)
|
|
{
|
|
struct LIBUSB20_CONTROL_SETUP_DECODED req;
|
|
int err;
|
|
uint16_t actlen;
|
|
|
|
LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
|
|
|
|
req.bmRequestType = requesttype;
|
|
req.bRequest = request;
|
|
req.wValue = value;
|
|
req.wIndex = wIndex;
|
|
req.wLength = size;
|
|
|
|
err = libusb20_dev_request_sync((void *)dev, &req, bytes,
|
|
&actlen, timeout, 0);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
return (actlen);
|
|
}
|
|
|
|
int
|
|
usb_set_configuration(usb_dev_handle * udev, int bConfigurationValue)
|
|
{
|
|
struct usb_device *dev;
|
|
int err;
|
|
uint8_t i;
|
|
|
|
/*
|
|
* Need to translate from "bConfigurationValue" to
|
|
* configuration index:
|
|
*/
|
|
|
|
if (bConfigurationValue == 0) {
|
|
/* unconfigure */
|
|
i = 255;
|
|
} else {
|
|
/* lookup configuration index */
|
|
dev = usb_device(udev);
|
|
|
|
/* check if the configuration array is not there */
|
|
if (dev->config == NULL) {
|
|
return (-1);
|
|
}
|
|
for (i = 0;; i++) {
|
|
if (i == dev->descriptor.bNumConfigurations) {
|
|
/* "bConfigurationValue" not found */
|
|
return (-1);
|
|
}
|
|
if ((dev->config + i)->bConfigurationValue ==
|
|
bConfigurationValue) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
err = libusb20_dev_set_config_index((void *)udev, i);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
usb_claim_interface(usb_dev_handle * dev, int interface)
|
|
{
|
|
struct libusb20_device *pdev = (void *)dev;
|
|
|
|
pdev->claimed_interface = interface;
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
usb_release_interface(usb_dev_handle * dev, int interface)
|
|
{
|
|
/* do nothing */
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
usb_set_altinterface(usb_dev_handle * dev, int alternate)
|
|
{
|
|
struct libusb20_device *pdev = (void *)dev;
|
|
int err;
|
|
uint8_t iface;
|
|
|
|
iface = pdev->claimed_interface;
|
|
|
|
err = libusb20_dev_set_alt_index((void *)dev, iface, alternate);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
usb_resetep(usb_dev_handle * dev, unsigned int ep)
|
|
{
|
|
/* emulate an endpoint reset through clear-STALL */
|
|
return (usb_clear_halt(dev, ep));
|
|
}
|
|
|
|
int
|
|
usb_clear_halt(usb_dev_handle * dev, unsigned int ep)
|
|
{
|
|
struct libusb20_transfer *xfer;
|
|
|
|
xfer = usb_get_transfer_by_ep_no(dev, ep);
|
|
if (xfer == NULL)
|
|
return (-1);
|
|
|
|
libusb20_tr_clear_stall_sync(xfer);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
usb_reset(usb_dev_handle * dev)
|
|
{
|
|
int err;
|
|
|
|
err = libusb20_dev_reset((void *)dev);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
/*
|
|
* Be compatible with LibUSB from sourceforge and close the
|
|
* handle after reset!
|
|
*/
|
|
return (usb_close(dev));
|
|
}
|
|
|
|
int
|
|
usb_check_connected(usb_dev_handle * dev)
|
|
{
|
|
int err;
|
|
|
|
err = libusb20_dev_check_connected((void *)dev);
|
|
|
|
if (err)
|
|
return (-1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
const char *
|
|
usb_strerror(void)
|
|
{
|
|
/* TODO */
|
|
return ("Unknown error");
|
|
}
|
|
|
|
void
|
|
usb_init(void)
|
|
{
|
|
/* nothing to do */
|
|
return;
|
|
}
|
|
|
|
void
|
|
usb_set_debug(int level)
|
|
{
|
|
/* use kernel UGEN debugging if you need to see what is going on */
|
|
return;
|
|
}
|
|
|
|
int
|
|
usb_find_busses(void)
|
|
{
|
|
usb_busses = &usb_global_bus;
|
|
return (1);
|
|
}
|
|
|
|
int
|
|
usb_find_devices(void)
|
|
{
|
|
struct libusb20_device *pdev;
|
|
struct usb_device *udev;
|
|
struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
|
|
int devnum;
|
|
int err;
|
|
|
|
/* cleanup after last device search */
|
|
/* close all opened devices, if any */
|
|
|
|
while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
|
|
udev = pdev->privLuData;
|
|
libusb20_be_dequeue_device(usb_backend, pdev);
|
|
libusb20_dev_free(pdev);
|
|
if (udev != NULL) {
|
|
LIST_DEL(usb_global_bus.devices, udev);
|
|
free(udev);
|
|
}
|
|
}
|
|
|
|
/* free old USB backend, if any */
|
|
|
|
libusb20_be_free(usb_backend);
|
|
|
|
/* do a new backend device search */
|
|
usb_backend = libusb20_be_alloc_default();
|
|
if (usb_backend == NULL) {
|
|
return (-1);
|
|
}
|
|
/* iterate all devices */
|
|
|
|
devnum = 1;
|
|
pdev = NULL;
|
|
while ((pdev = libusb20_be_device_foreach(usb_backend, pdev))) {
|
|
udev = malloc(sizeof(*udev));
|
|
if (udev == NULL)
|
|
break;
|
|
|
|
memset(udev, 0, sizeof(*udev));
|
|
|
|
udev->bus = &usb_global_bus;
|
|
|
|
snprintf(udev->filename, sizeof(udev->filename),
|
|
"/dev/ugen%u.%u",
|
|
libusb20_dev_get_bus_number(pdev),
|
|
libusb20_dev_get_address(pdev));
|
|
|
|
ddesc = libusb20_dev_get_device_desc(pdev);
|
|
|
|
udev->descriptor.bLength = sizeof(udev->descriptor);
|
|
udev->descriptor.bDescriptorType = ddesc->bDescriptorType;
|
|
udev->descriptor.bcdUSB = ddesc->bcdUSB;
|
|
udev->descriptor.bDeviceClass = ddesc->bDeviceClass;
|
|
udev->descriptor.bDeviceSubClass = ddesc->bDeviceSubClass;
|
|
udev->descriptor.bDeviceProtocol = ddesc->bDeviceProtocol;
|
|
udev->descriptor.bMaxPacketSize0 = ddesc->bMaxPacketSize0;
|
|
udev->descriptor.idVendor = ddesc->idVendor;
|
|
udev->descriptor.idProduct = ddesc->idProduct;
|
|
udev->descriptor.bcdDevice = ddesc->bcdDevice;
|
|
udev->descriptor.iManufacturer = ddesc->iManufacturer;
|
|
udev->descriptor.iProduct = ddesc->iProduct;
|
|
udev->descriptor.iSerialNumber = ddesc->iSerialNumber;
|
|
udev->descriptor.bNumConfigurations =
|
|
ddesc->bNumConfigurations;
|
|
if (udev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
|
|
/* truncate number of configurations */
|
|
udev->descriptor.bNumConfigurations = USB_MAXCONFIG;
|
|
}
|
|
udev->devnum = devnum++;
|
|
/* link together the two structures */
|
|
udev->dev = pdev;
|
|
pdev->privLuData = udev;
|
|
|
|
err = libusb20_dev_open(pdev, 0);
|
|
if (err == 0) {
|
|
/* XXX get all config descriptors by default */
|
|
usb_fetch_and_parse_descriptors((void *)pdev);
|
|
libusb20_dev_close(pdev);
|
|
}
|
|
LIST_ADD(usb_global_bus.devices, udev);
|
|
}
|
|
|
|
return (devnum - 1); /* success */
|
|
}
|
|
|
|
struct usb_device *
|
|
usb_device(usb_dev_handle * dev)
|
|
{
|
|
struct libusb20_device *pdev;
|
|
|
|
pdev = (void *)dev;
|
|
|
|
return (pdev->privLuData);
|
|
}
|
|
|
|
struct usb_bus *
|
|
usb_get_busses(void)
|
|
{
|
|
return (usb_busses);
|
|
}
|