diff options
Diffstat (limited to 'lib/libusb/libusb10_desc.c')
| -rw-r--r-- | lib/libusb/libusb10_desc.c | 301 |
1 files changed, 301 insertions, 0 deletions
diff --git a/lib/libusb/libusb10_desc.c b/lib/libusb/libusb10_desc.c new file mode 100644 index 000000000000..a150f4d568be --- /dev/null +++ b/lib/libusb/libusb10_desc.c @@ -0,0 +1,301 @@ +/* $FreeBSD$ */ +/*- + * Copyright (c) 2009 Sylvestre Gallon. 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. + */ + +#include <sys/queue.h> +#include <stdlib.h> +#include <stdio.h> +#include <pthread.h> + +#include "libusb20.h" +#include "libusb20_desc.h" +#include "libusb20_int.h" +#include "libusb.h" +#include "libusb10.h" + +/* USB descriptors */ + +int +libusb_get_device_descriptor(libusb_device * dev, + struct libusb_device_descriptor *desc) +{ + struct LIBUSB20_DEVICE_DESC_DECODED *pdesc; + struct libusb20_device *pdev; + libusb_context *ctx; + + ctx = NULL; + GET_CONTEXT(ctx); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_descriptor enter"); + + if ((dev == NULL) || (desc == NULL)) + return (LIBUSB_ERROR_INVALID_PARAM); + + pdev = dev->os_priv; + pdesc = libusb20_dev_get_device_desc(pdev); + + desc->bLength = pdesc->bLength; + desc->bDescriptorType = pdesc->bDescriptorType; + desc->bcdUSB = pdesc->bcdUSB; + desc->bDeviceClass = pdesc->bDeviceClass; + desc->bDeviceSubClass = pdesc->bDeviceSubClass; + desc->bDeviceProtocol = pdesc->bDeviceProtocol; + desc->bMaxPacketSize0 = pdesc->bMaxPacketSize0; + desc->idVendor = pdesc->idVendor; + desc->idProduct = pdesc->idProduct; + desc->bcdDevice = pdesc->bcdDevice; + desc->iManufacturer = pdesc->iManufacturer; + desc->iProduct = pdesc->iProduct; + desc->iSerialNumber = pdesc->iSerialNumber; + desc->bNumConfigurations = pdesc->bNumConfigurations; + + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_descriptor leave"); + return (0); +} + +int +libusb_get_active_config_descriptor(libusb_device * dev, + struct libusb_config_descriptor **config) +{ + struct libusb20_device *pdev; + libusb_context *ctx; + uint8_t idx; + + ctx = NULL; + GET_CONTEXT(ctx); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_active_config_descriptor enter"); + + pdev = dev->os_priv; + idx = libusb20_dev_get_config_index(pdev); + + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_active_config_descriptor leave"); + return (libusb_get_config_descriptor(dev, idx, config)); +} + +/* + * XXX Need to check if extra need a dup because + * XXX free pconf could free this char * + */ +int +libusb_get_config_descriptor(libusb_device * dev, uint8_t config_index, + struct libusb_config_descriptor **config) +{ + struct libusb20_device *pdev; + struct libusb20_config *pconf; + struct libusb20_interface *pinf; + struct libusb20_endpoint *pend; + libusb_interface_descriptor *ifd; + libusb_endpoint_descriptor *endd; + libusb_context *ctx; + uint8_t nif, nend, nalt, i, j, k; + uint32_t if_idx, endp_idx; + + ctx = NULL; + GET_CONTEXT(ctx); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor enter"); + + if (dev == NULL || config == NULL) + return (LIBUSB_ERROR_INVALID_PARAM); + + pdev = dev->os_priv; + pconf = libusb20_dev_alloc_config(pdev, config_index); + + if (pconf == NULL) + return (LIBUSB_ERROR_NOT_FOUND); + + nalt = nif = pconf->num_interface; + nend = 0; + for (i = 0 ; i < nif ; i++) { + if (pconf->interface[i].num_altsetting > 0) + { + nalt += pconf->interface[i].num_altsetting; + for (j = 0 ; j < nalt ; j++) { + nend += pconf->interface[i].altsetting[j].num_endpoints; + } + } + nend += pconf->interface[i].num_endpoints; + } + + *config = malloc(sizeof(libusb_config_descriptor) + + (nif * sizeof(libusb_interface)) + + (nalt * sizeof(libusb_interface_descriptor)) + + (nend * sizeof(libusb_endpoint_descriptor))); + if (*config == NULL) { + free(pconf); + return (LIBUSB_ERROR_NO_MEM); + } + + (*config)->interface = (libusb_interface *)(*config + + sizeof(libusb_config_descriptor)); + for (i = if_idx = endp_idx = 0 ; i < nif ; if_idx, i++) { + (*config)->interface[i].altsetting = (libusb_interface_descriptor *) + (*config + sizeof(libusb_config_descriptor) + + (nif * sizeof(libusb_interface)) + + (if_idx * sizeof(libusb_interface_descriptor))); + (*config)->interface[i].altsetting[0].endpoint = + (libusb_endpoint_descriptor *) (*config + + sizeof(libusb_config_descriptor) + + (nif * sizeof(libusb_interface)) + + (nalt * sizeof(libusb_interface_descriptor)) + + (endp_idx * sizeof(libusb_endpoint_descriptor))); + endp_idx += pconf->interface[i].num_endpoints; + + if (pconf->interface[i].num_altsetting > 0) + { + for (j = 0 ; j < pconf->interface[i].num_altsetting ; j++, if_idx++) { + (*config)->interface[i].altsetting[j + 1].endpoint = + (libusb_endpoint_descriptor *) (*config + + sizeof(libusb_config_descriptor) + + (nif * sizeof(libusb_interface)) + + (nalt * sizeof(libusb_interface_descriptor)) + + (endp_idx * sizeof(libusb_endpoint_descriptor))); + endp_idx += pconf->interface[i].altsetting[j].num_endpoints; + } + } + } + + (*config)->bLength = pconf->desc.bLength; + (*config)->bDescriptorType = pconf->desc.bDescriptorType; + (*config)->wTotalLength = pconf->desc.wTotalLength; + (*config)->bNumInterfaces = pconf->desc.bNumInterfaces; + (*config)->bConfigurationValue = pconf->desc.bConfigurationValue; + (*config)->iConfiguration = pconf->desc.iConfiguration; + (*config)->bmAttributes = pconf->desc.bmAttributes; + (*config)->MaxPower = pconf->desc.bMaxPower; + (*config)->extra_length = pconf->extra.len; + if ((*config)->extra_length != 0) + (*config)->extra = pconf->extra.ptr; + + for (i = 0 ; i < nif ; i++) { + pinf = &pconf->interface[i]; + (*config)->interface[i].num_altsetting = pinf->num_altsetting + 1; + for (j = 0 ; j < (*config)->interface[i].num_altsetting ; j++) { + if (j != 0) + pinf = &pconf->interface[i].altsetting[j - 1]; + ifd = &(*config)->interface[i].altsetting[j]; + ifd->bLength = pinf->desc.bLength; + ifd->bDescriptorType = pinf->desc.bDescriptorType; + ifd->bInterfaceNumber = pinf->desc.bInterfaceNumber; + ifd->bAlternateSetting = pinf->desc.bAlternateSetting; + ifd->bNumEndpoints = pinf->desc.bNumEndpoints; + ifd->bInterfaceClass = pinf->desc.bInterfaceClass; + ifd->bInterfaceSubClass = pinf->desc.bInterfaceSubClass; + ifd->bInterfaceProtocol = pinf->desc.bInterfaceProtocol; + ifd->iInterface = pinf->desc.iInterface; + ifd->extra_length = pinf->extra.len; + if (ifd->extra_length != 0) + ifd->extra = pinf->extra.ptr; + for (k = 0 ; k < pinf->num_endpoints ; k++) { + pend = &pinf->endpoints[k]; + endd = &ifd->endpoint[k]; + endd->bLength = pend->desc.bLength; + endd->bDescriptorType = pend->desc.bDescriptorType; + endd->bEndpointAddress = pend->desc.bEndpointAddress; + endd->bmAttributes = pend->desc.bmAttributes; + endd->wMaxPacketSize = pend->desc.wMaxPacketSize; + endd->bInterval = pend->desc.bInterval; + endd->bRefresh = pend->desc.bRefresh; + endd->bSynchAddress = pend->desc.bSynchAddress; + endd->extra_length = pend->extra.len; + if (endd->extra_length != 0) + endd->extra = pend->extra.ptr; + } + } + } + + free(pconf); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor leave"); + return (0); +} + +int +libusb_get_config_descriptor_by_value(libusb_device * dev, + uint8_t bConfigurationValue, struct libusb_config_descriptor **config) +{ + struct LIBUSB20_DEVICE_DESC_DECODED *pdesc; + struct libusb20_device *pdev; + struct libusb20_config *pconf; + libusb_context *ctx; + int i; + + ctx = NULL; + GET_CONTEXT(ctx); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor_by_value enter"); + + if (dev == NULL || config == NULL) + return (LIBUSB_ERROR_INVALID_PARAM); + + pdev = dev->os_priv; + pdesc = libusb20_dev_get_device_desc(pdev); + + for (i = 0 ; i < pdesc->bNumConfigurations ; i++) { + pconf = libusb20_dev_alloc_config(pdev, i); + if (pconf->desc.bConfigurationValue == bConfigurationValue) { + free(pconf); + return libusb_get_config_descriptor(dev, i, config); + + } + free(pconf); + } + + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor_by_value leave"); + return (LIBUSB_ERROR_NOT_FOUND); +} + +void +libusb_free_config_descriptor(struct libusb_config_descriptor *config) +{ + libusb_context *ctx; + + ctx = NULL; + GET_CONTEXT(ctx); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_config_descriptor enter"); + + free(config); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_config_descriptor leave"); +} + +int +libusb_get_string_descriptor_ascii(libusb_device_handle * dev, + uint8_t desc_index, unsigned char *data, int length) +{ + struct libusb20_device *pdev; + libusb_context *ctx; + int ret; + + ctx = NULL; + GET_CONTEXT(ctx); + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_string_descriptor_ascii enter"); + + if (dev == NULL || data == NULL) + return (LIBUSB20_ERROR_INVALID_PARAM); + + pdev = dev->os_priv; + dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_string_descriptor_ascii leave"); + if (libusb20_dev_req_string_simple_sync(pdev, desc_index, + data, length) == 0) + return (strlen(data)); + + return (LIBUSB_ERROR_OTHER); +} |