sys/dev/usb/template/usb_template.c

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