root/dev/usb/usb_subr.c

DEFINITIONS

1. usbd_errstr
2. usbd_get_string_desc
3. usbd_get_string
4. usbd_trim_spaces
5. usbd_devinfo_vp
6. usbd_printBCD
7. usbd_devinfo
8. usbd_devinfo_alloc
9. usbd_devinfo_free
10. usb_delay_ms
11. usbd_delay_ms
12. usbd_reset_port
13. usbd_find_idesc
14. usbd_find_edesc
15. usbd_fill_iface_data
16. usbd_free_iface_data
17. usbd_set_config
18. usbd_set_config_no
19. usbd_set_config_index
20. usbd_setup_pipe
21. usbd_kill_pipe
22. usbd_getnewaddr
23. usbd_probe_and_attach
24. usbd_new_device
25. usbd_reload_device_desc
26. usbd_remove_device
27. usbd_print
28. usbd_submatch
29. usbd_fill_deviceinfo
30. usb_free_device
31. usb_disconnect_port

    1 /*      $OpenBSD: usb_subr.c,v 1.57 2007/07/21 16:28:50 deraadt Exp $ */
    2 /*      $NetBSD: usb_subr.c,v 1.103 2003/01/10 11:19:13 augustss Exp $  */
    3 /*      $FreeBSD: src/sys/dev/usb/usb_subr.c,v 1.18 1999/11/17 22:33:47 n_hibma Exp $   */
    5 /*
    6  * Copyright (c) 1998 The NetBSD Foundation, Inc.
    7  * All rights reserved.
    8  *
    9  * This code is derived from software contributed to The NetBSD Foundation
   10  * by Lennart Augustsson (lennart@augustsson.net) at
   11  * Carlstedt Research & Technology.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. All advertising materials mentioning features or use of this software
   22  *    must display the following acknowledgement:
   23  *        This product includes software developed by the NetBSD
   24  *        Foundation, Inc. and its contributors.
   25  * 4. Neither the name of The NetBSD Foundation nor the names of its
   26  *    contributors may be used to endorse or promote products derived
   27  *    from this software without specific prior written permission.
   28  *
   29  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   31  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   32  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   33  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   39  * POSSIBILITY OF SUCH DAMAGE.
   40  */
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/kernel.h>
   45 #include <sys/malloc.h>
   46 #include <sys/device.h>
   47 #include <sys/selinfo.h>
   48 #include <sys/proc.h>
   50 #include <machine/bus.h>
   52 #include <dev/usb/usb.h>
   54 #include <dev/usb/usbdi.h>
   55 #include <dev/usb/usbdi_util.h>
   56 #include <dev/usb/usbdivar.h>
   57 #include <dev/usb/usbdevs.h>
   58 #include <dev/usb/usb_quirks.h>
   60 #ifdef USB_DEBUG
   61 #define DPRINTF(x)      do { if (usbdebug) printf x; } while (0)
   62 #define DPRINTFN(n,x)   do { if (usbdebug>(n)) printf x; } while (0)
   63 extern int usbdebug;
   64 #else
   65 #define DPRINTF(x)
   66 #define DPRINTFN(n,x)
   67 #endif
usbd_status     usbd_set_config(usbd_device_handle, int);
   70 void            usbd_devinfo(usbd_device_handle, int, char *, size_t);
   71 void            usbd_devinfo_vp(usbd_device_handle, char *, char *,
   72                             int);
   73 char            *usbd_get_string(usbd_device_handle, int, char *);
   74 int             usbd_getnewaddr(usbd_bus_handle);
   75 int             usbd_print(void *, const char *);
   76 int             usbd_submatch(struct device *, void *, void *);
   77 void            usbd_free_iface_data(usbd_device_handle, int);
   78 void            usbd_kill_pipe(usbd_pipe_handle);
usbd_status     usbd_probe_and_attach(struct device *,
usbd_device_handle, int, int);
u_int32_t       usb_cookie_no = 0;
   84 #ifdef USBVERBOSE
   85 #include <dev/usb/usbdevs_data.h>
   86 #endif /* USBVERBOSE */
   88 const char * const usbd_error_strs[] = {
   89         "NORMAL_COMPLETION",
   90         "IN_PROGRESS",
   91         "PENDING_REQUESTS",
   92         "NOT_STARTED",
   93         "INVAL",
   94         "NOMEM",
   95         "CANCELLED",
   96         "BAD_ADDRESS",
   97         "IN_USE",
   98         "NO_ADDR",
   99         "SET_ADDR_FAILED",
  100         "NO_POWER",
  101         "TOO_DEEP",
  102         "IOERROR",
  103         "NOT_CONFIGURED",
  104         "TIMEOUT",
  105         "SHORT_XFER",
  106         "STALLED",
  107         "INTERRUPTED",
  108         "XXX",
  109 };
  111 const char *
usbd_errstr(usbd_status err)
  113 {
  114         static char buffer[5];
  116         if (err < USBD_ERROR_MAX)
  117                 return (usbd_error_strs[err]);
  118         else {
snprintf(buffer, sizeof(buffer), "%d", err);
  120                 return (buffer);
  121         }
  122 }
usbd_status
usbd_get_string_desc(usbd_device_handle dev, int sindex, int langid,
usb_string_descriptor_t *sdesc, int *sizep)
  127 {
usb_device_request_t req;
usbd_status err;
  130         int actlen;
req.bmRequestType = UT_READ_DEVICE;
req.bRequest = UR_GET_DESCRIPTOR;
USETW2(req.wValue, UDESC_STRING, sindex);
USETW(req.wIndex, langid);
USETW(req.wLength, 1);  /* only size byte first */
err = usbd_do_request_flags(dev, &req, sdesc, USBD_SHORT_XFER_OK,
  138             &actlen, USBD_DEFAULT_TIMEOUT);
  139         if (err)
  140                 return (err);
  142         if (actlen < 1)
  143                 return (USBD_SHORT_XFER);
USETW(req.wLength, sdesc->bLength);     /* the whole string */
err = usbd_do_request_flags(dev, &req, sdesc, USBD_SHORT_XFER_OK,
  147             &actlen, USBD_DEFAULT_TIMEOUT);
  148         if (err)
  149                 return (err);
  151         if (actlen != sdesc->bLength) {
DPRINTFN(-1, ("usbd_get_string_desc: expected %d, got %d\n",
sdesc->bLength, actlen));
  154         }
  156         *sizep = actlen;
  157         return (USBD_NORMAL_COMPLETION);
  158 }
  160 char *
