From 7549fd80dceb76179c8bba85df341a74e670d373 Mon Sep 17 00:00:00 2001 From: hselasky Date: Fri, 24 Jun 2011 11:14:09 +0000 Subject: - Add two new API's to libusb20 which can be used to retrive information about the parent USB device: - libusb20_dev_get_parent_address - libusb20_dev_get_parent_port - Rename libusb20_compat01.c into libusb01.c MFC after: 3 days --- lib/libusb/Makefile | 4 +- lib/libusb/libusb01.c | 945 +++++++++++++++++++++++++++++++++++++++++ lib/libusb/libusb20.3 | 23 + lib/libusb/libusb20.c | 12 + lib/libusb/libusb20.h | 2 + lib/libusb/libusb20_compat01.c | 945 ----------------------------------------- lib/libusb/libusb20_int.h | 2 + lib/libusb/libusb20_ugen20.c | 5 + 8 files changed, 992 insertions(+), 946 deletions(-) create mode 100644 lib/libusb/libusb01.c delete mode 100644 lib/libusb/libusb20_compat01.c (limited to 'lib/libusb') diff --git a/lib/libusb/Makefile b/lib/libusb/Makefile index debbfa2..f438cff 100644 --- a/lib/libusb/Makefile +++ b/lib/libusb/Makefile @@ -22,7 +22,7 @@ MLINKS+= libusb.3 usb.3 # libusb 0.1 compat INCS+= usb.h -SRCS+= libusb20_compat01.c +SRCS+= libusb01.c # libusb 1.0 compat INCS+= libusb.h @@ -184,6 +184,8 @@ MLINKS += libusb20.3 libusb20_dev_get_device_desc.3 MLINKS += libusb20.3 libusb20_dev_alloc_config.3 MLINKS += libusb20.3 libusb20_dev_alloc.3 MLINKS += libusb20.3 libusb20_dev_get_address.3 +MLINKS += libusb20.3 libusb20_dev_get_parent_address.3 +MLINKS += libusb20.3 libusb20_dev_get_parent_port.3 MLINKS += libusb20.3 libusb20_dev_get_bus_number.3 MLINKS += libusb20.3 libusb20_dev_get_mode.3 MLINKS += libusb20.3 libusb20_dev_get_speed.3 diff --git a/lib/libusb/libusb01.c b/lib/libusb/libusb01.c new file mode 100644 index 0000000..4124ef6 --- /dev/null +++ b/lib/libusb/libusb01.c @@ -0,0 +1,945 @@ +/* $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 + +#include +#include +#include + +#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); + if (ptr == NULL) { + /* free config structure */ + free(ps.a.currcfg); + return (-1); + } + + /* "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); +} diff --git a/lib/libusb/libusb20.3 b/lib/libusb/libusb20.3 index 93dfe18..042f885 100644 --- a/lib/libusb/libusb20.3 +++ b/lib/libusb/libusb20.3 @@ -159,6 +159,10 @@ USB access library (libusb -lusb) .Ft uint8_t .Fn libusb20_dev_get_address "struct libusb20_device *pdev" .Ft uint8_t +.Fn libusb20_dev_get_parent_address "struct libusb20_device *pdev" +.Ft uint8_t +.Fn libusb20_dev_get_parent_port "struct libusb20_device *pdev" +.Ft uint8_t .Fn libusb20_dev_get_bus_number "struct libusb20_device *pdev" .Ft uint8_t .Fn libusb20_dev_get_mode "struct libusb20_device *pdev" @@ -756,12 +760,31 @@ is an internal function to allocate a new USB device. .Fn libusb20_dev_get_address returns the internal and not necessarily the real hardware address of the given USB device. +Valid addresses start at one. +. +.Pp +. +.Fn libusb20_dev_get_parent_address +returns the internal and not necessarily the real hardware address of +the given parent USB HUB device. +This value is zero for the root HUB which usually has a device address +equal to one. +Valid addresses start at one. +. +.Pp +. +.Fn libusb20_dev_get_parent_port +returns the port number on the parent USB HUB device. +This value is zero for the root HUB which usually has a device address +equal to one. +Valid port numbers start at one. . .Pp . .Fn libusb20_dev_get_bus_number returns the internal bus number which the given USB device belongs to. +Valid bus numbers start at zero. . .Pp . diff --git a/lib/libusb/libusb20.c b/lib/libusb/libusb20.c index bcaa1e4..716f540 100644 --- a/lib/libusb/libusb20.c +++ b/lib/libusb/libusb20.c @@ -1057,6 +1057,18 @@ libusb20_dev_get_address(struct libusb20_device *pdev) } uint8_t +libusb20_dev_get_parent_address(struct libusb20_device *pdev) +{ + return (pdev->parent_address); +} + +uint8_t +libusb20_dev_get_parent_port(struct libusb20_device *pdev) +{ + return (pdev->parent_port); +} + +uint8_t libusb20_dev_get_bus_number(struct libusb20_device *pdev) { return (pdev->bus_number); diff --git a/lib/libusb/libusb20.h b/lib/libusb/libusb20.h index 958a379..22a2899 100644 --- a/lib/libusb/libusb20.h +++ b/lib/libusb/libusb20.h @@ -262,6 +262,8 @@ struct LIBUSB20_DEVICE_DESC_DECODED *libusb20_dev_get_device_desc(struct libusb2 struct libusb20_config *libusb20_dev_alloc_config(struct libusb20_device *pdev, uint8_t config_index); struct libusb20_device *libusb20_dev_alloc(void); uint8_t libusb20_dev_get_address(struct libusb20_device *pdev); +uint8_t libusb20_dev_get_parent_address(struct libusb20_device *pdev); +uint8_t libusb20_dev_get_parent_port(struct libusb20_device *pdev); uint8_t libusb20_dev_get_bus_number(struct libusb20_device *pdev); uint8_t libusb20_dev_get_mode(struct libusb20_device *pdev); uint8_t libusb20_dev_get_speed(struct libusb20_device *pdev); diff --git a/lib/libusb/libusb20_compat01.c b/lib/libusb/libusb20_compat01.c deleted file mode 100644 index 4124ef6..0000000 --- a/lib/libusb/libusb20_compat01.c +++ /dev/null @@ -1,945 +0,0 @@ -/* $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 - -#include -#include -#include - -#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); - if (ptr == NULL) { - /* free config structure */ - free(ps.a.currcfg); - return (-1); - } - - /* "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); -} diff --git a/lib/libusb/libusb20_int.h b/lib/libusb/libusb20_int.h index 2ecfb47..bef4d02 100644 --- a/lib/libusb/libusb20_int.h +++ b/lib/libusb/libusb20_int.h @@ -226,6 +226,8 @@ struct libusb20_device { uint8_t usb_mode; uint8_t usb_speed; uint8_t is_opened; + uint8_t parent_address; + uint8_t parent_port; char usb_desc[96]; }; diff --git a/lib/libusb/libusb20_ugen20.c b/lib/libusb/libusb20_ugen20.c index 933d728..307ed96 100644 --- a/lib/libusb/libusb20_ugen20.c +++ b/lib/libusb/libusb20_ugen20.c @@ -195,6 +195,11 @@ ugen20_enumerate(struct libusb20_device *pdev, const char *id) break; } + /* get parent HUB index and port */ + + pdev->parent_address = devinfo.udi_hubindex; + pdev->parent_port = devinfo.udi_hubport; + /* generate a nice description for printout */ snprintf(pdev->usb_desc, sizeof(pdev->usb_desc), -- cgit v1.1