sys/dev/usb/template/usb_template.c

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