usbd_get_string(usbd_device_handle dev, int si, char *buf)
  162 {
  163         int swap = dev->quirks->uq_flags & UQ_SWAP_UNICODE;
usb_string_descriptor_t us;
  165         char *s;
  166         int i, n;
u_int16_t c;
usbd_status err;
  169         int size;
  171         if (si == 0)
  172                 return (0);
  173         if (dev->quirks->uq_flags & UQ_NO_STRINGS)
  174                 return (0);
  175         if (dev->langid == USBD_NOLANG) {
  176                 /* Set up default language */
err = usbd_get_string_desc(dev, USB_LANGUAGE_TABLE, 0, &us,
  178                     &size);
  179                 if (err || size < 4)
dev->langid = 0; /* Well, just pick English then */
  181                 else {
  182                         /* Pick the first language as the default. */
dev->langid = UGETW(us.bString[0]);
  184                 }
  185         }
err = usbd_get_string_desc(dev, si, dev->langid, &us, &size);
  187         if (err)
  188                 return (0);
s = buf;
n = size / 2 - 1;
  191         for (i = 0; i < n; i++) {
c = UGETW(us.bString[i]);
  193                 /* Convert from Unicode, handle buggy strings. */
  194                 if ((c & 0xff00) == 0)
  195                         *s++ = c;
  196                 else if ((c & 0x00ff) == 0 && swap)
  197                         *s++ = c >> 8;
  198                 else
  199                         *s++ = '?';
  200         }
  201         *s++ = 0;
  202         return (buf);
  203 }
  205 static void
usbd_trim_spaces(char *p)
  207 {
  208         char *q, *e;
  210         if (p == NULL)
  211                 return;
q = e = p;
  213         while (*q == ' ')       /* skip leading spaces */
q++;
  215         while ((*p = *q++))     /* copy string */
  216                 if (*p++ != ' ') /* remember last non-space */
e = p;
  218         *e = 0;                 /* kill trailing spaces */
  219 }
  221 void
usbd_devinfo_vp(usbd_device_handle dev, char *v, char *p, int usedev)
  223 {
usb_device_descriptor_t *udd = &dev->ddesc;
  225         char *vendor = 0, *product = 0;
  226 #ifdef USBVERBOSE
  227         const struct usb_known_vendor *ukv;
  228         const struct usb_known_product *ukp;
  229 #endif
  231         if (dev == NULL) {
v[0] = p[0] = '\0';
  233                 return;
  234         }
  236         if (usedev) {
vendor = usbd_get_string(dev, udd->iManufacturer, v);
usbd_trim_spaces(vendor);
product = usbd_get_string(dev, udd->iProduct, p);
usbd_trim_spaces(product);
  241         } else {
vendor = NULL;
product = NULL;
  244         }
  245 #ifdef USBVERBOSE
  246         if (vendor == NULL || product == NULL) {
  247                 for(ukv = usb_known_vendors;
ukv->vendorname != NULL;
ukv++) {
  250                         if (ukv->vendor == UGETW(udd->idVendor)) {
vendor = ukv->vendorname;
  252                                 break;
  253                         }
  254                 }
  255                 if (vendor != NULL) {
  256                         for(ukp = usb_known_products;
ukp->productname != NULL;
ukp++) {
  259                                 if (ukp->vendor == UGETW(udd->idVendor) &&
  260                                     (ukp->product == UGETW(udd->idProduct))) {
product = ukp->productname;
  262                                         break;
  263                                 }
  264                         }
  265                 }
  266         }
  267 #endif
  268         if (vendor != NULL && *vendor)
strlcpy(v, vendor, USB_MAX_STRING_LEN); /* XXX */
  270         else
snprintf(v, USB_MAX_STRING_LEN, "vendor 0x%04x", /* XXX */
UGETW(udd->idVendor));
  273         if (product != NULL && *product)
strlcpy(p, product, USB_MAX_STRING_LEN); /* XXX */
  275         else
snprintf(p, USB_MAX_STRING_LEN, "product 0x%04x", /* XXX */
UGETW(udd->idProduct));
  278 }
  280 int
usbd_printBCD(char *cp, size_t len, int bcd)
  282 {
  283         int l;
l = snprintf(cp, len, "%x.%02x", bcd >> 8, bcd & 0xff);
  286         if (l == -1 || len == 0)
  287                 return (0);
  288         if (l >= len)
  289                 return len - 1;
  290         return (l);
  291 }
  293 void
usbd_devinfo(usbd_device_handle dev, int showclass, char *base, size_t len)
  295 {
usb_device_descriptor_t *udd = &dev->ddesc;
  297         char vendor[USB_MAX_STRING_LEN];
  298         char product[USB_MAX_STRING_LEN];
  299         char *cp = base;
  300         int bcdDevice, bcdUSB;
usbd_devinfo_vp(dev, vendor, product, 1);
snprintf(cp, len, "%s %s", vendor, product);
cp += strlen(cp);
  305         if (showclass) {
snprintf(cp, base + len - cp, ", class %d/%d",
udd->bDeviceClass, udd->bDeviceSubClass);
cp += strlen(cp);
  309         }
bcdUSB = UGETW(udd->bcdUSB);
bcdDevice = UGETW(udd->bcdDevice);
snprintf(cp, base + len - cp, ", rev ");
cp += strlen(cp);
usbd_printBCD(cp, base + len - cp, bcdUSB);
cp += strlen(cp);
snprintf(cp, base + len - cp, "/");
cp += strlen(cp);
usbd_printBCD(cp, base + len - cp, bcdDevice);
cp += strlen(cp);
snprintf(cp, base + len - cp, ", addr %d", dev->address);
  321 }
  323 char *
usbd_devinfo_alloc(usbd_device_handle dev, int showclass)
  325 {
  326         char *devinfop;
devinfop = malloc(DEVINFOSIZE, M_TEMP, M_WAITOK);
usbd_devinfo(dev, showclass, devinfop, DEVINFOSIZE);
  330         return devinfop;
  331 }
  333 void
usbd_devinfo_free(char *devinfop)
  335 {
free(devinfop, M_TEMP);
  337 }
  339 /* Delay for a certain number of ms */
  340 void
usb_delay_ms(usbd_bus_handle bus, u_int ms)
  342 {
  343         /* Wait at least two clock ticks so we know the time has passed. */
  344         if (bus->use_polling || cold)
delay((ms+1) * 1000);
  346         else
tsleep(&ms, PRIBIO, "usbdly", (ms*hz+999)/1000 + 1);
  348 }
  350 /* Delay given a device handle. */
  351 void
usbd_delay_ms(usbd_device_handle dev, u_int ms)
  353 {
usb_delay_ms(dev->bus, ms);
  355 }
usbd_status
usbd_reset_port(usbd_device_handle dev, int port, usb_port_status_t *ps)
  359 {
usb_device_request_t req;
usbd_status err;
  362         int n;
req.bmRequestType = UT_WRITE_CLASS_OTHER;
req.bRequest = UR_SET_FEATURE;
USETW(req.wValue, UHF_PORT_RESET);
USETW(req.wIndex, port);
USETW(req.wLength, 0);
err = usbd_do_request(dev, &req, 0);
DPRINTFN(1,("usbd_reset_port: port %d reset done, error=%s\n",
port, usbd_errstr(err)));
  372         if (err)
  373                 return (err);
n = 10;
  375         do {
  376                 /* Wait for device to recover from reset. */
usbd_delay_ms(dev, USB_PORT_RESET_DELAY);
err = usbd_get_port_status(dev, port, ps);
  379                 if (err) {
DPRINTF(("usbd_reset_port: get status failed %d\n",
err));
  382                         return (err);
  383                 }
  384                 /* If the device disappeared, just give up. */
  385                 if (!(UGETW(ps->wPortStatus) & UPS_CURRENT_CONNECT_STATUS))
  386                         return (USBD_NORMAL_COMPLETION);
  387         } while ((UGETW(ps->wPortChange) & UPS_C_PORT_RESET) == 0 && --n > 0);
  388         if (n == 0)
  389                 return (USBD_TIMEOUT);
err = usbd_clear_port_feature(dev, port, UHF_C_PORT_RESET);
  391 #ifdef USB_DEBUG
  392         if (err)
DPRINTF(("usbd_reset_port: clear port feature failed %d\n",
err));
  395 #endif
  397         /* Wait for the device to recover from reset. */
usbd_delay_ms(dev, USB_PORT_RESET_RECOVERY);
  399         return (err);
  400 }
usb_interface_descriptor_t *
usbd_find_idesc(usb_config_descriptor_t *cd, int ifaceidx, int altidx)
  404 {
  405         char *p = (char *)cd;
  406         char *end = p + UGETW(cd->wTotalLength);
usb_interface_descriptor_t *d;
  408         int curidx, lastidx, curaidx = 0;
  410         for (curidx = lastidx = -1; p < end; ) {
d = (usb_interface_descriptor_t *)p;
DPRINTFN(4,("usbd_find_idesc: idx=%d(%d) altidx=%d(%d) len=%d "
  413                             "type=%d\n",
ifaceidx, curidx, altidx, curaidx,
d->bLength, d->bDescriptorType));
  416                 if (d->bLength == 0) /* bad descriptor */
  417                         break;
p += d->bLength;
  419                 if (p <= end && d->bDescriptorType == UDESC_INTERFACE) {
  420                         if (d->bInterfaceNumber != lastidx) {
lastidx = d->bInterfaceNumber;
curidx++;
curaidx = 0;
  424                         } else
curaidx++;
  426                         if (ifaceidx == curidx && altidx == curaidx)
  427                                 return (d);
  428                 }
  429         }
  430         return (NULL);
  431 }
usb_endpoint_descriptor_t *
usbd_find_edesc(usb_config_descriptor_t *cd, int ifaceidx, int altidx,
  435                 int endptidx)
  436 {
  437         char *p = (char *)cd;
  438         char *end = p + UGETW(cd->wTotalLength);
usb_interface_descriptor_t *d;
usb_endpoint_descriptor_t *e;
  441         int curidx;
d = usbd_find_idesc(cd, ifaceidx, altidx);
  444         if (d == NULL)
  445                 return (NULL);
  446         if (endptidx >= d->bNumEndpoints) /* quick exit */
  447                 return (NULL);
curidx = -1;
  450         for (p = (char *)d + d->bLength; p < end; ) {
e = (usb_endpoint_descriptor_t *)p;
  452                 if (e->bLength == 0) /* bad descriptor */
  453                         break;
p += e->bLength;
  455                 if (p <= end && e->bDescriptorType == UDESC_INTERFACE)
  456                         return (NULL);
  457                 if (p <= end && e->bDescriptorType == UDESC_ENDPOINT) {
curidx++;
  459                         if (curidx == endptidx)
  460                                 return (e);
  461                 }
  462         }
  463         return (NULL);
  464 }
usbd_status
usbd_fill_iface_data(usbd_device_handle dev, int ifaceidx, int altidx)
  468 {
usbd_interface_handle ifc = &dev->ifaces[ifaceidx];
usb_interface_descriptor_t *idesc;
  471         char *p, *end;
  472         int endpt, nendpt;
DPRINTFN(4,("usbd_fill_iface_data: ifaceidx=%d altidx=%d\n",
ifaceidx, altidx));
idesc = usbd_find_idesc(dev->cdesc, ifaceidx, altidx);
  477         if (idesc == NULL)
  478                 return (USBD_INVAL);
ifc->device = dev;
ifc->idesc = idesc;
ifc->index = ifaceidx;
ifc->altindex = altidx;
nendpt = ifc->idesc->bNumEndpoints;
DPRINTFN(4,("usbd_fill_iface_data: found idesc nendpt=%d\n", nendpt));
  485         if (nendpt != 0) {
ifc->endpoints = malloc(nendpt * sizeof(struct usbd_endpoint),
M_USB, M_NOWAIT);
  488                 if (ifc->endpoints == NULL)
  489                         return (USBD_NOMEM);
  490         } else
ifc->endpoints = NULL;
ifc->priv = NULL;
p = (char *)ifc->idesc + ifc->idesc->bLength;
end = (char *)dev->cdesc + UGETW(dev->cdesc->wTotalLength);
  495 #define ed ((usb_endpoint_descriptor_t *)p)
  496         for (endpt = 0; endpt < nendpt; endpt++) {
DPRINTFN(10,("usbd_fill_iface_data: endpt=%d\n", endpt));
  498                 for (; p < end; p += ed->bLength) {
DPRINTFN(10,("usbd_fill_iface_data: p=%p end=%p "
  500                             "len=%d type=%d\n", p, end, ed->bLength,
ed->bDescriptorType));
  502                         if (p + ed->bLength <= end && ed->bLength != 0 &&
ed->bDescriptorType == UDESC_ENDPOINT)
  504                                 goto found;
  505                         if (ed->bLength == 0 ||
ed->bDescriptorType == UDESC_INTERFACE)
  507                                 break;
  508                 }
  509                 /* passed end, or bad desc */
printf("usbd_fill_iface_data: bad descriptor(s): %s\n",
ed->bLength == 0 ? "0 length" :
ed->bDescriptorType == UDESC_INTERFACE ? "iface desc" :
  513                     "out of data");
  514                 goto bad;
found:
ifc->endpoints[endpt].edesc = ed;
  517                 if (dev->speed == USB_SPEED_HIGH) {
u_int mps;
  519                         /* Control and bulk endpoints have max packet
  520                            limits. */
  521                         switch (UE_GET_XFERTYPE(ed->bmAttributes)) {
  522                         case UE_CONTROL:
mps = USB_2_MAX_CTRL_PACKET;
  524                                 goto check;
  525                         case UE_BULK:
mps = USB_2_MAX_BULK_PACKET;
check:
  528                                 if (UGETW(ed->wMaxPacketSize) != mps) {
USETW(ed->wMaxPacketSize, mps);
  530 #ifdef DIAGNOSTIC
printf("usbd_fill_iface_data: bad max "
  532                                             "packet size\n");
  533 #endif
  534                                 }
  535                                 break;
  536                         default:
  537                                 break;
  538                         }
  539                 }
ifc->endpoints[endpt].refcnt = 0;
ifc->endpoints[endpt].savedtoggle = 0;
p += ed->bLength;
  543         }
  544 #undef ed
LIST_INIT(&ifc->pipes);
  546         return (USBD_NORMAL_COMPLETION);
bad:
  549         if (ifc->endpoints != NULL) {
free(ifc->endpoints, M_USB);
ifc->endpoints = NULL;
  552         }
  553         return (USBD_INVAL);
  554 }
  556 void
usbd_free_iface_data(usbd_device_handle dev, int ifcno)
  558 {
usbd_interface_handle ifc = &dev->ifaces[ifcno];
  560         if (ifc->endpoints)
free(ifc->endpoints, M_USB);
  562 }
usbd_status
usbd_set_config(usbd_device_handle dev, int conf)
  566 {
usb_device_request_t req;
req.bmRequestType = UT_WRITE_DEVICE;
req.bRequest = UR_SET_CONFIG;
USETW(req.wValue, conf);
USETW(req.wIndex, 0);
USETW(req.wLength, 0);
  574         return (usbd_do_request(dev, &req, 0));
  575 }
usbd_status
usbd_set_config_no(usbd_device_handle dev, int no, int msg)
  579 {
  580         int index;
usb_config_descriptor_t cd;
usbd_status err;
  584         if (no == USB_UNCONFIG_NO)
  585                 return (usbd_set_config_index(dev, USB_UNCONFIG_INDEX, msg));
DPRINTFN(5,("usbd_set_config_no: %d\n", no));
  588         /* Figure out what config index to use. */
  589         for (index = 0; index < dev->ddesc.bNumConfigurations; index++) {
err = usbd_get_config_desc(dev, index, &cd);
  591                 if (err)
  592                         return (err);
  593                 if (cd.bConfigurationValue == no)
  594                         return (usbd_set_config_index(dev, index, msg));
  595         }
  596         return (USBD_INVAL);
  597 }
usbd_status
usbd_set_config_index(usbd_device_handle dev, int index, int msg)
  601 {
usb_status_t ds;
usb_config_descriptor_t cd, *cdp;
usbd_status err;
  605         int i, ifcidx, nifc, len, selfpowered, power;
DPRINTFN(5,("usbd_set_config_index: dev=%p index=%d\n", dev, index));
  609         /* XXX check that all interfaces are idle */
  610         if (dev->config != USB_UNCONFIG_NO) {
DPRINTF(("usbd_set_config_index: free old config\n"));
  612                 /* Free all configuration data structures. */
nifc = dev->cdesc->bNumInterface;
  614                 for (ifcidx = 0; ifcidx < nifc; ifcidx++)
usbd_free_iface_data(dev, ifcidx);
free(dev->ifaces, M_USB);
free(dev->cdesc, M_USB);
dev->ifaces = NULL;
dev->cdesc = NULL;
dev->config = USB_UNCONFIG_NO;
  621         }
  623         if (index == USB_UNCONFIG_INDEX) {
  624                 /* We are unconfiguring the device, so leave unallocated. */
DPRINTF(("usbd_set_config_index: set config 0\n"));
err = usbd_set_config(dev, USB_UNCONFIG_NO);
  627                 if (err)
DPRINTF(("usbd_set_config_index: setting config=0 "
  629                                  "failed, error=%s\n", usbd_errstr(err)));
  630                 return (err);
  631         }
  633         /* Get the short descriptor. */
err = usbd_get_config_desc(dev, index, &cd);
  635         if (err)
  636                 return (err);
len = UGETW(cd.wTotalLength);
cdp = malloc(len, M_USB, M_NOWAIT);
  639         if (cdp == NULL)
  640                 return (USBD_NOMEM);
  641         /* Get the full descriptor. */
  642         for (i = 0; i < 3; i++) {
err = usbd_get_desc(dev, UDESC_CONFIG, index, len, cdp);
  644                 if (!err)
  645                         break;
usbd_delay_ms(dev, 200);
  647         }
  648         if (err)
  649                 goto bad;
  651         if (cdp->bDescriptorType != UDESC_CONFIG) {
DPRINTFN(-1,("usbd_set_config_index: bad desc %d\n",
cdp->bDescriptorType));
err = USBD_INVAL;
  655                 goto bad;
  656         }
  658         /* Figure out if the device is self or bus powered. */
selfpowered = 0;
  660         if (!(dev->quirks->uq_flags & UQ_BUS_POWERED) &&
  661             (cdp->bmAttributes & UC_SELF_POWERED)) {
  662                 /* May be self powered. */
  663                 if (cdp->bmAttributes & UC_BUS_POWERED) {
  664                         /* Must ask device. */
  665                         if (dev->quirks->uq_flags & UQ_POWER_CLAIM) {
  666                                 /*
  667                                  * Hub claims to be self powered, but isn't.
  668                                  * It seems that the power status can be
  669                                  * determined by the hub characteristics.
  670                                  */
usb_hub_descriptor_t hd;
usb_device_request_t req;
req.bmRequestType = UT_READ_CLASS_DEVICE;
req.bRequest = UR_GET_DESCRIPTOR;
USETW(req.wValue, 0);
USETW(req.wIndex, 0);
USETW(req.wLength, USB_HUB_DESCRIPTOR_SIZE);
err = usbd_do_request(dev, &req, &hd);
  679                                 if (!err &&
  680                                     (UGETW(hd.wHubCharacteristics) &
UHD_PWR_INDIVIDUAL))
selfpowered = 1;
DPRINTF(("usbd_set_config_index: charac=0x%04x"
  684                                     ", error=%s\n",
UGETW(hd.wHubCharacteristics),
usbd_errstr(err)));
  687                         } else {
err = usbd_get_device_status(dev, &ds);
  689                                 if (!err &&
  690                                     (UGETW(ds.wStatus) & UDS_SELF_POWERED))
selfpowered = 1;
DPRINTF(("usbd_set_config_index: status=0x%04x"
  693                                     ", error=%s\n",
UGETW(ds.wStatus), usbd_errstr(err)));
  695                         }
  696                 } else
selfpowered = 1;
  698         }
DPRINTF(("usbd_set_config_index: (addr %d) cno=%d attr=0x%02x, "
  700                  "selfpowered=%d, power=%d\n",
cdp->bConfigurationValue, dev->address, cdp->bmAttributes,
selfpowered, cdp->bMaxPower * 2));
  704         /* Check if we have enough power. */
  705 #ifdef USB_DEBUG
  706         if (dev->powersrc == NULL) {
DPRINTF(("usbd_set_config_index: No power source?\n"));
  708                 return (USBD_IOERROR);
  709         }
  710 #endif
power = cdp->bMaxPower * 2;
  712         if (power > dev->powersrc->power) {
DPRINTF(("power exceeded %d %d\n", power,dev->powersrc->power));
  714                 /* XXX print nicer message. */
  715                 if (msg)
printf("%s: device addr %d (config %d) exceeds power "
  717                             "budget, %d mA > %d mA\n",
dev->bus->bdev.dv_xname, dev->address,
cdp->bConfigurationValue,
power, dev->powersrc->power);
err = USBD_NO_POWER;
  722                 goto bad;
  723         }
dev->power = power;
dev->self_powered = selfpowered;
  727         /* Set the actual configuration value. */
DPRINTF(("usbd_set_config_index: set config %d\n",
cdp->bConfigurationValue));
err = usbd_set_config(dev, cdp->bConfigurationValue);
  731         if (err) {
DPRINTF(("usbd_set_config_index: setting config=%d failed, "
  733                     "error=%s\n", cdp->bConfigurationValue, usbd_errstr(err)));
  734                 goto bad;
  735         }
  737         /* Allocate and fill interface data. */
nifc = cdp->bNumInterface;
dev->ifaces = malloc(nifc * sizeof(struct usbd_interface),
M_USB, M_NOWAIT);
  741         if (dev->ifaces == NULL) {
err = USBD_NOMEM;
  743                 goto bad;
  744         }
DPRINTFN(5,("usbd_set_config_index: dev=%p cdesc=%p\n", dev, cdp));
dev->cdesc = cdp;
dev->config = cdp->bConfigurationValue;
  748         for (ifcidx = 0; ifcidx < nifc; ifcidx++) {
err = usbd_fill_iface_data(dev, ifcidx, 0);
  750                 if (err) {
  751                         while (--ifcidx >= 0)
usbd_free_iface_data(dev, ifcidx);
  753                         goto bad;
  754                 }
  755         }
  757         return (USBD_NORMAL_COMPLETION);
bad:
free(cdp, M_USB);
  761         return (err);
  762 }
  764 /* XXX add function for alternate settings */
