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