static int initialize_device(struct usb_device *dev)
{
libusb_device *newlib_dev = dev->dev;
int num_configurations;
size_t alloc_size;
int r;
int i;
/* device descriptor is identical in both libs */
r = libusb_get_device_descriptor(newlib_dev,
(struct libusb_device_descriptor *) &dev->descriptor);
if (r < 0) {
usbi_err("error %d getting device descriptor", r);
return compat_err(r);
}
num_configurations = dev->descriptor.bNumConfigurations;
alloc_size = sizeof(struct usb_config_descriptor) * num_configurations;
dev->config = malloc(alloc_size);
if (!dev->config)
return -ENOMEM;
memset(dev->config, 0, alloc_size);
/* even though structures are identical, we can't just use libusb-1.0's
* config descriptors because we have to store all configurations in
* a single flat memory area (libusb-1.0 provides separate allocations).
* we hand-copy libusb-1.0's descriptors into our own structures. */
for (i = 0; i < num_configurations; i++) {
struct libusb_config_descriptor *newlib_config;
r = libusb_get_config_descriptor(newlib_dev, i, &newlib_config);
if (r < 0) {
clear_device(dev);
free(dev->config);
return compat_err(r);
}
r = copy_config_descriptor(dev->config + i, newlib_config);
libusb_free_config_descriptor(newlib_config);
if (r < 0) {
clear_device(dev);
free(dev->config);
return r;
}
}
/* libusb doesn't implement this and it doesn't seem that important. If
* someone asks for it, we can implement it in v1.1 or later. */
dev->num_children = 0;
dev->children = NULL;
libusb_ref_device(newlib_dev);
return 0;
}
API_EXPORTED int usb_claim_interface(usb_dev_handle *dev, int interface)
{
int r;
usbi_dbg("interface %d", interface);
r = libusb_claim_interface(dev->handle, interface);
if(r == -6){
int err = libusb_kernel_driver_active(dev->handle, interface);
if(err == 1){
err = libusb_detach_kernel_driver(dev->handle, interface);
r = libusb_claim_interface(dev->handle, interface);
}
}
if (r == 0) {
dev->last_claimed_interface = interface;
return 0;
}
return compat_err(r);
}
API_EXPORTED int usb_set_altinterface(usb_dev_handle *dev, int alternate)
{
usbi_dbg("alternate %d", alternate);
if (dev->last_claimed_interface < 0)
return -(errno=EINVAL);
return compat_err(libusb_set_interface_alt_setting(dev->handle,
dev->last_claimed_interface, alternate));
}
API_EXPORTED int usb_get_descriptor(usb_dev_handle *dev, unsigned char type,
unsigned char desc_index, void *buf, int size)
{
int r;
r = libusb_get_descriptor(dev->handle, type, desc_index, buf, size);
if (r >= 0)
return r;
return compat_err(r);
}
API_EXPORTED int usb_get_string(usb_dev_handle *dev, int desc_index, int langid,
char *buf, size_t buflen)
{
int r;
r = dl_libusb_get_string_descriptor(dev->handle, desc_index & 0xff,
langid & 0xffff, buf, (int) buflen);
if (r >= 0)
return r;
return compat_err(r);
}
API_EXPORTED int usb_get_string_simple(usb_dev_handle *dev, int desc_index,
char *buf, size_t buflen)
{
int r;
r = libusb_get_string_descriptor_ascii(dev->handle, desc_index & 0xff,
buf, (int) buflen);
if (r >= 0)
return r;
return compat_err(r);
}
API_EXPORTED int usb_release_interface(usb_dev_handle *dev, int interface)
{
int r;
usbi_dbg("interface %d", interface);
r = libusb_release_interface(dev->handle, interface);
if (r == 0)
dev->last_claimed_interface = -1;
return compat_err(r);
}
API_EXPORTED int usb_get_descriptor_by_endpoint(usb_dev_handle *dev, int ep,
unsigned char type, unsigned char desc_index, void *buf, int size)
{
/* this function doesn't make much sense - the specs don't talk about
* getting a descriptor "by endpoint". libusb-1.0 does not provide this
* functionality so we just send a control message directly */
int r;
r = libusb_control_transfer(dev->handle,
LIBUSB_ENDPOINT_IN | (ep & 0xff), LIBUSB_REQUEST_GET_DESCRIPTOR,
(type << 8) | desc_index, 0, buf, size, 1000);
if (r >= 0)
return r;
return compat_err(r);
}
API_EXPORTED int usb_get_driver_np(usb_dev_handle *dev, int interface,
char *name, unsigned int namelen)
{
int r = libusb_kernel_driver_active(dev->handle, interface);
if (r == 1) {
/* libusb-1.0 doesn't expose driver name, so fill in a dummy value */
snprintf(name, namelen, "dummy");
return 0;
} else if (r == 0) {
return -(errno=ENODATA);
} else {
return compat_err(r);
}
}
API_EXPORTED int usb_control_msg(usb_dev_handle *dev, int bmRequestType,
int bRequest, int wValue, int wIndex, char *bytes, int size, int timeout)
{
int r;
usbi_dbg("RQT=%x RQ=%x V=%x I=%x len=%d timeout=%d", bmRequestType,
bRequest, wValue, wIndex, size, timeout);
r = libusb_control_transfer(dev->handle, bmRequestType & 0xff,
bRequest & 0xff, wValue & 0xffff, wIndex & 0xffff, bytes, size & 0xffff,
timeout);
if (r >= 0)
return r;
return compat_err(r);
}
static int usb_interrupt_io(usb_dev_handle *dev, int ep, char *bytes,
int size, int timeout)
{
int actual_length;
int r;
usbi_dbg("endpoint %x size %d timeout %d", ep, size, timeout);
r = libusb_interrupt_transfer(dev->handle, ep & 0xff, bytes, size,
&actual_length, timeout);
/* if we timed out but did transfer some data, report as successful short
* read. FIXME: is this how libusb-0.1 works? */
if (r == 0 || (r == LIBUSB_ERROR_TIMEOUT && actual_length > 0))
return actual_length;
return compat_err(r);
}
API_EXPORTED int usb_detach_kernel_driver_np(usb_dev_handle *dev, int interface)
{
int r = compat_err(libusb_detach_kernel_driver(dev->handle, interface));
switch (r) {
case LIBUSB_SUCCESS:
return 0;
case LIBUSB_ERROR_NOT_FOUND:
return -ENODATA;
case LIBUSB_ERROR_INVALID_PARAM:
return -EINVAL;
case LIBUSB_ERROR_NO_DEVICE:
return -ENODEV;
case LIBUSB_ERROR_OTHER:
return -errno;
/* default can be reached only in non-Linux implementations,
* mostly with LIBUSB_ERROR_NOT_SUPPORTED. */
default:
return -ENOSYS;
}
}
API_EXPORTED int usb_clear_halt(usb_dev_handle *dev, unsigned int ep)
{
usbi_dbg("endpoint %x", ep);
return compat_err(libusb_clear_halt(dev->handle, ep & 0xff));
}
static int find_busses(struct usb_bus **ret)
{
libusb_device **dev_list = NULL;
struct usb_bus *busses = NULL;
struct usb_bus *bus;
int dev_list_len = 0;
int i;
int r;
r = libusb_get_device_list(ctx, &dev_list);
if (r < 0) {
usbi_err("get_device_list failed with error %d", r);
return compat_err(r);
}
if (r == 0) {
libusb_free_device_list(dev_list, 1);
/* no buses */
return 0;
}
/* iterate over the device list, identifying the individual busses.
* we use the location field of the usb_bus structure to store the
* bus number. */
dev_list_len = r;
for (i = 0; i < dev_list_len; i++) {
libusb_device *dev = dev_list[i];
uint8_t bus_num = libusb_get_bus_number(dev);
/* if we already know about it, continue */
if (busses) {
bus = busses;
int found = 0;
do {
if (bus_num == bus->location) {
found = 1;
break;
}
} while ((bus = bus->next) != NULL);
if (found)
continue;
}
/* add it to the list of busses */
bus = malloc(sizeof(*bus));
if (!bus)
goto err;
memset(bus, 0, sizeof(*bus));
bus->location = bus_num;
sprintf(bus->dirname, "%03d", bus_num);
LIST_ADD(busses, bus);
}
libusb_free_device_list(dev_list, 1);
*ret = busses;
return 0;
err:
bus = busses;
while (bus) {
struct usb_bus *tbus = bus->next;
free(bus);
bus = tbus;
}
return -ENOMEM;
}
API_EXPORTED int usb_find_devices(void)
{
struct usb_bus *bus;
libusb_device **dev_list;
int dev_list_len;
int r;
int changes = 0;
/* libusb-1.0 initialization might have failed, but we can't indicate
* this with libusb-0.1, so trap that situation here */
if (!ctx)
return 0;
usbi_dbg("");
dev_list_len = libusb_get_device_list(ctx, &dev_list);
if (dev_list_len < 0)
return compat_err(dev_list_len);
for (bus = usb_busses; bus; bus = bus->next) {
struct usb_device *new_devices = NULL;
struct usb_device *dev;
r = find_devices(dev_list, dev_list_len, bus, &new_devices);
if (r < 0) {
libusb_free_device_list(dev_list, 1);
return r;
}
/* walk through the devices we already know about, removing duplicates
* from the new list. if we do not find it in the new list, the device
* has been removed. */
dev = bus->devices;
while (dev) {
int found = 0;
struct usb_device *tdev = dev->next;
struct usb_device *ndev = new_devices;
while (ndev) {
if (ndev->devnum == dev->devnum) {
LIST_DEL(new_devices, ndev);
free(ndev);
found = 1;
break;
}
ndev = ndev->next;
}
if (!found) {
usbi_dbg("device %d.%d removed",
dev->bus->location, dev->devnum);
LIST_DEL(bus->devices, dev);
free_device(dev);
changes++;
}
dev = tdev;
}
/* anything left in new_devices is a new device */
dev = new_devices;
while (dev) {
struct usb_device *tdev = dev->next;
r = initialize_device(dev);
if (r < 0) {
usbi_err("couldn't initialize device %d.%d (error %d)",
dev->bus->location, dev->devnum, r);
dev = tdev;
continue;
}
usbi_dbg("device %d.%d added", dev->bus->location, dev->devnum);
LIST_DEL(new_devices, dev);
LIST_ADD(bus->devices, dev);
changes++;
dev = tdev;
}
}
libusb_free_device_list(dev_list, 1);
return changes;
}
API_EXPORTED int usb_set_configuration(usb_dev_handle *dev, int configuration)
{
usbi_dbg("configuration %d", configuration);
return compat_err(libusb_set_configuration(dev->handle, configuration));
}
API_EXPORTED int usb_resetep(usb_dev_handle *dev, unsigned int ep)
{
return compat_err(usb_clear_halt(dev, ep));
}
API_EXPORTED int usb_reset(usb_dev_handle *dev)
{
usbi_dbg("");
return compat_err(libusb_reset_device(dev->handle));
}
