1/* $FreeBSD: stable/11/lib/libusb/libusb10_desc.c 328142 2018-01-18 21:39:03Z kevans $ */ 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#ifdef LIBUSB_GLOBAL_INCLUDE_FILE 28#include LIBUSB_GLOBAL_INCLUDE_FILE 29#else 30#include <stdio.h> 31#include <stdlib.h> 32#include <string.h> 33#include <time.h> 34#include <sys/queue.h> 35#endif 36 37#define libusb_device_handle libusb20_device 38 39#include "libusb20.h" 40#include "libusb20_desc.h" 41#include "libusb20_int.h" 42#include "libusb.h" 43#include "libusb10.h" 44 45#define N_ALIGN(n) (-((-(n)) & (-8UL))) 46 47/* USB descriptors */ 48 49int 50libusb_get_device_descriptor(libusb_device *dev, 51 struct libusb_device_descriptor *desc) 52{ 53 struct LIBUSB20_DEVICE_DESC_DECODED *pdesc; 54 struct libusb20_device *pdev; 55 56 if ((dev == NULL) || (desc == NULL)) 57 return (LIBUSB_ERROR_INVALID_PARAM); 58 59 pdev = dev->os_priv; 60 pdesc = libusb20_dev_get_device_desc(pdev); 61 62 desc->bLength = pdesc->bLength; 63 desc->bDescriptorType = pdesc->bDescriptorType; 64 desc->bcdUSB = pdesc->bcdUSB; 65 desc->bDeviceClass = pdesc->bDeviceClass; 66 desc->bDeviceSubClass = pdesc->bDeviceSubClass; 67 desc->bDeviceProtocol = pdesc->bDeviceProtocol; 68 desc->bMaxPacketSize0 = pdesc->bMaxPacketSize0; 69 desc->idVendor = pdesc->idVendor; 70 desc->idProduct = pdesc->idProduct; 71 desc->bcdDevice = pdesc->bcdDevice; 72 desc->iManufacturer = pdesc->iManufacturer; 73 desc->iProduct = pdesc->iProduct; 74 desc->iSerialNumber = pdesc->iSerialNumber; 75 desc->bNumConfigurations = pdesc->bNumConfigurations; 76 77 return (0); 78} 79 80int 81libusb_get_active_config_descriptor(libusb_device *dev, 82 struct libusb_config_descriptor **config) 83{ 84 struct libusb20_device *pdev; 85 uint8_t config_index; 86 87 pdev = dev->os_priv; 88 config_index = libusb20_dev_get_config_index(pdev); 89 90 return (libusb_get_config_descriptor(dev, config_index, config)); 91} 92 93int 94libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index, 95 struct libusb_config_descriptor **config) 96{ 97 struct libusb20_device *pdev; 98 struct libusb20_config *pconf; 99 struct libusb20_interface *pinf; 100 struct libusb20_endpoint *pend; 101 struct libusb_config_descriptor *pconfd; 102 struct libusb_interface_descriptor *ifd; 103 struct libusb_endpoint_descriptor *endd; 104 uint8_t *pextra; 105 uint16_t nextra; 106 uint8_t nif; 107 uint8_t nep; 108 uint8_t nalt; 109 uint8_t i; 110 uint8_t j; 111 uint8_t k; 112 113 if (dev == NULL || config == NULL) 114 return (LIBUSB_ERROR_INVALID_PARAM); 115 116 *config = NULL; 117 118 pdev = dev->os_priv; 119 pconf = libusb20_dev_alloc_config(pdev, config_index); 120 121 if (pconf == NULL) 122 return (LIBUSB_ERROR_NOT_FOUND); 123 124 nalt = nif = pconf->num_interface; 125 nep = 0; 126 nextra = N_ALIGN(pconf->extra.len); 127 128 for (i = 0; i < nif; i++) { 129 130 pinf = pconf->interface + i; 131 nextra += N_ALIGN(pinf->extra.len); 132 nep += pinf->num_endpoints; 133 k = pinf->num_endpoints; 134 pend = pinf->endpoints; 135 while (k--) { 136 nextra += N_ALIGN(pend->extra.len); 137 pend++; 138 } 139 140 j = pinf->num_altsetting; 141 nalt += pinf->num_altsetting; 142 pinf = pinf->altsetting; 143 while (j--) { 144 nextra += N_ALIGN(pinf->extra.len); 145 nep += pinf->num_endpoints; 146 k = pinf->num_endpoints; 147 pend = pinf->endpoints; 148 while (k--) { 149 nextra += N_ALIGN(pend->extra.len); 150 pend++; 151 } 152 pinf++; 153 } 154 } 155 156 nextra = nextra + 157 (1 * sizeof(libusb_config_descriptor)) + 158 (nif * sizeof(libusb_interface)) + 159 (nalt * sizeof(libusb_interface_descriptor)) + 160 (nep * sizeof(libusb_endpoint_descriptor)); 161 162 nextra = N_ALIGN(nextra); 163 164 pconfd = malloc(nextra); 165 166 if (pconfd == NULL) { 167 free(pconf); 168 return (LIBUSB_ERROR_NO_MEM); 169 } 170 /* make sure memory is initialised */ 171 memset(pconfd, 0, nextra); 172 173 pconfd->interface = (libusb_interface *) (pconfd + 1); 174 175 ifd = (libusb_interface_descriptor *) (pconfd->interface + nif); 176 endd = (libusb_endpoint_descriptor *) (ifd + nalt); 177 pextra = (uint8_t *)(endd + nep); 178 179 /* fill in config descriptor */ 180 181 pconfd->bLength = pconf->desc.bLength; 182 pconfd->bDescriptorType = pconf->desc.bDescriptorType; 183 pconfd->wTotalLength = pconf->desc.wTotalLength; 184 pconfd->bNumInterfaces = pconf->desc.bNumInterfaces; 185 pconfd->bConfigurationValue = pconf->desc.bConfigurationValue; 186 pconfd->iConfiguration = pconf->desc.iConfiguration; 187 pconfd->bmAttributes = pconf->desc.bmAttributes; 188 pconfd->MaxPower = pconf->desc.bMaxPower; 189 190 if (pconf->extra.len != 0) { 191 pconfd->extra_length = pconf->extra.len; 192 pconfd->extra = pextra; 193 memcpy(pextra, pconf->extra.ptr, pconfd->extra_length); 194 pextra += N_ALIGN(pconfd->extra_length); 195 } 196 /* setup all interface and endpoint pointers */ 197 198 for (i = 0; i < nif; i++) { 199 200 pconfd->interface[i].altsetting = ifd; 201 ifd->endpoint = endd; 202 endd += pconf->interface[i].num_endpoints; 203 ifd++; 204 205 for (j = 0; j < pconf->interface[i].num_altsetting; j++) { 206 ifd->endpoint = endd; 207 endd += pconf->interface[i].altsetting[j].num_endpoints; 208 ifd++; 209 } 210 } 211 212 /* fill in all interface and endpoint data */ 213 214 for (i = 0; i < nif; i++) { 215 pinf = &pconf->interface[i]; 216 pconfd->interface[i].num_altsetting = pinf->num_altsetting + 1; 217 for (j = 0; j < pconfd->interface[i].num_altsetting; j++) { 218 if (j != 0) 219 pinf = &pconf->interface[i].altsetting[j - 1]; 220 ifd = &pconfd->interface[i].altsetting[j]; 221 ifd->bLength = pinf->desc.bLength; 222 ifd->bDescriptorType = pinf->desc.bDescriptorType; 223 ifd->bInterfaceNumber = pinf->desc.bInterfaceNumber; 224 ifd->bAlternateSetting = pinf->desc.bAlternateSetting; 225 ifd->bNumEndpoints = pinf->desc.bNumEndpoints; 226 ifd->bInterfaceClass = pinf->desc.bInterfaceClass; 227 ifd->bInterfaceSubClass = pinf->desc.bInterfaceSubClass; 228 ifd->bInterfaceProtocol = pinf->desc.bInterfaceProtocol; 229 ifd->iInterface = pinf->desc.iInterface; 230 if (pinf->extra.len != 0) { 231 ifd->extra_length = pinf->extra.len; 232 ifd->extra = pextra; 233 memcpy(pextra, pinf->extra.ptr, pinf->extra.len); 234 pextra += N_ALIGN(pinf->extra.len); 235 } 236 for (k = 0; k < pinf->num_endpoints; k++) { 237 pend = &pinf->endpoints[k]; 238 endd = &ifd->endpoint[k]; 239 endd->bLength = pend->desc.bLength; 240 endd->bDescriptorType = pend->desc.bDescriptorType; 241 endd->bEndpointAddress = pend->desc.bEndpointAddress; 242 endd->bmAttributes = pend->desc.bmAttributes; 243 endd->wMaxPacketSize = pend->desc.wMaxPacketSize; 244 endd->bInterval = pend->desc.bInterval; 245 endd->bRefresh = pend->desc.bRefresh; 246 endd->bSynchAddress = pend->desc.bSynchAddress; 247 if (pend->extra.len != 0) { 248 endd->extra_length = pend->extra.len; 249 endd->extra = pextra; 250 memcpy(pextra, pend->extra.ptr, pend->extra.len); 251 pextra += N_ALIGN(pend->extra.len); 252 } 253 } 254 } 255 } 256 257 free(pconf); 258 259 *config = pconfd; 260 261 return (0); /* success */ 262} 263 264int 265libusb_get_config_descriptor_by_value(libusb_device *dev, 266 uint8_t bConfigurationValue, struct libusb_config_descriptor **config) 267{ 268 struct LIBUSB20_DEVICE_DESC_DECODED *pdesc; 269 struct libusb20_device *pdev; 270 int i; 271 int err; 272 273 if (dev == NULL || config == NULL) 274 return (LIBUSB_ERROR_INVALID_PARAM); 275 276 pdev = dev->os_priv; 277 pdesc = libusb20_dev_get_device_desc(pdev); 278 279 for (i = 0; i < pdesc->bNumConfigurations; i++) { 280 err = libusb_get_config_descriptor(dev, i, config); 281 if (err) 282 return (err); 283 284 if ((*config)->bConfigurationValue == bConfigurationValue) 285 return (0); /* success */ 286 287 libusb_free_config_descriptor(*config); 288 } 289 290 *config = NULL; 291 292 return (LIBUSB_ERROR_NOT_FOUND); 293} 294 295void 296libusb_free_config_descriptor(struct libusb_config_descriptor *config) 297{ 298 free(config); 299} 300 301int 302libusb_get_string_descriptor(libusb_device_handle *pdev, 303 uint8_t desc_index, uint16_t langid, unsigned char *data, 304 int length) 305{ 306 if (pdev == NULL || data == NULL || length < 1) 307 return (LIBUSB_ERROR_INVALID_PARAM); 308 309 if (length > 65535) 310 length = 65535; 311 312 /* put some default data into the destination buffer */ 313 data[0] = 0; 314 315 return (libusb_control_transfer(pdev, LIBUSB_ENDPOINT_IN, 316 LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc_index, 317 langid, data, length, 1000)); 318} 319 320int 321libusb_get_string_descriptor_ascii(libusb_device_handle *pdev, 322 uint8_t desc_index, unsigned char *data, int length) 323{ 324 if (pdev == NULL || data == NULL || length < 1) 325 return (LIBUSB_ERROR_INVALID_PARAM); 326 327 if (length > 65535) 328 length = 65535; 329 330 /* put some default data into the destination buffer */ 331 data[0] = 0; 332 333 if (libusb20_dev_req_string_simple_sync(pdev, desc_index, 334 data, length) == 0) 335 return (strlen((char *)data)); 336 337 return (LIBUSB_ERROR_OTHER); 338} 339 340int 341libusb_get_descriptor(libusb_device_handle * devh, uint8_t desc_type, 342 uint8_t desc_index, uint8_t *data, int length) 343{ 344 if (devh == NULL || data == NULL || length < 1) 345 return (LIBUSB_ERROR_INVALID_PARAM); 346 347 if (length > 65535) 348 length = 65535; 349 350 return (libusb_control_transfer(devh, LIBUSB_ENDPOINT_IN, 351 LIBUSB_REQUEST_GET_DESCRIPTOR, (desc_type << 8) | desc_index, 0, data, 352 length, 1000)); 353} 354 355int 356libusb_parse_ss_endpoint_comp(const void *buf, int len, 357 struct libusb_ss_endpoint_companion_descriptor **ep_comp) 358{ 359 if (buf == NULL || ep_comp == NULL || len < 1) 360 return (LIBUSB_ERROR_INVALID_PARAM); 361 362 if (len > 65535) 363 len = 65535; 364 365 *ep_comp = NULL; 366 367 while (len != 0) { 368 uint8_t dlen; 369 uint8_t dtype; 370 371 dlen = ((const uint8_t *)buf)[0]; 372 dtype = ((const uint8_t *)buf)[1]; 373 374 if (dlen < 2 || dlen > len) 375 break; 376 377 if (dlen >= LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE && 378 dtype == LIBUSB_DT_SS_ENDPOINT_COMPANION) { 379 struct libusb_ss_endpoint_companion_descriptor *ptr; 380 381 ptr = malloc(sizeof(*ptr)); 382 if (ptr == NULL) 383 return (LIBUSB_ERROR_NO_MEM); 384 385 ptr->bLength = LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE; 386 ptr->bDescriptorType = dtype; 387 ptr->bMaxBurst = ((const uint8_t *)buf)[2]; 388 ptr->bmAttributes = ((const uint8_t *)buf)[3]; 389 ptr->wBytesPerInterval = ((const uint8_t *)buf)[4] | 390 (((const uint8_t *)buf)[5] << 8); 391 392 *ep_comp = ptr; 393 394 return (0); /* success */ 395 } 396 397 buf = ((const uint8_t *)buf) + dlen; 398 len -= dlen; 399 } 400 return (LIBUSB_ERROR_IO); 401} 402 403void 404libusb_free_ss_endpoint_comp(struct libusb_ss_endpoint_companion_descriptor *ep_comp) 405{ 406 if (ep_comp == NULL) 407 return; 408 409 free(ep_comp); 410} 411 412int 413libusb_get_ss_endpoint_companion_descriptor(struct libusb_context *ctx, 414 const struct libusb_endpoint_descriptor *endpoint, 415 struct libusb_ss_endpoint_companion_descriptor **ep_comp) 416{ 417 if (endpoint == NULL) 418 return (LIBUSB_ERROR_INVALID_PARAM); 419 return (libusb_parse_ss_endpoint_comp(endpoint->extra, endpoint->extra_length, ep_comp)); 420} 421 422void 423libusb_free_ss_endpoint_companion_descriptor(struct libusb_ss_endpoint_companion_descriptor *ep_comp) 424{ 425 426 libusb_free_ss_endpoint_comp(ep_comp); 427} 428 429int 430libusb_parse_bos_descriptor(const void *buf, int len, 431 struct libusb_bos_descriptor **bos) 432{ 433 struct libusb_bos_descriptor *ptr; 434 struct libusb_usb_2_0_device_capability_descriptor *dcap_20 = NULL; 435 struct libusb_ss_usb_device_capability_descriptor *ss_cap = NULL; 436 uint8_t index = 0; 437 438 if (buf == NULL || bos == NULL || len < 1) 439 return (LIBUSB_ERROR_INVALID_PARAM); 440 441 if (len > 65535) 442 len = 65535; 443 444 *bos = ptr = NULL; 445 446 while (len != 0) { 447 uint8_t dlen; 448 uint8_t dtype; 449 450 dlen = ((const uint8_t *)buf)[0]; 451 dtype = ((const uint8_t *)buf)[1]; 452 453 if (dlen < 2 || dlen > len) 454 break; 455 456 if (dlen >= LIBUSB_DT_BOS_SIZE && 457 dtype == LIBUSB_DT_BOS && 458 ptr == NULL) { 459 460 ptr = malloc(sizeof(*ptr) + sizeof(*dcap_20) + 461 sizeof(*ss_cap)); 462 463 if (ptr == NULL) 464 return (LIBUSB_ERROR_NO_MEM); 465 466 *bos = ptr; 467 468 ptr->bLength = LIBUSB_DT_BOS_SIZE; 469 ptr->bDescriptorType = dtype; 470 ptr->wTotalLength = ((const uint8_t *)buf)[2] | 471 (((const uint8_t *)buf)[3] << 8); 472 ptr->bNumDeviceCapabilities = ((const uint8_t *)buf)[4]; 473 ptr->usb_2_0_ext_cap = NULL; 474 ptr->ss_usb_cap = NULL; 475 ptr->dev_capability = calloc(ptr->bNumDeviceCapabilities, sizeof(void *)); 476 if (ptr->dev_capability == NULL) { 477 free(ptr); 478 return (LIBUSB_ERROR_NO_MEM); 479 } 480 481 dcap_20 = (void *)(ptr + 1); 482 ss_cap = (void *)(dcap_20 + 1); 483 } 484 if (dlen >= 3 && 485 ptr != NULL && 486 dtype == LIBUSB_DT_DEVICE_CAPABILITY) { 487 if (index != ptr->bNumDeviceCapabilities) { 488 ptr->dev_capability[index] = malloc(dlen); 489 if (ptr->dev_capability[index] == NULL) { 490 libusb_free_bos_descriptor(ptr); 491 return LIBUSB_ERROR_NO_MEM; 492 } 493 memcpy(ptr->dev_capability[index], buf, dlen); 494 index++; 495 } 496 switch (((const uint8_t *)buf)[2]) { 497 case LIBUSB_USB_2_0_EXTENSION_DEVICE_CAPABILITY: 498 if (ptr->usb_2_0_ext_cap != NULL || dcap_20 == NULL) 499 break; 500 if (dlen < LIBUSB_USB_2_0_EXTENSION_DEVICE_CAPABILITY_SIZE) 501 break; 502 503 ptr->usb_2_0_ext_cap = dcap_20; 504 505 dcap_20->bLength = LIBUSB_USB_2_0_EXTENSION_DEVICE_CAPABILITY_SIZE; 506 dcap_20->bDescriptorType = dtype; 507 dcap_20->bDevCapabilityType = ((const uint8_t *)buf)[2]; 508 dcap_20->bmAttributes = ((const uint8_t *)buf)[3] | 509 (((const uint8_t *)buf)[4] << 8) | 510 (((const uint8_t *)buf)[5] << 16) | 511 (((const uint8_t *)buf)[6] << 24); 512 break; 513 514 case LIBUSB_SS_USB_DEVICE_CAPABILITY: 515 if (ptr->ss_usb_cap != NULL || ss_cap == NULL) 516 break; 517 if (dlen < LIBUSB_SS_USB_DEVICE_CAPABILITY_SIZE) 518 break; 519 520 ptr->ss_usb_cap = ss_cap; 521 522 ss_cap->bLength = LIBUSB_SS_USB_DEVICE_CAPABILITY_SIZE; 523 ss_cap->bDescriptorType = dtype; 524 ss_cap->bDevCapabilityType = ((const uint8_t *)buf)[2]; 525 ss_cap->bmAttributes = ((const uint8_t *)buf)[3]; 526 ss_cap->wSpeedSupported = ((const uint8_t *)buf)[4] | 527 (((const uint8_t *)buf)[5] << 8); 528 ss_cap->bFunctionalitySupport = ((const uint8_t *)buf)[6]; 529 ss_cap->bU1DevExitLat = ((const uint8_t *)buf)[7]; 530 ss_cap->wU2DevExitLat = ((const uint8_t *)buf)[8] | 531 (((const uint8_t *)buf)[9] << 8); 532 break; 533 534 default: 535 break; 536 } 537 } 538 539 buf = ((const uint8_t *)buf) + dlen; 540 len -= dlen; 541 } 542 543 if (ptr != NULL) { 544 ptr->bNumDeviceCapabilities = index; 545 return (0); /* success */ 546 } 547 548 return (LIBUSB_ERROR_IO); 549} 550 551void 552libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos) 553{ 554 uint8_t i; 555 556 if (bos == NULL) 557 return; 558 559 for (i = 0; i != bos->bNumDeviceCapabilities; i++) 560 free(bos->dev_capability[i]); 561 free(bos->dev_capability); 562 free(bos); 563} 564 565int 566libusb_get_bos_descriptor(libusb_device_handle *handle, 567 struct libusb_bos_descriptor **bos) 568{ 569 uint8_t bos_header[LIBUSB_DT_BOS_SIZE] = {0}; 570 uint16_t wTotalLength; 571 uint8_t *bos_data; 572 int err; 573 574 err = libusb_get_descriptor(handle, LIBUSB_DT_BOS, 0, 575 bos_header, sizeof(bos_header)); 576 if (err < 0) 577 return (err); 578 579 wTotalLength = bos_header[2] | (bos_header[3] << 8); 580 if (wTotalLength < LIBUSB_DT_BOS_SIZE) 581 return (LIBUSB_ERROR_INVALID_PARAM); 582 583 bos_data = calloc(wTotalLength, 1); 584 if (bos_data == NULL) 585 return (LIBUSB_ERROR_NO_MEM); 586 587 err = libusb_get_descriptor(handle, LIBUSB_DT_BOS, 0, 588 bos_data, wTotalLength); 589 if (err < 0) 590 goto done; 591 592 /* avoid descriptor length mismatches */ 593 bos_data[2] = (wTotalLength & 0xFF); 594 bos_data[3] = (wTotalLength >> 8); 595 596 err = libusb_parse_bos_descriptor(bos_data, wTotalLength, bos); 597done: 598 free(bos_data); 599 return (err); 600} 601 602int 603libusb_get_usb_2_0_extension_descriptor(struct libusb_context *ctx, 604 struct libusb_bos_dev_capability_descriptor *dev_cap, 605 struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension) 606{ 607 struct libusb_usb_2_0_extension_descriptor *desc; 608 609 if (dev_cap == NULL || usb_2_0_extension == NULL || 610 dev_cap->bDevCapabilityType != LIBUSB_BT_USB_2_0_EXTENSION) 611 return (LIBUSB_ERROR_INVALID_PARAM); 612 if (dev_cap->bLength < LIBUSB_BT_USB_2_0_EXTENSION_SIZE) 613 return (LIBUSB_ERROR_IO); 614 615 desc = malloc(sizeof(*desc)); 616 if (desc == NULL) 617 return (LIBUSB_ERROR_NO_MEM); 618 619 desc->bLength = LIBUSB_BT_USB_2_0_EXTENSION_SIZE; 620 desc->bDescriptorType = dev_cap->bDescriptorType; 621 desc->bDevCapabilityType = dev_cap->bDevCapabilityType; 622 desc->bmAttributes = 623 (dev_cap->dev_capability_data[0]) | 624 (dev_cap->dev_capability_data[1] << 8) | 625 (dev_cap->dev_capability_data[2] << 16) | 626 (dev_cap->dev_capability_data[3] << 24); 627 628 *usb_2_0_extension = desc; 629 return (0); 630} 631 632void 633libusb_free_usb_2_0_extension_descriptor( 634 struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension) 635{ 636 637 free(usb_2_0_extension); 638} 639 640int 641libusb_get_ss_usb_device_capability_descriptor(struct libusb_context *ctx, 642 struct libusb_bos_dev_capability_descriptor *dev_cap, 643 struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_capability) 644{ 645 struct libusb_ss_usb_device_capability_descriptor *desc; 646 647 if (dev_cap == NULL || ss_usb_device_capability == NULL || 648 dev_cap->bDevCapabilityType != LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) 649 return (LIBUSB_ERROR_INVALID_PARAM); 650 if (dev_cap->bLength < LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE) 651 return (LIBUSB_ERROR_IO); 652 653 desc = malloc(sizeof(*desc)); 654 if (desc == NULL) 655 return (LIBUSB_ERROR_NO_MEM); 656 657 desc->bLength = LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE; 658 desc->bDescriptorType = dev_cap->bDescriptorType; 659 desc->bDevCapabilityType = dev_cap->bDevCapabilityType; 660 desc->bmAttributes = dev_cap->dev_capability_data[0]; 661 desc->wSpeedSupported = dev_cap->dev_capability_data[1] | 662 (dev_cap->dev_capability_data[2] << 8); 663 desc->bFunctionalitySupport = dev_cap->dev_capability_data[3]; 664 desc->bU1DevExitLat = dev_cap->dev_capability_data[4]; 665 desc->wU2DevExitLat = dev_cap->dev_capability_data[5] | 666 (dev_cap->dev_capability_data[6] << 8); 667 668 *ss_usb_device_capability = desc; 669 return (0); 670} 671 672void 673libusb_free_ss_usb_device_capability_descriptor( 674 struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_capability) 675{ 676 677 free(ss_usb_device_capability); 678} 679 680int 681libusb_get_container_id_descriptor(struct libusb_context *ctx, 682 struct libusb_bos_dev_capability_descriptor *dev_cap, 683 struct libusb_container_id_descriptor **container_id) 684{ 685 struct libusb_container_id_descriptor *desc; 686 687 if (dev_cap == NULL || container_id == NULL || 688 dev_cap->bDevCapabilityType != LIBUSB_BT_CONTAINER_ID) 689 return (LIBUSB_ERROR_INVALID_PARAM); 690 if (dev_cap->bLength < LIBUSB_BT_CONTAINER_ID_SIZE) 691 return (LIBUSB_ERROR_IO); 692 693 desc = malloc(sizeof(*desc)); 694 if (desc == NULL) 695 return (LIBUSB_ERROR_NO_MEM); 696 697 desc->bLength = LIBUSB_BT_CONTAINER_ID_SIZE; 698 desc->bDescriptorType = dev_cap->bDescriptorType; 699 desc->bDevCapabilityType = dev_cap->bDevCapabilityType; 700 desc->bReserved = dev_cap->dev_capability_data[0]; 701 memcpy(desc->ContainerID, dev_cap->dev_capability_data + 1, 702 sizeof(desc->ContainerID)); 703 704 *container_id = desc; 705 return (0); 706} 707 708void 709libusb_free_container_id_descriptor( 710 struct libusb_container_id_descriptor *container_id) 711{ 712 713 free(container_id); 714} 715