usbd_status
usbd_setup_pipe(usbd_device_handle dev, usbd_interface_handle iface,
  768                 struct usbd_endpoint *ep, int ival, usbd_pipe_handle *pipe)
  769 {
usbd_pipe_handle p;
usbd_status err;
DPRINTFN(1,("usbd_setup_pipe: dev=%p iface=%p ep=%p pipe=%p\n",
dev, iface, ep, pipe));
p = malloc(dev->bus->pipe_size, M_USB, M_NOWAIT);
  776         if (p == NULL)
  777                 return (USBD_NOMEM);
p->device = dev;
p->iface = iface;
p->endpoint = ep;
ep->refcnt++;
p->refcnt = 1;
p->intrxfer = 0;
p->running = 0;
p->aborting = 0;
p->repeat = 0;
p->interval = ival;
SIMPLEQ_INIT(&p->queue);
err = dev->bus->methods->open_pipe(p);
  790         if (err) {
DPRINTFN(-1,("usbd_setup_pipe: endpoint=0x%x failed, error="
  792                          "%s\n",
ep->edesc->bEndpointAddress, usbd_errstr(err)));
free(p, M_USB);
  795                 return (err);
  796         }
  797         *pipe = p;
  798         return (USBD_NORMAL_COMPLETION);
  799 }
  801 /* Abort the device control pipe. */
  802 void
usbd_kill_pipe(usbd_pipe_handle pipe)
  804 {
usbd_abort_pipe(pipe);
pipe->methods->close(pipe);
pipe->endpoint->refcnt--;
free(pipe, M_USB);
  809 }
  811 int
usbd_getnewaddr(usbd_bus_handle bus)
  813 {
  814         int addr;
  816         for (addr = 1; addr < USB_MAX_DEVICES; addr++)
  817                 if (bus->devices[addr] == 0)
  818                         return (addr);
  819         return (-1);
  820 }
usbd_status
usbd_probe_and_attach(struct device *parent, usbd_device_handle dev, int port,
  825     int addr)
  826 {
  827         struct usb_attach_arg uaa;
usb_device_descriptor_t *dd = &dev->ddesc;
  829         int found, i, confi, nifaces, len;
usbd_status err;
  831         struct device *dv;
usbd_interface_handle *ifaces;
uaa.device = dev;
uaa.iface = NULL;
uaa.ifaces = NULL;
uaa.nifaces = 0;
uaa.usegeneric = 0;
uaa.port = port;
uaa.configno = UHUB_UNK_CONFIGURATION;
uaa.ifaceno = UHUB_UNK_INTERFACE;
uaa.vendor = UGETW(dd->idVendor);
uaa.product = UGETW(dd->idProduct);
uaa.release = UGETW(dd->bcdDevice);
  846         /* First try with device specific drivers. */
DPRINTF(("usbd_probe_and_attach: trying device specific drivers\n"));
dv = config_found_sm(parent, &uaa, usbd_print, usbd_submatch);
  849         if (dv) {
dev->subdevs = malloc(2 * sizeof dv, M_USB, M_NOWAIT);
  851                 if (dev->subdevs == NULL)
  852                         return (USBD_NOMEM);
dev->subdevs[0] = dv;
dev->subdevs[1] = 0;
  855                 return (USBD_NORMAL_COMPLETION);
  856         }
DPRINTF(("usbd_probe_and_attach: no device specific driver found\n"));
DPRINTF(("usbd_probe_and_attach: looping over %d configurations\n",
dd->bNumConfigurations));
  862         /* Next try with interface drivers. */
  863         for (confi = 0; confi < dd->bNumConfigurations; confi++) {
DPRINTFN(1,("usbd_probe_and_attach: trying config idx=%d\n",
confi));
err = usbd_set_config_index(dev, confi, 1);
  867                 if (err) {
  868 #ifdef USB_DEBUG
DPRINTF(("%s: port %d, set config at addr %d failed, "
  870                                  "error=%s\n", parent->dv_xname, port,
addr, usbd_errstr(err)));
  872 #else
printf("%s: port %d, set config at addr %d failed\n",
parent->dv_xname, port, addr);
  875 #endif
  877                         return (err);
  878                 }
nifaces = dev->cdesc->bNumInterface;
uaa.configno = dev->cdesc->bConfigurationValue;
ifaces = malloc(nifaces * sizeof(usbd_interface_handle),
M_USB, M_NOWAIT);
  883                 if (ifaces == NULL)
  884                         return (USBD_NOMEM);
  885                 for (i = 0; i < nifaces; i++)
ifaces[i] = &dev->ifaces[i];
uaa.ifaces = ifaces;
uaa.nifaces = nifaces;
len = (nifaces+1) * sizeof dv;
dev->subdevs = malloc(len, M_USB, M_NOWAIT);
  891                 if (dev->subdevs == NULL) {
free(ifaces, M_USB);
  893                         return (USBD_NOMEM);
  894                 }
bzero(dev->subdevs, len);
found = 0;
  898                 for (i = 0; i < nifaces; i++) {
  899                         if (ifaces[i] == NULL)
  900                                 continue; /* interface already claimed */
uaa.iface = ifaces[i];
uaa.ifaceno = ifaces[i]->idesc->bInterfaceNumber;
dv = config_found_sm(parent, &uaa, usbd_print,
usbd_submatch);
  906                         if (dv != NULL) {
dev->subdevs[found++] = dv;
ifaces[i] = NULL; /* consumed */
  909                         }
  910                 }
free(ifaces, M_USB);
  912                 if (found != 0) {
  913                         return (USBD_NORMAL_COMPLETION);
  914                 }
free(dev->subdevs, M_USB);
dev->subdevs = 0;
  917         }
  918         /* No interfaces were attached in any of the configurations. */
  920         if (dd->bNumConfigurations > 1) /* don't change if only 1 config */
usbd_set_config_index(dev, 0, 0);
DPRINTF(("usbd_probe_and_attach: no interface drivers found\n"));
  925         /* Finally try the generic driver. */
uaa.iface = NULL;
uaa.usegeneric = 1;
uaa.configno = UHUB_UNK_CONFIGURATION;
uaa.ifaceno = UHUB_UNK_INTERFACE;
dv = config_found_sm(parent, &uaa, usbd_print, usbd_submatch);
  931         if (dv != NULL) {
dev->subdevs = malloc(2 * sizeof dv, M_USB, M_NOWAIT);
  933                 if (dev->subdevs == 0)
  934                         return (USBD_NOMEM);
dev->subdevs[0] = dv;
dev->subdevs[1] = 0;
  937                 return (USBD_NORMAL_COMPLETION);
  938         }
  940         /*
  941          * The generic attach failed, but leave the device as it is.
  942          * We just did not find any drivers, that's all.  The device is
  943          * fully operational and not harming anyone.
  944          */
DPRINTF(("usbd_probe_and_attach: generic attach failed\n"));
  946         return (USBD_NORMAL_COMPLETION);
  947 }
  950 /*
  951  * Called when a new device has been put in the powered state,
  952  * but not yet in the addressed state.
  953  * Get initial descriptor, set the address, get full descriptor,
  954  * and attach a driver.
  955  */
usbd_status
usbd_new_device(struct device *parent, usbd_bus_handle bus, int depth,
  958                 int speed, int port, struct usbd_port *up)
  959 {
usbd_device_handle dev, adev;
  961         struct usbd_device *hub;
usb_device_descriptor_t *dd;
usbd_status err;
  964         int addr;
  965         int i;
  966         int p;
DPRINTF(("usbd_new_device bus=%p port=%d depth=%d speed=%d\n",
bus, port, depth, speed));
addr = usbd_getnewaddr(bus);
  971         if (addr < 0) {
printf("%s: No free USB addresses, new device ignored.\n",
bus->bdev.dv_xname);
  974                 return (USBD_NO_ADDR);
  975         }
dev = malloc(sizeof *dev, M_USB, M_NOWAIT);
  978         if (dev == NULL)
  979                 return (USBD_NOMEM);
memset(dev, 0, sizeof *dev);
dev->bus = bus;
  984         /* Set up default endpoint handle. */
dev->def_ep.edesc = &dev->def_ep_desc;
  987         /* Set up default endpoint descriptor. */
dev->def_ep_desc.bLength = USB_ENDPOINT_DESCRIPTOR_SIZE;
dev->def_ep_desc.bDescriptorType = UDESC_ENDPOINT;
dev->def_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT;
dev->def_ep_desc.bmAttributes = UE_CONTROL;
USETW(dev->def_ep_desc.wMaxPacketSize, USB_MAX_IPACKET);
dev->def_ep_desc.bInterval = 0;
dev->quirks = &usbd_no_quirk;
dev->address = USB_START_ADDR;
dev->ddesc.bMaxPacketSize = 0;
dev->depth = depth;
dev->powersrc = up;
dev->myhub = up->parent;
up->device = dev;
 1004         /* Locate port on upstream high speed hub */
 1005         for (adev = dev, hub = up->parent;
hub != NULL && hub->speed != USB_SPEED_HIGH;
adev = hub, hub = hub->myhub)
 1008                 ;
 1009         if (hub) {
 1010                 for (p = 0; p < hub->hub->hubdesc.bNbrPorts; p++) {
 1011                         if (hub->hub->ports[p].device == adev) {
dev->myhsport = &hub->hub->ports[p];
 1013                                 goto found;
 1014                         }
 1015                 }
panic("usbd_new_device: cannot find HS port");
found:
DPRINTFN(1,("usbd_new_device: high speed port %d\n", p));
 1019         } else {
dev->myhsport = NULL;
 1021         }
dev->speed = speed;
dev->langid = USBD_NOLANG;
dev->cookie.cookie = ++usb_cookie_no;
 1026         /* Establish the default pipe. */
err = usbd_setup_pipe(dev, 0, &dev->def_ep, USBD_DEFAULT_INTERVAL,
 1028             &dev->default_pipe);
 1029         if (err) {
usbd_remove_device(dev, up);
 1031                 return (err);
 1032         }
dd = &dev->ddesc;
 1035         /* Try a few times in case the device is slow (i.e. outside specs.) */
 1036         for (i = 0; i < 5; i++) {
 1037                 /* Get the first 8 bytes of the device descriptor. */
err = usbd_get_desc(dev, UDESC_DEVICE, 0, USB_MAX_IPACKET, dd);
 1039                 if (!err)
 1040                         break;
 1041                 /* progressively increase the delay */
usbd_delay_ms(dev, 200 * (i + 1));
 1043         }
 1044         if (err) {
DPRINTFN(-1, ("usbd_new_device: addr=%d, getting first desc "
 1046                     "failed\n", addr));
usbd_remove_device(dev, up);
 1048                 return (err);
 1049         }
 1051         if (speed == USB_SPEED_HIGH) {
 1052                 /* Max packet size must be 64 (sec 5.5.3). */
 1053                 if (dd->bMaxPacketSize != USB_2_MAX_CTRL_PACKET) {
 1054 #ifdef DIAGNOSTIC
printf("usbd_new_device: addr=%d bad max packet size\n",
addr);
 1057 #endif
dd->bMaxPacketSize = USB_2_MAX_CTRL_PACKET;
 1059                 }
 1060         }
DPRINTF(("usbd_new_device: adding unit addr=%d, rev=%02x, class=%d, "
 1063                  "subclass=%d, protocol=%d, maxpacket=%d, len=%d, speed=%d\n",
addr,UGETW(dd->bcdUSB), dd->bDeviceClass, dd->bDeviceSubClass,
dd->bDeviceProtocol, dd->bMaxPacketSize, dd->bLength,
dev->speed));
 1068         if (dd->bDescriptorType != UDESC_DEVICE) {
 1069                 /* Illegal device descriptor */
DPRINTFN(-1,("usbd_new_device: illegal descriptor %d\n",
dd->bDescriptorType));
usbd_remove_device(dev, up);
 1073                 return (USBD_INVAL);
 1074         }
 1076         if (dd->bLength < USB_DEVICE_DESCRIPTOR_SIZE) {
DPRINTFN(-1,("usbd_new_device: bad length %d\n", dd->bLength));
usbd_remove_device(dev, up);
 1079                 return (USBD_INVAL);
 1080         }
USETW(dev->def_ep_desc.wMaxPacketSize, dd->bMaxPacketSize);
err = usbd_reload_device_desc(dev);
 1085         if (err) {
DPRINTFN(-1, ("usbd_new_device: addr=%d, getting full desc "
 1087                     "failed\n", addr));
usbd_remove_device(dev, up);
 1089                 return (err);
 1090         }
 1092         /* Set the address */
DPRINTFN(5,("usbd_new_device: setting device address=%d\n", addr));
err = usbd_set_address(dev, addr);
 1095         if (err) {
DPRINTFN(-1,("usbd_new_device: set address %d failed\n", addr));
err = USBD_SET_ADDR_FAILED;
usbd_remove_device(dev, up);
 1099                 return (err);
 1100         }
 1101         /* Allow device time to set new address */
usbd_delay_ms(dev, USB_SET_ADDRESS_SETTLE);
dev->address = addr;    /* New device address now */
bus->devices[addr] = dev;
 1107         /* Assume 100mA bus powered for now. Changed when configured. */
dev->power = USB_MIN_POWER;
dev->self_powered = 0;
DPRINTF(("usbd_new_device: new dev (addr %d), dev=%p, parent=%p\n",
addr, dev, parent));
usbd_add_dev_event(USB_EVENT_DEVICE_ATTACH, dev);
err = usbd_probe_and_attach(parent, dev, port, addr);
 1117         if (err) {
usbd_remove_device(dev, up);
 1119                 return (err);
 1120         }
 1122         return (USBD_NORMAL_COMPLETION);
 1123 }
