1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 2007 Hans Petter Selasky. 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 /* 28 * This file contains sub-routines to build up USB descriptors from 29 * USB templates. 30 */ 31 32 #include <sys/stdint.h> 33 #include <sys/stddef.h> 34 #include <sys/param.h> 35 #include <sys/queue.h> 36 #include <sys/types.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/bus.h> 40 #include <sys/linker_set.h> 41 #include <sys/module.h> 42 #include <sys/lock.h> 43 #include <sys/mutex.h> 44 #include <sys/condvar.h> 45 #include <sys/sysctl.h> 46 #include <sys/sx.h> 47 #include <sys/unistd.h> 48 #include <sys/callout.h> 49 #include <sys/malloc.h> 50 #include <sys/priv.h> 51 52 #include <dev/usb/usb.h> 53 #include <dev/usb/usbdi.h> 54 #include <dev/usb/usbdi_util.h> 55 #include "usbdevs.h" 56 57 #include <dev/usb/usb_cdc.h> 58 #include <dev/usb/usb_core.h> 59 #include <dev/usb/usb_dynamic.h> 60 #include <dev/usb/usb_busdma.h> 61 #include <dev/usb/usb_process.h> 62 #include <dev/usb/usb_device.h> 63 64 #define USB_DEBUG_VAR usb_debug 65 #include <dev/usb/usb_debug.h> 66 67 #include <dev/usb/usb_controller.h> 68 #include <dev/usb/usb_bus.h> 69 #include <dev/usb/template/usb_template.h> 70 71 MODULE_DEPEND(usb_template, usb, 1, 1, 1); 72 MODULE_VERSION(usb_template, 1); 73 74 /* function prototypes */ 75 76 static void usb_make_raw_desc(struct usb_temp_setup *, const uint8_t *); 77 static void usb_make_endpoint_desc(struct usb_temp_setup *, 78 const struct usb_temp_endpoint_desc *); 79 static void usb_make_interface_desc(struct usb_temp_setup *, 80 const struct usb_temp_interface_desc *); 81 static void usb_make_config_desc(struct usb_temp_setup *, 82 const struct usb_temp_config_desc *); 83 static void usb_make_device_desc(struct usb_temp_setup *, 84 const struct usb_temp_device_desc *); 85 static uint8_t usb_hw_ep_match(const struct usb_hw_ep_profile *, uint8_t, 86 uint8_t); 87 static uint8_t usb_hw_ep_find_match(struct usb_hw_ep_scratch *, 88 struct usb_hw_ep_scratch_sub *, uint8_t); 89 static uint8_t usb_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t, 90 uint8_t); 91 static usb_error_t usb_hw_ep_resolve(struct usb_device *, 92 struct usb_descriptor *); 93 static const struct usb_temp_device_desc *usb_temp_get_tdd(struct usb_device *); 94 static void *usb_temp_get_device_desc(struct usb_device *); 95 static void *usb_temp_get_qualifier_desc(struct usb_device *); 96 static void *usb_temp_get_config_desc(struct usb_device *, uint16_t *, 97 uint8_t); 98 static const void *usb_temp_get_string_desc(struct usb_device *, uint16_t, 99 uint8_t); 100 static const void *usb_temp_get_vendor_desc(struct usb_device *, 101 const struct usb_device_request *, uint16_t *plen); 102 static const void *usb_temp_get_hub_desc(struct usb_device *); 103 static usb_error_t usb_temp_get_desc(struct usb_device *, 104 struct usb_device_request *, const void **, uint16_t *); 105 static usb_error_t usb_temp_setup_by_index(struct usb_device *, 106 uint16_t index); 107 static void usb_temp_init(void *); 108 109 /*------------------------------------------------------------------------* 110 * usb_make_raw_desc 111 * 112 * This function will insert a raw USB descriptor into the generated 113 * USB configuration. 114 *------------------------------------------------------------------------*/ 115 static void 116 usb_make_raw_desc(struct usb_temp_setup *temp, 117 const uint8_t *raw) 118 { 119 void *dst; 120 uint8_t len; 121 122 /* 123 * The first byte of any USB descriptor gives the length. 124 */ 125 if (raw) { 126 len = raw[0]; 127 if (temp->buf) { 128 dst = USB_ADD_BYTES(temp->buf, temp->size); 129 bcopy(raw, dst, len); 130 131 /* check if we have got a CDC union descriptor */ 132 133 if ((raw[0] >= sizeof(struct usb_cdc_union_descriptor)) && 134 (raw[1] == UDESC_CS_INTERFACE) && 135 (raw[2] == UDESCSUB_CDC_UNION)) { 136 struct usb_cdc_union_descriptor *ud = (void *)dst; 137 138 /* update the interface numbers */ 139 140 ud->bMasterInterface += 141 temp->bInterfaceNumber; 142 ud->bSlaveInterface[0] += 143 temp->bInterfaceNumber; 144 } 145 } 146 temp->size += len; 147 } 148 } 149 150 /*------------------------------------------------------------------------* 151 * usb_make_endpoint_desc 152 * 153 * This function will generate an USB endpoint descriptor from the 154 * given USB template endpoint descriptor, which will be inserted into 155 * the USB configuration. 156 *------------------------------------------------------------------------*/ 157 static void 158 usb_make_endpoint_desc(struct usb_temp_setup *temp, 159 const struct usb_temp_endpoint_desc *ted) 160 { 161 struct usb_endpoint_descriptor *ed; 162 const void **rd; 163 uint16_t old_size; 164 uint16_t mps; 165 uint8_t ea; /* Endpoint Address */ 166 uint8_t et; /* Endpiont Type */ 167 168 /* Reserve memory */ 169 old_size = temp->size; 170 171 ea = (ted->bEndpointAddress & (UE_ADDR | UE_DIR_IN | UE_DIR_OUT)); 172 et = (ted->bmAttributes & UE_XFERTYPE); 173 174 if (et == UE_ISOCHRONOUS) { 175 /* account for extra byte fields */ 176 temp->size += sizeof(*ed) + 2; 177 } else { 178 temp->size += sizeof(*ed); 179 } 180 181 /* Scan all Raw Descriptors first */ 182 rd = ted->ppRawDesc; 183 if (rd) { 184 while (*rd) { 185 usb_make_raw_desc(temp, *rd); 186 rd++; 187 } 188 } 189 if (ted->pPacketSize == NULL) { 190 /* not initialized */ 191 temp->err = USB_ERR_INVAL; 192 return; 193 } 194 mps = ted->pPacketSize->mps[temp->usb_speed]; 195 if (mps == 0) { 196 /* not initialized */ 197 temp->err = USB_ERR_INVAL; 198 return; 199 } else if (mps == UE_ZERO_MPS) { 200 /* escape for Zero Max Packet Size */ 201 mps = 0; 202 } 203 204 /* 205 * Fill out the real USB endpoint descriptor 206 * in case there is a buffer present: 207 */ 208 if (temp->buf) { 209 ed = USB_ADD_BYTES(temp->buf, old_size); 210 if (et == UE_ISOCHRONOUS) 211 ed->bLength = sizeof(*ed) + 2; 212 else 213 ed->bLength = sizeof(*ed); 214 ed->bDescriptorType = UDESC_ENDPOINT; 215 ed->bEndpointAddress = ea; 216 ed->bmAttributes = ted->bmAttributes; 217 USETW(ed->wMaxPacketSize, mps); 218 219 /* setup bInterval parameter */ 220 221 if (ted->pIntervals && 222 ted->pIntervals->bInterval[temp->usb_speed]) { 223 ed->bInterval = 224 ted->pIntervals->bInterval[temp->usb_speed]; 225 } else { 226 switch (et) { 227 case UE_BULK: 228 case UE_CONTROL: 229 ed->bInterval = 0; /* not used */ 230 break; 231 case UE_INTERRUPT: 232 switch (temp->usb_speed) { 233 case USB_SPEED_LOW: 234 case USB_SPEED_FULL: 235 ed->bInterval = 1; /* 1 ms */ 236 break; 237 default: 238 ed->bInterval = 8; /* 8*125 us */ 239 break; 240 } 241 break; 242 default: /* UE_ISOCHRONOUS */ 243 switch (temp->usb_speed) { 244 case USB_SPEED_LOW: 245 case USB_SPEED_FULL: 246 ed->bInterval = 1; /* 1 ms */ 247 break; 248 default: 249 ed->bInterval = 1; /* 125 us */ 250 break; 251 } 252 break; 253 } 254 } 255 } 256 temp->bNumEndpoints++; 257 } 258 259 /*------------------------------------------------------------------------* 260 * usb_make_interface_desc 261 * 262 * This function will generate an USB interface descriptor from the 263 * given USB template interface descriptor, which will be inserted 264 * into the USB configuration. 265 *------------------------------------------------------------------------*/ 266 static void 267 usb_make_interface_desc(struct usb_temp_setup *temp, 268 const struct usb_temp_interface_desc *tid) 269 { 270 struct usb_interface_descriptor *id; 271 const struct usb_temp_endpoint_desc **ted; 272 const void **rd; 273 uint16_t old_size; 274 275 /* Reserve memory */ 276 277 old_size = temp->size; 278 temp->size += sizeof(*id); 279 280 /* Update interface and alternate interface numbers */ 281 282 if (tid->isAltInterface == 0) { 283 temp->bAlternateSetting = 0; 284 temp->bInterfaceNumber++; 285 } else { 286 temp->bAlternateSetting++; 287 } 288 289 /* Scan all Raw Descriptors first */ 290 291 rd = tid->ppRawDesc; 292 293 if (rd) { 294 while (*rd) { 295 usb_make_raw_desc(temp, *rd); 296 rd++; 297 } 298 } 299 /* Reset some counters */ 300 301 temp->bNumEndpoints = 0; 302 303 /* Scan all Endpoint Descriptors second */ 304 305 ted = tid->ppEndpoints; 306 if (ted) { 307 while (*ted) { 308 usb_make_endpoint_desc(temp, *ted); 309 ted++; 310 } 311 } 312 /* 313 * Fill out the real USB interface descriptor 314 * in case there is a buffer present: 315 */ 316 if (temp->buf) { 317 id = USB_ADD_BYTES(temp->buf, old_size); 318 id->bLength = sizeof(*id); 319 id->bDescriptorType = UDESC_INTERFACE; 320 id->bInterfaceNumber = temp->bInterfaceNumber; 321 id->bAlternateSetting = temp->bAlternateSetting; 322 id->bNumEndpoints = temp->bNumEndpoints; 323 id->bInterfaceClass = tid->bInterfaceClass; 324 id->bInterfaceSubClass = tid->bInterfaceSubClass; 325 id->bInterfaceProtocol = tid->bInterfaceProtocol; 326 id->iInterface = tid->iInterface; 327 } 328 } 329 330 /*------------------------------------------------------------------------* 331 * usb_make_config_desc 332 * 333 * This function will generate an USB config descriptor from the given 334 * USB template config descriptor, which will be inserted into the USB 335 * configuration. 336 *------------------------------------------------------------------------*/ 337 static void 338 usb_make_config_desc(struct usb_temp_setup *temp, 339 const struct usb_temp_config_desc *tcd) 340 { 341 struct usb_config_descriptor *cd; 342 const struct usb_temp_interface_desc **tid; 343 uint16_t old_size; 344 345 /* Reserve memory */ 346 347 old_size = temp->size; 348 temp->size += sizeof(*cd); 349 350 /* Reset some counters */ 351 352 temp->bInterfaceNumber = 0 - 1; 353 temp->bAlternateSetting = 0; 354 355 /* Scan all the USB interfaces */ 356 357 tid = tcd->ppIfaceDesc; 358 if (tid) { 359 while (*tid) { 360 usb_make_interface_desc(temp, *tid); 361 tid++; 362 } 363 } 364 /* 365 * Fill out the real USB config descriptor 366 * in case there is a buffer present: 367 */ 368 if (temp->buf) { 369 cd = USB_ADD_BYTES(temp->buf, old_size); 370 371 /* compute total size */ 372 old_size = temp->size - old_size; 373 374 cd->bLength = sizeof(*cd); 375 cd->bDescriptorType = UDESC_CONFIG; 376 USETW(cd->wTotalLength, old_size); 377 cd->bNumInterface = temp->bInterfaceNumber + 1; 378 cd->bConfigurationValue = temp->bConfigurationValue; 379 cd->iConfiguration = tcd->iConfiguration; 380 cd->bmAttributes = tcd->bmAttributes; 381 cd->bMaxPower = tcd->bMaxPower; 382 cd->bmAttributes |= (UC_REMOTE_WAKEUP | UC_BUS_POWERED); 383 384 if (temp->self_powered) { 385 cd->bmAttributes |= UC_SELF_POWERED; 386 } else { 387 cd->bmAttributes &= ~UC_SELF_POWERED; 388 } 389 } 390 } 391 392 /*------------------------------------------------------------------------* 393 * usb_make_device_desc 394 * 395 * This function will generate an USB device descriptor from the 396 * given USB template device descriptor. 397 *------------------------------------------------------------------------*/ 398 static void 399 usb_make_device_desc(struct usb_temp_setup *temp, 400 const struct usb_temp_device_desc *tdd) 401 { 402 struct usb_temp_data *utd; 403 const struct usb_temp_config_desc **tcd; 404 uint16_t old_size; 405 406 /* Reserve memory */ 407 408 old_size = temp->size; 409 temp->size += sizeof(*utd); 410 411 /* Scan all the USB configs */ 412 413 temp->bConfigurationValue = 1; 414 tcd = tdd->ppConfigDesc; 415 if (tcd) { 416 while (*tcd) { 417 usb_make_config_desc(temp, *tcd); 418 temp->bConfigurationValue++; 419 tcd++; 420 } 421 } 422 /* 423 * Fill out the real USB device descriptor 424 * in case there is a buffer present: 425 */ 426 427 if (temp->buf) { 428 utd = USB_ADD_BYTES(temp->buf, old_size); 429 430 /* Store a pointer to our template device descriptor */ 431 utd->tdd = tdd; 432 433 /* Fill out USB device descriptor */ 434 utd->udd.bLength = sizeof(utd->udd); 435 utd->udd.bDescriptorType = UDESC_DEVICE; 436 utd->udd.bDeviceClass = tdd->bDeviceClass; 437 utd->udd.bDeviceSubClass = tdd->bDeviceSubClass; 438 utd->udd.bDeviceProtocol = tdd->bDeviceProtocol; 439 USETW(utd->udd.idVendor, tdd->idVendor); 440 USETW(utd->udd.idProduct, tdd->idProduct); 441 USETW(utd->udd.bcdDevice, tdd->bcdDevice); 442 utd->udd.iManufacturer = tdd->iManufacturer; 443 utd->udd.iProduct = tdd->iProduct; 444 utd->udd.iSerialNumber = tdd->iSerialNumber; 445 utd->udd.bNumConfigurations = temp->bConfigurationValue - 1; 446 447 /* 448 * Fill out the USB device qualifier. Pretend that we 449 * don't support any other speeds by setting 450 * "bNumConfigurations" equal to zero. That saves us 451 * generating an extra set of configuration 452 * descriptors. 453 */ 454 utd->udq.bLength = sizeof(utd->udq); 455 utd->udq.bDescriptorType = UDESC_DEVICE_QUALIFIER; 456 utd->udq.bDeviceClass = tdd->bDeviceClass; 457 utd->udq.bDeviceSubClass = tdd->bDeviceSubClass; 458 utd->udq.bDeviceProtocol = tdd->bDeviceProtocol; 459 utd->udq.bNumConfigurations = 0; 460 USETW(utd->udq.bcdUSB, 0x0200); 461 utd->udq.bMaxPacketSize0 = 0; 462 463 switch (temp->usb_speed) { 464 case USB_SPEED_LOW: 465 USETW(utd->udd.bcdUSB, 0x0110); 466 utd->udd.bMaxPacketSize = 8; 467 break; 468 case USB_SPEED_FULL: 469 USETW(utd->udd.bcdUSB, 0x0110); 470 utd->udd.bMaxPacketSize = 32; 471 break; 472 case USB_SPEED_HIGH: 473 USETW(utd->udd.bcdUSB, 0x0200); 474 utd->udd.bMaxPacketSize = 64; 475 break; 476 case USB_SPEED_VARIABLE: 477 USETW(utd->udd.bcdUSB, 0x0250); 478 utd->udd.bMaxPacketSize = 255; /* 512 bytes */ 479 break; 480 default: 481 temp->err = USB_ERR_INVAL; 482 break; 483 } 484 } 485 } 486 487 /*------------------------------------------------------------------------* 488 * usb_hw_ep_match 489 * 490 * Return values: 491 * 0: The endpoint profile does not match the criterias 492 * Else: The endpoint profile matches the criterias 493 *------------------------------------------------------------------------*/ 494 static uint8_t 495 usb_hw_ep_match(const struct usb_hw_ep_profile *pf, 496 uint8_t ep_type, uint8_t ep_dir_in) 497 { 498 if (ep_type == UE_CONTROL) { 499 /* special */ 500 return (pf->support_control); 501 } 502 if ((pf->support_in && ep_dir_in) || 503 (pf->support_out && !ep_dir_in)) { 504 if ((pf->support_interrupt && (ep_type == UE_INTERRUPT)) || 505 (pf->support_isochronous && (ep_type == UE_ISOCHRONOUS)) || 506 (pf->support_bulk && (ep_type == UE_BULK))) { 507 return (1); 508 } 509 } 510 return (0); 511 } 512 513 /*------------------------------------------------------------------------* 514 * usb_hw_ep_find_match 515 * 516 * This function is used to find the best matching endpoint profile 517 * for and endpoint belonging to an USB descriptor. 518 * 519 * Return values: 520 * 0: Success. Got a match. 521 * Else: Failure. No match. 522 *------------------------------------------------------------------------*/ 523 static uint8_t 524 usb_hw_ep_find_match(struct usb_hw_ep_scratch *ues, 525 struct usb_hw_ep_scratch_sub *ep, uint8_t is_simplex) 526 { 527 const struct usb_hw_ep_profile *pf; 528 uint16_t distance; 529 uint16_t temp; 530 uint16_t max_frame_size; 531 uint8_t n; 532 uint8_t best_n; 533 uint8_t dir_in; 534 uint8_t dir_out; 535 536 distance = 0xFFFF; 537 best_n = 0; 538 539 if ((!ep->needs_in) && (!ep->needs_out)) { 540 return (0); /* we are done */ 541 } 542 if (ep->needs_ep_type == UE_CONTROL) { 543 dir_in = 1; 544 dir_out = 1; 545 } else { 546 if (ep->needs_in) { 547 dir_in = 1; 548 dir_out = 0; 549 } else { 550 dir_in = 0; 551 dir_out = 1; 552 } 553 } 554 555 for (n = 1; n != (USB_EP_MAX / 2); n++) { 556 557 /* get HW endpoint profile */ 558 (ues->methods->get_hw_ep_profile) (ues->udev, &pf, n); 559 if (pf == NULL) { 560 /* end of profiles */ 561 break; 562 } 563 /* check if IN-endpoint is reserved */ 564 if (dir_in || pf->is_simplex) { 565 if (ues->bmInAlloc[n / 8] & (1 << (n % 8))) { 566 /* mismatch */ 567 continue; 568 } 569 } 570 /* check if OUT-endpoint is reserved */ 571 if (dir_out || pf->is_simplex) { 572 if (ues->bmOutAlloc[n / 8] & (1 << (n % 8))) { 573 /* mismatch */ 574 continue; 575 } 576 } 577 /* check simplex */ 578 if (pf->is_simplex == is_simplex) { 579 /* mismatch */ 580 continue; 581 } 582 /* check if HW endpoint matches */ 583 if (!usb_hw_ep_match(pf, ep->needs_ep_type, dir_in)) { 584 /* mismatch */ 585 continue; 586 } 587 /* get maximum frame size */ 588 if (dir_in) 589 max_frame_size = pf->max_in_frame_size; 590 else 591 max_frame_size = pf->max_out_frame_size; 592 593 /* check if we have a matching profile */ 594 if (max_frame_size >= ep->max_frame_size) { 595 temp = (max_frame_size - ep->max_frame_size); 596 if (distance > temp) { 597 distance = temp; 598 best_n = n; 599 ep->pf = pf; 600 } 601 } 602 } 603 604 /* see if we got a match */ 605 if (best_n != 0) { 606 /* get the correct profile */ 607 pf = ep->pf; 608 609 /* reserve IN-endpoint */ 610 if (dir_in) { 611 ues->bmInAlloc[best_n / 8] |= 612 (1 << (best_n % 8)); 613 ep->hw_endpoint_in = best_n | UE_DIR_IN; 614 ep->needs_in = 0; 615 } 616 /* reserve OUT-endpoint */ 617 if (dir_out) { 618 ues->bmOutAlloc[best_n / 8] |= 619 (1 << (best_n % 8)); 620 ep->hw_endpoint_out = best_n | UE_DIR_OUT; 621 ep->needs_out = 0; 622 } 623 return (0); /* got a match */ 624 } 625 return (1); /* failure */ 626 } 627 628 /*------------------------------------------------------------------------* 629 * usb_hw_ep_get_needs 630 * 631 * This function will figure out the type and number of endpoints 632 * which are needed for an USB configuration. 633 * 634 * Return values: 635 * 0: Success. 636 * Else: Failure. 637 *------------------------------------------------------------------------*/ 638 static uint8_t 639 usb_hw_ep_get_needs(struct usb_hw_ep_scratch *ues, 640 uint8_t ep_type, uint8_t is_complete) 641 { 642 const struct usb_hw_ep_profile *pf; 643 struct usb_hw_ep_scratch_sub *ep_iface; 644 struct usb_hw_ep_scratch_sub *ep_curr; 645 struct usb_hw_ep_scratch_sub *ep_max; 646 struct usb_hw_ep_scratch_sub *ep_end; 647 struct usb_descriptor *desc; 648 struct usb_interface_descriptor *id; 649 struct usb_endpoint_descriptor *ed; 650 enum usb_dev_speed speed; 651 uint16_t wMaxPacketSize; 652 uint16_t temp; 653 uint8_t ep_no; 654 655 ep_iface = ues->ep_max; 656 ep_curr = ues->ep_max; 657 ep_end = ues->ep + USB_EP_MAX; 658 ep_max = ues->ep_max; 659 desc = NULL; 660 speed = usbd_get_speed(ues->udev); 661 662 repeat: 663 664 while ((desc = usb_desc_foreach(ues->cd, desc))) { 665 666 if ((desc->bDescriptorType == UDESC_INTERFACE) && 667 (desc->bLength >= sizeof(*id))) { 668 669 id = (void *)desc; 670 671 if (id->bAlternateSetting == 0) { 672 /* going forward */ 673 ep_iface = ep_max; 674 } else { 675 /* reset */ 676 ep_curr = ep_iface; 677 } 678 } 679 if ((desc->bDescriptorType == UDESC_ENDPOINT) && 680 (desc->bLength >= sizeof(*ed))) { 681 682 ed = (void *)desc; 683 684 goto handle_endpoint_desc; 685 } 686 } 687 ues->ep_max = ep_max; 688 return (0); 689 690 handle_endpoint_desc: 691 temp = (ed->bmAttributes & UE_XFERTYPE); 692 693 if (temp == ep_type) { 694 695 if (ep_curr == ep_end) { 696 /* too many endpoints */ 697 return (1); /* failure */ 698 } 699 wMaxPacketSize = UGETW(ed->wMaxPacketSize); 700 if ((wMaxPacketSize & 0xF800) && 701 (speed == USB_SPEED_HIGH)) { 702 /* handle packet multiplier */ 703 temp = (wMaxPacketSize >> 11) & 3; 704 wMaxPacketSize &= 0x7FF; 705 if (temp == 1) { 706 wMaxPacketSize *= 2; 707 } else { 708 wMaxPacketSize *= 3; 709 } 710 } 711 /* 712 * Check if we have a fixed endpoint number, else the 713 * endpoint number is allocated dynamically: 714 */ 715 ep_no = (ed->bEndpointAddress & UE_ADDR); 716 if (ep_no != 0) { 717 718 /* get HW endpoint profile */ 719 (ues->methods->get_hw_ep_profile) 720 (ues->udev, &pf, ep_no); 721 if (pf == NULL) { 722 /* HW profile does not exist - failure */ 723 DPRINTFN(0, "Endpoint profile %u " 724 "does not exist\n", ep_no); 725 return (1); 726 } 727 /* reserve fixed endpoint number */ 728 if (ep_type == UE_CONTROL) { 729 ues->bmInAlloc[ep_no / 8] |= 730 (1 << (ep_no % 8)); 731 ues->bmOutAlloc[ep_no / 8] |= 732 (1 << (ep_no % 8)); 733 if ((pf->max_in_frame_size < wMaxPacketSize) || 734 (pf->max_out_frame_size < wMaxPacketSize)) { 735 DPRINTFN(0, "Endpoint profile %u " 736 "has too small buffer\n", ep_no); 737 return (1); 738 } 739 } else if (ed->bEndpointAddress & UE_DIR_IN) { 740 ues->bmInAlloc[ep_no / 8] |= 741 (1 << (ep_no % 8)); 742 if (pf->max_in_frame_size < wMaxPacketSize) { 743 DPRINTFN(0, "Endpoint profile %u " 744 "has too small buffer\n", ep_no); 745 return (1); 746 } 747 } else { 748 ues->bmOutAlloc[ep_no / 8] |= 749 (1 << (ep_no % 8)); 750 if (pf->max_out_frame_size < wMaxPacketSize) { 751 DPRINTFN(0, "Endpoint profile %u " 752 "has too small buffer\n", ep_no); 753 return (1); 754 } 755 } 756 } else if (is_complete) { 757 758 /* check if we have enough buffer space */ 759 if (wMaxPacketSize > 760 ep_curr->max_frame_size) { 761 return (1); /* failure */ 762 } 763 if (ed->bEndpointAddress & UE_DIR_IN) { 764 ed->bEndpointAddress = 765 ep_curr->hw_endpoint_in; 766 } else { 767 ed->bEndpointAddress = 768 ep_curr->hw_endpoint_out; 769 } 770 771 } else { 772 773 /* compute the maximum frame size */ 774 if (ep_curr->max_frame_size < wMaxPacketSize) { 775 ep_curr->max_frame_size = wMaxPacketSize; 776 } 777 if (temp == UE_CONTROL) { 778 ep_curr->needs_in = 1; 779 ep_curr->needs_out = 1; 780 } else { 781 if (ed->bEndpointAddress & UE_DIR_IN) { 782 ep_curr->needs_in = 1; 783 } else { 784 ep_curr->needs_out = 1; 785 } 786 } 787 ep_curr->needs_ep_type = ep_type; 788 } 789 790 ep_curr++; 791 if (ep_max < ep_curr) { 792 ep_max = ep_curr; 793 } 794 } 795 goto repeat; 796 } 797 798 /*------------------------------------------------------------------------* 799 * usb_hw_ep_resolve 800 * 801 * This function will try to resolve endpoint requirements by the 802 * given endpoint profiles that the USB hardware reports. 803 * 804 * Return values: 805 * 0: Success 806 * Else: Failure 807 *------------------------------------------------------------------------*/ 808 static usb_error_t 809 usb_hw_ep_resolve(struct usb_device *udev, 810 struct usb_descriptor *desc) 811 { 812 struct usb_hw_ep_scratch *ues; 813 struct usb_hw_ep_scratch_sub *ep; 814 const struct usb_hw_ep_profile *pf; 815 struct usb_bus_methods *methods; 816 struct usb_device_descriptor *dd; 817 uint16_t mps; 818 819 if (desc == NULL) { 820 return (USB_ERR_INVAL); 821 } 822 /* get bus methods */ 823 methods = udev->bus->methods; 824 825 if (methods->get_hw_ep_profile == NULL) { 826 return (USB_ERR_INVAL); 827 } 828 if (desc->bDescriptorType == UDESC_DEVICE) { 829 830 if (desc->bLength < sizeof(*dd)) { 831 return (USB_ERR_INVAL); 832 } 833 dd = (void *)desc; 834 835 /* get HW control endpoint 0 profile */ 836 (methods->get_hw_ep_profile) (udev, &pf, 0); 837 if (pf == NULL) { 838 return (USB_ERR_INVAL); 839 } 840 if (!usb_hw_ep_match(pf, UE_CONTROL, 0)) { 841 DPRINTFN(0, "Endpoint 0 does not " 842 "support control\n"); 843 return (USB_ERR_INVAL); 844 } 845 mps = dd->bMaxPacketSize; 846 847 if (udev->speed == USB_SPEED_FULL) { 848 /* 849 * We can optionally choose another packet size ! 850 */ 851 while (1) { 852 /* check if "mps" is ok */ 853 if (pf->max_in_frame_size >= mps) { 854 break; 855 } 856 /* reduce maximum packet size */ 857 mps /= 2; 858 859 /* check if "mps" is too small */ 860 if (mps < 8) { 861 return (USB_ERR_INVAL); 862 } 863 } 864 865 dd->bMaxPacketSize = mps; 866 867 } else { 868 /* We only have one choice */ 869 if (mps == 255) { 870 mps = 512; 871 } 872 /* Check if we support the specified wMaxPacketSize */ 873 if (pf->max_in_frame_size < mps) { 874 return (USB_ERR_INVAL); 875 } 876 } 877 return (0); /* success */ 878 } 879 if (desc->bDescriptorType != UDESC_CONFIG) { 880 return (USB_ERR_INVAL); 881 } 882 if (desc->bLength < sizeof(*(ues->cd))) { 883 return (USB_ERR_INVAL); 884 } 885 ues = udev->bus->scratch[0].hw_ep_scratch; 886 887 bzero(ues, sizeof(*ues)); 888 889 ues->ep_max = ues->ep; 890 ues->cd = (void *)desc; 891 ues->methods = methods; 892 ues->udev = udev; 893 894 /* Get all the endpoints we need */ 895 896 if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) || 897 usb_hw_ep_get_needs(ues, UE_INTERRUPT, 0) || 898 usb_hw_ep_get_needs(ues, UE_CONTROL, 0) || 899 usb_hw_ep_get_needs(ues, UE_BULK, 0)) { 900 DPRINTFN(0, "Could not get needs\n"); 901 return (USB_ERR_INVAL); 902 } 903 for (ep = ues->ep; ep != ues->ep_max; ep++) { 904 905 while (ep->needs_in || ep->needs_out) { 906 907 /* 908 * First try to use a simplex endpoint. 909 * Then try to use a duplex endpoint. 910 */ 911 if (usb_hw_ep_find_match(ues, ep, 1) && 912 usb_hw_ep_find_match(ues, ep, 0)) { 913 DPRINTFN(0, "Could not find match\n"); 914 return (USB_ERR_INVAL); 915 } 916 } 917 } 918 919 ues->ep_max = ues->ep; 920 921 /* Update all endpoint addresses */ 922 923 if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) || 924 usb_hw_ep_get_needs(ues, UE_INTERRUPT, 1) || 925 usb_hw_ep_get_needs(ues, UE_CONTROL, 1) || 926 usb_hw_ep_get_needs(ues, UE_BULK, 1)) { 927 DPRINTFN(0, "Could not update endpoint address\n"); 928 return (USB_ERR_INVAL); 929 } 930 return (0); /* success */ 931 } 932 933 /*------------------------------------------------------------------------* 934 * usb_temp_get_tdd 935 * 936 * Returns: 937 * NULL: No USB template device descriptor found. 938 * Else: Pointer to the USB template device descriptor. 939 *------------------------------------------------------------------------*/ 940 static const struct usb_temp_device_desc * 941 usb_temp_get_tdd(struct usb_device *udev) 942 { 943 if (udev->usb_template_ptr == NULL) { 944 return (NULL); 945 } 946 return (udev->usb_template_ptr->tdd); 947 } 948 949 /*------------------------------------------------------------------------* 950 * usb_temp_get_device_desc 951 * 952 * Returns: 953 * NULL: No USB device descriptor found. 954 * Else: Pointer to USB device descriptor. 955 *------------------------------------------------------------------------*/ 956 static void * 957 usb_temp_get_device_desc(struct usb_device *udev) 958 { 959 struct usb_device_descriptor *dd; 960 961 if (udev->usb_template_ptr == NULL) { 962 return (NULL); 963 } 964 dd = &udev->usb_template_ptr->udd; 965 if (dd->bDescriptorType != UDESC_DEVICE) { 966 /* sanity check failed */ 967 return (NULL); 968 } 969 return (dd); 970 } 971 972 /*------------------------------------------------------------------------* 973 * usb_temp_get_qualifier_desc 974 * 975 * Returns: 976 * NULL: No USB device_qualifier descriptor found. 977 * Else: Pointer to USB device_qualifier descriptor. 978 *------------------------------------------------------------------------*/ 979 static void * 980 usb_temp_get_qualifier_desc(struct usb_device *udev) 981 { 982 struct usb_device_qualifier *dq; 983 984 if (udev->usb_template_ptr == NULL) { 985 return (NULL); 986 } 987 dq = &udev->usb_template_ptr->udq; 988 if (dq->bDescriptorType != UDESC_DEVICE_QUALIFIER) { 989 /* sanity check failed */ 990 return (NULL); 991 } 992 return (dq); 993 } 994 995 /*------------------------------------------------------------------------* 996 * usb_temp_get_config_desc 997 * 998 * Returns: 999 * NULL: No USB config descriptor found. 1000 * Else: Pointer to USB config descriptor having index "index". 1001 *------------------------------------------------------------------------*/ 1002 static void * 1003 usb_temp_get_config_desc(struct usb_device *udev, 1004 uint16_t *pLength, uint8_t index) 1005 { 1006 struct usb_device_descriptor *dd; 1007 struct usb_config_descriptor *cd; 1008 uint16_t temp; 1009 1010 if (udev->usb_template_ptr == NULL) { 1011 return (NULL); 1012 } 1013 dd = &udev->usb_template_ptr->udd; 1014 cd = (void *)(udev->usb_template_ptr + 1); 1015 1016 if (index >= dd->bNumConfigurations) { 1017 /* out of range */ 1018 return (NULL); 1019 } 1020 while (index--) { 1021 if (cd->bDescriptorType != UDESC_CONFIG) { 1022 /* sanity check failed */ 1023 return (NULL); 1024 } 1025 temp = UGETW(cd->wTotalLength); 1026 cd = USB_ADD_BYTES(cd, temp); 1027 } 1028 1029 if (pLength) { 1030 *pLength = UGETW(cd->wTotalLength); 1031 } 1032 return (cd); 1033 } 1034 1035 /*------------------------------------------------------------------------* 1036 * usb_temp_get_vendor_desc 1037 * 1038 * Returns: 1039 * NULL: No vendor descriptor found. 1040 * Else: Pointer to a vendor descriptor. 1041 *------------------------------------------------------------------------*/ 1042 static const void * 1043 usb_temp_get_vendor_desc(struct usb_device *udev, 1044 const struct usb_device_request *req, uint16_t *plen) 1045 { 1046 const struct usb_temp_device_desc *tdd; 1047 1048 tdd = usb_temp_get_tdd(udev); 1049 if (tdd == NULL) { 1050 return (NULL); 1051 } 1052 if (tdd->getVendorDesc == NULL) { 1053 return (NULL); 1054 } 1055 return ((tdd->getVendorDesc) (req, plen)); 1056 } 1057 1058 /*------------------------------------------------------------------------* 1059 * usb_temp_get_string_desc 1060 * 1061 * Returns: 1062 * NULL: No string descriptor found. 1063 * Else: Pointer to a string descriptor. 1064 *------------------------------------------------------------------------*/ 1065 static const void * 1066 usb_temp_get_string_desc(struct usb_device *udev, 1067 uint16_t lang_id, uint8_t string_index) 1068 { 1069 const struct usb_temp_device_desc *tdd; 1070 1071 tdd = usb_temp_get_tdd(udev); 1072 if (tdd == NULL) { 1073 return (NULL); 1074 } 1075 if (tdd->getStringDesc == NULL) { 1076 return (NULL); 1077 } 1078 return ((tdd->getStringDesc) (lang_id, string_index)); 1079 } 1080 1081 /*------------------------------------------------------------------------* 1082 * usb_temp_get_hub_desc 1083 * 1084 * Returns: 1085 * NULL: No USB HUB descriptor found. 1086 * Else: Pointer to a USB HUB descriptor. 1087 *------------------------------------------------------------------------*/ 1088 static const void * 1089 usb_temp_get_hub_desc(struct usb_device *udev) 1090 { 1091 return (NULL); /* needs to be implemented */ 1092 } 1093 1094 /*------------------------------------------------------------------------* 1095 * usb_temp_get_desc 1096 * 1097 * This function is a demultiplexer for local USB device side control 1098 * endpoint requests. 1099 *------------------------------------------------------------------------*/ 1100 static usb_error_t 1101 usb_temp_get_desc(struct usb_device *udev, struct usb_device_request *req, 1102 const void **pPtr, uint16_t *pLength) 1103 { 1104 const uint8_t *buf; 1105 uint16_t len; 1106 1107 buf = NULL; 1108 len = 0; 1109 1110 switch (req->bmRequestType) { 1111 case UT_READ_DEVICE: 1112 switch (req->bRequest) { 1113 case UR_GET_DESCRIPTOR: 1114 goto tr_handle_get_descriptor; 1115 default: 1116 goto tr_stalled; 1117 } 1118 case UT_READ_CLASS_DEVICE: 1119 switch (req->bRequest) { 1120 case UR_GET_DESCRIPTOR: 1121 goto tr_handle_get_class_descriptor; 1122 default: 1123 goto tr_stalled; 1124 } 1125 default: 1126 goto tr_stalled; 1127 } 1128 1129 tr_handle_get_descriptor: 1130 switch (req->wValue[1]) { 1131 case UDESC_DEVICE: 1132 if (req->wValue[0]) { 1133 goto tr_stalled; 1134 } 1135 buf = usb_temp_get_device_desc(udev); 1136 goto tr_valid; 1137 case UDESC_DEVICE_QUALIFIER: 1138 if (udev->speed != USB_SPEED_HIGH) { 1139 goto tr_stalled; 1140 } 1141 if (req->wValue[0]) { 1142 goto tr_stalled; 1143 } 1144 buf = usb_temp_get_qualifier_desc(udev); 1145 goto tr_valid; 1146 case UDESC_OTHER_SPEED_CONFIGURATION: 1147 if (udev->speed != USB_SPEED_HIGH) { 1148 goto tr_stalled; 1149 } 1150 case UDESC_CONFIG: 1151 buf = usb_temp_get_config_desc(udev, 1152 &len, req->wValue[0]); 1153 goto tr_valid; 1154 case UDESC_STRING: 1155 buf = usb_temp_get_string_desc(udev, 1156 UGETW(req->wIndex), req->wValue[0]); 1157 goto tr_valid; 1158 default: 1159 goto tr_stalled; 1160 } 1161 1162 tr_handle_get_class_descriptor: 1163 if (req->wValue[0]) { 1164 goto tr_stalled; 1165 } 1166 buf = usb_temp_get_hub_desc(udev); 1167 goto tr_valid; 1168 1169 tr_valid: 1170 if (buf == NULL) 1171 goto tr_stalled; 1172 if (len == 0) 1173 len = buf[0]; 1174 *pPtr = buf; 1175 *pLength = len; 1176 return (0); /* success */ 1177 1178 tr_stalled: 1179 /* try to get a vendor specific descriptor */ 1180 len = 0; 1181 buf = usb_temp_get_vendor_desc(udev, req, &len); 1182 if (buf != NULL) 1183 goto tr_valid; 1184 *pPtr = NULL; 1185 *pLength = 0; 1186 return (0); /* we ignore failures */ 1187 } 1188 1189 /*------------------------------------------------------------------------* 1190 * usb_temp_setup 1191 * 1192 * This function generates USB descriptors according to the given USB 1193 * template device descriptor. It will also try to figure out the best 1194 * matching endpoint addresses using the hardware endpoint profiles. 1195 * 1196 * Returns: 1197 * 0: Success 1198 * Else: Failure 1199 *------------------------------------------------------------------------*/ 1200 usb_error_t 1201 usb_temp_setup(struct usb_device *udev, 1202 const struct usb_temp_device_desc *tdd) 1203 { 1204 struct usb_temp_setup *uts; 1205 void *buf; 1206 uint8_t n; 1207 1208 if (tdd == NULL) { 1209 /* be NULL safe */ 1210 return (0); 1211 } 1212 uts = udev->bus->scratch[0].temp_setup; 1213 1214 bzero(uts, sizeof(*uts)); 1215 1216 uts->usb_speed = udev->speed; 1217 uts->self_powered = udev->flags.self_powered; 1218 1219 /* first pass */ 1220 1221 usb_make_device_desc(uts, tdd); 1222 1223 if (uts->err) { 1224 /* some error happened */ 1225 return (uts->err); 1226 } 1227 /* sanity check */ 1228 if (uts->size == 0) { 1229 return (USB_ERR_INVAL); 1230 } 1231 /* allocate zeroed memory */ 1232 uts->buf = malloc(uts->size, M_USB, M_WAITOK | M_ZERO); 1233 if (uts->buf == NULL) { 1234 /* could not allocate memory */ 1235 return (USB_ERR_NOMEM); 1236 } 1237 /* second pass */ 1238 1239 uts->size = 0; 1240 1241 usb_make_device_desc(uts, tdd); 1242 1243 /* 1244 * Store a pointer to our descriptors: 1245 */ 1246 udev->usb_template_ptr = uts->buf; 1247 1248 if (uts->err) { 1249 /* some error happened during second pass */ 1250 goto error; 1251 } 1252 /* 1253 * Resolve all endpoint addresses ! 1254 */ 1255 buf = usb_temp_get_device_desc(udev); 1256 uts->err = usb_hw_ep_resolve(udev, buf); 1257 if (uts->err) { 1258 DPRINTFN(0, "Could not resolve endpoints for " 1259 "Device Descriptor, error = %s\n", 1260 usbd_errstr(uts->err)); 1261 goto error; 1262 } 1263 for (n = 0;; n++) { 1264 1265 buf = usb_temp_get_config_desc(udev, NULL, n); 1266 if (buf == NULL) { 1267 break; 1268 } 1269 uts->err = usb_hw_ep_resolve(udev, buf); 1270 if (uts->err) { 1271 DPRINTFN(0, "Could not resolve endpoints for " 1272 "Config Descriptor %u, error = %s\n", n, 1273 usbd_errstr(uts->err)); 1274 goto error; 1275 } 1276 } 1277 return (uts->err); 1278 1279 error: 1280 usb_temp_unsetup(udev); 1281 return (uts->err); 1282 } 1283 1284 /*------------------------------------------------------------------------* 1285 * usb_temp_unsetup 1286 * 1287 * This function frees any memory associated with the currently 1288 * setup template, if any. 1289 *------------------------------------------------------------------------*/ 1290 void 1291 usb_temp_unsetup(struct usb_device *udev) 1292 { 1293 if (udev->usb_template_ptr) { 1294 1295 free(udev->usb_template_ptr, M_USB); 1296 1297 udev->usb_template_ptr = NULL; 1298 } 1299 } 1300 1301 static usb_error_t 1302 usb_temp_setup_by_index(struct usb_device *udev, uint16_t index) 1303 { 1304 usb_error_t err; 1305 1306 switch (index) { 1307 case 0: 1308 err = usb_temp_setup(udev, &usb_template_msc); 1309 break; 1310 case 1: 1311 err = usb_temp_setup(udev, &usb_template_cdce); 1312 break; 1313 case 2: 1314 err = usb_temp_setup(udev, &usb_template_mtp); 1315 break; 1316 default: 1317 return (USB_ERR_INVAL); 1318 } 1319 1320 return (err); 1321 } 1322 1323 static void 1324 usb_temp_init(void *arg) 1325 { 1326 /* register our functions */ 1327 usb_temp_get_desc_p = &usb_temp_get_desc; 1328 usb_temp_setup_by_index_p = &usb_temp_setup_by_index; 1329 usb_temp_unsetup_p = &usb_temp_unsetup; 1330 } 1331 1332 SYSINIT(usb_temp_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_temp_init, NULL); 1333 SYSUNINIT(usb_temp_unload, SI_SUB_LOCK, SI_ORDER_ANY, usb_temp_unload, NULL); 1334