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