usbd_status
usbd_reload_device_desc(usbd_device_handle dev)
 1127 {
usbd_status err;
 1130         /* Get the full device descriptor. */
err = usbd_get_device_desc(dev, &dev->ddesc);
 1132         if (err)
 1133                 return (err);
 1135         /* Figure out what's wrong with this device. */
dev->quirks = usbd_find_quirk(&dev->ddesc);
 1138         return (USBD_NORMAL_COMPLETION);
 1139 }
 1141 void
usbd_remove_device(usbd_device_handle dev, struct usbd_port *up)
 1143 {
DPRINTF(("usbd_remove_device: %p\n", dev));
 1146         if (dev->default_pipe != NULL)
usbd_kill_pipe(dev->default_pipe);
up->device = NULL;
dev->bus->devices[dev->address] = NULL;
free(dev, M_USB);
 1152 }
 1154 int
usbd_print(void *aux, const char *pnp)
 1156 {
 1157         struct usb_attach_arg *uaa = aux;
 1158         char devinfo[1024];
DPRINTFN(15, ("usbd_print dev=%p\n", uaa->device));
 1161         if (pnp) {
 1162                 if (!uaa->usegeneric)
 1163                         return (QUIET);
usbd_devinfo(uaa->device, 1, devinfo, sizeof devinfo);
printf("%s, %s", devinfo, pnp);
 1166         }
 1167         if (uaa->port != 0)
printf(" port %d", uaa->port);
 1169         if (uaa->configno != UHUB_UNK_CONFIGURATION)
printf(" configuration %d", uaa->configno);
 1171         if (uaa->ifaceno != UHUB_UNK_INTERFACE)
printf(" interface %d", uaa->ifaceno);
 1173 #if 0
 1174         /*
 1175          * It gets very crowded with these locators on the attach line.
 1176          * They are not really needed since they are printed in the clear
 1177          * by each driver.
 1178          */
 1179         if (uaa->vendor != UHUB_UNK_VENDOR)
printf(" vendor 0x%04x", uaa->vendor);
 1181         if (uaa->product != UHUB_UNK_PRODUCT)
printf(" product 0x%04x", uaa->product);
 1183         if (uaa->release != UHUB_UNK_RELEASE)
printf(" release 0x%04x", uaa->release);
 1185 #endif
 1186         return (UNCONF);
 1187 }
 1189 int
usbd_submatch(struct device *parent, void *match, void *aux)
 1191 {
 1192         struct cfdata *cf = match;
 1193         struct usb_attach_arg *uaa = aux;
DPRINTFN(5,("usbd_submatch port=%d,%d configno=%d,%d "
 1196             "ifaceno=%d,%d vendor=%d,%d product=%d,%d release=%d,%d\n",
uaa->port, cf->uhubcf_port,
uaa->configno, cf->uhubcf_configuration,
uaa->ifaceno, cf->uhubcf_interface,
uaa->vendor, cf->uhubcf_vendor,
uaa->product, cf->uhubcf_product,
uaa->release, cf->uhubcf_release));
 1203         if (uaa->port != 0 &&   /* root hub has port 0, it should match */
 1204             ((uaa->port != 0 &&
cf->uhubcf_port != UHUB_UNK_PORT &&
cf->uhubcf_port != uaa->port) ||
 1207              (uaa->configno != UHUB_UNK_CONFIGURATION &&
cf->uhubcf_configuration != UHUB_UNK_CONFIGURATION &&
cf->uhubcf_configuration != uaa->configno) ||
 1210              (uaa->ifaceno != UHUB_UNK_INTERFACE &&
cf->uhubcf_interface != UHUB_UNK_INTERFACE &&
cf->uhubcf_interface != uaa->ifaceno) ||
 1213              (uaa->vendor != UHUB_UNK_VENDOR &&
cf->uhubcf_vendor != UHUB_UNK_VENDOR &&
cf->uhubcf_vendor != uaa->vendor) ||
 1216              (uaa->product != UHUB_UNK_PRODUCT &&
cf->uhubcf_product != UHUB_UNK_PRODUCT &&
cf->uhubcf_product != uaa->product) ||
 1219              (uaa->release != UHUB_UNK_RELEASE &&
cf->uhubcf_release != UHUB_UNK_RELEASE &&
cf->uhubcf_release != uaa->release)
 1222              )
 1223            )
 1224                 return 0;
 1225         if (cf->uhubcf_vendor != UHUB_UNK_VENDOR &&
cf->uhubcf_vendor == uaa->vendor &&
cf->uhubcf_product != UHUB_UNK_PRODUCT &&
cf->uhubcf_product == uaa->product) {
 1229                 /* We have a vendor&product locator match */
 1230                 if (cf->uhubcf_release != UHUB_UNK_RELEASE &&
cf->uhubcf_release == uaa->release)
uaa->matchlvl = UMATCH_VENDOR_PRODUCT_REV;
 1233                 else
uaa->matchlvl = UMATCH_VENDOR_PRODUCT;
 1235         } else
uaa->matchlvl = 0;
 1237         return ((*cf->cf_attach->ca_match)(parent, cf, aux));
 1238 }
 1240 void
