Annotation of sys/dev/usb/usb_subr.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 4:
! 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: */
! 41:
! 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>
! 49:
! 50: #include <machine/bus.h>
! 51:
! 52: #include <dev/usb/usb.h>
! 53:
! 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>
! 59:
! 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
! 68:
! 69: 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);
! 79: usbd_status usbd_probe_and_attach(struct device *,
! 80: usbd_device_handle, int, int);
! 81:
! 82: u_int32_t usb_cookie_no = 0;
! 83:
! 84: #ifdef USBVERBOSE
! 85: #include <dev/usb/usbdevs_data.h>
! 86: #endif /* USBVERBOSE */
! 87:
! 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: };
! 110:
! 111: const char *
! 112: usbd_errstr(usbd_status err)
! 113: {
! 114: static char buffer[5];
! 115:
! 116: if (err < USBD_ERROR_MAX)
! 117: return (usbd_error_strs[err]);
! 118: else {
! 119: snprintf(buffer, sizeof(buffer), "%d", err);
! 120: return (buffer);
! 121: }
! 122: }
! 123:
! 124: usbd_status
! 125: usbd_get_string_desc(usbd_device_handle dev, int sindex, int langid,
! 126: usb_string_descriptor_t *sdesc, int *sizep)
! 127: {
! 128: usb_device_request_t req;
! 129: usbd_status err;
! 130: int actlen;
! 131:
! 132: req.bmRequestType = UT_READ_DEVICE;
! 133: req.bRequest = UR_GET_DESCRIPTOR;
! 134: USETW2(req.wValue, UDESC_STRING, sindex);
! 135: USETW(req.wIndex, langid);
! 136: USETW(req.wLength, 1); /* only size byte first */
! 137: err = usbd_do_request_flags(dev, &req, sdesc, USBD_SHORT_XFER_OK,
! 138: &actlen, USBD_DEFAULT_TIMEOUT);
! 139: if (err)
! 140: return (err);
! 141:
! 142: if (actlen < 1)
! 143: return (USBD_SHORT_XFER);
! 144:
! 145: USETW(req.wLength, sdesc->bLength); /* the whole string */
! 146: err = usbd_do_request_flags(dev, &req, sdesc, USBD_SHORT_XFER_OK,
! 147: &actlen, USBD_DEFAULT_TIMEOUT);
! 148: if (err)
! 149: return (err);
! 150:
! 151: if (actlen != sdesc->bLength) {
! 152: DPRINTFN(-1, ("usbd_get_string_desc: expected %d, got %d\n",
! 153: sdesc->bLength, actlen));
! 154: }
! 155:
! 156: *sizep = actlen;
! 157: return (USBD_NORMAL_COMPLETION);
! 158: }
! 159:
! 160: char *
! 161: usbd_get_string(usbd_device_handle dev, int si, char *buf)
! 162: {
! 163: int swap = dev->quirks->uq_flags & UQ_SWAP_UNICODE;
! 164: usb_string_descriptor_t us;
! 165: char *s;
! 166: int i, n;
! 167: u_int16_t c;
! 168: usbd_status err;
! 169: int size;
! 170:
! 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 */
! 177: err = usbd_get_string_desc(dev, USB_LANGUAGE_TABLE, 0, &us,
! 178: &size);
! 179: if (err || size < 4)
! 180: dev->langid = 0; /* Well, just pick English then */
! 181: else {
! 182: /* Pick the first language as the default. */
! 183: dev->langid = UGETW(us.bString[0]);
! 184: }
! 185: }
! 186: err = usbd_get_string_desc(dev, si, dev->langid, &us, &size);
! 187: if (err)
! 188: return (0);
! 189: s = buf;
! 190: n = size / 2 - 1;
! 191: for (i = 0; i < n; i++) {
! 192: 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: }
! 204:
! 205: static void
! 206: usbd_trim_spaces(char *p)
! 207: {
! 208: char *q, *e;
! 209:
! 210: if (p == NULL)
! 211: return;
! 212: q = e = p;
! 213: while (*q == ' ') /* skip leading spaces */
! 214: q++;
! 215: while ((*p = *q++)) /* copy string */
! 216: if (*p++ != ' ') /* remember last non-space */
! 217: e = p;
! 218: *e = 0; /* kill trailing spaces */
! 219: }
! 220:
! 221: void
! 222: usbd_devinfo_vp(usbd_device_handle dev, char *v, char *p, int usedev)
! 223: {
! 224: 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
! 230:
! 231: if (dev == NULL) {
! 232: v[0] = p[0] = '\0';
! 233: return;
! 234: }
! 235:
! 236: if (usedev) {
! 237: vendor = usbd_get_string(dev, udd->iManufacturer, v);
! 238: usbd_trim_spaces(vendor);
! 239: product = usbd_get_string(dev, udd->iProduct, p);
! 240: usbd_trim_spaces(product);
! 241: } else {
! 242: vendor = NULL;
! 243: product = NULL;
! 244: }
! 245: #ifdef USBVERBOSE
! 246: if (vendor == NULL || product == NULL) {
! 247: for(ukv = usb_known_vendors;
! 248: ukv->vendorname != NULL;
! 249: ukv++) {
! 250: if (ukv->vendor == UGETW(udd->idVendor)) {
! 251: vendor = ukv->vendorname;
! 252: break;
! 253: }
! 254: }
! 255: if (vendor != NULL) {
! 256: for(ukp = usb_known_products;
! 257: ukp->productname != NULL;
! 258: ukp++) {
! 259: if (ukp->vendor == UGETW(udd->idVendor) &&
! 260: (ukp->product == UGETW(udd->idProduct))) {
! 261: product = ukp->productname;
! 262: break;
! 263: }
! 264: }
! 265: }
! 266: }
! 267: #endif
! 268: if (vendor != NULL && *vendor)
! 269: strlcpy(v, vendor, USB_MAX_STRING_LEN); /* XXX */
! 270: else
! 271: snprintf(v, USB_MAX_STRING_LEN, "vendor 0x%04x", /* XXX */
! 272: UGETW(udd->idVendor));
! 273: if (product != NULL && *product)
! 274: strlcpy(p, product, USB_MAX_STRING_LEN); /* XXX */
! 275: else
! 276: snprintf(p, USB_MAX_STRING_LEN, "product 0x%04x", /* XXX */
! 277: UGETW(udd->idProduct));
! 278: }
! 279:
! 280: int
! 281: usbd_printBCD(char *cp, size_t len, int bcd)
! 282: {
! 283: int l;
! 284:
! 285: 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: }
! 292:
! 293: void
! 294: usbd_devinfo(usbd_device_handle dev, int showclass, char *base, size_t len)
! 295: {
! 296: 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;
! 301:
! 302: usbd_devinfo_vp(dev, vendor, product, 1);
! 303: snprintf(cp, len, "%s %s", vendor, product);
! 304: cp += strlen(cp);
! 305: if (showclass) {
! 306: snprintf(cp, base + len - cp, ", class %d/%d",
! 307: udd->bDeviceClass, udd->bDeviceSubClass);
! 308: cp += strlen(cp);
! 309: }
! 310: bcdUSB = UGETW(udd->bcdUSB);
! 311: bcdDevice = UGETW(udd->bcdDevice);
! 312: snprintf(cp, base + len - cp, ", rev ");
! 313: cp += strlen(cp);
! 314: usbd_printBCD(cp, base + len - cp, bcdUSB);
! 315: cp += strlen(cp);
! 316: snprintf(cp, base + len - cp, "/");
! 317: cp += strlen(cp);
! 318: usbd_printBCD(cp, base + len - cp, bcdDevice);
! 319: cp += strlen(cp);
! 320: snprintf(cp, base + len - cp, ", addr %d", dev->address);
! 321: }
! 322:
! 323: char *
! 324: usbd_devinfo_alloc(usbd_device_handle dev, int showclass)
! 325: {
! 326: char *devinfop;
! 327:
! 328: devinfop = malloc(DEVINFOSIZE, M_TEMP, M_WAITOK);
! 329: usbd_devinfo(dev, showclass, devinfop, DEVINFOSIZE);
! 330: return devinfop;
! 331: }
! 332:
! 333: void
! 334: usbd_devinfo_free(char *devinfop)
! 335: {
! 336: free(devinfop, M_TEMP);
! 337: }
! 338:
! 339: /* Delay for a certain number of ms */
! 340: void
! 341: 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)
! 345: delay((ms+1) * 1000);
! 346: else
! 347: tsleep(&ms, PRIBIO, "usbdly", (ms*hz+999)/1000 + 1);
! 348: }
! 349:
! 350: /* Delay given a device handle. */
! 351: void
! 352: usbd_delay_ms(usbd_device_handle dev, u_int ms)
! 353: {
! 354: usb_delay_ms(dev->bus, ms);
! 355: }
! 356:
! 357: usbd_status
! 358: usbd_reset_port(usbd_device_handle dev, int port, usb_port_status_t *ps)
! 359: {
! 360: usb_device_request_t req;
! 361: usbd_status err;
! 362: int n;
! 363:
! 364: req.bmRequestType = UT_WRITE_CLASS_OTHER;
! 365: req.bRequest = UR_SET_FEATURE;
! 366: USETW(req.wValue, UHF_PORT_RESET);
! 367: USETW(req.wIndex, port);
! 368: USETW(req.wLength, 0);
! 369: err = usbd_do_request(dev, &req, 0);
! 370: DPRINTFN(1,("usbd_reset_port: port %d reset done, error=%s\n",
! 371: port, usbd_errstr(err)));
! 372: if (err)
! 373: return (err);
! 374: n = 10;
! 375: do {
! 376: /* Wait for device to recover from reset. */
! 377: usbd_delay_ms(dev, USB_PORT_RESET_DELAY);
! 378: err = usbd_get_port_status(dev, port, ps);
! 379: if (err) {
! 380: DPRINTF(("usbd_reset_port: get status failed %d\n",
! 381: 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);
! 390: err = usbd_clear_port_feature(dev, port, UHF_C_PORT_RESET);
! 391: #ifdef USB_DEBUG
! 392: if (err)
! 393: DPRINTF(("usbd_reset_port: clear port feature failed %d\n",
! 394: err));
! 395: #endif
! 396:
! 397: /* Wait for the device to recover from reset. */
! 398: usbd_delay_ms(dev, USB_PORT_RESET_RECOVERY);
! 399: return (err);
! 400: }
! 401:
! 402: usb_interface_descriptor_t *
! 403: 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);
! 407: usb_interface_descriptor_t *d;
! 408: int curidx, lastidx, curaidx = 0;
! 409:
! 410: for (curidx = lastidx = -1; p < end; ) {
! 411: d = (usb_interface_descriptor_t *)p;
! 412: DPRINTFN(4,("usbd_find_idesc: idx=%d(%d) altidx=%d(%d) len=%d "
! 413: "type=%d\n",
! 414: ifaceidx, curidx, altidx, curaidx,
! 415: d->bLength, d->bDescriptorType));
! 416: if (d->bLength == 0) /* bad descriptor */
! 417: break;
! 418: p += d->bLength;
! 419: if (p <= end && d->bDescriptorType == UDESC_INTERFACE) {
! 420: if (d->bInterfaceNumber != lastidx) {
! 421: lastidx = d->bInterfaceNumber;
! 422: curidx++;
! 423: curaidx = 0;
! 424: } else
! 425: curaidx++;
! 426: if (ifaceidx == curidx && altidx == curaidx)
! 427: return (d);
! 428: }
! 429: }
! 430: return (NULL);
! 431: }
! 432:
! 433: usb_endpoint_descriptor_t *
! 434: 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);
! 439: usb_interface_descriptor_t *d;
! 440: usb_endpoint_descriptor_t *e;
! 441: int curidx;
! 442:
! 443: d = usbd_find_idesc(cd, ifaceidx, altidx);
! 444: if (d == NULL)
! 445: return (NULL);
! 446: if (endptidx >= d->bNumEndpoints) /* quick exit */
! 447: return (NULL);
! 448:
! 449: curidx = -1;
! 450: for (p = (char *)d + d->bLength; p < end; ) {
! 451: e = (usb_endpoint_descriptor_t *)p;
! 452: if (e->bLength == 0) /* bad descriptor */
! 453: break;
! 454: p += e->bLength;
! 455: if (p <= end && e->bDescriptorType == UDESC_INTERFACE)
! 456: return (NULL);
! 457: if (p <= end && e->bDescriptorType == UDESC_ENDPOINT) {
! 458: curidx++;
! 459: if (curidx == endptidx)
! 460: return (e);
! 461: }
! 462: }
! 463: return (NULL);
! 464: }
! 465:
! 466: usbd_status
! 467: usbd_fill_iface_data(usbd_device_handle dev, int ifaceidx, int altidx)
! 468: {
! 469: usbd_interface_handle ifc = &dev->ifaces[ifaceidx];
! 470: usb_interface_descriptor_t *idesc;
! 471: char *p, *end;
! 472: int endpt, nendpt;
! 473:
! 474: DPRINTFN(4,("usbd_fill_iface_data: ifaceidx=%d altidx=%d\n",
! 475: ifaceidx, altidx));
! 476: idesc = usbd_find_idesc(dev->cdesc, ifaceidx, altidx);
! 477: if (idesc == NULL)
! 478: return (USBD_INVAL);
! 479: ifc->device = dev;
! 480: ifc->idesc = idesc;
! 481: ifc->index = ifaceidx;
! 482: ifc->altindex = altidx;
! 483: nendpt = ifc->idesc->bNumEndpoints;
! 484: DPRINTFN(4,("usbd_fill_iface_data: found idesc nendpt=%d\n", nendpt));
! 485: if (nendpt != 0) {
! 486: ifc->endpoints = malloc(nendpt * sizeof(struct usbd_endpoint),
! 487: M_USB, M_NOWAIT);
! 488: if (ifc->endpoints == NULL)
! 489: return (USBD_NOMEM);
! 490: } else
! 491: ifc->endpoints = NULL;
! 492: ifc->priv = NULL;
! 493: p = (char *)ifc->idesc + ifc->idesc->bLength;
! 494: end = (char *)dev->cdesc + UGETW(dev->cdesc->wTotalLength);
! 495: #define ed ((usb_endpoint_descriptor_t *)p)
! 496: for (endpt = 0; endpt < nendpt; endpt++) {
! 497: DPRINTFN(10,("usbd_fill_iface_data: endpt=%d\n", endpt));
! 498: for (; p < end; p += ed->bLength) {
! 499: DPRINTFN(10,("usbd_fill_iface_data: p=%p end=%p "
! 500: "len=%d type=%d\n", p, end, ed->bLength,
! 501: ed->bDescriptorType));
! 502: if (p + ed->bLength <= end && ed->bLength != 0 &&
! 503: ed->bDescriptorType == UDESC_ENDPOINT)
! 504: goto found;
! 505: if (ed->bLength == 0 ||
! 506: ed->bDescriptorType == UDESC_INTERFACE)
! 507: break;
! 508: }
! 509: /* passed end, or bad desc */
! 510: printf("usbd_fill_iface_data: bad descriptor(s): %s\n",
! 511: ed->bLength == 0 ? "0 length" :
! 512: ed->bDescriptorType == UDESC_INTERFACE ? "iface desc" :
! 513: "out of data");
! 514: goto bad;
! 515: found:
! 516: ifc->endpoints[endpt].edesc = ed;
! 517: if (dev->speed == USB_SPEED_HIGH) {
! 518: u_int mps;
! 519: /* Control and bulk endpoints have max packet
! 520: limits. */
! 521: switch (UE_GET_XFERTYPE(ed->bmAttributes)) {
! 522: case UE_CONTROL:
! 523: mps = USB_2_MAX_CTRL_PACKET;
! 524: goto check;
! 525: case UE_BULK:
! 526: mps = USB_2_MAX_BULK_PACKET;
! 527: check:
! 528: if (UGETW(ed->wMaxPacketSize) != mps) {
! 529: USETW(ed->wMaxPacketSize, mps);
! 530: #ifdef DIAGNOSTIC
! 531: printf("usbd_fill_iface_data: bad max "
! 532: "packet size\n");
! 533: #endif
! 534: }
! 535: break;
! 536: default:
! 537: break;
! 538: }
! 539: }
! 540: ifc->endpoints[endpt].refcnt = 0;
! 541: ifc->endpoints[endpt].savedtoggle = 0;
! 542: p += ed->bLength;
! 543: }
! 544: #undef ed
! 545: LIST_INIT(&ifc->pipes);
! 546: return (USBD_NORMAL_COMPLETION);
! 547:
! 548: bad:
! 549: if (ifc->endpoints != NULL) {
! 550: free(ifc->endpoints, M_USB);
! 551: ifc->endpoints = NULL;
! 552: }
! 553: return (USBD_INVAL);
! 554: }
! 555:
! 556: void
! 557: usbd_free_iface_data(usbd_device_handle dev, int ifcno)
! 558: {
! 559: usbd_interface_handle ifc = &dev->ifaces[ifcno];
! 560: if (ifc->endpoints)
! 561: free(ifc->endpoints, M_USB);
! 562: }
! 563:
! 564: usbd_status
! 565: usbd_set_config(usbd_device_handle dev, int conf)
! 566: {
! 567: usb_device_request_t req;
! 568:
! 569: req.bmRequestType = UT_WRITE_DEVICE;
! 570: req.bRequest = UR_SET_CONFIG;
! 571: USETW(req.wValue, conf);
! 572: USETW(req.wIndex, 0);
! 573: USETW(req.wLength, 0);
! 574: return (usbd_do_request(dev, &req, 0));
! 575: }
! 576:
! 577: usbd_status
! 578: usbd_set_config_no(usbd_device_handle dev, int no, int msg)
! 579: {
! 580: int index;
! 581: usb_config_descriptor_t cd;
! 582: usbd_status err;
! 583:
! 584: if (no == USB_UNCONFIG_NO)
! 585: return (usbd_set_config_index(dev, USB_UNCONFIG_INDEX, msg));
! 586:
! 587: 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++) {
! 590: 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: }
! 598:
! 599: usbd_status
! 600: usbd_set_config_index(usbd_device_handle dev, int index, int msg)
! 601: {
! 602: usb_status_t ds;
! 603: usb_config_descriptor_t cd, *cdp;
! 604: usbd_status err;
! 605: int i, ifcidx, nifc, len, selfpowered, power;
! 606:
! 607: DPRINTFN(5,("usbd_set_config_index: dev=%p index=%d\n", dev, index));
! 608:
! 609: /* XXX check that all interfaces are idle */
! 610: if (dev->config != USB_UNCONFIG_NO) {
! 611: DPRINTF(("usbd_set_config_index: free old config\n"));
! 612: /* Free all configuration data structures. */
! 613: nifc = dev->cdesc->bNumInterface;
! 614: for (ifcidx = 0; ifcidx < nifc; ifcidx++)
! 615: usbd_free_iface_data(dev, ifcidx);
! 616: free(dev->ifaces, M_USB);
! 617: free(dev->cdesc, M_USB);
! 618: dev->ifaces = NULL;
! 619: dev->cdesc = NULL;
! 620: dev->config = USB_UNCONFIG_NO;
! 621: }
! 622:
! 623: if (index == USB_UNCONFIG_INDEX) {
! 624: /* We are unconfiguring the device, so leave unallocated. */
! 625: DPRINTF(("usbd_set_config_index: set config 0\n"));
! 626: err = usbd_set_config(dev, USB_UNCONFIG_NO);
! 627: if (err)
! 628: DPRINTF(("usbd_set_config_index: setting config=0 "
! 629: "failed, error=%s\n", usbd_errstr(err)));
! 630: return (err);
! 631: }
! 632:
! 633: /* Get the short descriptor. */
! 634: err = usbd_get_config_desc(dev, index, &cd);
! 635: if (err)
! 636: return (err);
! 637: len = UGETW(cd.wTotalLength);
! 638: 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++) {
! 643: err = usbd_get_desc(dev, UDESC_CONFIG, index, len, cdp);
! 644: if (!err)
! 645: break;
! 646: usbd_delay_ms(dev, 200);
! 647: }
! 648: if (err)
! 649: goto bad;
! 650:
! 651: if (cdp->bDescriptorType != UDESC_CONFIG) {
! 652: DPRINTFN(-1,("usbd_set_config_index: bad desc %d\n",
! 653: cdp->bDescriptorType));
! 654: err = USBD_INVAL;
! 655: goto bad;
! 656: }
! 657:
! 658: /* Figure out if the device is self or bus powered. */
! 659: 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: */
! 671: usb_hub_descriptor_t hd;
! 672: usb_device_request_t req;
! 673: req.bmRequestType = UT_READ_CLASS_DEVICE;
! 674: req.bRequest = UR_GET_DESCRIPTOR;
! 675: USETW(req.wValue, 0);
! 676: USETW(req.wIndex, 0);
! 677: USETW(req.wLength, USB_HUB_DESCRIPTOR_SIZE);
! 678: err = usbd_do_request(dev, &req, &hd);
! 679: if (!err &&
! 680: (UGETW(hd.wHubCharacteristics) &
! 681: UHD_PWR_INDIVIDUAL))
! 682: selfpowered = 1;
! 683: DPRINTF(("usbd_set_config_index: charac=0x%04x"
! 684: ", error=%s\n",
! 685: UGETW(hd.wHubCharacteristics),
! 686: usbd_errstr(err)));
! 687: } else {
! 688: err = usbd_get_device_status(dev, &ds);
! 689: if (!err &&
! 690: (UGETW(ds.wStatus) & UDS_SELF_POWERED))
! 691: selfpowered = 1;
! 692: DPRINTF(("usbd_set_config_index: status=0x%04x"
! 693: ", error=%s\n",
! 694: UGETW(ds.wStatus), usbd_errstr(err)));
! 695: }
! 696: } else
! 697: selfpowered = 1;
! 698: }
! 699: DPRINTF(("usbd_set_config_index: (addr %d) cno=%d attr=0x%02x, "
! 700: "selfpowered=%d, power=%d\n",
! 701: cdp->bConfigurationValue, dev->address, cdp->bmAttributes,
! 702: selfpowered, cdp->bMaxPower * 2));
! 703:
! 704: /* Check if we have enough power. */
! 705: #ifdef USB_DEBUG
! 706: if (dev->powersrc == NULL) {
! 707: DPRINTF(("usbd_set_config_index: No power source?\n"));
! 708: return (USBD_IOERROR);
! 709: }
! 710: #endif
! 711: power = cdp->bMaxPower * 2;
! 712: if (power > dev->powersrc->power) {
! 713: DPRINTF(("power exceeded %d %d\n", power,dev->powersrc->power));
! 714: /* XXX print nicer message. */
! 715: if (msg)
! 716: printf("%s: device addr %d (config %d) exceeds power "
! 717: "budget, %d mA > %d mA\n",
! 718: dev->bus->bdev.dv_xname, dev->address,
! 719: cdp->bConfigurationValue,
! 720: power, dev->powersrc->power);
! 721: err = USBD_NO_POWER;
! 722: goto bad;
! 723: }
! 724: dev->power = power;
! 725: dev->self_powered = selfpowered;
! 726:
! 727: /* Set the actual configuration value. */
! 728: DPRINTF(("usbd_set_config_index: set config %d\n",
! 729: cdp->bConfigurationValue));
! 730: err = usbd_set_config(dev, cdp->bConfigurationValue);
! 731: if (err) {
! 732: DPRINTF(("usbd_set_config_index: setting config=%d failed, "
! 733: "error=%s\n", cdp->bConfigurationValue, usbd_errstr(err)));
! 734: goto bad;
! 735: }
! 736:
! 737: /* Allocate and fill interface data. */
! 738: nifc = cdp->bNumInterface;
! 739: dev->ifaces = malloc(nifc * sizeof(struct usbd_interface),
! 740: M_USB, M_NOWAIT);
! 741: if (dev->ifaces == NULL) {
! 742: err = USBD_NOMEM;
! 743: goto bad;
! 744: }
! 745: DPRINTFN(5,("usbd_set_config_index: dev=%p cdesc=%p\n", dev, cdp));
! 746: dev->cdesc = cdp;
! 747: dev->config = cdp->bConfigurationValue;
! 748: for (ifcidx = 0; ifcidx < nifc; ifcidx++) {
! 749: err = usbd_fill_iface_data(dev, ifcidx, 0);
! 750: if (err) {
! 751: while (--ifcidx >= 0)
! 752: usbd_free_iface_data(dev, ifcidx);
! 753: goto bad;
! 754: }
! 755: }
! 756:
! 757: return (USBD_NORMAL_COMPLETION);
! 758:
! 759: bad:
! 760: free(cdp, M_USB);
! 761: return (err);
! 762: }
! 763:
! 764: /* XXX add function for alternate settings */
! 765:
! 766: usbd_status
! 767: usbd_setup_pipe(usbd_device_handle dev, usbd_interface_handle iface,
! 768: struct usbd_endpoint *ep, int ival, usbd_pipe_handle *pipe)
! 769: {
! 770: usbd_pipe_handle p;
! 771: usbd_status err;
! 772:
! 773: DPRINTFN(1,("usbd_setup_pipe: dev=%p iface=%p ep=%p pipe=%p\n",
! 774: dev, iface, ep, pipe));
! 775: p = malloc(dev->bus->pipe_size, M_USB, M_NOWAIT);
! 776: if (p == NULL)
! 777: return (USBD_NOMEM);
! 778: p->device = dev;
! 779: p->iface = iface;
! 780: p->endpoint = ep;
! 781: ep->refcnt++;
! 782: p->refcnt = 1;
! 783: p->intrxfer = 0;
! 784: p->running = 0;
! 785: p->aborting = 0;
! 786: p->repeat = 0;
! 787: p->interval = ival;
! 788: SIMPLEQ_INIT(&p->queue);
! 789: err = dev->bus->methods->open_pipe(p);
! 790: if (err) {
! 791: DPRINTFN(-1,("usbd_setup_pipe: endpoint=0x%x failed, error="
! 792: "%s\n",
! 793: ep->edesc->bEndpointAddress, usbd_errstr(err)));
! 794: free(p, M_USB);
! 795: return (err);
! 796: }
! 797: *pipe = p;
! 798: return (USBD_NORMAL_COMPLETION);
! 799: }
! 800:
! 801: /* Abort the device control pipe. */
! 802: void
! 803: usbd_kill_pipe(usbd_pipe_handle pipe)
! 804: {
! 805: usbd_abort_pipe(pipe);
! 806: pipe->methods->close(pipe);
! 807: pipe->endpoint->refcnt--;
! 808: free(pipe, M_USB);
! 809: }
! 810:
! 811: int
! 812: usbd_getnewaddr(usbd_bus_handle bus)
! 813: {
! 814: int addr;
! 815:
! 816: for (addr = 1; addr < USB_MAX_DEVICES; addr++)
! 817: if (bus->devices[addr] == 0)
! 818: return (addr);
! 819: return (-1);
! 820: }
! 821:
! 822:
! 823: usbd_status
! 824: usbd_probe_and_attach(struct device *parent, usbd_device_handle dev, int port,
! 825: int addr)
! 826: {
! 827: struct usb_attach_arg uaa;
! 828: usb_device_descriptor_t *dd = &dev->ddesc;
! 829: int found, i, confi, nifaces, len;
! 830: usbd_status err;
! 831: struct device *dv;
! 832: usbd_interface_handle *ifaces;
! 833:
! 834: uaa.device = dev;
! 835: uaa.iface = NULL;
! 836: uaa.ifaces = NULL;
! 837: uaa.nifaces = 0;
! 838: uaa.usegeneric = 0;
! 839: uaa.port = port;
! 840: uaa.configno = UHUB_UNK_CONFIGURATION;
! 841: uaa.ifaceno = UHUB_UNK_INTERFACE;
! 842: uaa.vendor = UGETW(dd->idVendor);
! 843: uaa.product = UGETW(dd->idProduct);
! 844: uaa.release = UGETW(dd->bcdDevice);
! 845:
! 846: /* First try with device specific drivers. */
! 847: DPRINTF(("usbd_probe_and_attach: trying device specific drivers\n"));
! 848: dv = config_found_sm(parent, &uaa, usbd_print, usbd_submatch);
! 849: if (dv) {
! 850: dev->subdevs = malloc(2 * sizeof dv, M_USB, M_NOWAIT);
! 851: if (dev->subdevs == NULL)
! 852: return (USBD_NOMEM);
! 853: dev->subdevs[0] = dv;
! 854: dev->subdevs[1] = 0;
! 855: return (USBD_NORMAL_COMPLETION);
! 856: }
! 857:
! 858: DPRINTF(("usbd_probe_and_attach: no device specific driver found\n"));
! 859:
! 860: DPRINTF(("usbd_probe_and_attach: looping over %d configurations\n",
! 861: dd->bNumConfigurations));
! 862: /* Next try with interface drivers. */
! 863: for (confi = 0; confi < dd->bNumConfigurations; confi++) {
! 864: DPRINTFN(1,("usbd_probe_and_attach: trying config idx=%d\n",
! 865: confi));
! 866: err = usbd_set_config_index(dev, confi, 1);
! 867: if (err) {
! 868: #ifdef USB_DEBUG
! 869: DPRINTF(("%s: port %d, set config at addr %d failed, "
! 870: "error=%s\n", parent->dv_xname, port,
! 871: addr, usbd_errstr(err)));
! 872: #else
! 873: printf("%s: port %d, set config at addr %d failed\n",
! 874: parent->dv_xname, port, addr);
! 875: #endif
! 876:
! 877: return (err);
! 878: }
! 879: nifaces = dev->cdesc->bNumInterface;
! 880: uaa.configno = dev->cdesc->bConfigurationValue;
! 881: ifaces = malloc(nifaces * sizeof(usbd_interface_handle),
! 882: M_USB, M_NOWAIT);
! 883: if (ifaces == NULL)
! 884: return (USBD_NOMEM);
! 885: for (i = 0; i < nifaces; i++)
! 886: ifaces[i] = &dev->ifaces[i];
! 887: uaa.ifaces = ifaces;
! 888: uaa.nifaces = nifaces;
! 889: len = (nifaces+1) * sizeof dv;
! 890: dev->subdevs = malloc(len, M_USB, M_NOWAIT);
! 891: if (dev->subdevs == NULL) {
! 892: free(ifaces, M_USB);
! 893: return (USBD_NOMEM);
! 894: }
! 895: bzero(dev->subdevs, len);
! 896:
! 897: found = 0;
! 898: for (i = 0; i < nifaces; i++) {
! 899: if (ifaces[i] == NULL)
! 900: continue; /* interface already claimed */
! 901: uaa.iface = ifaces[i];
! 902: uaa.ifaceno = ifaces[i]->idesc->bInterfaceNumber;
! 903: dv = config_found_sm(parent, &uaa, usbd_print,
! 904: usbd_submatch);
! 905:
! 906: if (dv != NULL) {
! 907: dev->subdevs[found++] = dv;
! 908: ifaces[i] = NULL; /* consumed */
! 909: }
! 910: }
! 911: free(ifaces, M_USB);
! 912: if (found != 0) {
! 913: return (USBD_NORMAL_COMPLETION);
! 914: }
! 915: free(dev->subdevs, M_USB);
! 916: dev->subdevs = 0;
! 917: }
! 918: /* No interfaces were attached in any of the configurations. */
! 919:
! 920: if (dd->bNumConfigurations > 1) /* don't change if only 1 config */
! 921: usbd_set_config_index(dev, 0, 0);
! 922:
! 923: DPRINTF(("usbd_probe_and_attach: no interface drivers found\n"));
! 924:
! 925: /* Finally try the generic driver. */
! 926: uaa.iface = NULL;
! 927: uaa.usegeneric = 1;
! 928: uaa.configno = UHUB_UNK_CONFIGURATION;
! 929: uaa.ifaceno = UHUB_UNK_INTERFACE;
! 930: dv = config_found_sm(parent, &uaa, usbd_print, usbd_submatch);
! 931: if (dv != NULL) {
! 932: dev->subdevs = malloc(2 * sizeof dv, M_USB, M_NOWAIT);
! 933: if (dev->subdevs == 0)
! 934: return (USBD_NOMEM);
! 935: dev->subdevs[0] = dv;
! 936: dev->subdevs[1] = 0;
! 937: return (USBD_NORMAL_COMPLETION);
! 938: }
! 939:
! 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: */
! 945: DPRINTF(("usbd_probe_and_attach: generic attach failed\n"));
! 946: return (USBD_NORMAL_COMPLETION);
! 947: }
! 948:
! 949:
! 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: */
! 956: usbd_status
! 957: usbd_new_device(struct device *parent, usbd_bus_handle bus, int depth,
! 958: int speed, int port, struct usbd_port *up)
! 959: {
! 960: usbd_device_handle dev, adev;
! 961: struct usbd_device *hub;
! 962: usb_device_descriptor_t *dd;
! 963: usbd_status err;
! 964: int addr;
! 965: int i;
! 966: int p;
! 967:
! 968: DPRINTF(("usbd_new_device bus=%p port=%d depth=%d speed=%d\n",
! 969: bus, port, depth, speed));
! 970: addr = usbd_getnewaddr(bus);
! 971: if (addr < 0) {
! 972: printf("%s: No free USB addresses, new device ignored.\n",
! 973: bus->bdev.dv_xname);
! 974: return (USBD_NO_ADDR);
! 975: }
! 976:
! 977: dev = malloc(sizeof *dev, M_USB, M_NOWAIT);
! 978: if (dev == NULL)
! 979: return (USBD_NOMEM);
! 980: memset(dev, 0, sizeof *dev);
! 981:
! 982: dev->bus = bus;
! 983:
! 984: /* Set up default endpoint handle. */
! 985: dev->def_ep.edesc = &dev->def_ep_desc;
! 986:
! 987: /* Set up default endpoint descriptor. */
! 988: dev->def_ep_desc.bLength = USB_ENDPOINT_DESCRIPTOR_SIZE;
! 989: dev->def_ep_desc.bDescriptorType = UDESC_ENDPOINT;
! 990: dev->def_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT;
! 991: dev->def_ep_desc.bmAttributes = UE_CONTROL;
! 992: USETW(dev->def_ep_desc.wMaxPacketSize, USB_MAX_IPACKET);
! 993: dev->def_ep_desc.bInterval = 0;
! 994:
! 995: dev->quirks = &usbd_no_quirk;
! 996: dev->address = USB_START_ADDR;
! 997: dev->ddesc.bMaxPacketSize = 0;
! 998: dev->depth = depth;
! 999: dev->powersrc = up;
! 1000: dev->myhub = up->parent;
! 1001:
! 1002: up->device = dev;
! 1003:
! 1004: /* Locate port on upstream high speed hub */
! 1005: for (adev = dev, hub = up->parent;
! 1006: hub != NULL && hub->speed != USB_SPEED_HIGH;
! 1007: 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) {
! 1012: dev->myhsport = &hub->hub->ports[p];
! 1013: goto found;
! 1014: }
! 1015: }
! 1016: panic("usbd_new_device: cannot find HS port");
! 1017: found:
! 1018: DPRINTFN(1,("usbd_new_device: high speed port %d\n", p));
! 1019: } else {
! 1020: dev->myhsport = NULL;
! 1021: }
! 1022: dev->speed = speed;
! 1023: dev->langid = USBD_NOLANG;
! 1024: dev->cookie.cookie = ++usb_cookie_no;
! 1025:
! 1026: /* Establish the default pipe. */
! 1027: err = usbd_setup_pipe(dev, 0, &dev->def_ep, USBD_DEFAULT_INTERVAL,
! 1028: &dev->default_pipe);
! 1029: if (err) {
! 1030: usbd_remove_device(dev, up);
! 1031: return (err);
! 1032: }
! 1033:
! 1034: 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. */
! 1038: err = usbd_get_desc(dev, UDESC_DEVICE, 0, USB_MAX_IPACKET, dd);
! 1039: if (!err)
! 1040: break;
! 1041: /* progressively increase the delay */
! 1042: usbd_delay_ms(dev, 200 * (i + 1));
! 1043: }
! 1044: if (err) {
! 1045: DPRINTFN(-1, ("usbd_new_device: addr=%d, getting first desc "
! 1046: "failed\n", addr));
! 1047: usbd_remove_device(dev, up);
! 1048: return (err);
! 1049: }
! 1050:
! 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
! 1055: printf("usbd_new_device: addr=%d bad max packet size\n",
! 1056: addr);
! 1057: #endif
! 1058: dd->bMaxPacketSize = USB_2_MAX_CTRL_PACKET;
! 1059: }
! 1060: }
! 1061:
! 1062: DPRINTF(("usbd_new_device: adding unit addr=%d, rev=%02x, class=%d, "
! 1063: "subclass=%d, protocol=%d, maxpacket=%d, len=%d, speed=%d\n",
! 1064: addr,UGETW(dd->bcdUSB), dd->bDeviceClass, dd->bDeviceSubClass,
! 1065: dd->bDeviceProtocol, dd->bMaxPacketSize, dd->bLength,
! 1066: dev->speed));
! 1067:
! 1068: if (dd->bDescriptorType != UDESC_DEVICE) {
! 1069: /* Illegal device descriptor */
! 1070: DPRINTFN(-1,("usbd_new_device: illegal descriptor %d\n",
! 1071: dd->bDescriptorType));
! 1072: usbd_remove_device(dev, up);
! 1073: return (USBD_INVAL);
! 1074: }
! 1075:
! 1076: if (dd->bLength < USB_DEVICE_DESCRIPTOR_SIZE) {
! 1077: DPRINTFN(-1,("usbd_new_device: bad length %d\n", dd->bLength));
! 1078: usbd_remove_device(dev, up);
! 1079: return (USBD_INVAL);
! 1080: }
! 1081:
! 1082: USETW(dev->def_ep_desc.wMaxPacketSize, dd->bMaxPacketSize);
! 1083:
! 1084: err = usbd_reload_device_desc(dev);
! 1085: if (err) {
! 1086: DPRINTFN(-1, ("usbd_new_device: addr=%d, getting full desc "
! 1087: "failed\n", addr));
! 1088: usbd_remove_device(dev, up);
! 1089: return (err);
! 1090: }
! 1091:
! 1092: /* Set the address */
! 1093: DPRINTFN(5,("usbd_new_device: setting device address=%d\n", addr));
! 1094: err = usbd_set_address(dev, addr);
! 1095: if (err) {
! 1096: DPRINTFN(-1,("usbd_new_device: set address %d failed\n", addr));
! 1097: err = USBD_SET_ADDR_FAILED;
! 1098: usbd_remove_device(dev, up);
! 1099: return (err);
! 1100: }
! 1101: /* Allow device time to set new address */
! 1102: usbd_delay_ms(dev, USB_SET_ADDRESS_SETTLE);
! 1103:
! 1104: dev->address = addr; /* New device address now */
! 1105: bus->devices[addr] = dev;
! 1106:
! 1107: /* Assume 100mA bus powered for now. Changed when configured. */
! 1108: dev->power = USB_MIN_POWER;
! 1109: dev->self_powered = 0;
! 1110:
! 1111: DPRINTF(("usbd_new_device: new dev (addr %d), dev=%p, parent=%p\n",
! 1112: addr, dev, parent));
! 1113:
! 1114: usbd_add_dev_event(USB_EVENT_DEVICE_ATTACH, dev);
! 1115:
! 1116: err = usbd_probe_and_attach(parent, dev, port, addr);
! 1117: if (err) {
! 1118: usbd_remove_device(dev, up);
! 1119: return (err);
! 1120: }
! 1121:
! 1122: return (USBD_NORMAL_COMPLETION);
! 1123: }
! 1124:
! 1125: usbd_status
! 1126: usbd_reload_device_desc(usbd_device_handle dev)
! 1127: {
! 1128: usbd_status err;
! 1129:
! 1130: /* Get the full device descriptor. */
! 1131: err = usbd_get_device_desc(dev, &dev->ddesc);
! 1132: if (err)
! 1133: return (err);
! 1134:
! 1135: /* Figure out what's wrong with this device. */
! 1136: dev->quirks = usbd_find_quirk(&dev->ddesc);
! 1137:
! 1138: return (USBD_NORMAL_COMPLETION);
! 1139: }
! 1140:
! 1141: void
! 1142: usbd_remove_device(usbd_device_handle dev, struct usbd_port *up)
! 1143: {
! 1144: DPRINTF(("usbd_remove_device: %p\n", dev));
! 1145:
! 1146: if (dev->default_pipe != NULL)
! 1147: usbd_kill_pipe(dev->default_pipe);
! 1148: up->device = NULL;
! 1149: dev->bus->devices[dev->address] = NULL;
! 1150:
! 1151: free(dev, M_USB);
! 1152: }
! 1153:
! 1154: int
! 1155: usbd_print(void *aux, const char *pnp)
! 1156: {
! 1157: struct usb_attach_arg *uaa = aux;
! 1158: char devinfo[1024];
! 1159:
! 1160: DPRINTFN(15, ("usbd_print dev=%p\n", uaa->device));
! 1161: if (pnp) {
! 1162: if (!uaa->usegeneric)
! 1163: return (QUIET);
! 1164: usbd_devinfo(uaa->device, 1, devinfo, sizeof devinfo);
! 1165: printf("%s, %s", devinfo, pnp);
! 1166: }
! 1167: if (uaa->port != 0)
! 1168: printf(" port %d", uaa->port);
! 1169: if (uaa->configno != UHUB_UNK_CONFIGURATION)
! 1170: printf(" configuration %d", uaa->configno);
! 1171: if (uaa->ifaceno != UHUB_UNK_INTERFACE)
! 1172: 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)
! 1180: printf(" vendor 0x%04x", uaa->vendor);
! 1181: if (uaa->product != UHUB_UNK_PRODUCT)
! 1182: printf(" product 0x%04x", uaa->product);
! 1183: if (uaa->release != UHUB_UNK_RELEASE)
! 1184: printf(" release 0x%04x", uaa->release);
! 1185: #endif
! 1186: return (UNCONF);
! 1187: }
! 1188:
! 1189: int
! 1190: usbd_submatch(struct device *parent, void *match, void *aux)
! 1191: {
! 1192: struct cfdata *cf = match;
! 1193: struct usb_attach_arg *uaa = aux;
! 1194:
! 1195: DPRINTFN(5,("usbd_submatch port=%d,%d configno=%d,%d "
! 1196: "ifaceno=%d,%d vendor=%d,%d product=%d,%d release=%d,%d\n",
! 1197: uaa->port, cf->uhubcf_port,
! 1198: uaa->configno, cf->uhubcf_configuration,
! 1199: uaa->ifaceno, cf->uhubcf_interface,
! 1200: uaa->vendor, cf->uhubcf_vendor,
! 1201: uaa->product, cf->uhubcf_product,
! 1202: uaa->release, cf->uhubcf_release));
! 1203: if (uaa->port != 0 && /* root hub has port 0, it should match */
! 1204: ((uaa->port != 0 &&
! 1205: cf->uhubcf_port != UHUB_UNK_PORT &&
! 1206: cf->uhubcf_port != uaa->port) ||
! 1207: (uaa->configno != UHUB_UNK_CONFIGURATION &&
! 1208: cf->uhubcf_configuration != UHUB_UNK_CONFIGURATION &&
! 1209: cf->uhubcf_configuration != uaa->configno) ||
! 1210: (uaa->ifaceno != UHUB_UNK_INTERFACE &&
! 1211: cf->uhubcf_interface != UHUB_UNK_INTERFACE &&
! 1212: cf->uhubcf_interface != uaa->ifaceno) ||
! 1213: (uaa->vendor != UHUB_UNK_VENDOR &&
! 1214: cf->uhubcf_vendor != UHUB_UNK_VENDOR &&
! 1215: cf->uhubcf_vendor != uaa->vendor) ||
! 1216: (uaa->product != UHUB_UNK_PRODUCT &&
! 1217: cf->uhubcf_product != UHUB_UNK_PRODUCT &&
! 1218: cf->uhubcf_product != uaa->product) ||
! 1219: (uaa->release != UHUB_UNK_RELEASE &&
! 1220: cf->uhubcf_release != UHUB_UNK_RELEASE &&
! 1221: cf->uhubcf_release != uaa->release)
! 1222: )
! 1223: )
! 1224: return 0;
! 1225: if (cf->uhubcf_vendor != UHUB_UNK_VENDOR &&
! 1226: cf->uhubcf_vendor == uaa->vendor &&
! 1227: cf->uhubcf_product != UHUB_UNK_PRODUCT &&
! 1228: cf->uhubcf_product == uaa->product) {
! 1229: /* We have a vendor&product locator match */
! 1230: if (cf->uhubcf_release != UHUB_UNK_RELEASE &&
! 1231: cf->uhubcf_release == uaa->release)
! 1232: uaa->matchlvl = UMATCH_VENDOR_PRODUCT_REV;
! 1233: else
! 1234: uaa->matchlvl = UMATCH_VENDOR_PRODUCT;
! 1235: } else
! 1236: uaa->matchlvl = 0;
! 1237: return ((*cf->cf_attach->ca_match)(parent, cf, aux));
! 1238: }
! 1239:
! 1240: void
! 1241: 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;
! 1246:
! 1247: di->udi_bus = dev->bus->bdev.dv_unit;
! 1248: di->udi_addr = dev->address;
! 1249: di->udi_cookie = dev->cookie;
! 1250: usbd_devinfo_vp(dev, di->udi_vendor, di->udi_product, usedev);
! 1251: usbd_printBCD(di->udi_release, sizeof di->udi_release,
! 1252: UGETW(dev->ddesc.bcdDevice));
! 1253: di->udi_vendorNo = UGETW(dev->ddesc.idVendor);
! 1254: di->udi_productNo = UGETW(dev->ddesc.idProduct);
! 1255: di->udi_releaseNo = UGETW(dev->ddesc.bcdDevice);
! 1256: di->udi_class = dev->ddesc.bDeviceClass;
! 1257: di->udi_subclass = dev->ddesc.bDeviceSubClass;
! 1258: di->udi_protocol = dev->ddesc.bDeviceProtocol;
! 1259: di->udi_config = dev->config;
! 1260: di->udi_power = dev->self_powered ? 0 : dev->power;
! 1261: di->udi_speed = dev->speed;
! 1262:
! 1263: if (dev->subdevs != NULL) {
! 1264: for (i = 0; dev->subdevs[i] && i < USB_MAX_DEVNAMES; i++) {
! 1265: strncpy(di->udi_devnames[i],
! 1266: dev->subdevs[i]->dv_xname, USB_MAX_DEVNAMELEN);
! 1267: di->udi_devnames[i][USB_MAX_DEVNAMELEN-1] = '\0';
! 1268: }
! 1269: } else
! 1270: i = 0;
! 1271:
! 1272: for (/*i is set */; i < USB_MAX_DEVNAMES; i++)
! 1273: di->udi_devnames[i][0] = 0; /* empty */
! 1274:
! 1275: if (dev->hub) {
! 1276: for (i = 0;
! 1277: i < sizeof(di->udi_ports) / sizeof(di->udi_ports[0]) &&
! 1278: i < dev->hub->hubdesc.bNbrPorts; i++) {
! 1279: p = &dev->hub->ports[i];
! 1280: if (p->device)
! 1281: err = p->device->address;
! 1282: else {
! 1283: s = UGETW(p->status.wPortStatus);
! 1284: if (s & UPS_PORT_ENABLED)
! 1285: err = USB_PORT_ENABLED;
! 1286: else if (s & UPS_SUSPEND)
! 1287: err = USB_PORT_SUSPENDED;
! 1288: else if (s & UPS_PORT_POWER)
! 1289: err = USB_PORT_POWERED;
! 1290: else
! 1291: err = USB_PORT_DISABLED;
! 1292: }
! 1293: di->udi_ports[i] = err;
! 1294: }
! 1295: di->udi_nports = dev->hub->hubdesc.bNbrPorts;
! 1296: } else
! 1297: di->udi_nports = 0;
! 1298: }
! 1299:
! 1300: void
! 1301: usb_free_device(usbd_device_handle dev)
! 1302: {
! 1303: int ifcidx, nifc;
! 1304:
! 1305: if (dev->default_pipe != NULL)
! 1306: usbd_kill_pipe(dev->default_pipe);
! 1307: if (dev->ifaces != NULL) {
! 1308: nifc = dev->cdesc->bNumInterface;
! 1309: for (ifcidx = 0; ifcidx < nifc; ifcidx++)
! 1310: usbd_free_iface_data(dev, ifcidx);
! 1311: free(dev->ifaces, M_USB);
! 1312: }
! 1313: if (dev->cdesc != NULL)
! 1314: free(dev->cdesc, M_USB);
! 1315: if (dev->subdevs != NULL)
! 1316: free(dev->subdevs, M_USB);
! 1317: free(dev, M_USB);
! 1318: }
! 1319:
! 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: */
! 1332:
! 1333: /*
! 1334: * Called from process context when we discover that a port has
! 1335: * been disconnected.
! 1336: */
! 1337: void
! 1338: usb_disconnect_port(struct usbd_port *up, struct device *parent)
! 1339: {
! 1340: usbd_device_handle dev = up->device;
! 1341: int i;
! 1342:
! 1343: DPRINTFN(3,("uhub_disconnect: up=%p dev=%p port=%d\n",
! 1344: up, dev, up->portno));
! 1345:
! 1346: #ifdef DIAGNOSTIC
! 1347: if (dev == NULL) {
! 1348: printf("usb_disconnect_port: no device\n");
! 1349: return;
! 1350: }
! 1351: #endif
! 1352:
! 1353: if (dev->subdevs != NULL) {
! 1354: DPRINTFN(3,("usb_disconnect_port: disconnect subdevs\n"));
! 1355: for (i = 0; dev->subdevs[i]; i++) {
! 1356: DPRINTF(("%s: at %s", dev->subdevs[i]->dv_xname,
! 1357: parent->dv_xname));
! 1358: if (up->portno != 0)
! 1359: DPRINTF((" port %d", up->portno));
! 1360: DPRINTF((" (addr %d) disconnected\n", dev->address));
! 1361: config_detach(dev->subdevs[i], DETACH_FORCE);
! 1362: dev->subdevs[i] = 0;
! 1363: }
! 1364: }
! 1365:
! 1366: usbd_add_dev_event(USB_EVENT_DEVICE_DETACH, dev);
! 1367: dev->bus->devices[dev->address] = NULL;
! 1368: up->device = NULL;
! 1369: usb_free_device(dev);
! 1370: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to usb_subr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb