Annotation of sys/dev/usb/usbdi.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: usbdi.c,v 1.33 2007/06/18 11:37:04 mbalmer Exp $ */
! 2: /* $NetBSD: usbdi.c,v 1.103 2002/09/27 15:37:38 provos Exp $ */
! 3: /* $FreeBSD: src/sys/dev/usb/usbdi.c,v 1.28 1999/11/17 22:33:49 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/device.h>
! 46: #include <sys/malloc.h>
! 47: #include <sys/proc.h>
! 48:
! 49: #include <machine/bus.h>
! 50:
! 51: #include <dev/usb/usb.h>
! 52: #include <dev/usb/usbdi.h>
! 53: #include <dev/usb/usbdi_util.h>
! 54: #include <dev/usb/usbdivar.h>
! 55: #include <dev/usb/usb_mem.h>
! 56:
! 57: #ifdef USB_DEBUG
! 58: #define DPRINTF(x) do { if (usbdebug) printf x; } while (0)
! 59: #define DPRINTFN(n,x) do { if (usbdebug>(n)) printf x; } while (0)
! 60: extern int usbdebug;
! 61: #else
! 62: #define DPRINTF(x)
! 63: #define DPRINTFN(n,x)
! 64: #endif
! 65:
! 66: usbd_status usbd_ar_pipe(usbd_pipe_handle pipe);
! 67: void usbd_do_request_async_cb(usbd_xfer_handle, usbd_private_handle,
! 68: usbd_status);
! 69: void usbd_start_next(usbd_pipe_handle pipe);
! 70: usbd_status usbd_open_pipe_ival(usbd_interface_handle, u_int8_t, u_int8_t,
! 71: usbd_pipe_handle *, int);
! 72:
! 73: int usbd_nbuses = 0;
! 74:
! 75: void
! 76: usbd_init(void)
! 77: {
! 78: usbd_nbuses++;
! 79: }
! 80:
! 81: void
! 82: usbd_finish(void)
! 83: {
! 84: --usbd_nbuses;
! 85: }
! 86:
! 87: static __inline int
! 88: usbd_xfer_isread(usbd_xfer_handle xfer)
! 89: {
! 90: if (xfer->rqflags & URQ_REQUEST)
! 91: return (xfer->request.bmRequestType & UT_READ);
! 92: else
! 93: return (xfer->pipe->endpoint->edesc->bEndpointAddress &
! 94: UE_DIR_IN);
! 95: }
! 96:
! 97: #ifdef USB_DEBUG
! 98: void
! 99: usbd_dump_iface(struct usbd_interface *iface)
! 100: {
! 101: printf("usbd_dump_iface: iface=%p\n", iface);
! 102: if (iface == NULL)
! 103: return;
! 104: printf(" device=%p idesc=%p index=%d altindex=%d priv=%p\n",
! 105: iface->device, iface->idesc, iface->index, iface->altindex,
! 106: iface->priv);
! 107: }
! 108:
! 109: void
! 110: usbd_dump_device(struct usbd_device *dev)
! 111: {
! 112: printf("usbd_dump_device: dev=%p\n", dev);
! 113: if (dev == NULL)
! 114: return;
! 115: printf(" bus=%p default_pipe=%p\n", dev->bus, dev->default_pipe);
! 116: printf(" address=%d config=%d depth=%d speed=%d self_powered=%d "
! 117: "power=%d langid=%d\n", dev->address, dev->config, dev->depth,
! 118: dev->speed, dev->self_powered, dev->power, dev->langid);
! 119: }
! 120:
! 121: void
! 122: usbd_dump_endpoint(struct usbd_endpoint *endp)
! 123: {
! 124: printf("usbd_dump_endpoint: endp=%p\n", endp);
! 125: if (endp == NULL)
! 126: return;
! 127: printf(" edesc=%p refcnt=%d\n", endp->edesc, endp->refcnt);
! 128: if (endp->edesc)
! 129: printf(" bEndpointAddress=0x%02x\n",
! 130: endp->edesc->bEndpointAddress);
! 131: }
! 132:
! 133: void
! 134: usbd_dump_queue(usbd_pipe_handle pipe)
! 135: {
! 136: usbd_xfer_handle xfer;
! 137:
! 138: printf("usbd_dump_queue: pipe=%p\n", pipe);
! 139: SIMPLEQ_FOREACH(xfer, &pipe->queue, next) {
! 140: printf(" xfer=%p\n", xfer);
! 141: }
! 142: }
! 143:
! 144: void
! 145: usbd_dump_pipe(usbd_pipe_handle pipe)
! 146: {
! 147: printf("usbd_dump_pipe: pipe=%p\n", pipe);
! 148: if (pipe == NULL)
! 149: return;
! 150: usbd_dump_iface(pipe->iface);
! 151: usbd_dump_device(pipe->device);
! 152: usbd_dump_endpoint(pipe->endpoint);
! 153: printf(" (usbd_dump_pipe:)\n refcnt=%d running=%d aborting=%d\n",
! 154: pipe->refcnt, pipe->running, pipe->aborting);
! 155: printf(" intrxfer=%p, repeat=%d, interval=%d\n", pipe->intrxfer,
! 156: pipe->repeat, pipe->interval);
! 157: }
! 158: #endif
! 159:
! 160: usbd_status
! 161: usbd_open_pipe(usbd_interface_handle iface, u_int8_t address, u_int8_t flags,
! 162: usbd_pipe_handle *pipe)
! 163: {
! 164: return (usbd_open_pipe_ival(iface, address, flags, pipe,
! 165: USBD_DEFAULT_INTERVAL));
! 166: }
! 167:
! 168: usbd_status
! 169: usbd_open_pipe_ival(usbd_interface_handle iface, u_int8_t address,
! 170: u_int8_t flags, usbd_pipe_handle *pipe, int ival)
! 171: {
! 172: usbd_pipe_handle p;
! 173: struct usbd_endpoint *ep;
! 174: usbd_status err;
! 175: int i;
! 176:
! 177: DPRINTFN(3,("usbd_open_pipe: iface=%p address=0x%x flags=0x%x\n",
! 178: iface, address, flags));
! 179:
! 180: for (i = 0; i < iface->idesc->bNumEndpoints; i++) {
! 181: ep = &iface->endpoints[i];
! 182: if (ep->edesc == NULL)
! 183: return (USBD_IOERROR);
! 184: if (ep->edesc->bEndpointAddress == address)
! 185: goto found;
! 186: }
! 187: return (USBD_BAD_ADDRESS);
! 188: found:
! 189: if ((flags & USBD_EXCLUSIVE_USE) && ep->refcnt != 0)
! 190: return (USBD_IN_USE);
! 191: err = usbd_setup_pipe(iface->device, iface, ep, ival, &p);
! 192: if (err)
! 193: return (err);
! 194: LIST_INSERT_HEAD(&iface->pipes, p, next);
! 195: *pipe = p;
! 196: return (USBD_NORMAL_COMPLETION);
! 197: }
! 198:
! 199: usbd_status
! 200: usbd_open_pipe_intr(usbd_interface_handle iface, u_int8_t address,
! 201: u_int8_t flags, usbd_pipe_handle *pipe, usbd_private_handle priv,
! 202: void *buffer, u_int32_t len, usbd_callback cb, int ival)
! 203: {
! 204: usbd_status err;
! 205: usbd_xfer_handle xfer;
! 206: usbd_pipe_handle ipipe;
! 207:
! 208: DPRINTFN(3,("usbd_open_pipe_intr: address=0x%x flags=0x%x len=%d\n",
! 209: address, flags, len));
! 210:
! 211: err = usbd_open_pipe_ival(iface, address, USBD_EXCLUSIVE_USE, &ipipe,
! 212: ival);
! 213: if (err)
! 214: return (err);
! 215: xfer = usbd_alloc_xfer(iface->device);
! 216: if (xfer == NULL) {
! 217: err = USBD_NOMEM;
! 218: goto bad1;
! 219: }
! 220: usbd_setup_xfer(xfer, ipipe, priv, buffer, len, flags,
! 221: USBD_NO_TIMEOUT, cb);
! 222: ipipe->intrxfer = xfer;
! 223: ipipe->repeat = 1;
! 224: err = usbd_transfer(xfer);
! 225: *pipe = ipipe;
! 226: if (err != USBD_IN_PROGRESS)
! 227: goto bad2;
! 228: return (USBD_NORMAL_COMPLETION);
! 229:
! 230: bad2:
! 231: ipipe->intrxfer = NULL;
! 232: ipipe->repeat = 0;
! 233: usbd_free_xfer(xfer);
! 234: bad1:
! 235: usbd_close_pipe(ipipe);
! 236: return (err);
! 237: }
! 238:
! 239: usbd_status
! 240: usbd_close_pipe(usbd_pipe_handle pipe)
! 241: {
! 242: #ifdef DIAGNOSTIC
! 243: if (pipe == NULL) {
! 244: printf("usbd_close_pipe: pipe==NULL\n");
! 245: return (USBD_NORMAL_COMPLETION);
! 246: }
! 247: #endif
! 248:
! 249: if (--pipe->refcnt != 0)
! 250: return (USBD_NORMAL_COMPLETION);
! 251: if (! SIMPLEQ_EMPTY(&pipe->queue))
! 252: return (USBD_PENDING_REQUESTS);
! 253: LIST_REMOVE(pipe, next);
! 254: pipe->endpoint->refcnt--;
! 255: pipe->methods->close(pipe);
! 256: if (pipe->intrxfer != NULL)
! 257: usbd_free_xfer(pipe->intrxfer);
! 258: free(pipe, M_USB);
! 259: return (USBD_NORMAL_COMPLETION);
! 260: }
! 261:
! 262: usbd_status
! 263: usbd_transfer(usbd_xfer_handle xfer)
! 264: {
! 265: usbd_pipe_handle pipe = xfer->pipe;
! 266: usb_dma_t *dmap = &xfer->dmabuf;
! 267: usbd_status err;
! 268: u_int size;
! 269: int s;
! 270:
! 271: DPRINTFN(5,("usbd_transfer: xfer=%p, flags=%d, pipe=%p, running=%d\n",
! 272: xfer, xfer->flags, pipe, pipe->running));
! 273: #ifdef USB_DEBUG
! 274: if (usbdebug > 5)
! 275: usbd_dump_queue(pipe);
! 276: #endif
! 277: xfer->done = 0;
! 278:
! 279: if (pipe->aborting)
! 280: return (USBD_CANCELLED);
! 281:
! 282: size = xfer->length;
! 283: /* If there is no buffer, allocate one. */
! 284: if (!(xfer->rqflags & URQ_DEV_DMABUF) && size != 0) {
! 285: struct usbd_bus *bus = pipe->device->bus;
! 286:
! 287: #ifdef DIAGNOSTIC
! 288: if (xfer->rqflags & URQ_AUTO_DMABUF)
! 289: printf("usbd_transfer: has old buffer!\n");
! 290: #endif
! 291: err = bus->methods->allocm(bus, dmap, size);
! 292: if (err)
! 293: return (err);
! 294: xfer->rqflags |= URQ_AUTO_DMABUF;
! 295: }
! 296:
! 297: /* Copy data if going out. */
! 298: if (!(xfer->flags & USBD_NO_COPY) && size != 0 &&
! 299: !usbd_xfer_isread(xfer))
! 300: memcpy(KERNADDR(dmap, 0), xfer->buffer, size);
! 301:
! 302: err = pipe->methods->transfer(xfer);
! 303:
! 304: if (err != USBD_IN_PROGRESS && err) {
! 305: /* The transfer has not been queued, so free buffer. */
! 306: if (xfer->rqflags & URQ_AUTO_DMABUF) {
! 307: struct usbd_bus *bus = pipe->device->bus;
! 308:
! 309: bus->methods->freem(bus, &xfer->dmabuf);
! 310: xfer->rqflags &= ~URQ_AUTO_DMABUF;
! 311: }
! 312: }
! 313:
! 314: if (!(xfer->flags & USBD_SYNCHRONOUS))
! 315: return (err);
! 316:
! 317: /* Sync transfer, wait for completion. */
! 318: if (err != USBD_IN_PROGRESS)
! 319: return (err);
! 320: s = splusb();
! 321: while (!xfer->done) {
! 322: if (pipe->device->bus->use_polling)
! 323: panic("usbd_transfer: not done");
! 324: tsleep(xfer, PRIBIO, "usbsyn", 0);
! 325: }
! 326: splx(s);
! 327: return (xfer->status);
! 328: }
! 329:
! 330: /* Like usbd_transfer(), but waits for completion. */
! 331: usbd_status
! 332: usbd_sync_transfer(usbd_xfer_handle xfer)
! 333: {
! 334: xfer->flags |= USBD_SYNCHRONOUS;
! 335: return (usbd_transfer(xfer));
! 336: }
! 337:
! 338: void *
! 339: usbd_alloc_buffer(usbd_xfer_handle xfer, u_int32_t size)
! 340: {
! 341: struct usbd_bus *bus = xfer->device->bus;
! 342: usbd_status err;
! 343:
! 344: #ifdef DIAGNOSTIC
! 345: if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))
! 346: printf("usbd_alloc_buffer: xfer already has a buffer\n");
! 347: #endif
! 348: err = bus->methods->allocm(bus, &xfer->dmabuf, size);
! 349: if (err)
! 350: return (NULL);
! 351: xfer->rqflags |= URQ_DEV_DMABUF;
! 352: return (KERNADDR(&xfer->dmabuf, 0));
! 353: }
! 354:
! 355: void
! 356: usbd_free_buffer(usbd_xfer_handle xfer)
! 357: {
! 358: #ifdef DIAGNOSTIC
! 359: if (!(xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))) {
! 360: printf("usbd_free_buffer: no buffer\n");
! 361: return;
! 362: }
! 363: #endif
! 364: xfer->rqflags &= ~(URQ_DEV_DMABUF | URQ_AUTO_DMABUF);
! 365: xfer->device->bus->methods->freem(xfer->device->bus, &xfer->dmabuf);
! 366: }
! 367:
! 368: void *
! 369: usbd_get_buffer(usbd_xfer_handle xfer)
! 370: {
! 371: if (!(xfer->rqflags & URQ_DEV_DMABUF))
! 372: return (0);
! 373: return (KERNADDR(&xfer->dmabuf, 0));
! 374: }
! 375:
! 376: usbd_xfer_handle
! 377: usbd_alloc_xfer(usbd_device_handle dev)
! 378: {
! 379: usbd_xfer_handle xfer;
! 380:
! 381: xfer = dev->bus->methods->allocx(dev->bus);
! 382: if (xfer == NULL)
! 383: return (NULL);
! 384: xfer->device = dev;
! 385: timeout_set(&xfer->timeout_handle, NULL, NULL);
! 386: DPRINTFN(5,("usbd_alloc_xfer() = %p\n", xfer));
! 387: return (xfer);
! 388: }
! 389:
! 390: usbd_status
! 391: usbd_free_xfer(usbd_xfer_handle xfer)
! 392: {
! 393: DPRINTFN(5,("usbd_free_xfer: %p\n", xfer));
! 394: if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))
! 395: usbd_free_buffer(xfer);
! 396: xfer->device->bus->methods->freex(xfer->device->bus, xfer);
! 397: return (USBD_NORMAL_COMPLETION);
! 398: }
! 399:
! 400: void
! 401: usbd_setup_xfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
! 402: usbd_private_handle priv, void *buffer, u_int32_t length, u_int16_t flags,
! 403: u_int32_t timeout, usbd_callback callback)
! 404: {
! 405: xfer->pipe = pipe;
! 406: xfer->priv = priv;
! 407: xfer->buffer = buffer;
! 408: xfer->length = length;
! 409: xfer->actlen = 0;
! 410: xfer->flags = flags;
! 411: xfer->timeout = timeout;
! 412: xfer->status = USBD_NOT_STARTED;
! 413: xfer->callback = callback;
! 414: xfer->rqflags &= ~URQ_REQUEST;
! 415: xfer->nframes = 0;
! 416: }
! 417:
! 418: void
! 419: usbd_setup_default_xfer(usbd_xfer_handle xfer, usbd_device_handle dev,
! 420: usbd_private_handle priv, u_int32_t timeout, usb_device_request_t *req,
! 421: void *buffer, u_int32_t length, u_int16_t flags, usbd_callback callback)
! 422: {
! 423: xfer->pipe = dev->default_pipe;
! 424: xfer->priv = priv;
! 425: xfer->buffer = buffer;
! 426: xfer->length = length;
! 427: xfer->actlen = 0;
! 428: xfer->flags = flags;
! 429: xfer->timeout = timeout;
! 430: xfer->status = USBD_NOT_STARTED;
! 431: xfer->callback = callback;
! 432: xfer->request = *req;
! 433: xfer->rqflags |= URQ_REQUEST;
! 434: xfer->nframes = 0;
! 435: }
! 436:
! 437: void
! 438: usbd_setup_isoc_xfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
! 439: usbd_private_handle priv, u_int16_t *frlengths, u_int32_t nframes,
! 440: u_int16_t flags, usbd_callback callback)
! 441: {
! 442: xfer->pipe = pipe;
! 443: xfer->priv = priv;
! 444: xfer->buffer = 0;
! 445: xfer->length = 0;
! 446: xfer->actlen = 0;
! 447: xfer->flags = flags;
! 448: xfer->timeout = USBD_NO_TIMEOUT;
! 449: xfer->status = USBD_NOT_STARTED;
! 450: xfer->callback = callback;
! 451: xfer->rqflags &= ~URQ_REQUEST;
! 452: xfer->frlengths = frlengths;
! 453: xfer->nframes = nframes;
! 454: }
! 455:
! 456: void
! 457: usbd_get_xfer_status(usbd_xfer_handle xfer, usbd_private_handle *priv,
! 458: void **buffer, u_int32_t *count, usbd_status *status)
! 459: {
! 460: if (priv != NULL)
! 461: *priv = xfer->priv;
! 462: if (buffer != NULL)
! 463: *buffer = xfer->buffer;
! 464: if (count != NULL)
! 465: *count = xfer->actlen;
! 466: if (status != NULL)
! 467: *status = xfer->status;
! 468: }
! 469:
! 470: usb_config_descriptor_t *
! 471: usbd_get_config_descriptor(usbd_device_handle dev)
! 472: {
! 473: #ifdef DIAGNOSTIC
! 474: if (dev == NULL) {
! 475: printf("usbd_get_config_descriptor: dev == NULL\n");
! 476: return (NULL);
! 477: }
! 478: #endif
! 479: return (dev->cdesc);
! 480: }
! 481:
! 482: usb_interface_descriptor_t *
! 483: usbd_get_interface_descriptor(usbd_interface_handle iface)
! 484: {
! 485: #ifdef DIAGNOSTIC
! 486: if (iface == NULL) {
! 487: printf("usbd_get_interface_descriptor: dev == NULL\n");
! 488: return (NULL);
! 489: }
! 490: #endif
! 491: return (iface->idesc);
! 492: }
! 493:
! 494: usb_device_descriptor_t *
! 495: usbd_get_device_descriptor(usbd_device_handle dev)
! 496: {
! 497: return (&dev->ddesc);
! 498: }
! 499:
! 500: usb_endpoint_descriptor_t *
! 501: usbd_interface2endpoint_descriptor(usbd_interface_handle iface, u_int8_t index)
! 502: {
! 503: if (index >= iface->idesc->bNumEndpoints)
! 504: return (0);
! 505: return (iface->endpoints[index].edesc);
! 506: }
! 507:
! 508: usbd_status
! 509: usbd_abort_pipe(usbd_pipe_handle pipe)
! 510: {
! 511: usbd_status err;
! 512: int s;
! 513:
! 514: #ifdef DIAGNOSTIC
! 515: if (pipe == NULL) {
! 516: printf("usbd_abort_pipe: pipe==NULL\n");
! 517: return (USBD_NORMAL_COMPLETION);
! 518: }
! 519: #endif
! 520: s = splusb();
! 521: err = usbd_ar_pipe(pipe);
! 522: splx(s);
! 523: return (err);
! 524: }
! 525:
! 526: usbd_status
! 527: usbd_clear_endpoint_stall(usbd_pipe_handle pipe)
! 528: {
! 529: usbd_device_handle dev = pipe->device;
! 530: usb_device_request_t req;
! 531: usbd_status err;
! 532:
! 533: DPRINTFN(8, ("usbd_clear_endpoint_stall\n"));
! 534:
! 535: /*
! 536: * Clearing en endpoint stall resets the endpoint toggle, so
! 537: * do the same to the HC toggle.
! 538: */
! 539: pipe->methods->cleartoggle(pipe);
! 540:
! 541: req.bmRequestType = UT_WRITE_ENDPOINT;
! 542: req.bRequest = UR_CLEAR_FEATURE;
! 543: USETW(req.wValue, UF_ENDPOINT_HALT);
! 544: USETW(req.wIndex, pipe->endpoint->edesc->bEndpointAddress);
! 545: USETW(req.wLength, 0);
! 546: err = usbd_do_request(dev, &req, 0);
! 547: #if 0
! 548: XXX should we do this?
! 549: if (!err) {
! 550: pipe->state = USBD_PIPE_ACTIVE;
! 551: /* XXX activate pipe */
! 552: }
! 553: #endif
! 554: return (err);
! 555: }
! 556:
! 557: usbd_status
! 558: usbd_clear_endpoint_stall_async(usbd_pipe_handle pipe)
! 559: {
! 560: usbd_device_handle dev = pipe->device;
! 561: usb_device_request_t req;
! 562: usbd_status err;
! 563:
! 564: pipe->methods->cleartoggle(pipe);
! 565:
! 566: req.bmRequestType = UT_WRITE_ENDPOINT;
! 567: req.bRequest = UR_CLEAR_FEATURE;
! 568: USETW(req.wValue, UF_ENDPOINT_HALT);
! 569: USETW(req.wIndex, pipe->endpoint->edesc->bEndpointAddress);
! 570: USETW(req.wLength, 0);
! 571: err = usbd_do_request_async(dev, &req, 0);
! 572: return (err);
! 573: }
! 574:
! 575: void
! 576: usbd_clear_endpoint_toggle(usbd_pipe_handle pipe)
! 577: {
! 578: pipe->methods->cleartoggle(pipe);
! 579: }
! 580:
! 581: usbd_status
! 582: usbd_endpoint_count(usbd_interface_handle iface, u_int8_t *count)
! 583: {
! 584: #ifdef DIAGNOSTIC
! 585: if (iface == NULL || iface->idesc == NULL) {
! 586: printf("usbd_endpoint_count: NULL pointer\n");
! 587: return (USBD_INVAL);
! 588: }
! 589: #endif
! 590: *count = iface->idesc->bNumEndpoints;
! 591: return (USBD_NORMAL_COMPLETION);
! 592: }
! 593:
! 594: usbd_status
! 595: usbd_interface_count(usbd_device_handle dev, u_int8_t *count)
! 596: {
! 597: if (dev->cdesc == NULL)
! 598: return (USBD_NOT_CONFIGURED);
! 599: *count = dev->cdesc->bNumInterface;
! 600: return (USBD_NORMAL_COMPLETION);
! 601: }
! 602:
! 603: void
! 604: usbd_interface2device_handle(usbd_interface_handle iface,
! 605: usbd_device_handle *dev)
! 606: {
! 607: *dev = iface->device;
! 608: }
! 609:
! 610: usbd_status
! 611: usbd_device2interface_handle(usbd_device_handle dev, u_int8_t ifaceno,
! 612: usbd_interface_handle *iface)
! 613: {
! 614: if (dev->cdesc == NULL)
! 615: return (USBD_NOT_CONFIGURED);
! 616: if (ifaceno >= dev->cdesc->bNumInterface)
! 617: return (USBD_INVAL);
! 618: *iface = &dev->ifaces[ifaceno];
! 619: return (USBD_NORMAL_COMPLETION);
! 620: }
! 621:
! 622: usbd_device_handle
! 623: usbd_pipe2device_handle(usbd_pipe_handle pipe)
! 624: {
! 625: return (pipe->device);
! 626: }
! 627:
! 628: /* XXXX use altno */
! 629: usbd_status
! 630: usbd_set_interface(usbd_interface_handle iface, int altidx)
! 631: {
! 632: usb_device_request_t req;
! 633: usbd_status err;
! 634: void *endpoints;
! 635:
! 636: if (LIST_FIRST(&iface->pipes) != 0)
! 637: return (USBD_IN_USE);
! 638:
! 639: endpoints = iface->endpoints;
! 640: err = usbd_fill_iface_data(iface->device, iface->index, altidx);
! 641: if (err)
! 642: return (err);
! 643:
! 644: /* new setting works, we can free old endpoints */
! 645: if (endpoints != NULL)
! 646: free(endpoints, M_USB);
! 647:
! 648: #ifdef DIAGNOSTIC
! 649: if (iface->idesc == NULL) {
! 650: printf("usbd_set_interface: NULL pointer\n");
! 651: return (USBD_INVAL);
! 652: }
! 653: #endif
! 654:
! 655: req.bmRequestType = UT_WRITE_INTERFACE;
! 656: req.bRequest = UR_SET_INTERFACE;
! 657: USETW(req.wValue, iface->idesc->bAlternateSetting);
! 658: USETW(req.wIndex, iface->idesc->bInterfaceNumber);
! 659: USETW(req.wLength, 0);
! 660: return (usbd_do_request(iface->device, &req, 0));
! 661: }
! 662:
! 663: int
! 664: usbd_get_no_alts(usb_config_descriptor_t *cdesc, int ifaceno)
! 665: {
! 666: char *p = (char *)cdesc;
! 667: char *end = p + UGETW(cdesc->wTotalLength);
! 668: usb_interface_descriptor_t *d;
! 669: int n;
! 670:
! 671: for (n = 0; p < end; p += d->bLength) {
! 672: d = (usb_interface_descriptor_t *)p;
! 673: if (p + d->bLength <= end &&
! 674: d->bDescriptorType == UDESC_INTERFACE &&
! 675: d->bInterfaceNumber == ifaceno)
! 676: n++;
! 677: }
! 678: return (n);
! 679: }
! 680:
! 681: int
! 682: usbd_get_interface_altindex(usbd_interface_handle iface)
! 683: {
! 684: return (iface->altindex);
! 685: }
! 686:
! 687: usbd_status
! 688: usbd_get_interface(usbd_interface_handle iface, u_int8_t *aiface)
! 689: {
! 690: usb_device_request_t req;
! 691:
! 692: req.bmRequestType = UT_READ_INTERFACE;
! 693: req.bRequest = UR_GET_INTERFACE;
! 694: USETW(req.wValue, 0);
! 695: USETW(req.wIndex, iface->idesc->bInterfaceNumber);
! 696: USETW(req.wLength, 1);
! 697: return (usbd_do_request(iface->device, &req, aiface));
! 698: }
! 699:
! 700: /*** Internal routines ***/
! 701:
! 702: /* Dequeue all pipe operations, called at splusb(). */
! 703: usbd_status
! 704: usbd_ar_pipe(usbd_pipe_handle pipe)
! 705: {
! 706: usbd_xfer_handle xfer;
! 707:
! 708: SPLUSBCHECK;
! 709:
! 710: DPRINTFN(2,("usbd_ar_pipe: pipe=%p\n", pipe));
! 711: #ifdef USB_DEBUG
! 712: if (usbdebug > 5)
! 713: usbd_dump_queue(pipe);
! 714: #endif
! 715: pipe->repeat = 0;
! 716: pipe->aborting = 1;
! 717: while ((xfer = SIMPLEQ_FIRST(&pipe->queue)) != NULL) {
! 718: DPRINTFN(2,("usbd_ar_pipe: pipe=%p xfer=%p (methods=%p)\n",
! 719: pipe, xfer, pipe->methods));
! 720: /* Make the HC abort it (and invoke the callback). */
! 721: pipe->methods->abort(xfer);
! 722: /* XXX only for non-0 usbd_clear_endpoint_stall(pipe); */
! 723: }
! 724: pipe->aborting = 0;
! 725: return (USBD_NORMAL_COMPLETION);
! 726: }
! 727:
! 728: /* Called at splusb() */
! 729: void
! 730: usb_transfer_complete(usbd_xfer_handle xfer)
! 731: {
! 732: usbd_pipe_handle pipe = xfer->pipe;
! 733: usb_dma_t *dmap = &xfer->dmabuf;
! 734: int repeat = pipe->repeat;
! 735: int polling;
! 736:
! 737: SPLUSBCHECK;
! 738:
! 739: DPRINTFN(5, ("usb_transfer_complete: pipe=%p xfer=%p status=%d "
! 740: "actlen=%d\n", pipe, xfer, xfer->status, xfer->actlen));
! 741: #ifdef DIAGNOSTIC
! 742: if (xfer->busy_free != XFER_ONQU) {
! 743: printf("usb_transfer_complete: xfer=%p not busy 0x%08x\n",
! 744: xfer, xfer->busy_free);
! 745: return;
! 746: }
! 747: #endif
! 748:
! 749: #ifdef DIAGNOSTIC
! 750: if (pipe == NULL) {
! 751: printf("usbd_transfer_cb: pipe==0, xfer=%p\n", xfer);
! 752: return;
! 753: }
! 754: #endif
! 755: polling = pipe->device->bus->use_polling;
! 756: /* XXXX */
! 757: if (polling)
! 758: pipe->running = 0;
! 759:
! 760: if (!(xfer->flags & USBD_NO_COPY) && xfer->actlen != 0 &&
! 761: usbd_xfer_isread(xfer)) {
! 762: #ifdef DIAGNOSTIC
! 763: if (xfer->actlen > xfer->length) {
! 764: printf("usb_transfer_complete: actlen > len %d > %d\n",
! 765: xfer->actlen, xfer->length);
! 766: xfer->actlen = xfer->length;
! 767: }
! 768: #endif
! 769: memcpy(xfer->buffer, KERNADDR(dmap, 0), xfer->actlen);
! 770: }
! 771:
! 772: /* if we allocated the buffer in usbd_transfer() we free it here. */
! 773: if (xfer->rqflags & URQ_AUTO_DMABUF) {
! 774: if (!repeat) {
! 775: struct usbd_bus *bus = pipe->device->bus;
! 776: bus->methods->freem(bus, dmap);
! 777: xfer->rqflags &= ~URQ_AUTO_DMABUF;
! 778: }
! 779: }
! 780:
! 781: if (!repeat) {
! 782: /* Remove request from queue. */
! 783: #ifdef DIAGNOSTIC
! 784: if (xfer != SIMPLEQ_FIRST(&pipe->queue))
! 785: printf("usb_transfer_complete: bad dequeue %p != %p\n",
! 786: xfer, SIMPLEQ_FIRST(&pipe->queue));
! 787: xfer->busy_free = XFER_BUSY;
! 788: #endif
! 789: SIMPLEQ_REMOVE_HEAD(&pipe->queue, next);
! 790: }
! 791: DPRINTFN(5,("usb_transfer_complete: repeat=%d new head=%p\n", repeat,
! 792: SIMPLEQ_FIRST(&pipe->queue)));
! 793:
! 794: /* Count completed transfers. */
! 795: ++pipe->device->bus->stats.uds_requests
! 796: [pipe->endpoint->edesc->bmAttributes & UE_XFERTYPE];
! 797:
! 798: xfer->done = 1;
! 799: if (!xfer->status && xfer->actlen < xfer->length &&
! 800: !(xfer->flags & USBD_SHORT_XFER_OK)) {
! 801: DPRINTFN(-1,("usbd_transfer_cb: short transfer %d<%d\n",
! 802: xfer->actlen, xfer->length));
! 803: xfer->status = USBD_SHORT_XFER;
! 804: }
! 805:
! 806: if (xfer->callback)
! 807: xfer->callback(xfer, xfer->priv, xfer->status);
! 808:
! 809: #ifdef DIAGNOSTIC
! 810: if (pipe->methods->done != NULL)
! 811: pipe->methods->done(xfer);
! 812: else
! 813: printf("usb_transfer_complete: pipe->methods->done == NULL\n");
! 814: #else
! 815: pipe->methods->done(xfer);
! 816: #endif
! 817:
! 818: if ((xfer->flags & USBD_SYNCHRONOUS) && !polling)
! 819: wakeup(xfer);
! 820:
! 821: if (!repeat) {
! 822: /* XXX should we stop the queue on all errors? */
! 823: if ((xfer->status == USBD_CANCELLED ||
! 824: xfer->status == USBD_TIMEOUT) &&
! 825: pipe->iface != NULL) /* not control pipe */
! 826: pipe->running = 0;
! 827: else
! 828: usbd_start_next(pipe);
! 829: }
! 830: }
! 831:
! 832: usbd_status
! 833: usb_insert_transfer(usbd_xfer_handle xfer)
! 834: {
! 835: usbd_pipe_handle pipe = xfer->pipe;
! 836: usbd_status err;
! 837: int s;
! 838:
! 839: DPRINTFN(5,("usb_insert_transfer: pipe=%p running=%d timeout=%d\n",
! 840: pipe, pipe->running, xfer->timeout));
! 841: #ifdef DIAGNOSTIC
! 842: if (xfer->busy_free != XFER_BUSY) {
! 843: printf("usb_insert_transfer: xfer=%p not busy 0x%08x\n", xfer,
! 844: xfer->busy_free);
! 845: return (USBD_INVAL);
! 846: }
! 847: xfer->busy_free = XFER_ONQU;
! 848: #endif
! 849: s = splusb();
! 850: SIMPLEQ_INSERT_TAIL(&pipe->queue, xfer, next);
! 851: if (pipe->running)
! 852: err = USBD_IN_PROGRESS;
! 853: else {
! 854: pipe->running = 1;
! 855: err = USBD_NORMAL_COMPLETION;
! 856: }
! 857: splx(s);
! 858: return (err);
! 859: }
! 860:
! 861: /* Called at splusb() */
! 862: void
! 863: usbd_start_next(usbd_pipe_handle pipe)
! 864: {
! 865: usbd_xfer_handle xfer;
! 866: usbd_status err;
! 867:
! 868: SPLUSBCHECK;
! 869:
! 870: #ifdef DIAGNOSTIC
! 871: if (pipe == NULL) {
! 872: printf("usbd_start_next: pipe == NULL\n");
! 873: return;
! 874: }
! 875: if (pipe->methods == NULL || pipe->methods->start == NULL) {
! 876: printf("usbd_start_next: pipe=%p no start method\n", pipe);
! 877: return;
! 878: }
! 879: #endif
! 880:
! 881: /* Get next request in queue. */
! 882: xfer = SIMPLEQ_FIRST(&pipe->queue);
! 883: DPRINTFN(5, ("usbd_start_next: pipe=%p, xfer=%p\n", pipe, xfer));
! 884: if (xfer == NULL) {
! 885: pipe->running = 0;
! 886: } else {
! 887: err = pipe->methods->start(xfer);
! 888: if (err != USBD_IN_PROGRESS) {
! 889: printf("usbd_start_next: error=%d\n", err);
! 890: pipe->running = 0;
! 891: /* XXX do what? */
! 892: }
! 893: }
! 894: }
! 895:
! 896: usbd_status
! 897: usbd_do_request(usbd_device_handle dev, usb_device_request_t *req, void *data)
! 898: {
! 899: return (usbd_do_request_flags(dev, req, data, 0, 0,
! 900: USBD_DEFAULT_TIMEOUT));
! 901: }
! 902:
! 903: usbd_status
! 904: usbd_do_request_flags(usbd_device_handle dev, usb_device_request_t *req,
! 905: void *data, u_int16_t flags, int *actlen, u_int32_t timo)
! 906: {
! 907: return (usbd_do_request_flags_pipe(dev, dev->default_pipe, req, data,
! 908: flags, actlen, timo));
! 909: }
! 910:
! 911: usbd_status
! 912: usbd_do_request_flags_pipe(usbd_device_handle dev, usbd_pipe_handle pipe,
! 913: usb_device_request_t *req, void *data, u_int16_t flags, int *actlen,
! 914: u_int32_t timeout)
! 915: {
! 916: usbd_xfer_handle xfer;
! 917: usbd_status err;
! 918:
! 919: #ifdef DIAGNOSTIC
! 920: if (dev->bus->intr_context) {
! 921: printf("usbd_do_request: not in process context\n");
! 922: return (USBD_INVAL);
! 923: }
! 924: #endif
! 925:
! 926: xfer = usbd_alloc_xfer(dev);
! 927: if (xfer == NULL)
! 928: return (USBD_NOMEM);
! 929: usbd_setup_default_xfer(xfer, dev, 0, timeout, req, data,
! 930: UGETW(req->wLength), flags, 0);
! 931: xfer->pipe = pipe;
! 932: err = usbd_sync_transfer(xfer);
! 933: #if defined(USB_DEBUG) || defined(DIAGNOSTIC)
! 934: if (xfer->actlen > xfer->length)
! 935: DPRINTF(("usbd_do_request: overrun addr=%d type=0x%02x req=0x"
! 936: "%02x val=%d index=%d rlen=%d length=%d actlen=%d\n",
! 937: dev->address, xfer->request.bmRequestType,
! 938: xfer->request.bRequest, UGETW(xfer->request.wValue),
! 939: UGETW(xfer->request.wIndex), UGETW(xfer->request.wLength),
! 940: xfer->length, xfer->actlen));
! 941: #endif
! 942: if (actlen != NULL)
! 943: *actlen = xfer->actlen;
! 944: if (err == USBD_STALLED) {
! 945: /*
! 946: * The control endpoint has stalled. Control endpoints
! 947: * should not halt, but some may do so anyway so clear
! 948: * any halt condition.
! 949: */
! 950: usb_device_request_t treq;
! 951: usb_status_t status;
! 952: u_int16_t s;
! 953: usbd_status nerr;
! 954:
! 955: treq.bmRequestType = UT_READ_ENDPOINT;
! 956: treq.bRequest = UR_GET_STATUS;
! 957: USETW(treq.wValue, 0);
! 958: USETW(treq.wIndex, 0);
! 959: USETW(treq.wLength, sizeof(usb_status_t));
! 960: usbd_setup_default_xfer(xfer, dev, 0, USBD_DEFAULT_TIMEOUT,
! 961: &treq, &status,sizeof(usb_status_t), 0, 0);
! 962: nerr = usbd_sync_transfer(xfer);
! 963: if (nerr)
! 964: goto bad;
! 965: s = UGETW(status.wStatus);
! 966: DPRINTF(("usbd_do_request: status = 0x%04x\n", s));
! 967: if (!(s & UES_HALT))
! 968: goto bad;
! 969: treq.bmRequestType = UT_WRITE_ENDPOINT;
! 970: treq.bRequest = UR_CLEAR_FEATURE;
! 971: USETW(treq.wValue, UF_ENDPOINT_HALT);
! 972: USETW(treq.wIndex, 0);
! 973: USETW(treq.wLength, 0);
! 974: usbd_setup_default_xfer(xfer, dev, 0, USBD_DEFAULT_TIMEOUT,
! 975: &treq, &status, 0, 0, 0);
! 976: nerr = usbd_sync_transfer(xfer);
! 977: if (nerr)
! 978: goto bad;
! 979: }
! 980:
! 981: bad:
! 982: usbd_free_xfer(xfer);
! 983: return (err);
! 984: }
! 985:
! 986: void
! 987: usbd_do_request_async_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
! 988: usbd_status status)
! 989: {
! 990: #if defined(USB_DEBUG) || defined(DIAGNOSTIC)
! 991: if (xfer->actlen > xfer->length)
! 992: DPRINTF(("usbd_do_request: overrun addr=%d type=0x%02x req=0x"
! 993: "%02x val=%d index=%d rlen=%d length=%d actlen=%d\n",
! 994: xfer->pipe->device->address, xfer->request.bmRequestType,
! 995: xfer->request.bRequest, UGETW(xfer->request.wValue),
! 996: UGETW(xfer->request.wIndex), UGETW(xfer->request.wLength),
! 997: xfer->length, xfer->actlen));
! 998: #endif
! 999: usbd_free_xfer(xfer);
! 1000: }
! 1001:
! 1002: /*
! 1003: * Execute a request without waiting for completion.
! 1004: * Can be used from interrupt context.
! 1005: */
! 1006: usbd_status
! 1007: usbd_do_request_async(usbd_device_handle dev, usb_device_request_t *req,
! 1008: void *data)
! 1009: {
! 1010: usbd_xfer_handle xfer;
! 1011: usbd_status err;
! 1012:
! 1013: xfer = usbd_alloc_xfer(dev);
! 1014: if (xfer == NULL)
! 1015: return (USBD_NOMEM);
! 1016: usbd_setup_default_xfer(xfer, dev, 0, USBD_DEFAULT_TIMEOUT, req,
! 1017: data, UGETW(req->wLength), 0, usbd_do_request_async_cb);
! 1018: err = usbd_transfer(xfer);
! 1019: if (err != USBD_IN_PROGRESS) {
! 1020: usbd_free_xfer(xfer);
! 1021: return (err);
! 1022: }
! 1023: return (USBD_NORMAL_COMPLETION);
! 1024: }
! 1025:
! 1026: const struct usbd_quirks *
! 1027: usbd_get_quirks(usbd_device_handle dev)
! 1028: {
! 1029: #ifdef DIAGNOSTIC
! 1030: if (dev == NULL) {
! 1031: printf("usbd_get_quirks: dev == NULL\n");
! 1032: return 0;
! 1033: }
! 1034: #endif
! 1035: return (dev->quirks);
! 1036: }
! 1037:
! 1038: /* XXX do periodic free() of free list */
! 1039:
! 1040: /*
! 1041: * Called from keyboard driver when in polling mode.
! 1042: */
! 1043: void
! 1044: usbd_dopoll(usbd_interface_handle iface)
! 1045: {
! 1046: iface->device->bus->methods->do_poll(iface->device->bus);
! 1047: }
! 1048:
! 1049: void
! 1050: usbd_set_polling(usbd_device_handle dev, int on)
! 1051: {
! 1052: if (on)
! 1053: dev->bus->use_polling++;
! 1054: else
! 1055: dev->bus->use_polling--;
! 1056: /* When polling we need to make sure there is nothing pending to do. */
! 1057: if (dev->bus->use_polling)
! 1058: dev->bus->methods->soft_intr(dev->bus);
! 1059: }
! 1060:
! 1061: usb_endpoint_descriptor_t *
! 1062: usbd_get_endpoint_descriptor(usbd_interface_handle iface, u_int8_t address)
! 1063: {
! 1064: struct usbd_endpoint *ep;
! 1065: int i;
! 1066:
! 1067: for (i = 0; i < iface->idesc->bNumEndpoints; i++) {
! 1068: ep = &iface->endpoints[i];
! 1069: if (ep->edesc->bEndpointAddress == address)
! 1070: return (iface->endpoints[i].edesc);
! 1071: }
! 1072: return (0);
! 1073: }
! 1074:
! 1075: /*
! 1076: * usbd_ratecheck() can limit the number of error messages that occurs.
! 1077: * When a device is unplugged it may take up to 0.25s for the hub driver
! 1078: * to notice it. If the driver continuosly tries to do I/O operations
! 1079: * this can generate a large number of messages.
! 1080: */
! 1081: int
! 1082: usbd_ratecheck(struct timeval *last)
! 1083: {
! 1084: static struct timeval errinterval = { 0, 250000 }; /* 0.25 s*/
! 1085:
! 1086: return (ratecheck(last, &errinterval));
! 1087: }
! 1088:
! 1089: /*
! 1090: * Search for a vendor/product pair in an array. The item size is
! 1091: * given as an argument.
! 1092: */
! 1093: const struct usb_devno *
! 1094: usb_match_device(const struct usb_devno *tbl, u_int nentries, u_int sz,
! 1095: u_int16_t vendor, u_int16_t product)
! 1096: {
! 1097: while (nentries-- > 0) {
! 1098: u_int16_t tproduct = tbl->ud_product;
! 1099: if (tbl->ud_vendor == vendor &&
! 1100: (tproduct == product || tproduct == USB_PRODUCT_ANY))
! 1101: return (tbl);
! 1102: tbl = (const struct usb_devno *)((const char *)tbl + sz);
! 1103: }
! 1104: return (NULL);
! 1105: }
! 1106:
! 1107: void
! 1108: usb_desc_iter_init(usbd_device_handle dev, usbd_desc_iter_t *iter)
! 1109: {
! 1110: const usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev);
! 1111:
! 1112: iter->cur = (const uByte *)cd;
! 1113: iter->end = (const uByte *)cd + UGETW(cd->wTotalLength);
! 1114: }
! 1115:
! 1116: const usb_descriptor_t *
! 1117: usb_desc_iter_next(usbd_desc_iter_t *iter)
! 1118: {
! 1119: const usb_descriptor_t *desc;
! 1120:
! 1121: if (iter->cur + sizeof(usb_descriptor_t) >= iter->end) {
! 1122: if (iter->cur != iter->end)
! 1123: printf("usb_desc_iter_next: bad descriptor\n");
! 1124: return NULL;
! 1125: }
! 1126: desc = (const usb_descriptor_t *)iter->cur;
! 1127: if (desc->bLength == 0) {
! 1128: printf("usb_desc_iter_next: descriptor length = 0\n");
! 1129: return NULL;
! 1130: }
! 1131: iter->cur += desc->bLength;
! 1132: if (iter->cur > iter->end) {
! 1133: printf("usb_desc_iter_next: descriptor length too large\n");
! 1134: return NULL;
! 1135: }
! 1136: return desc;
! 1137: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to usbdi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb