1#include <linux/usb.h> 2#include <linux/usb/ch9.h> 3#include <linux/usb/hcd.h> 4#include <linux/usb/quirks.h> 5#include <linux/module.h> 6#include <linux/slab.h> 7#include <linux/device.h> 8#include <asm/byteorder.h> 9#include "usb.h" 10 11 12#define USB_MAXALTSETTING 128 /* Hard limit */ 13 14#define USB_MAXCONFIG 8 /* Arbitrary limit */ 15 16 17static inline const char *plural(int n) 18{ 19 return (n == 1 ? "" : "s"); 20} 21 22static int find_next_descriptor(unsigned char *buffer, int size, 23 int dt1, int dt2, int *num_skipped) 24{ 25 struct usb_descriptor_header *h; 26 int n = 0; 27 unsigned char *buffer0 = buffer; 28 29 /* Find the next descriptor of type dt1 or dt2 */ 30 while (size > 0) { 31 h = (struct usb_descriptor_header *) buffer; 32 if (h->bDescriptorType == dt1 || h->bDescriptorType == dt2) 33 break; 34 buffer += h->bLength; 35 size -= h->bLength; 36 ++n; 37 } 38 39 /* Store the number of descriptors skipped and return the 40 * number of bytes skipped */ 41 if (num_skipped) 42 *num_skipped = n; 43 return buffer - buffer0; 44} 45 46static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno, 47 int inum, int asnum, struct usb_host_endpoint *ep, 48 unsigned char *buffer, int size) 49{ 50 struct usb_ss_ep_comp_descriptor *desc; 51 int max_tx; 52 53 /* The SuperSpeed endpoint companion descriptor is supposed to 54 * be the first thing immediately following the endpoint descriptor. 55 */ 56 desc = (struct usb_ss_ep_comp_descriptor *) buffer; 57 if (desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP || 58 size < USB_DT_SS_EP_COMP_SIZE) { 59 dev_warn(ddev, "No SuperSpeed endpoint companion for config %d " 60 " interface %d altsetting %d ep %d: " 61 "using minimum values\n", 62 cfgno, inum, asnum, ep->desc.bEndpointAddress); 63 64 /* Fill in some default values. 65 * Leave bmAttributes as zero, which will mean no streams for 66 * bulk, and isoc won't support multiple bursts of packets. 67 * With bursts of only one packet, and a Mult of 1, the max 68 * amount of data moved per endpoint service interval is one 69 * packet. 70 */ 71 ep->ss_ep_comp.bLength = USB_DT_SS_EP_COMP_SIZE; 72 ep->ss_ep_comp.bDescriptorType = USB_DT_SS_ENDPOINT_COMP; 73 if (usb_endpoint_xfer_isoc(&ep->desc) || 74 usb_endpoint_xfer_int(&ep->desc)) 75 ep->ss_ep_comp.wBytesPerInterval = 76 ep->desc.wMaxPacketSize; 77 return; 78 } 79 80 memcpy(&ep->ss_ep_comp, desc, USB_DT_SS_EP_COMP_SIZE); 81 82 /* Check the various values */ 83 if (usb_endpoint_xfer_control(&ep->desc) && desc->bMaxBurst != 0) { 84 dev_warn(ddev, "Control endpoint with bMaxBurst = %d in " 85 "config %d interface %d altsetting %d ep %d: " 86 "setting to zero\n", desc->bMaxBurst, 87 cfgno, inum, asnum, ep->desc.bEndpointAddress); 88 ep->ss_ep_comp.bMaxBurst = 0; 89 } else if (desc->bMaxBurst > 15) { 90 dev_warn(ddev, "Endpoint with bMaxBurst = %d in " 91 "config %d interface %d altsetting %d ep %d: " 92 "setting to 15\n", desc->bMaxBurst, 93 cfgno, inum, asnum, ep->desc.bEndpointAddress); 94 ep->ss_ep_comp.bMaxBurst = 15; 95 } 96 97 if ((usb_endpoint_xfer_control(&ep->desc) || 98 usb_endpoint_xfer_int(&ep->desc)) && 99 desc->bmAttributes != 0) { 100 dev_warn(ddev, "%s endpoint with bmAttributes = %d in " 101 "config %d interface %d altsetting %d ep %d: " 102 "setting to zero\n", 103 usb_endpoint_xfer_control(&ep->desc) ? "Control" : "Bulk", 104 desc->bmAttributes, 105 cfgno, inum, asnum, ep->desc.bEndpointAddress); 106 ep->ss_ep_comp.bmAttributes = 0; 107 } else if (usb_endpoint_xfer_bulk(&ep->desc) && 108 desc->bmAttributes > 16) { 109 dev_warn(ddev, "Bulk endpoint with more than 65536 streams in " 110 "config %d interface %d altsetting %d ep %d: " 111 "setting to max\n", 112 cfgno, inum, asnum, ep->desc.bEndpointAddress); 113 ep->ss_ep_comp.bmAttributes = 16; 114 } else if (usb_endpoint_xfer_isoc(&ep->desc) && 115 USB_SS_MULT(desc->bmAttributes) > 3) { 116 dev_warn(ddev, "Isoc endpoint has Mult of %d in " 117 "config %d interface %d altsetting %d ep %d: " 118 "setting to 3\n", 119 USB_SS_MULT(desc->bmAttributes), 120 cfgno, inum, asnum, ep->desc.bEndpointAddress); 121 ep->ss_ep_comp.bmAttributes = 2; 122 } 123 124 if (usb_endpoint_xfer_isoc(&ep->desc)) 125 max_tx = (desc->bMaxBurst + 1) * 126 (USB_SS_MULT(desc->bmAttributes)) * 127 usb_endpoint_maxp(&ep->desc); 128 else if (usb_endpoint_xfer_int(&ep->desc)) 129 max_tx = usb_endpoint_maxp(&ep->desc) * 130 (desc->bMaxBurst + 1); 131 else 132 max_tx = 999999; 133 if (le16_to_cpu(desc->wBytesPerInterval) > max_tx) { 134 dev_warn(ddev, "%s endpoint with wBytesPerInterval of %d in " 135 "config %d interface %d altsetting %d ep %d: " 136 "setting to %d\n", 137 usb_endpoint_xfer_isoc(&ep->desc) ? "Isoc" : "Int", 138 le16_to_cpu(desc->wBytesPerInterval), 139 cfgno, inum, asnum, ep->desc.bEndpointAddress, 140 max_tx); 141 ep->ss_ep_comp.wBytesPerInterval = cpu_to_le16(max_tx); 142 } 143} 144 145static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, 146 int asnum, struct usb_host_interface *ifp, int num_ep, 147 unsigned char *buffer, int size) 148{ 149 unsigned char *buffer0 = buffer; 150 struct usb_endpoint_descriptor *d; 151 struct usb_host_endpoint *endpoint; 152 int n, i, j, retval; 153 154 d = (struct usb_endpoint_descriptor *) buffer; 155 buffer += d->bLength; 156 size -= d->bLength; 157 158 if (d->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE) 159 n = USB_DT_ENDPOINT_AUDIO_SIZE; 160 else if (d->bLength >= USB_DT_ENDPOINT_SIZE) 161 n = USB_DT_ENDPOINT_SIZE; 162 else { 163 dev_warn(ddev, "config %d interface %d altsetting %d has an " 164 "invalid endpoint descriptor of length %d, skipping\n", 165 cfgno, inum, asnum, d->bLength); 166 goto skip_to_next_endpoint_or_interface_descriptor; 167 } 168 169 i = d->bEndpointAddress & ~USB_ENDPOINT_DIR_MASK; 170 if (i >= 16 || i == 0) { 171 dev_warn(ddev, "config %d interface %d altsetting %d has an " 172 "invalid endpoint with address 0x%X, skipping\n", 173 cfgno, inum, asnum, d->bEndpointAddress); 174 goto skip_to_next_endpoint_or_interface_descriptor; 175 } 176 177 /* Only store as many endpoints as we have room for */ 178 if (ifp->desc.bNumEndpoints >= num_ep) 179 goto skip_to_next_endpoint_or_interface_descriptor; 180 181 endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints]; 182 ++ifp->desc.bNumEndpoints; 183 184 memcpy(&endpoint->desc, d, n); 185 INIT_LIST_HEAD(&endpoint->urb_list); 186 187 /* Fix up bInterval values outside the legal range. Use 32 ms if no 188 * proper value can be guessed. */ 189 i = 0; /* i = min, j = max, n = default */ 190 j = 255; 191 if (usb_endpoint_xfer_int(d)) { 192 i = 1; 193 switch (to_usb_device(ddev)->speed) { 194 case USB_SPEED_SUPER: 195 case USB_SPEED_HIGH: 196 /* Many device manufacturers are using full-speed 197 * bInterval values in high-speed interrupt endpoint 198 * descriptors. Try to fix those and fall back to a 199 * 32 ms default value otherwise. */ 200 n = fls(d->bInterval*8); 201 if (n == 0) 202 n = 9; /* 32 ms = 2^(9-1) uframes */ 203 j = 16; 204 205 /* 206 * Adjust bInterval for quirked devices. 207 * This quirk fixes bIntervals reported in 208 * linear microframes. 209 */ 210 if (to_usb_device(ddev)->quirks & 211 USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL) { 212 n = clamp(fls(d->bInterval), i, j); 213 i = j = n; 214 } 215 break; 216 default: /* USB_SPEED_FULL or _LOW */ 217 /* For low-speed, 10 ms is the official minimum. 218 * But some "overclocked" devices might want faster 219 * polling so we'll allow it. */ 220 n = 32; 221 break; 222 } 223 } else if (usb_endpoint_xfer_isoc(d)) { 224 i = 1; 225 j = 16; 226 switch (to_usb_device(ddev)->speed) { 227 case USB_SPEED_HIGH: 228 n = 9; /* 32 ms = 2^(9-1) uframes */ 229 break; 230 default: /* USB_SPEED_FULL */ 231 n = 6; /* 32 ms = 2^(6-1) frames */ 232 break; 233 } 234 } 235 if (d->bInterval < i || d->bInterval > j) { 236 dev_warn(ddev, "config %d interface %d altsetting %d " 237 "endpoint 0x%X has an invalid bInterval %d, " 238 "changing to %d\n", 239 cfgno, inum, asnum, 240 d->bEndpointAddress, d->bInterval, n); 241 endpoint->desc.bInterval = n; 242 } 243 244 /* Some buggy low-speed devices have Bulk endpoints, which is 245 * explicitly forbidden by the USB spec. In an attempt to make 246 * them usable, we will try treating them as Interrupt endpoints. 247 */ 248 if (to_usb_device(ddev)->speed == USB_SPEED_LOW && 249 usb_endpoint_xfer_bulk(d)) { 250 dev_warn(ddev, "config %d interface %d altsetting %d " 251 "endpoint 0x%X is Bulk; changing to Interrupt\n", 252 cfgno, inum, asnum, d->bEndpointAddress); 253 endpoint->desc.bmAttributes = USB_ENDPOINT_XFER_INT; 254 endpoint->desc.bInterval = 1; 255 if (usb_endpoint_maxp(&endpoint->desc) > 8) 256 endpoint->desc.wMaxPacketSize = cpu_to_le16(8); 257 } 258 259 /* 260 * Some buggy high speed devices have bulk endpoints using 261 * maxpacket sizes other than 512. High speed HCDs may not 262 * be able to handle that particular bug, so let's warn... 263 */ 264 if (to_usb_device(ddev)->speed == USB_SPEED_HIGH 265 && usb_endpoint_xfer_bulk(d)) { 266 unsigned maxp; 267 268 maxp = usb_endpoint_maxp(&endpoint->desc) & 0x07ff; 269 if (maxp != 512) 270 dev_warn(ddev, "config %d interface %d altsetting %d " 271 "bulk endpoint 0x%X has invalid maxpacket %d\n", 272 cfgno, inum, asnum, d->bEndpointAddress, 273 maxp); 274 } 275 276 /* Parse a possible SuperSpeed endpoint companion descriptor */ 277 if (to_usb_device(ddev)->speed == USB_SPEED_SUPER) 278 usb_parse_ss_endpoint_companion(ddev, cfgno, 279 inum, asnum, endpoint, buffer, size); 280 281 /* Skip over any Class Specific or Vendor Specific descriptors; 282 * find the next endpoint or interface descriptor */ 283 endpoint->extra = buffer; 284 i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, 285 USB_DT_INTERFACE, &n); 286 endpoint->extralen = i; 287 retval = buffer - buffer0 + i; 288 if (n > 0) 289 dev_dbg(ddev, "skipped %d descriptor%s after %s\n", 290 n, plural(n), "endpoint"); 291 return retval; 292 293skip_to_next_endpoint_or_interface_descriptor: 294 i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, 295 USB_DT_INTERFACE, NULL); 296 return buffer - buffer0 + i; 297} 298 299void usb_release_interface_cache(struct kref *ref) 300{ 301 struct usb_interface_cache *intfc = ref_to_usb_interface_cache(ref); 302 int j; 303 304 for (j = 0; j < intfc->num_altsetting; j++) { 305 struct usb_host_interface *alt = &intfc->altsetting[j]; 306 307 kfree(alt->endpoint); 308 kfree(alt->string); 309 } 310 kfree(intfc); 311} 312 313static int usb_parse_interface(struct device *ddev, int cfgno, 314 struct usb_host_config *config, unsigned char *buffer, int size, 315 u8 inums[], u8 nalts[]) 316{ 317 unsigned char *buffer0 = buffer; 318 struct usb_interface_descriptor *d; 319 int inum, asnum; 320 struct usb_interface_cache *intfc; 321 struct usb_host_interface *alt; 322 int i, n; 323 int len, retval; 324 int num_ep, num_ep_orig; 325 326 d = (struct usb_interface_descriptor *) buffer; 327 buffer += d->bLength; 328 size -= d->bLength; 329 330 if (d->bLength < USB_DT_INTERFACE_SIZE) 331 goto skip_to_next_interface_descriptor; 332 333 /* Which interface entry is this? */ 334 intfc = NULL; 335 inum = d->bInterfaceNumber; 336 for (i = 0; i < config->desc.bNumInterfaces; ++i) { 337 if (inums[i] == inum) { 338 intfc = config->intf_cache[i]; 339 break; 340 } 341 } 342 if (!intfc || intfc->num_altsetting >= nalts[i]) 343 goto skip_to_next_interface_descriptor; 344 345 /* Check for duplicate altsetting entries */ 346 asnum = d->bAlternateSetting; 347 for ((i = 0, alt = &intfc->altsetting[0]); 348 i < intfc->num_altsetting; 349 (++i, ++alt)) { 350 if (alt->desc.bAlternateSetting == asnum) { 351 dev_warn(ddev, "Duplicate descriptor for config %d " 352 "interface %d altsetting %d, skipping\n", 353 cfgno, inum, asnum); 354 goto skip_to_next_interface_descriptor; 355 } 356 } 357 358 ++intfc->num_altsetting; 359 memcpy(&alt->desc, d, USB_DT_INTERFACE_SIZE); 360 361 /* Skip over any Class Specific or Vendor Specific descriptors; 362 * find the first endpoint or interface descriptor */ 363 alt->extra = buffer; 364 i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, 365 USB_DT_INTERFACE, &n); 366 alt->extralen = i; 367 if (n > 0) 368 dev_dbg(ddev, "skipped %d descriptor%s after %s\n", 369 n, plural(n), "interface"); 370 buffer += i; 371 size -= i; 372 373 /* Allocate space for the right(?) number of endpoints */ 374 num_ep = num_ep_orig = alt->desc.bNumEndpoints; 375 alt->desc.bNumEndpoints = 0; /* Use as a counter */ 376 if (num_ep > USB_MAXENDPOINTS) { 377 dev_warn(ddev, "too many endpoints for config %d interface %d " 378 "altsetting %d: %d, using maximum allowed: %d\n", 379 cfgno, inum, asnum, num_ep, USB_MAXENDPOINTS); 380 num_ep = USB_MAXENDPOINTS; 381 } 382 383 if (num_ep > 0) { 384 /* Can't allocate 0 bytes */ 385 len = sizeof(struct usb_host_endpoint) * num_ep; 386 alt->endpoint = kzalloc(len, GFP_KERNEL); 387 if (!alt->endpoint) 388 return -ENOMEM; 389 } 390 391 /* Parse all the endpoint descriptors */ 392 n = 0; 393 while (size > 0) { 394 if (((struct usb_descriptor_header *) buffer)->bDescriptorType 395 == USB_DT_INTERFACE) 396 break; 397 retval = usb_parse_endpoint(ddev, cfgno, inum, asnum, alt, 398 num_ep, buffer, size); 399 if (retval < 0) 400 return retval; 401 ++n; 402 403 buffer += retval; 404 size -= retval; 405 } 406 407 if (n != num_ep_orig) 408 dev_warn(ddev, "config %d interface %d altsetting %d has %d " 409 "endpoint descriptor%s, different from the interface " 410 "descriptor's value: %d\n", 411 cfgno, inum, asnum, n, plural(n), num_ep_orig); 412 return buffer - buffer0; 413 414skip_to_next_interface_descriptor: 415 i = find_next_descriptor(buffer, size, USB_DT_INTERFACE, 416 USB_DT_INTERFACE, NULL); 417 return buffer - buffer0 + i; 418} 419 420static int usb_parse_configuration(struct usb_device *dev, int cfgidx, 421 struct usb_host_config *config, unsigned char *buffer, int size) 422{ 423 struct device *ddev = &dev->dev; 424 unsigned char *buffer0 = buffer; 425 int cfgno; 426 int nintf, nintf_orig; 427 int i, j, n; 428 struct usb_interface_cache *intfc; 429 unsigned char *buffer2; 430 int size2; 431 struct usb_descriptor_header *header; 432 int len, retval; 433 u8 inums[USB_MAXINTERFACES], nalts[USB_MAXINTERFACES]; 434 unsigned iad_num = 0; 435 436 memcpy(&config->desc, buffer, USB_DT_CONFIG_SIZE); 437 if (config->desc.bDescriptorType != USB_DT_CONFIG || 438 config->desc.bLength < USB_DT_CONFIG_SIZE || 439 config->desc.bLength > size) { 440 dev_err(ddev, "invalid descriptor for config index %d: " 441 "type = 0x%X, length = %d\n", cfgidx, 442 config->desc.bDescriptorType, config->desc.bLength); 443 return -EINVAL; 444 } 445 cfgno = config->desc.bConfigurationValue; 446 447 buffer += config->desc.bLength; 448 size -= config->desc.bLength; 449 450 nintf = nintf_orig = config->desc.bNumInterfaces; 451 if (nintf > USB_MAXINTERFACES) { 452 dev_warn(ddev, "config %d has too many interfaces: %d, " 453 "using maximum allowed: %d\n", 454 cfgno, nintf, USB_MAXINTERFACES); 455 nintf = USB_MAXINTERFACES; 456 } 457 458 /* Go through the descriptors, checking their length and counting the 459 * number of altsettings for each interface */ 460 n = 0; 461 for ((buffer2 = buffer, size2 = size); 462 size2 > 0; 463 (buffer2 += header->bLength, size2 -= header->bLength)) { 464 465 if (size2 < sizeof(struct usb_descriptor_header)) { 466 dev_warn(ddev, "config %d descriptor has %d excess " 467 "byte%s, ignoring\n", 468 cfgno, size2, plural(size2)); 469 break; 470 } 471 472 header = (struct usb_descriptor_header *) buffer2; 473 if ((header->bLength > size2) || (header->bLength < 2)) { 474 dev_warn(ddev, "config %d has an invalid descriptor " 475 "of length %d, skipping remainder of the config\n", 476 cfgno, header->bLength); 477 break; 478 } 479 480 if (header->bDescriptorType == USB_DT_INTERFACE) { 481 struct usb_interface_descriptor *d; 482 int inum; 483 484 d = (struct usb_interface_descriptor *) header; 485 if (d->bLength < USB_DT_INTERFACE_SIZE) { 486 dev_warn(ddev, "config %d has an invalid " 487 "interface descriptor of length %d, " 488 "skipping\n", cfgno, d->bLength); 489 continue; 490 } 491 492 inum = d->bInterfaceNumber; 493 494 if ((dev->quirks & USB_QUIRK_HONOR_BNUMINTERFACES) && 495 n >= nintf_orig) { 496 dev_warn(ddev, "config %d has more interface " 497 "descriptors, than it declares in " 498 "bNumInterfaces, ignoring interface " 499 "number: %d\n", cfgno, inum); 500 continue; 501 } 502 503 if (inum >= nintf_orig) 504 dev_warn(ddev, "config %d has an invalid " 505 "interface number: %d but max is %d\n", 506 cfgno, inum, nintf_orig - 1); 507 508 /* Have we already encountered this interface? 509 * Count its altsettings */ 510 for (i = 0; i < n; ++i) { 511 if (inums[i] == inum) 512 break; 513 } 514 if (i < n) { 515 if (nalts[i] < 255) 516 ++nalts[i]; 517 } else if (n < USB_MAXINTERFACES) { 518 inums[n] = inum; 519 nalts[n] = 1; 520 ++n; 521 } 522 523 } else if (header->bDescriptorType == 524 USB_DT_INTERFACE_ASSOCIATION) { 525 if (iad_num == USB_MAXIADS) { 526 dev_warn(ddev, "found more Interface " 527 "Association Descriptors " 528 "than allocated for in " 529 "configuration %d\n", cfgno); 530 } else { 531 config->intf_assoc[iad_num] = 532 (struct usb_interface_assoc_descriptor 533 *)header; 534 iad_num++; 535 } 536 537 } else if (header->bDescriptorType == USB_DT_DEVICE || 538 header->bDescriptorType == USB_DT_CONFIG) 539 dev_warn(ddev, "config %d contains an unexpected " 540 "descriptor of type 0x%X, skipping\n", 541 cfgno, header->bDescriptorType); 542 543 } /* for ((buffer2 = buffer, size2 = size); ...) */ 544 size = buffer2 - buffer; 545 config->desc.wTotalLength = cpu_to_le16(buffer2 - buffer0); 546 547 if (n != nintf) 548 dev_warn(ddev, "config %d has %d interface%s, different from " 549 "the descriptor's value: %d\n", 550 cfgno, n, plural(n), nintf_orig); 551 else if (n == 0) 552 dev_warn(ddev, "config %d has no interfaces?\n", cfgno); 553 config->desc.bNumInterfaces = nintf = n; 554 555 /* Check for missing interface numbers */ 556 for (i = 0; i < nintf; ++i) { 557 for (j = 0; j < nintf; ++j) { 558 if (inums[j] == i) 559 break; 560 } 561 if (j >= nintf) 562 dev_warn(ddev, "config %d has no interface number " 563 "%d\n", cfgno, i); 564 } 565 566 /* Allocate the usb_interface_caches and altsetting arrays */ 567 for (i = 0; i < nintf; ++i) { 568 j = nalts[i]; 569 if (j > USB_MAXALTSETTING) { 570 dev_warn(ddev, "too many alternate settings for " 571 "config %d interface %d: %d, " 572 "using maximum allowed: %d\n", 573 cfgno, inums[i], j, USB_MAXALTSETTING); 574 nalts[i] = j = USB_MAXALTSETTING; 575 } 576 577 len = sizeof(*intfc) + sizeof(struct usb_host_interface) * j; 578 config->intf_cache[i] = intfc = kzalloc(len, GFP_KERNEL); 579 if (!intfc) 580 return -ENOMEM; 581 kref_init(&intfc->ref); 582 } 583 584 /* FIXME: parse the BOS descriptor */ 585 586 /* Skip over any Class Specific or Vendor Specific descriptors; 587 * find the first interface descriptor */ 588 config->extra = buffer; 589 i = find_next_descriptor(buffer, size, USB_DT_INTERFACE, 590 USB_DT_INTERFACE, &n); 591 config->extralen = i; 592 if (n > 0) 593 dev_dbg(ddev, "skipped %d descriptor%s after %s\n", 594 n, plural(n), "configuration"); 595 buffer += i; 596 size -= i; 597 598 /* Parse all the interface/altsetting descriptors */ 599 while (size > 0) { 600 retval = usb_parse_interface(ddev, cfgno, config, 601 buffer, size, inums, nalts); 602 if (retval < 0) 603 return retval; 604 605 buffer += retval; 606 size -= retval; 607 } 608 609 /* Check for missing altsettings */ 610 for (i = 0; i < nintf; ++i) { 611 intfc = config->intf_cache[i]; 612 for (j = 0; j < intfc->num_altsetting; ++j) { 613 for (n = 0; n < intfc->num_altsetting; ++n) { 614 if (intfc->altsetting[n].desc. 615 bAlternateSetting == j) 616 break; 617 } 618 if (n >= intfc->num_altsetting) 619 dev_warn(ddev, "config %d interface %d has no " 620 "altsetting %d\n", cfgno, inums[i], j); 621 } 622 } 623 624 return 0; 625} 626 627/* hub-only!! ... and only exported for reset/reinit path. 628 * otherwise used internally on disconnect/destroy path 629 */ 630void usb_destroy_configuration(struct usb_device *dev) 631{ 632 int c, i; 633 634 if (!dev->config) 635 return; 636 637 if (dev->rawdescriptors) { 638 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) 639 kfree(dev->rawdescriptors[i]); 640 641 kfree(dev->rawdescriptors); 642 dev->rawdescriptors = NULL; 643 } 644 645 for (c = 0; c < dev->descriptor.bNumConfigurations; c++) { 646 struct usb_host_config *cf = &dev->config[c]; 647 648 kfree(cf->string); 649 for (i = 0; i < cf->desc.bNumInterfaces; i++) { 650 if (cf->intf_cache[i]) 651 kref_put(&cf->intf_cache[i]->ref, 652 usb_release_interface_cache); 653 } 654 } 655 kfree(dev->config); 656 dev->config = NULL; 657} 658 659 660/* 661 * Get the USB config descriptors, cache and parse'em 662 * 663 * hub-only!! ... and only in reset path, or usb_new_device() 664 * (used by real hubs and virtual root hubs) 665 */ 666int usb_get_configuration(struct usb_device *dev) 667{ 668 struct device *ddev = &dev->dev; 669 int ncfg = dev->descriptor.bNumConfigurations; 670 int result = 0; 671 unsigned int cfgno, length; 672 unsigned char *bigbuffer; 673 struct usb_config_descriptor *desc; 674 675 cfgno = 0; 676 result = -ENOMEM; 677 if (ncfg > USB_MAXCONFIG) { 678 dev_warn(ddev, "too many configurations: %d, " 679 "using maximum allowed: %d\n", ncfg, USB_MAXCONFIG); 680 dev->descriptor.bNumConfigurations = ncfg = USB_MAXCONFIG; 681 } 682 683 if (ncfg < 1) { 684 dev_err(ddev, "no configurations\n"); 685 return -EINVAL; 686 } 687 688 length = ncfg * sizeof(struct usb_host_config); 689 dev->config = kzalloc(length, GFP_KERNEL); 690 if (!dev->config) 691 goto err2; 692 693 length = ncfg * sizeof(char *); 694 dev->rawdescriptors = kzalloc(length, GFP_KERNEL); 695 if (!dev->rawdescriptors) 696 goto err2; 697 698 desc = kmalloc(USB_DT_CONFIG_SIZE, GFP_KERNEL); 699 if (!desc) 700 goto err2; 701 702 result = 0; 703 for (; cfgno < ncfg; cfgno++) { 704 /* We grab just the first descriptor so we know how long 705 * the whole configuration is */ 706 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, 707 desc, USB_DT_CONFIG_SIZE); 708 if (result < 0) { 709 dev_err(ddev, "unable to read config index %d " 710 "descriptor/%s: %d\n", cfgno, "start", result); 711 if (result != -EPIPE) 712 goto err; 713 dev_err(ddev, "chopping to %d config(s)\n", cfgno); 714 dev->descriptor.bNumConfigurations = cfgno; 715 break; 716 } else if (result < 4) { 717 dev_err(ddev, "config index %d descriptor too short " 718 "(expected %i, got %i)\n", cfgno, 719 USB_DT_CONFIG_SIZE, result); 720 result = -EINVAL; 721 goto err; 722 } 723 length = max((int) le16_to_cpu(desc->wTotalLength), 724 USB_DT_CONFIG_SIZE); 725 726 /* Now that we know the length, get the whole thing */ 727 bigbuffer = kmalloc(length, GFP_KERNEL); 728 if (!bigbuffer) { 729 result = -ENOMEM; 730 goto err; 731 } 732 733 if (dev->quirks & USB_QUIRK_DELAY_INIT) 734 msleep(100); 735 736 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, 737 bigbuffer, length); 738 if (result < 0) { 739 dev_err(ddev, "unable to read config index %d " 740 "descriptor/%s\n", cfgno, "all"); 741 kfree(bigbuffer); 742 goto err; 743 } 744 if (result < length) { 745 dev_warn(ddev, "config index %d descriptor too short " 746 "(expected %i, got %i)\n", cfgno, length, result); 747 length = result; 748 } 749 750 dev->rawdescriptors[cfgno] = bigbuffer; 751 752 result = usb_parse_configuration(dev, cfgno, 753 &dev->config[cfgno], bigbuffer, length); 754 if (result < 0) { 755 ++cfgno; 756 goto err; 757 } 758 } 759 result = 0; 760 761err: 762 kfree(desc); 763 dev->descriptor.bNumConfigurations = cfgno; 764err2: 765 if (result == -ENOMEM) 766 dev_err(ddev, "out of memory\n"); 767 return result; 768} 769 770void usb_release_bos_descriptor(struct usb_device *dev) 771{ 772 if (dev->bos) { 773 kfree(dev->bos->desc); 774 kfree(dev->bos); 775 dev->bos = NULL; 776 } 777} 778 779/* Get BOS descriptor set */ 780int usb_get_bos_descriptor(struct usb_device *dev) 781{ 782 struct device *ddev = &dev->dev; 783 struct usb_bos_descriptor *bos; 784 struct usb_dev_cap_header *cap; 785 unsigned char *buffer; 786 int length, total_len, num, i; 787 int ret; 788 789 bos = kzalloc(sizeof(struct usb_bos_descriptor), GFP_KERNEL); 790 if (!bos) 791 return -ENOMEM; 792 793 /* Get BOS descriptor */ 794 ret = usb_get_descriptor(dev, USB_DT_BOS, 0, bos, USB_DT_BOS_SIZE); 795 if (ret < USB_DT_BOS_SIZE) { 796 dev_err(ddev, "unable to get BOS descriptor\n"); 797 if (ret >= 0) 798 ret = -ENOMSG; 799 kfree(bos); 800 return ret; 801 } 802 803 length = bos->bLength; 804 total_len = le16_to_cpu(bos->wTotalLength); 805 num = bos->bNumDeviceCaps; 806 kfree(bos); 807 if (total_len < length) 808 return -EINVAL; 809 810 dev->bos = kzalloc(sizeof(struct usb_host_bos), GFP_KERNEL); 811 if (!dev->bos) 812 return -ENOMEM; 813 814 /* Now let's get the whole BOS descriptor set */ 815 buffer = kzalloc(total_len, GFP_KERNEL); 816 if (!buffer) { 817 ret = -ENOMEM; 818 goto err; 819 } 820 dev->bos->desc = (struct usb_bos_descriptor *)buffer; 821 822 ret = usb_get_descriptor(dev, USB_DT_BOS, 0, buffer, total_len); 823 if (ret < total_len) { 824 dev_err(ddev, "unable to get BOS descriptor set\n"); 825 if (ret >= 0) 826 ret = -ENOMSG; 827 goto err; 828 } 829 total_len -= length; 830 831 for (i = 0; i < num; i++) { 832 buffer += length; 833 cap = (struct usb_dev_cap_header *)buffer; 834 length = cap->bLength; 835 836 if (total_len < length) 837 break; 838 total_len -= length; 839 840 if (cap->bDescriptorType != USB_DT_DEVICE_CAPABILITY) { 841 dev_warn(ddev, "descriptor type invalid, skip\n"); 842 continue; 843 } 844 845 switch (cap->bDevCapabilityType) { 846 case USB_CAP_TYPE_WIRELESS_USB: 847 /* Wireless USB cap descriptor is handled by wusb */ 848 break; 849 case USB_CAP_TYPE_EXT: 850 dev->bos->ext_cap = 851 (struct usb_ext_cap_descriptor *)buffer; 852 break; 853 case USB_SS_CAP_TYPE: 854 dev->bos->ss_cap = 855 (struct usb_ss_cap_descriptor *)buffer; 856 break; 857 case CONTAINER_ID_TYPE: 858 dev->bos->ss_id = 859 (struct usb_ss_container_id_descriptor *)buffer; 860 break; 861 default: 862 break; 863 } 864 } 865 866 return 0; 867 868err: 869 usb_release_bos_descriptor(dev); 870 return ret; 871} 872