2009-06-23 01:04:58 +00:00
|
|
|
/* $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.
|
|
|
|
*/
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
#include <sys/queue.h>
|
2009-06-23 01:04:58 +00:00
|
|
|
|
2010-02-13 09:45:50 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
2009-06-23 01:04:58 +00:00
|
|
|
#include "libusb20.h"
|
|
|
|
#include "libusb20_desc.h"
|
|
|
|
#include "libusb20_int.h"
|
|
|
|
#include "libusb.h"
|
|
|
|
#include "libusb10.h"
|
|
|
|
|
2009-11-08 20:03:52 +00:00
|
|
|
#define N_ALIGN(n) (-((-(n)) & (-8UL)))
|
|
|
|
|
2009-06-23 01:04:58 +00:00
|
|
|
/* USB descriptors */
|
|
|
|
|
|
|
|
int
|
2009-07-30 00:11:41 +00:00
|
|
|
libusb_get_device_descriptor(libusb_device *dev,
|
2009-06-23 01:04:58 +00:00
|
|
|
struct libusb_device_descriptor *desc)
|
|
|
|
{
|
|
|
|
struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
|
|
|
|
struct libusb20_device *pdev;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-07-30 00:11:41 +00:00
|
|
|
libusb_get_active_config_descriptor(libusb_device *dev,
|
2009-06-23 01:04:58 +00:00
|
|
|
struct libusb_config_descriptor **config)
|
|
|
|
{
|
|
|
|
struct libusb20_device *pdev;
|
2009-07-30 00:11:41 +00:00
|
|
|
uint8_t config_index;
|
2009-06-23 01:04:58 +00:00
|
|
|
|
|
|
|
pdev = dev->os_priv;
|
2009-07-30 00:11:41 +00:00
|
|
|
config_index = libusb20_dev_get_config_index(pdev);
|
2009-06-23 01:04:58 +00:00
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
return (libusb_get_config_descriptor(dev, config_index, config));
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-07-30 00:11:41 +00:00
|
|
|
libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index,
|
2009-06-23 01:04:58 +00:00
|
|
|
struct libusb_config_descriptor **config)
|
|
|
|
{
|
|
|
|
struct libusb20_device *pdev;
|
|
|
|
struct libusb20_config *pconf;
|
|
|
|
struct libusb20_interface *pinf;
|
|
|
|
struct libusb20_endpoint *pend;
|
2009-07-30 00:11:41 +00:00
|
|
|
struct libusb_config_descriptor *pconfd;
|
|
|
|
struct libusb_interface_descriptor *ifd;
|
|
|
|
struct libusb_endpoint_descriptor *endd;
|
|
|
|
uint8_t *pextra;
|
|
|
|
uint16_t nextra;
|
|
|
|
uint8_t nif;
|
|
|
|
uint8_t nep;
|
|
|
|
uint8_t nalt;
|
|
|
|
uint8_t i;
|
|
|
|
uint8_t j;
|
|
|
|
uint8_t k;
|
2009-06-23 01:04:58 +00:00
|
|
|
|
|
|
|
if (dev == NULL || config == NULL)
|
|
|
|
return (LIBUSB_ERROR_INVALID_PARAM);
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
*config = NULL;
|
|
|
|
|
2009-06-23 01:04:58 +00:00
|
|
|
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;
|
2009-07-30 00:11:41 +00:00
|
|
|
nep = 0;
|
2009-11-08 20:03:52 +00:00
|
|
|
nextra = N_ALIGN(pconf->extra.len);
|
2009-07-30 00:11:41 +00:00
|
|
|
|
|
|
|
for (i = 0; i < nif; i++) {
|
|
|
|
|
|
|
|
pinf = pconf->interface + i;
|
2009-11-08 20:03:52 +00:00
|
|
|
nextra += N_ALIGN(pinf->extra.len);
|
2009-07-30 00:11:41 +00:00
|
|
|
nep += pinf->num_endpoints;
|
|
|
|
k = pinf->num_endpoints;
|
|
|
|
pend = pinf->endpoints;
|
|
|
|
while (k--) {
|
2009-11-08 20:03:52 +00:00
|
|
|
nextra += N_ALIGN(pend->extra.len);
|
2009-07-30 00:11:41 +00:00
|
|
|
pend++;
|
|
|
|
}
|
|
|
|
|
|
|
|
j = pinf->num_altsetting;
|
|
|
|
nalt += pinf->num_altsetting;
|
|
|
|
pinf = pinf->altsetting;
|
|
|
|
while (j--) {
|
2009-11-08 20:03:52 +00:00
|
|
|
nextra += N_ALIGN(pinf->extra.len);
|
2009-07-30 00:11:41 +00:00
|
|
|
nep += pinf->num_endpoints;
|
|
|
|
k = pinf->num_endpoints;
|
|
|
|
pend = pinf->endpoints;
|
|
|
|
while (k--) {
|
2009-11-08 20:03:52 +00:00
|
|
|
nextra += N_ALIGN(pend->extra.len);
|
2009-07-30 00:11:41 +00:00
|
|
|
pend++;
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
2009-07-30 00:11:41 +00:00
|
|
|
pinf++;
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
nextra = nextra +
|
|
|
|
(1 * sizeof(libusb_config_descriptor)) +
|
2009-06-23 01:04:58 +00:00
|
|
|
(nif * sizeof(libusb_interface)) +
|
|
|
|
(nalt * sizeof(libusb_interface_descriptor)) +
|
2009-07-30 00:11:41 +00:00
|
|
|
(nep * sizeof(libusb_endpoint_descriptor));
|
|
|
|
|
2009-11-08 20:03:52 +00:00
|
|
|
nextra = N_ALIGN(nextra);
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
pconfd = malloc(nextra);
|
|
|
|
|
|
|
|
if (pconfd == NULL) {
|
2009-06-23 01:04:58 +00:00
|
|
|
free(pconf);
|
|
|
|
return (LIBUSB_ERROR_NO_MEM);
|
|
|
|
}
|
2009-11-08 20:03:52 +00:00
|
|
|
/* make sure memory is initialised */
|
2009-07-30 00:11:41 +00:00
|
|
|
memset(pconfd, 0, nextra);
|
2009-06-23 01:04:58 +00:00
|
|
|
|
2009-11-08 20:03:52 +00:00
|
|
|
pconfd->interface = (libusb_interface *) (pconfd + 1);
|
2009-07-30 00:11:41 +00:00
|
|
|
|
|
|
|
ifd = (libusb_interface_descriptor *) (pconfd->interface + nif);
|
|
|
|
endd = (libusb_endpoint_descriptor *) (ifd + nalt);
|
|
|
|
pextra = (uint8_t *)(endd + nep);
|
|
|
|
|
|
|
|
/* fill in config descriptor */
|
|
|
|
|
|
|
|
pconfd->bLength = pconf->desc.bLength;
|
|
|
|
pconfd->bDescriptorType = pconf->desc.bDescriptorType;
|
|
|
|
pconfd->wTotalLength = pconf->desc.wTotalLength;
|
|
|
|
pconfd->bNumInterfaces = pconf->desc.bNumInterfaces;
|
|
|
|
pconfd->bConfigurationValue = pconf->desc.bConfigurationValue;
|
|
|
|
pconfd->iConfiguration = pconf->desc.iConfiguration;
|
|
|
|
pconfd->bmAttributes = pconf->desc.bmAttributes;
|
|
|
|
pconfd->MaxPower = pconf->desc.bMaxPower;
|
|
|
|
|
|
|
|
if (pconf->extra.len != 0) {
|
|
|
|
pconfd->extra_length = pconf->extra.len;
|
|
|
|
pconfd->extra = pextra;
|
|
|
|
memcpy(pextra, pconf->extra.ptr, pconfd->extra_length);
|
2009-11-08 20:03:52 +00:00
|
|
|
pextra += N_ALIGN(pconfd->extra_length);
|
2009-07-30 00:11:41 +00:00
|
|
|
}
|
|
|
|
/* setup all interface and endpoint pointers */
|
|
|
|
|
|
|
|
for (i = 0; i < nif; i++) {
|
|
|
|
|
|
|
|
pconfd->interface[i].altsetting = ifd;
|
|
|
|
ifd->endpoint = endd;
|
|
|
|
endd += pconf->interface[i].num_endpoints;
|
|
|
|
ifd++;
|
|
|
|
|
|
|
|
for (j = 0; j < pconf->interface[i].num_altsetting; j++) {
|
|
|
|
ifd->endpoint = endd;
|
|
|
|
endd += pconf->interface[i].altsetting[j].num_endpoints;
|
|
|
|
ifd++;
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
/* fill in all interface and endpoint data */
|
|
|
|
|
|
|
|
for (i = 0; i < nif; i++) {
|
2009-06-23 01:04:58 +00:00
|
|
|
pinf = &pconf->interface[i];
|
2009-07-30 00:11:41 +00:00
|
|
|
pconfd->interface[i].num_altsetting = pinf->num_altsetting + 1;
|
|
|
|
for (j = 0; j < pconfd->interface[i].num_altsetting; j++) {
|
2009-06-23 01:04:58 +00:00
|
|
|
if (j != 0)
|
|
|
|
pinf = &pconf->interface[i].altsetting[j - 1];
|
2009-07-30 00:11:41 +00:00
|
|
|
ifd = &pconfd->interface[i].altsetting[j];
|
2009-06-23 01:04:58 +00:00
|
|
|
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;
|
2009-07-30 00:11:41 +00:00
|
|
|
if (pinf->extra.len != 0) {
|
|
|
|
ifd->extra_length = pinf->extra.len;
|
|
|
|
ifd->extra = pextra;
|
|
|
|
memcpy(pextra, pinf->extra.ptr, pinf->extra.len);
|
2009-11-08 20:03:52 +00:00
|
|
|
pextra += N_ALIGN(pinf->extra.len);
|
2009-07-30 00:11:41 +00:00
|
|
|
}
|
|
|
|
for (k = 0; k < pinf->num_endpoints; k++) {
|
2009-06-23 01:04:58 +00:00
|
|
|
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;
|
2009-07-30 00:11:41 +00:00
|
|
|
if (pend->extra.len != 0) {
|
|
|
|
endd->extra_length = pend->extra.len;
|
|
|
|
endd->extra = pextra;
|
|
|
|
memcpy(pextra, pend->extra.ptr, pend->extra.len);
|
2009-11-08 20:03:52 +00:00
|
|
|
pextra += N_ALIGN(pend->extra.len);
|
2009-07-30 00:11:41 +00:00
|
|
|
}
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
2009-07-30 00:11:41 +00:00
|
|
|
}
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
free(pconf);
|
2009-07-30 00:11:41 +00:00
|
|
|
|
|
|
|
*config = pconfd;
|
|
|
|
|
|
|
|
return (0); /* success */
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-07-30 00:11:41 +00:00
|
|
|
libusb_get_config_descriptor_by_value(libusb_device *dev,
|
2009-06-23 01:04:58 +00:00
|
|
|
uint8_t bConfigurationValue, struct libusb_config_descriptor **config)
|
|
|
|
{
|
|
|
|
struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
|
|
|
|
struct libusb20_device *pdev;
|
|
|
|
int i;
|
2009-07-30 00:11:41 +00:00
|
|
|
int err;
|
2009-06-23 01:04:58 +00:00
|
|
|
|
|
|
|
if (dev == NULL || config == NULL)
|
|
|
|
return (LIBUSB_ERROR_INVALID_PARAM);
|
2009-07-30 00:11:41 +00:00
|
|
|
|
2009-06-23 01:04:58 +00:00
|
|
|
pdev = dev->os_priv;
|
|
|
|
pdesc = libusb20_dev_get_device_desc(pdev);
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
for (i = 0; i < pdesc->bNumConfigurations; i++) {
|
|
|
|
err = libusb_get_config_descriptor(dev, i, config);
|
|
|
|
if (err)
|
|
|
|
return (err);
|
2009-06-23 01:04:58 +00:00
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
if ((*config)->bConfigurationValue == bConfigurationValue)
|
|
|
|
return (0); /* success */
|
|
|
|
|
|
|
|
libusb_free_config_descriptor(*config);
|
2009-06-23 01:04:58 +00:00
|
|
|
}
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
*config = NULL;
|
|
|
|
|
2009-06-23 01:04:58 +00:00
|
|
|
return (LIBUSB_ERROR_NOT_FOUND);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
libusb_free_config_descriptor(struct libusb_config_descriptor *config)
|
|
|
|
{
|
|
|
|
free(config);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-07-30 00:11:41 +00:00
|
|
|
libusb_get_string_descriptor_ascii(libusb_device_handle *pdev,
|
2009-06-23 01:04:58 +00:00
|
|
|
uint8_t desc_index, unsigned char *data, int length)
|
|
|
|
{
|
2009-07-30 00:11:41 +00:00
|
|
|
if (pdev == NULL || data == NULL || length < 1)
|
2009-06-23 01:04:58 +00:00
|
|
|
return (LIBUSB20_ERROR_INVALID_PARAM);
|
|
|
|
|
2009-07-30 00:11:41 +00:00
|
|
|
/* put some default data into the destination buffer */
|
|
|
|
data[0] = 0;
|
|
|
|
|
|
|
|
if (libusb20_dev_req_string_simple_sync(pdev, desc_index,
|
2009-06-23 01:04:58 +00:00
|
|
|
data, length) == 0)
|
|
|
|
return (strlen(data));
|
|
|
|
|
|
|
|
return (LIBUSB_ERROR_OTHER);
|
|
|
|
}
|
2009-11-08 20:03:52 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
libusb_get_descriptor(libusb_device_handle * devh, uint8_t desc_type,
|
|
|
|
uint8_t desc_index, uint8_t *data, int length)
|
|
|
|
{
|
|
|
|
return (libusb_control_transfer(devh, LIBUSB_ENDPOINT_IN,
|
|
|
|
LIBUSB_REQUEST_GET_DESCRIPTOR, (desc_type << 8) | desc_index, 0, data,
|
|
|
|
length, 1000));
|
|
|
|
}
|