usbd_fill_deviceinfo(usbd_device_handle dev, struct usb_device_info *di,
 1242     int usedev)
 1243 {
 1244         struct usbd_port *p;
 1245         int i, err, s;
di->udi_bus = dev->bus->bdev.dv_unit;
di->udi_addr = dev->address;
di->udi_cookie = dev->cookie;
usbd_devinfo_vp(dev, di->udi_vendor, di->udi_product, usedev);
usbd_printBCD(di->udi_release, sizeof di->udi_release,
UGETW(dev->ddesc.bcdDevice));
di->udi_vendorNo = UGETW(dev->ddesc.idVendor);
di->udi_productNo = UGETW(dev->ddesc.idProduct);
di->udi_releaseNo = UGETW(dev->ddesc.bcdDevice);
di->udi_class = dev->ddesc.bDeviceClass;
di->udi_subclass = dev->ddesc.bDeviceSubClass;
di->udi_protocol = dev->ddesc.bDeviceProtocol;
di->udi_config = dev->config;
di->udi_power = dev->self_powered ? 0 : dev->power;
di->udi_speed = dev->speed;
 1263         if (dev->subdevs != NULL) {
 1264                 for (i = 0; dev->subdevs[i] && i < USB_MAX_DEVNAMES; i++) {
strncpy(di->udi_devnames[i],
dev->subdevs[i]->dv_xname, USB_MAX_DEVNAMELEN);
di->udi_devnames[i][USB_MAX_DEVNAMELEN-1] = '\0';
 1268                 }
 1269         } else
i = 0;
 1272         for (/*i is set */; i < USB_MAX_DEVNAMES; i++)
di->udi_devnames[i][0] = 0; /* empty */
 1275         if (dev->hub) {
 1276                 for (i = 0;
i < sizeof(di->udi_ports) / sizeof(di->udi_ports[0]) &&
i < dev->hub->hubdesc.bNbrPorts; i++) {
p = &dev->hub->ports[i];
 1280                         if (p->device)
err = p->device->address;
 1282                         else {
s = UGETW(p->status.wPortStatus);
 1284                                 if (s & UPS_PORT_ENABLED)
err = USB_PORT_ENABLED;
 1286                                 else if (s & UPS_SUSPEND)
err = USB_PORT_SUSPENDED;
 1288                                 else if (s & UPS_PORT_POWER)
err = USB_PORT_POWERED;
 1290                                 else
err = USB_PORT_DISABLED;
 1292                         }
di->udi_ports[i] = err;
 1294                 }
di->udi_nports = dev->hub->hubdesc.bNbrPorts;
 1296         } else
di->udi_nports = 0;
 1298 }
 1300 void
usb_free_device(usbd_device_handle dev)
 1302 {
 1303         int ifcidx, nifc;
 1305         if (dev->default_pipe != NULL)
usbd_kill_pipe(dev->default_pipe);
 1307         if (dev->ifaces != NULL) {
nifc = dev->cdesc->bNumInterface;
 1309                 for (ifcidx = 0; ifcidx < nifc; ifcidx++)
usbd_free_iface_data(dev, ifcidx);
free(dev->ifaces, M_USB);
 1312         }
 1313         if (dev->cdesc != NULL)
free(dev->cdesc, M_USB);
 1315         if (dev->subdevs != NULL)
free(dev->subdevs, M_USB);
free(dev, M_USB);
 1318 }
 1320 /*
 1321  * The general mechanism for detaching drivers works as follows: Each
 1322  * driver is responsible for maintaining a reference count on the
 1323  * number of outstanding references to its softc (e.g.  from
 1324  * processing hanging in a read or write).  The detach method of the
 1325  * driver decrements this counter and flags in the softc that the
 1326  * driver is dying and then wakes any sleepers.  It then sleeps on the
 1327  * softc.  Each place that can sleep must maintain the reference
 1328  * count.  When the reference count drops to -1 (0 is the normal value
 1329  * of the reference count) the a wakeup on the softc is performed
 1330  * signaling to the detach waiter that all references are gone.
 1331  */
 1333 /*
 1334  * Called from process context when we discover that a port has
 1335  * been disconnected.
 1336  */
 1337 void
usb_disconnect_port(struct usbd_port *up, struct device *parent)
 1339 {
usbd_device_handle dev = up->device;
 1341         int i;
DPRINTFN(3,("uhub_disconnect: up=%p dev=%p port=%d\n",
up, dev, up->portno));
 1346 #ifdef DIAGNOSTIC
 1347         if (dev == NULL) {
printf("usb_disconnect_port: no device\n");
 1349                 return;
 1350         }
 1351 #endif
 1353         if (dev->subdevs != NULL) {
DPRINTFN(3,("usb_disconnect_port: disconnect subdevs\n"));
 1355                 for (i = 0; dev->subdevs[i]; i++) {
DPRINTF(("%s: at %s", dev->subdevs[i]->dv_xname,
parent->dv_xname));
 1358                         if (up->portno != 0)
DPRINTF((" port %d", up->portno));
DPRINTF((" (addr %d) disconnected\n", dev->address));
config_detach(dev->subdevs[i], DETACH_FORCE);
dev->subdevs[i] = 0;
 1363                 }
 1364         }
usbd_add_dev_event(USB_EVENT_DEVICE_DETACH, dev);
dev->bus->devices[dev->address] = NULL;
up->device = NULL;
usb_free_device(dev);
 1370 }