lib/libusb/libusb10_desc.c

   1 /* $FreeBSD$ */
   2 /*-
   3  * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <pthread.h>
  30 #include <sys/queue.h>
  31
  32 #include "libusb20.h"
  33 #include "libusb20_desc.h"
  34 #include "libusb20_int.h"
  35 #include "libusb.h"
  36 #include "libusb10.h"
  37
  38 #define N_ALIGN(n) (-((-(n)) & (-8UL)))
  39
  40 /* USB descriptors */
  41
  42 int
  43 libusb_get_device_descriptor(libusb_device *dev,
  44     struct libusb_device_descriptor *desc)
  45 {
  46         struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
  47         struct libusb20_device *pdev;
  48
  49         if ((dev == NULL) || (desc == NULL))
  50                 return (LIBUSB_ERROR_INVALID_PARAM);
  51
  52         pdev = dev->os_priv;
  53         pdesc = libusb20_dev_get_device_desc(pdev);
  54
  55         desc->bLength = pdesc->bLength;
  56         desc->bDescriptorType = pdesc->bDescriptorType;
  57         desc->bcdUSB = pdesc->bcdUSB;
  58         desc->bDeviceClass = pdesc->bDeviceClass;
  59         desc->bDeviceSubClass = pdesc->bDeviceSubClass;
  60         desc->bDeviceProtocol = pdesc->bDeviceProtocol;
  61         desc->bMaxPacketSize0 = pdesc->bMaxPacketSize0;
  62         desc->idVendor = pdesc->idVendor;
  63         desc->idProduct = pdesc->idProduct;
  64         desc->bcdDevice = pdesc->bcdDevice;
  65         desc->iManufacturer = pdesc->iManufacturer;
  66         desc->iProduct = pdesc->iProduct;
  67         desc->iSerialNumber = pdesc->iSerialNumber;
  68         desc->bNumConfigurations = pdesc->bNumConfigurations;
  69
  70         return (0);
  71 }
  72
  73 int
  74 libusb_get_active_config_descriptor(libusb_device *dev,
  75     struct libusb_config_descriptor **config)
  76 {
  77         struct libusb20_device *pdev;
  78         uint8_t config_index;
  79
  80         pdev = dev->os_priv;
  81         config_index = libusb20_dev_get_config_index(pdev);
  82
  83         return (libusb_get_config_descriptor(dev, config_index, config));
  84 }
  85
  86 int
  87 libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index,
  88     struct libusb_config_descriptor **config)
  89 {
  90         struct libusb20_device *pdev;
  91         struct libusb20_config *pconf;
  92         struct libusb20_interface *pinf;
  93         struct libusb20_endpoint *pend;
  94         struct libusb_config_descriptor *pconfd;
  95         struct libusb_interface_descriptor *ifd;
  96         struct libusb_endpoint_descriptor *endd;
  97         uint8_t *pextra;
  98         uint16_t nextra;
  99         uint8_t nif;
 100         uint8_t nep;
 101         uint8_t nalt;
 102         uint8_t i;
 103         uint8_t j;
 104         uint8_t k;
 105
 106         if (dev == NULL || config == NULL)
 107                 return (LIBUSB_ERROR_INVALID_PARAM);
 108
 109         *config = NULL;
 110
 111         pdev = dev->os_priv;
 112         pconf = libusb20_dev_alloc_config(pdev, config_index);
 113
 114         if (pconf == NULL)
 115                 return (LIBUSB_ERROR_NOT_FOUND);
 116
 117         nalt = nif = pconf->num_interface;
 118         nep = 0;
 119         nextra = N_ALIGN(pconf->extra.len);
 120
 121         for (i = 0; i < nif; i++) {
 122
 123                 pinf = pconf->interface + i;
 124                 nextra += N_ALIGN(pinf->extra.len);
 125                 nep += pinf->num_endpoints;
 126                 k = pinf->num_endpoints;
 127                 pend = pinf->endpoints;
 128                 while (k--) {
 129                         nextra += N_ALIGN(pend->extra.len);
 130                         pend++;
 131                 }
 132
 133                 j = pinf->num_altsetting;
 134                 nalt += pinf->num_altsetting;
 135                 pinf = pinf->altsetting;
 136                 while (j--) {
 137                         nextra += N_ALIGN(pinf->extra.len);
 138                         nep += pinf->num_endpoints;
 139                         k = pinf->num_endpoints;
 140                         pend = pinf->endpoints;
 141                         while (k--) {
 142                                 nextra += N_ALIGN(pend->extra.len);
 143                                 pend++;
 144                         }
 145                         pinf++;
 146                 }
 147         }
 148
 149         nextra = nextra +
 150             (1 * sizeof(libusb_config_descriptor)) +
 151             (nif * sizeof(libusb_interface)) +
 152             (nalt * sizeof(libusb_interface_descriptor)) +
 153             (nep * sizeof(libusb_endpoint_descriptor));
 154
 155         nextra = N_ALIGN(nextra);
 156
 157         pconfd = malloc(nextra);
 158
 159         if (pconfd == NULL) {
 160                 free(pconf);
 161                 return (LIBUSB_ERROR_NO_MEM);
 162         }
 163         /* make sure memory is initialised */
 164         memset(pconfd, 0, nextra);
 165
 166         pconfd->interface = (libusb_interface *) (pconfd + 1);
 167
 168         ifd = (libusb_interface_descriptor *) (pconfd->interface + nif);
 169         endd = (libusb_endpoint_descriptor *) (ifd + nalt);
 170         pextra = (uint8_t *)(endd + nep);
 171
 172         /* fill in config descriptor */
 173
 174         pconfd->bLength = pconf->desc.bLength;
 175         pconfd->bDescriptorType = pconf->desc.bDescriptorType;
 176         pconfd->wTotalLength = pconf->desc.wTotalLength;
 177         pconfd->bNumInterfaces = pconf->desc.bNumInterfaces;
 178         pconfd->bConfigurationValue = pconf->desc.bConfigurationValue;
 179         pconfd->iConfiguration = pconf->desc.iConfiguration;
 180         pconfd->bmAttributes = pconf->desc.bmAttributes;
 181         pconfd->MaxPower = pconf->desc.bMaxPower;
 182
 183         if (pconf->extra.len != 0) {
 184                 pconfd->extra_length = pconf->extra.len;
 185                 pconfd->extra = pextra;
 186                 memcpy(pextra, pconf->extra.ptr, pconfd->extra_length);
 187                 pextra += N_ALIGN(pconfd->extra_length);
 188         }
 189         /* setup all interface and endpoint pointers */
 190
 191         for (i = 0; i < nif; i++) {
 192
 193                 pconfd->interface[i].altsetting = ifd;
 194                 ifd->endpoint = endd;
 195                 endd += pconf->interface[i].num_endpoints;
 196                 ifd++;
 197
 198                 for (j = 0; j < pconf->interface[i].num_altsetting; j++) {
 199                         ifd->endpoint = endd;
 200                         endd += pconf->interface[i].altsetting[j].num_endpoints;
 201                         ifd++;
 202                 }
 203         }
 204
 205         /* fill in all interface and endpoint data */
 206
 207         for (i = 0; i < nif; i++) {
 208                 pinf = &pconf->interface[i];
 209                 pconfd->interface[i].num_altsetting = pinf->num_altsetting + 1;
 210                 for (j = 0; j < pconfd->interface[i].num_altsetting; j++) {
 211                         if (j != 0)
 212                                 pinf = &pconf->interface[i].altsetting[j - 1];
 213                         ifd = &pconfd->interface[i].altsetting[j];
 214                         ifd->bLength = pinf->desc.bLength;
 215                         ifd->bDescriptorType = pinf->desc.bDescriptorType;
 216                         ifd->bInterfaceNumber = pinf->desc.bInterfaceNumber;
 217                         ifd->bAlternateSetting = pinf->desc.bAlternateSetting;
 218                         ifd->bNumEndpoints = pinf->desc.bNumEndpoints;
 219                         ifd->bInterfaceClass = pinf->desc.bInterfaceClass;
 220                         ifd->bInterfaceSubClass = pinf->desc.bInterfaceSubClass;
 221                         ifd->bInterfaceProtocol = pinf->desc.bInterfaceProtocol;
 222                         ifd->iInterface = pinf->desc.iInterface;
 223                         if (pinf->extra.len != 0) {
 224                                 ifd->extra_length = pinf->extra.len;
 225                                 ifd->extra = pextra;
 226                                 memcpy(pextra, pinf->extra.ptr, pinf->extra.len);
 227                                 pextra += N_ALIGN(pinf->extra.len);
 228                         }
 229                         for (k = 0; k < pinf->num_endpoints; k++) {
 230                                 pend = &pinf->endpoints[k];
 231                                 endd = &ifd->endpoint[k];
 232                                 endd->bLength = pend->desc.bLength;
 233                                 endd->bDescriptorType = pend->desc.bDescriptorType;
 234                                 endd->bEndpointAddress = pend->desc.bEndpointAddress;
 235                                 endd->bmAttributes = pend->desc.bmAttributes;
 236                                 endd->wMaxPacketSize = pend->desc.wMaxPacketSize;
 237                                 endd->bInterval = pend->desc.bInterval;
 238                                 endd->bRefresh = pend->desc.bRefresh;
 239                                 endd->bSynchAddress = pend->desc.bSynchAddress;
 240                                 if (pend->extra.len != 0) {
 241                                         endd->extra_length = pend->extra.len;
 242                                         endd->extra = pextra;
 243                                         memcpy(pextra, pend->extra.ptr, pend->extra.len);
 244                                         pextra += N_ALIGN(pend->extra.len);
 245                                 }
 246                         }
 247                 }
 248         }
 249
 250         free(pconf);
 251
 252         *config = pconfd;
 253
 254         return (0);                     /* success */
 255 }
 256
 257 int
 258 libusb_get_config_descriptor_by_value(libusb_device *dev,
 259     uint8_t bConfigurationValue, struct libusb_config_descriptor **config)
 260 {
 261         struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
 262         struct libusb20_device *pdev;
 263         int i;
 264         int err;
 265
 266         if (dev == NULL || config == NULL)
 267                 return (LIBUSB_ERROR_INVALID_PARAM);
 268
 269         pdev = dev->os_priv;
 270         pdesc = libusb20_dev_get_device_desc(pdev);
 271
 272         for (i = 0; i < pdesc->bNumConfigurations; i++) {
 273                 err = libusb_get_config_descriptor(dev, i, config);
 274                 if (err)
 275                         return (err);
 276
 277                 if ((*config)->bConfigurationValue == bConfigurationValue)
 278                         return (0);     /* success */
 279
 280                 libusb_free_config_descriptor(*config);
 281         }
 282
 283         *config = NULL;
 284
 285         return (LIBUSB_ERROR_NOT_FOUND);
 286 }
 287
 288 void
 289 libusb_free_config_descriptor(struct libusb_config_descriptor *config)
 290 {
 291         free(config);
 292 }
 293
 294 int
 295 libusb_get_string_descriptor_ascii(libusb_device_handle *pdev,
 296     uint8_t desc_index, unsigned char *data, int length)
 297 {
 298         if (pdev == NULL || data == NULL || length < 1)
 299                 return (LIBUSB20_ERROR_INVALID_PARAM);
 300
 301         /* put some default data into the destination buffer */
 302         data[0] = 0;
 303
 304         if (libusb20_dev_req_string_simple_sync(pdev, desc_index,
 305             data, length) == 0)
 306                 return (strlen(data));
 307
 308         return (LIBUSB_ERROR_OTHER);
 309 }
 310
 311 int
 312 libusb_get_descriptor(libusb_device_handle * devh, uint8_t desc_type,
 313     uint8_t desc_index, uint8_t *data, int length)
 314 {
 315         return (libusb_control_transfer(devh, LIBUSB_ENDPOINT_IN,
 316             LIBUSB_REQUEST_GET_DESCRIPTOR, (desc_type << 8) | desc_index, 0, data,
 317             length, 1000));
 318 }