Annotation of src/sys/dev/usb/usbdi.c, Revision 1.183
1.183 ! mrg 1: /* $NetBSD: usbdi.c,v 1.182 2019/02/17 04:17:31 rin Exp $ */
1.1 augustss 2:
3: /*
1.169 skrll 4: * Copyright (c) 1998, 2012, 2015 The NetBSD Foundation, Inc.
1.1 augustss 5: * All rights reserved.
6: *
1.11 augustss 7: * This code is derived from software contributed to The NetBSD Foundation
1.72 augustss 8: * by Lennart Augustsson (lennart@augustsson.net) at
1.169 skrll 9: * Carlstedt Research & Technology, Matthew R. Green (mrg@eterna.com.au),
10: * and Nick Hudson.
1.1 augustss 11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31: * POSSIBILITY OF SUCH DAMAGE.
32: */
1.84 lukem 33:
34: #include <sys/cdefs.h>
1.183 ! mrg 35: __KERNEL_RCSID(0, "$NetBSD: usbdi.c,v 1.182 2019/02/17 04:17:31 rin Exp $");
1.115 pavel 36:
1.141 christos 37: #ifdef _KERNEL_OPT
1.162 skrll 38: #include "opt_usb.h"
1.115 pavel 39: #include "opt_compat_netbsd.h"
1.169 skrll 40: #include "usb_dma.h"
1.141 christos 41: #endif
1.1 augustss 42:
43: #include <sys/param.h>
44: #include <sys/systm.h>
45: #include <sys/kernel.h>
1.15 augustss 46: #include <sys/device.h>
1.169 skrll 47: #include <sys/kmem.h>
1.1 augustss 48: #include <sys/proc.h>
1.121 ad 49: #include <sys/bus.h>
1.136 mrg 50: #include <sys/cpu.h>
1.36 augustss 51:
1.1 augustss 52: #include <dev/usb/usb.h>
53: #include <dev/usb/usbdi.h>
54: #include <dev/usb/usbdi_util.h>
55: #include <dev/usb/usbdivar.h>
1.36 augustss 56: #include <dev/usb/usb_mem.h>
1.105 augustss 57: #include <dev/usb/usb_quirks.h>
1.162 skrll 58: #include <dev/usb/usbhist.h>
1.1 augustss 59:
1.119 drochner 60: /* UTF-8 encoding stuff */
61: #include <fs/unicode.h>
62:
1.1 augustss 63: extern int usbdebug;
64:
1.169 skrll 65: Static usbd_status usbd_ar_pipe(struct usbd_pipe *);
66: Static void usbd_start_next(struct usbd_pipe *);
1.69 augustss 67: Static usbd_status usbd_open_pipe_ival
1.169 skrll 68: (struct usbd_interface *, uint8_t, uint8_t, struct usbd_pipe **, int);
69: static void *usbd_alloc_buffer(struct usbd_xfer *, uint32_t);
70: static void usbd_free_buffer(struct usbd_xfer *);
71: static struct usbd_xfer *usbd_alloc_xfer(struct usbd_device *, unsigned int);
72: static usbd_status usbd_free_xfer(struct usbd_xfer *);
1.176 khorben 73: static void usbd_request_async_cb(struct usbd_xfer *, void *, usbd_status);
1.1 augustss 74:
1.162 skrll 75: #if defined(USB_DEBUG)
1.82 augustss 76: void
77: usbd_dump_iface(struct usbd_interface *iface)
78: {
1.183 ! mrg 79: USBHIST_FUNC();
! 80: USBHIST_CALLARGS(usbdebug, "iface %#jx", (uintptr_t)iface, 0, 0, 0);
1.162 skrll 81:
1.82 augustss 82: if (iface == NULL)
83: return;
1.175 pgoyette 84: USBHIST_LOG(usbdebug, " device = %#jx idesc = %#jx index = %d",
85: (uintptr_t)iface->ui_dev, (uintptr_t)iface->ui_idesc,
86: iface->ui_index, 0);
87: USBHIST_LOG(usbdebug, " altindex=%d priv=%#jx",
88: iface->ui_altindex, (uintptr_t)iface->ui_priv, 0, 0);
1.82 augustss 89: }
90:
91: void
92: usbd_dump_device(struct usbd_device *dev)
93: {
1.183 ! mrg 94: USBHIST_FUNC();
! 95: USBHIST_CALLARGS(usbdebug, "dev = %#jx", (uintptr_t)dev, 0, 0, 0);
1.162 skrll 96:
1.82 augustss 97: if (dev == NULL)
98: return;
1.175 pgoyette 99: USBHIST_LOG(usbdebug, " bus = %#jx default_pipe = %#jx",
100: (uintptr_t)dev->ud_bus, (uintptr_t)dev->ud_pipe0, 0, 0);
101: USBHIST_LOG(usbdebug, " address = %jd config = %jd depth = %jd ",
1.169 skrll 102: dev->ud_addr, dev->ud_config, dev->ud_depth, 0);
1.175 pgoyette 103: USBHIST_LOG(usbdebug, " speed = %jd self_powered = %jd "
104: "power = %jd langid = %jd",
1.169 skrll 105: dev->ud_speed, dev->ud_selfpowered, dev->ud_power, dev->ud_langid);
1.82 augustss 106: }
107:
108: void
109: usbd_dump_endpoint(struct usbd_endpoint *endp)
110: {
1.183 ! mrg 111: USBHIST_FUNC();
! 112: USBHIST_CALLARGS(usbdebug, "endp = %#jx", (uintptr_t)endp, 0, 0, 0);
1.162 skrll 113:
1.82 augustss 114: if (endp == NULL)
115: return;
1.175 pgoyette 116: USBHIST_LOG(usbdebug, " edesc = %#jx refcnt = %jd",
117: (uintptr_t)endp->ue_edesc, endp->ue_refcnt, 0, 0);
1.169 skrll 118: if (endp->ue_edesc)
1.162 skrll 119: USBHIST_LOG(usbdebug, " bEndpointAddress=0x%02x",
1.169 skrll 120: endp->ue_edesc->bEndpointAddress, 0, 0, 0);
1.82 augustss 121: }
122:
1.28 augustss 123: void
1.169 skrll 124: usbd_dump_queue(struct usbd_pipe *pipe)
1.28 augustss 125: {
1.169 skrll 126: struct usbd_xfer *xfer;
1.28 augustss 127:
1.183 ! mrg 128: USBHIST_FUNC();
! 129: USBHIST_CALLARGS(usbdebug, "pipe = %#jx", (uintptr_t)pipe, 0, 0, 0);
1.162 skrll 130:
1.169 skrll 131: SIMPLEQ_FOREACH(xfer, &pipe->up_queue, ux_next) {
1.175 pgoyette 132: USBHIST_LOG(usbdebug, " xfer = %#jx", (uintptr_t)xfer,
133: 0, 0, 0);
1.28 augustss 134: }
1.82 augustss 135: }
136:
137: void
1.169 skrll 138: usbd_dump_pipe(struct usbd_pipe *pipe)
1.82 augustss 139: {
1.183 ! mrg 140: USBHIST_FUNC();
! 141: USBHIST_CALLARGS(usbdebug, "pipe = %#jx", (uintptr_t)pipe, 0, 0, 0);
1.162 skrll 142:
1.82 augustss 143: if (pipe == NULL)
144: return;
1.169 skrll 145: usbd_dump_iface(pipe->up_iface);
146: usbd_dump_device(pipe->up_dev);
147: usbd_dump_endpoint(pipe->up_endpoint);
1.162 skrll 148: USBHIST_LOG(usbdebug, "(usbd_dump_pipe)", 0, 0, 0, 0);
1.175 pgoyette 149: USBHIST_LOG(usbdebug, " running = %jd aborting = %jd",
1.169 skrll 150: pipe->up_running, pipe->up_aborting, 0, 0);
1.175 pgoyette 151: USBHIST_LOG(usbdebug, " intrxfer = %#jx, repeat = %jd, "
152: "interval = %jd", (uintptr_t)pipe->up_intrxfer, pipe->up_repeat,
153: pipe->up_interval, 0);
1.28 augustss 154: }
155: #endif
156:
1.102 augustss 157: usbd_status
1.169 skrll 158: usbd_open_pipe(struct usbd_interface *iface, uint8_t address,
159: uint8_t flags, struct usbd_pipe **pipe)
1.102 augustss 160: {
161: return (usbd_open_pipe_ival(iface, address, flags, pipe,
1.60 augustss 162: USBD_DEFAULT_INTERVAL));
163: }
164:
1.102 augustss 165: usbd_status
1.169 skrll 166: usbd_open_pipe_ival(struct usbd_interface *iface, uint8_t address,
167: uint8_t flags, struct usbd_pipe **pipe, int ival)
1.102 augustss 168: {
1.169 skrll 169: struct usbd_pipe *p;
1.1 augustss 170: struct usbd_endpoint *ep;
1.48 augustss 171: usbd_status err;
1.12 augustss 172: int i;
1.1 augustss 173:
1.183 ! mrg 174: USBHIST_FUNC();
! 175: USBHIST_CALLARGS(usbdebug, "iface = %#jx address = 0x%jx flags = 0x%jx",
1.175 pgoyette 176: (uintptr_t)iface, address, flags, 0);
1.53 augustss 177:
1.169 skrll 178: for (i = 0; i < iface->ui_idesc->bNumEndpoints; i++) {
179: ep = &iface->ui_endpoints[i];
180: if (ep->ue_edesc == NULL)
181: return USBD_IOERROR;
182: if (ep->ue_edesc->bEndpointAddress == address)
1.1 augustss 183: goto found;
184: }
1.169 skrll 185: return USBD_BAD_ADDRESS;
1.1 augustss 186: found:
1.169 skrll 187: if ((flags & USBD_EXCLUSIVE_USE) && ep->ue_refcnt != 0)
188: return USBD_IN_USE;
189: err = usbd_setup_pipe_flags(iface->ui_dev, iface, ep, ival, &p, flags);
1.48 augustss 190: if (err)
1.169 skrll 191: return err;
192: LIST_INSERT_HEAD(&iface->ui_pipes, p, up_next);
1.1 augustss 193: *pipe = p;
1.169 skrll 194: return USBD_NORMAL_COMPLETION;
1.1 augustss 195: }
196:
1.102 augustss 197: usbd_status
1.169 skrll 198: usbd_open_pipe_intr(struct usbd_interface *iface, uint8_t address,
199: uint8_t flags, struct usbd_pipe **pipe,
200: void *priv, void *buffer, uint32_t len,
1.74 augustss 201: usbd_callback cb, int ival)
1.1 augustss 202: {
1.48 augustss 203: usbd_status err;
1.169 skrll 204: struct usbd_xfer *xfer;
205: struct usbd_pipe *ipipe;
1.1 augustss 206:
1.183 ! mrg 207: USBHIST_FUNC();
! 208: USBHIST_CALLARGS(usbdebug, "address = 0x%jx flags = 0x%jx len = %jd",
1.162 skrll 209: address, flags, len, 0);
1.53 augustss 210:
1.150 jmcneill 211: err = usbd_open_pipe_ival(iface, address,
212: USBD_EXCLUSIVE_USE | (flags & USBD_MPSAFE),
1.60 augustss 213: &ipipe, ival);
1.48 augustss 214: if (err)
1.169 skrll 215: return err;
216: err = usbd_create_xfer(ipipe, len, flags, 0, &xfer);
217: if (err)
1.1 augustss 218: goto bad1;
1.169 skrll 219:
220: usbd_setup_xfer(xfer, priv, buffer, len, flags, USBD_NO_TIMEOUT, cb);
221: ipipe->up_intrxfer = xfer;
222: ipipe->up_repeat = 1;
1.48 augustss 223: err = usbd_transfer(xfer);
1.1 augustss 224: *pipe = ipipe;
1.48 augustss 225: if (err != USBD_IN_PROGRESS)
1.169 skrll 226: goto bad3;
227: return USBD_NORMAL_COMPLETION;
228:
229: bad3:
230: ipipe->up_intrxfer = NULL;
231: ipipe->up_repeat = 0;
1.1 augustss 232:
1.169 skrll 233: usbd_destroy_xfer(xfer);
1.36 augustss 234: bad1:
1.1 augustss 235: usbd_close_pipe(ipipe);
1.169 skrll 236: return err;
1.9 augustss 237: }
238:
1.1 augustss 239: usbd_status
1.169 skrll 240: usbd_close_pipe(struct usbd_pipe *pipe)
1.1 augustss 241: {
1.162 skrll 242: USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
243:
1.169 skrll 244: KASSERT(pipe != NULL);
1.26 augustss 245:
1.138 mrg 246: usbd_lock_pipe(pipe);
1.169 skrll 247:
248: if (!SIMPLEQ_EMPTY(&pipe->up_queue)) {
249: printf("WARNING: pipe closed with active xfers on addr %d\n",
250: pipe->up_dev->ud_addr);
251: usbd_ar_pipe(pipe);
1.138 mrg 252: }
1.169 skrll 253:
254: KASSERT(SIMPLEQ_EMPTY(&pipe->up_queue));
255:
256: LIST_REMOVE(pipe, up_next);
257: pipe->up_endpoint->ue_refcnt--;
258:
1.181 skrll 259: pipe->up_methods->upm_close(pipe);
260:
1.169 skrll 261: if (pipe->up_intrxfer != NULL) {
262: usbd_unlock_pipe(pipe);
263: usbd_destroy_xfer(pipe->up_intrxfer);
264: usbd_lock_pipe(pipe);
1.138 mrg 265: }
1.169 skrll 266:
1.138 mrg 267: usbd_unlock_pipe(pipe);
1.169 skrll 268: kmem_free(pipe, pipe->up_dev->ud_bus->ub_pipesize);
269:
270: return USBD_NORMAL_COMPLETION;
1.1 augustss 271: }
272:
1.31 augustss 273: usbd_status
1.169 skrll 274: usbd_transfer(struct usbd_xfer *xfer)
1.1 augustss 275: {
1.169 skrll 276: struct usbd_pipe *pipe = xfer->ux_pipe;
1.48 augustss 277: usbd_status err;
1.120 kiyohara 278: unsigned int size, flags;
1.16 augustss 279:
1.183 ! mrg 280: USBHIST_FUNC(); USBHIST_CALLARGS(usbdebug,
1.175 pgoyette 281: "xfer = %#jx, flags = %#jx, pipe = %#jx, running = %jd",
282: (uintptr_t)xfer, xfer->ux_flags, (uintptr_t)pipe, pipe->up_running);
1.177 mrg 283: KASSERT(xfer->ux_status == USBD_NOT_STARTED);
1.134 jmcneill 284:
1.28 augustss 285: #ifdef USB_DEBUG
286: if (usbdebug > 5)
287: usbd_dump_queue(pipe);
288: #endif
1.169 skrll 289: xfer->ux_done = 0;
1.31 augustss 290:
1.169 skrll 291: if (pipe->up_aborting) {
1.175 pgoyette 292: USBHIST_LOG(usbdebug, "<- done xfer %#jx, aborting",
293: (uintptr_t)xfer, 0, 0, 0);
1.169 skrll 294: return USBD_CANCELLED;
1.162 skrll 295: }
1.71 augustss 296:
1.169 skrll 297: KASSERT(xfer->ux_length == 0 || xfer->ux_buf != NULL);
298:
299: size = xfer->ux_length;
300: flags = xfer->ux_flags;
1.37 augustss 301:
1.169 skrll 302: if (size != 0) {
303: /*
304: * Use the xfer buffer if none specified in transfer setup.
305: * isoc transfers always use the xfer buffer, i.e.
306: * ux_buffer is always NULL for isoc.
307: */
308: if (xfer->ux_buffer == NULL) {
309: xfer->ux_buffer = xfer->ux_buf;
310: }
311:
312: /*
313: * If not using the xfer buffer copy data to the
314: * xfer buffer for OUT transfers of >0 length
315: */
316: if (xfer->ux_buffer != xfer->ux_buf) {
317: KASSERT(xfer->ux_buf);
318: if (!usbd_xfer_isread(xfer)) {
319: memcpy(xfer->ux_buf, xfer->ux_buffer, size);
320: }
1.162 skrll 321: }
1.38 augustss 322: }
1.37 augustss 323:
1.120 kiyohara 324: /* xfer is not valid after the transfer method unless synchronous */
1.169 skrll 325: err = pipe->up_methods->upm_transfer(xfer);
1.175 pgoyette 326: USBHIST_LOG(usbdebug, "<- done transfer %#jx, err = %jd",
327: (uintptr_t)xfer, err, 0, 0);
1.37 augustss 328:
1.51 augustss 329: if (err != USBD_IN_PROGRESS && err) {
1.168 skrll 330: /*
331: * The transfer made it onto the pipe queue, but didn't get
332: * accepted by the HCD for some reason. It needs removing
333: * from the pipe queue.
334: */
335: usbd_lock_pipe(pipe);
1.169 skrll 336: SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next);
337: if (pipe->up_serialise)
338: usbd_start_next(pipe);
1.168 skrll 339: usbd_unlock_pipe(pipe);
1.37 augustss 340: }
341:
1.162 skrll 342: if (!(flags & USBD_SYNCHRONOUS)) {
1.175 pgoyette 343: USBHIST_LOG(usbdebug, "<- done xfer %#jx, not sync (err %jd)",
344: (uintptr_t)xfer, err, 0, 0);
1.169 skrll 345: return err;
1.162 skrll 346: }
1.31 augustss 347:
1.162 skrll 348: if (err != USBD_IN_PROGRESS) {
1.177 mrg 349: USBHIST_LOG(usbdebug, "<- done xfer %#jx, sync (err %jd)"
1.175 pgoyette 350: "(complete/error)", (uintptr_t)xfer, err, 0, 0);
1.169 skrll 351: return err;
1.162 skrll 352: }
1.167 skrll 353:
354: /* Sync transfer, wait for completion. */
1.138 mrg 355: usbd_lock_pipe(pipe);
1.169 skrll 356: while (!xfer->ux_done) {
357: if (pipe->up_dev->ud_bus->ub_usepolling)
1.103 provos 358: panic("usbd_transfer: not done");
1.175 pgoyette 359: USBHIST_LOG(usbdebug, "<- sleeping on xfer %#jx",
360: (uintptr_t)xfer, 0, 0, 0);
1.138 mrg 361:
1.144 christos 362: err = 0;
1.138 mrg 363: if ((flags & USBD_SYNCHRONOUS_SIG) != 0) {
1.169 skrll 364: err = cv_wait_sig(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock);
1.138 mrg 365: } else {
1.169 skrll 366: cv_wait(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock);
1.138 mrg 367: }
1.154 aymeric 368: if (err) {
1.169 skrll 369: if (!xfer->ux_done)
370: pipe->up_methods->upm_abort(xfer);
1.144 christos 371: break;
1.154 aymeric 372: }
1.31 augustss 373: }
1.138 mrg 374: usbd_unlock_pipe(pipe);
1.169 skrll 375: return xfer->ux_status;
1.31 augustss 376: }
377:
378: /* Like usbd_transfer(), but waits for completion. */
379: usbd_status
1.169 skrll 380: usbd_sync_transfer(struct usbd_xfer *xfer)
1.31 augustss 381: {
1.169 skrll 382: xfer->ux_flags |= USBD_SYNCHRONOUS;
383: return usbd_transfer(xfer);
1.16 augustss 384: }
385:
1.138 mrg 386: /* Like usbd_transfer(), but waits for completion and listens for signals. */
387: usbd_status
1.169 skrll 388: usbd_sync_transfer_sig(struct usbd_xfer *xfer)
1.138 mrg 389: {
1.169 skrll 390: xfer->ux_flags |= USBD_SYNCHRONOUS | USBD_SYNCHRONOUS_SIG;
391: return usbd_transfer(xfer);
1.138 mrg 392: }
393:
1.169 skrll 394: static void *
395: usbd_alloc_buffer(struct usbd_xfer *xfer, uint32_t size)
1.36 augustss 396: {
1.169 skrll 397: KASSERT(xfer->ux_buf == NULL);
398: KASSERT(size != 0);
399:
400: xfer->ux_bufsize = 0;
401: #if NUSB_DMA > 0
402: struct usbd_bus *bus = xfer->ux_bus;
403:
404: if (bus->ub_usedma) {
405: usb_dma_t *dmap = &xfer->ux_dmabuf;
406:
407: int err = usb_allocmem_flags(bus, size, 0, dmap, bus->ub_dmaflags);
408: if (err) {
409: return NULL;
410: }
411: xfer->ux_buf = KERNADDR(&xfer->ux_dmabuf, 0);
412: xfer->ux_bufsize = size;
1.37 augustss 413:
1.169 skrll 414: return xfer->ux_buf;
415: }
1.92 augustss 416: #endif
1.169 skrll 417: KASSERT(xfer->ux_bus->ub_usedma == false);
418: xfer->ux_buf = kmem_alloc(size, KM_SLEEP);
1.173 chs 419: xfer->ux_bufsize = size;
1.169 skrll 420: return xfer->ux_buf;
1.36 augustss 421: }
422:
1.169 skrll 423: static void
424: usbd_free_buffer(struct usbd_xfer *xfer)
1.36 augustss 425: {
1.169 skrll 426: KASSERT(xfer->ux_buf != NULL);
427: KASSERT(xfer->ux_bufsize != 0);
428:
429: void *buf = xfer->ux_buf;
430: uint32_t size = xfer->ux_bufsize;
431:
432: xfer->ux_buf = NULL;
433: xfer->ux_bufsize = 0;
434:
435: #if NUSB_DMA > 0
436: struct usbd_bus *bus = xfer->ux_bus;
437:
438: if (bus->ub_usedma) {
439: usb_dma_t *dmap = &xfer->ux_dmabuf;
440:
441: usb_freemem(bus, dmap);
1.37 augustss 442: return;
443: }
444: #endif
1.169 skrll 445: KASSERT(xfer->ux_bus->ub_usedma == false);
446:
447: kmem_free(buf, size);
1.36 augustss 448: }
449:
1.38 augustss 450: void *
1.169 skrll 451: usbd_get_buffer(struct usbd_xfer *xfer)
1.38 augustss 452: {
1.169 skrll 453: return xfer->ux_buf;
1.38 augustss 454: }
455:
1.169 skrll 456: struct usbd_pipe *
457: usbd_get_pipe0(struct usbd_device *dev)
1.1 augustss 458: {
1.169 skrll 459:
460: return dev->ud_pipe0;
461: }
462:
463: static struct usbd_xfer *
464: usbd_alloc_xfer(struct usbd_device *dev, unsigned int nframes)
465: {
466: struct usbd_xfer *xfer;
1.1 augustss 467:
1.183 ! mrg 468: USBHIST_FUNC();
1.162 skrll 469:
1.169 skrll 470: ASSERT_SLEEPABLE();
471:
472: xfer = dev->ud_bus->ub_methods->ubm_allocx(dev->ud_bus, nframes);
1.48 augustss 473: if (xfer == NULL)
1.183 ! mrg 474: goto out;
1.169 skrll 475: xfer->ux_bus = dev->ud_bus;
476: callout_init(&xfer->ux_callout, CALLOUT_MPSAFE);
477: cv_init(&xfer->ux_cv, "usbxfer");
1.162 skrll 478:
1.183 ! mrg 479: out:
! 480: USBHIST_CALLARGS(usbdebug, "returns %#jx", (uintptr_t)xfer, 0, 0, 0);
1.162 skrll 481:
1.169 skrll 482: return xfer;
1.1 augustss 483: }
484:
1.169 skrll 485: static usbd_status
486: usbd_free_xfer(struct usbd_xfer *xfer)
1.1 augustss 487: {
1.183 ! mrg 488: USBHIST_FUNC();
! 489: USBHIST_CALLARGS(usbdebug, "%#jx", (uintptr_t)xfer, 0, 0, 0);
1.162 skrll 490:
1.169 skrll 491: if (xfer->ux_buf) {
1.48 augustss 492: usbd_free_buffer(xfer);
1.169 skrll 493: }
1.123 drochner 494: #if defined(DIAGNOSTIC)
1.169 skrll 495: if (callout_pending(&xfer->ux_callout)) {
496: callout_stop(&xfer->ux_callout);
1.140 skrll 497: printf("usbd_free_xfer: timeout_handle pending\n");
1.68 augustss 498: }
1.66 thorpej 499: #endif
1.169 skrll 500: cv_destroy(&xfer->ux_cv);
501: xfer->ux_bus->ub_methods->ubm_freex(xfer->ux_bus, xfer);
502: return USBD_NORMAL_COMPLETION;
503: }
504:
505: int
506: usbd_create_xfer(struct usbd_pipe *pipe, size_t len, unsigned int flags,
507: unsigned int nframes, struct usbd_xfer **xp)
508: {
509: KASSERT(xp != NULL);
1.171 pooka 510: void *buf = NULL;
1.169 skrll 511:
512: struct usbd_xfer *xfer = usbd_alloc_xfer(pipe->up_dev, nframes);
513: if (xfer == NULL)
514: return ENOMEM;
515:
516: if (len) {
517: buf = usbd_alloc_buffer(xfer, len);
518: if (!buf) {
519: usbd_free_xfer(xfer);
520: return ENOMEM;
521: }
522: }
523: xfer->ux_pipe = pipe;
524: xfer->ux_flags = flags;
525: xfer->ux_nframes = nframes;
526: xfer->ux_methods = pipe->up_methods;
527:
528: if (xfer->ux_methods->upm_init) {
529: int err = xfer->ux_methods->upm_init(xfer);
530: if (err) {
531: if (buf)
532: usbd_free_buffer(xfer);
533: usbd_free_xfer(xfer);
534: return err;
535: }
536: }
537:
538: *xp = xfer;
539: return 0;
1.1 augustss 540: }
541:
1.36 augustss 542: void
1.169 skrll 543: usbd_destroy_xfer(struct usbd_xfer *xfer)
544: {
545:
546: if (xfer->ux_methods->upm_fini) {
547: xfer->ux_methods->upm_fini(xfer);
548: }
549:
550: usbd_free_xfer(xfer);
1.1 augustss 551: }
552:
1.36 augustss 553: void
1.169 skrll 554: usbd_setup_xfer(struct usbd_xfer *xfer, void *priv, void *buffer,
555: uint32_t length, uint16_t flags, uint32_t timeout, usbd_callback callback)
556: {
557: KASSERT(xfer->ux_pipe);
558:
559: xfer->ux_priv = priv;
560: xfer->ux_buffer = buffer;
561: xfer->ux_length = length;
562: xfer->ux_actlen = 0;
563: xfer->ux_flags = flags;
564: xfer->ux_timeout = timeout;
565: xfer->ux_status = USBD_NOT_STARTED;
566: xfer->ux_callback = callback;
567: xfer->ux_rqflags &= ~URQ_REQUEST;
568: xfer->ux_nframes = 0;
1.36 augustss 569: }
570:
571: void
1.169 skrll 572: usbd_setup_default_xfer(struct usbd_xfer *xfer, struct usbd_device *dev,
573: void *priv, uint32_t timeout, usb_device_request_t *req, void *buffer,
574: uint32_t length, uint16_t flags, usbd_callback callback)
575: {
576: KASSERT(xfer->ux_pipe == dev->ud_pipe0);
577:
578: xfer->ux_priv = priv;
579: xfer->ux_buffer = buffer;
580: xfer->ux_length = length;
581: xfer->ux_actlen = 0;
582: xfer->ux_flags = flags;
583: xfer->ux_timeout = timeout;
584: xfer->ux_status = USBD_NOT_STARTED;
585: xfer->ux_callback = callback;
586: xfer->ux_request = *req;
587: xfer->ux_rqflags |= URQ_REQUEST;
588: xfer->ux_nframes = 0;
589: }
590:
591: void
592: usbd_setup_isoc_xfer(struct usbd_xfer *xfer, void *priv, uint16_t *frlengths,
593: uint32_t nframes, uint16_t flags, usbd_callback callback)
594: {
595: xfer->ux_priv = priv;
596: xfer->ux_buffer = NULL;
597: xfer->ux_length = 0;
598: xfer->ux_actlen = 0;
599: xfer->ux_flags = flags;
600: xfer->ux_timeout = USBD_NO_TIMEOUT;
601: xfer->ux_status = USBD_NOT_STARTED;
602: xfer->ux_callback = callback;
603: xfer->ux_rqflags &= ~URQ_REQUEST;
604: xfer->ux_frlengths = frlengths;
605: xfer->ux_nframes = nframes;
1.1 augustss 606: }
607:
1.31 augustss 608: void
1.169 skrll 609: usbd_get_xfer_status(struct usbd_xfer *xfer, void **priv,
610: void **buffer, uint32_t *count, usbd_status *status)
1.1 augustss 611: {
1.48 augustss 612: if (priv != NULL)
1.169 skrll 613: *priv = xfer->ux_priv;
1.48 augustss 614: if (buffer != NULL)
1.169 skrll 615: *buffer = xfer->ux_buffer;
1.48 augustss 616: if (count != NULL)
1.169 skrll 617: *count = xfer->ux_actlen;
1.48 augustss 618: if (status != NULL)
1.169 skrll 619: *status = xfer->ux_status;
1.1 augustss 620: }
621:
622: usb_config_descriptor_t *
1.169 skrll 623: usbd_get_config_descriptor(struct usbd_device *dev)
1.1 augustss 624: {
1.169 skrll 625: KASSERT(dev != NULL);
626:
627: return dev->ud_cdesc;
1.1 augustss 628: }
629:
630: usb_interface_descriptor_t *
1.169 skrll 631: usbd_get_interface_descriptor(struct usbd_interface *iface)
1.1 augustss 632: {
1.169 skrll 633: KASSERT(iface != NULL);
634:
635: return iface->ui_idesc;
1.1 augustss 636: }
637:
638: usb_device_descriptor_t *
1.169 skrll 639: usbd_get_device_descriptor(struct usbd_device *dev)
1.1 augustss 640: {
1.169 skrll 641: KASSERT(dev != NULL);
642:
643: return &dev->ud_ddesc;
1.1 augustss 644: }
645:
646: usb_endpoint_descriptor_t *
1.169 skrll 647: usbd_interface2endpoint_descriptor(struct usbd_interface *iface, uint8_t index)
1.1 augustss 648: {
1.169 skrll 649:
650: if (index >= iface->ui_idesc->bNumEndpoints)
651: return NULL;
652: return iface->ui_endpoints[index].ue_edesc;
1.1 augustss 653: }
654:
1.125 jmorse 655: /* Some drivers may wish to abort requests on the default pipe, *
656: * but there is no mechanism for getting a handle on it. */
657: usbd_status
658: usbd_abort_default_pipe(struct usbd_device *device)
659: {
1.169 skrll 660: return usbd_abort_pipe(device->ud_pipe0);
1.125 jmorse 661: }
662:
1.102 augustss 663: usbd_status
1.169 skrll 664: usbd_abort_pipe(struct usbd_pipe *pipe)
1.1 augustss 665: {
1.48 augustss 666: usbd_status err;
1.1 augustss 667:
1.169 skrll 668: KASSERT(pipe != NULL);
669:
1.138 mrg 670: usbd_lock_pipe(pipe);
1.48 augustss 671: err = usbd_ar_pipe(pipe);
1.138 mrg 672: usbd_unlock_pipe(pipe);
1.169 skrll 673: return err;
1.1 augustss 674: }
1.102 augustss 675:
676: usbd_status
1.169 skrll 677: usbd_clear_endpoint_stall(struct usbd_pipe *pipe)
1.1 augustss 678: {
1.169 skrll 679: struct usbd_device *dev = pipe->up_dev;
1.1 augustss 680: usb_device_request_t req;
1.48 augustss 681: usbd_status err;
1.1 augustss 682:
1.162 skrll 683: USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
1.33 augustss 684:
1.102 augustss 685: /*
1.87 augustss 686: * Clearing en endpoint stall resets the endpoint toggle, so
1.33 augustss 687: * do the same to the HC toggle.
688: */
1.169 skrll 689: pipe->up_methods->upm_cleartoggle(pipe);
1.33 augustss 690:
1.1 augustss 691: req.bmRequestType = UT_WRITE_ENDPOINT;
692: req.bRequest = UR_CLEAR_FEATURE;
1.15 augustss 693: USETW(req.wValue, UF_ENDPOINT_HALT);
1.169 skrll 694: USETW(req.wIndex, pipe->up_endpoint->ue_edesc->bEndpointAddress);
1.1 augustss 695: USETW(req.wLength, 0);
1.48 augustss 696: err = usbd_do_request(dev, &req, 0);
1.1 augustss 697: #if 0
698: XXX should we do this?
1.51 augustss 699: if (!err) {
1.1 augustss 700: pipe->state = USBD_PIPE_ACTIVE;
701: /* XXX activate pipe */
702: }
703: #endif
1.169 skrll 704: return err;
1.1 augustss 705: }
706:
1.139 mrg 707: void
1.156 skrll 708: usbd_clear_endpoint_stall_task(void *arg)
1.7 augustss 709: {
1.169 skrll 710: struct usbd_pipe *pipe = arg;
711: struct usbd_device *dev = pipe->up_dev;
1.7 augustss 712: usb_device_request_t req;
713:
1.169 skrll 714: pipe->up_methods->upm_cleartoggle(pipe);
1.33 augustss 715:
1.7 augustss 716: req.bmRequestType = UT_WRITE_ENDPOINT;
717: req.bRequest = UR_CLEAR_FEATURE;
1.15 augustss 718: USETW(req.wValue, UF_ENDPOINT_HALT);
1.169 skrll 719: USETW(req.wIndex, pipe->up_endpoint->ue_edesc->bEndpointAddress);
1.7 augustss 720: USETW(req.wLength, 0);
1.156 skrll 721: (void)usbd_do_request(dev, &req, 0);
1.139 mrg 722: }
723:
724: void
1.169 skrll 725: usbd_clear_endpoint_stall_async(struct usbd_pipe *pipe)
1.139 mrg 726: {
1.169 skrll 727: usb_add_task(pipe->up_dev, &pipe->up_async_task, USB_TASKQ_DRIVER);
1.7 augustss 728: }
729:
1.61 augustss 730: void
1.169 skrll 731: usbd_clear_endpoint_toggle(struct usbd_pipe *pipe)
1.61 augustss 732: {
1.169 skrll 733:
734: pipe->up_methods->upm_cleartoggle(pipe);
1.61 augustss 735: }
736:
1.102 augustss 737: usbd_status
1.169 skrll 738: usbd_endpoint_count(struct usbd_interface *iface, uint8_t *count)
1.1 augustss 739: {
1.169 skrll 740: KASSERT(iface != NULL);
741: KASSERT(iface->ui_idesc != NULL);
742:
743: *count = iface->ui_idesc->bNumEndpoints;
744: return USBD_NORMAL_COMPLETION;
1.1 augustss 745: }
746:
1.102 augustss 747: usbd_status
1.169 skrll 748: usbd_interface_count(struct usbd_device *dev, uint8_t *count)
1.1 augustss 749: {
1.169 skrll 750:
751: if (dev->ud_cdesc == NULL)
752: return USBD_NOT_CONFIGURED;
753: *count = dev->ud_cdesc->bNumInterface;
754: return USBD_NORMAL_COMPLETION;
1.1 augustss 755: }
756:
1.85 augustss 757: void
1.169 skrll 758: usbd_interface2device_handle(struct usbd_interface *iface,
759: struct usbd_device **dev)
1.1 augustss 760: {
1.169 skrll 761:
762: *dev = iface->ui_dev;
1.1 augustss 763: }
764:
1.102 augustss 765: usbd_status
1.169 skrll 766: usbd_device2interface_handle(struct usbd_device *dev,
767: uint8_t ifaceno, struct usbd_interface **iface)
1.1 augustss 768: {
1.169 skrll 769:
770: if (dev->ud_cdesc == NULL)
771: return USBD_NOT_CONFIGURED;
772: if (ifaceno >= dev->ud_cdesc->bNumInterface)
773: return USBD_INVAL;
774: *iface = &dev->ud_ifaces[ifaceno];
775: return USBD_NORMAL_COMPLETION;
1.1 augustss 776: }
777:
1.169 skrll 778: struct usbd_device *
779: usbd_pipe2device_handle(struct usbd_pipe *pipe)
1.36 augustss 780: {
1.169 skrll 781: KASSERT(pipe != NULL);
782:
783: return pipe->up_dev;
1.36 augustss 784: }
785:
1.13 augustss 786: /* XXXX use altno */
1.3 augustss 787: usbd_status
1.169 skrll 788: usbd_set_interface(struct usbd_interface *iface, int altidx)
1.3 augustss 789: {
790: usb_device_request_t req;
1.48 augustss 791: usbd_status err;
1.73 augustss 792: void *endpoints;
1.13 augustss 793:
1.183 ! mrg 794: USBHIST_FUNC();
1.169 skrll 795:
796: if (LIST_FIRST(&iface->ui_pipes) != NULL)
797: return USBD_IN_USE;
1.13 augustss 798:
1.169 skrll 799: endpoints = iface->ui_endpoints;
800: int nendpt = iface->ui_idesc->bNumEndpoints;
1.183 ! mrg 801: USBHIST_CALLARGS(usbdebug, "iface %#jx endpoints = %#jx nendpt %jd",
1.175 pgoyette 802: (uintptr_t)iface, (uintptr_t)endpoints,
803: iface->ui_idesc->bNumEndpoints, 0);
1.169 skrll 804: err = usbd_fill_iface_data(iface->ui_dev, iface->ui_index, altidx);
1.48 augustss 805: if (err)
1.169 skrll 806: return err;
1.73 augustss 807:
1.76 augustss 808: /* new setting works, we can free old endpoints */
1.169 skrll 809: if (endpoints != NULL) {
1.175 pgoyette 810: USBHIST_LOG(usbdebug, "iface %#jx endpoints = %#jx nendpt %jd",
811: (uintptr_t)iface, (uintptr_t)endpoints, nendpt, 0);
1.169 skrll 812: kmem_free(endpoints, nendpt * sizeof(struct usbd_endpoint));
1.73 augustss 813: }
1.169 skrll 814: KASSERT(iface->ui_idesc != NULL);
1.3 augustss 815:
816: req.bmRequestType = UT_WRITE_INTERFACE;
817: req.bRequest = UR_SET_INTERFACE;
1.169 skrll 818: USETW(req.wValue, iface->ui_idesc->bAlternateSetting);
819: USETW(req.wIndex, iface->ui_idesc->bInterfaceNumber);
1.3 augustss 820: USETW(req.wLength, 0);
1.169 skrll 821: return usbd_do_request(iface->ui_dev, &req, 0);
1.12 augustss 822: }
823:
824: int
1.74 augustss 825: usbd_get_no_alts(usb_config_descriptor_t *cdesc, int ifaceno)
1.12 augustss 826: {
1.13 augustss 827: char *p = (char *)cdesc;
828: char *end = p + UGETW(cdesc->wTotalLength);
1.12 augustss 829: usb_interface_descriptor_t *d;
830: int n;
831:
832: for (n = 0; p < end; p += d->bLength) {
833: d = (usb_interface_descriptor_t *)p;
1.102 augustss 834: if (p + d->bLength <= end &&
1.12 augustss 835: d->bDescriptorType == UDESC_INTERFACE &&
1.13 augustss 836: d->bInterfaceNumber == ifaceno)
1.12 augustss 837: n++;
838: }
1.169 skrll 839: return n;
1.13 augustss 840: }
841:
842: int
1.169 skrll 843: usbd_get_interface_altindex(struct usbd_interface *iface)
1.13 augustss 844: {
1.169 skrll 845: return iface->ui_altindex;
1.12 augustss 846: }
847:
848: usbd_status
1.169 skrll 849: usbd_get_interface(struct usbd_interface *iface, uint8_t *aiface)
1.12 augustss 850: {
851: usb_device_request_t req;
852:
853: req.bmRequestType = UT_READ_INTERFACE;
854: req.bRequest = UR_GET_INTERFACE;
855: USETW(req.wValue, 0);
1.169 skrll 856: USETW(req.wIndex, iface->ui_idesc->bInterfaceNumber);
1.12 augustss 857: USETW(req.wLength, 1);
1.169 skrll 858: return usbd_do_request(iface->ui_dev, &req, aiface);
1.3 augustss 859: }
1.1 augustss 860:
861: /*** Internal routines ***/
862:
1.174 skrll 863: /* Dequeue all pipe operations, called with bus lock held. */
1.69 augustss 864: Static usbd_status
1.169 skrll 865: usbd_ar_pipe(struct usbd_pipe *pipe)
1.1 augustss 866: {
1.169 skrll 867: struct usbd_xfer *xfer;
1.1 augustss 868:
1.183 ! mrg 869: USBHIST_FUNC();
! 870: USBHIST_CALLARGS(usbdebug, "pipe = %#jx", (uintptr_t)pipe, 0, 0, 0);
1.162 skrll 871:
1.169 skrll 872: KASSERT(mutex_owned(pipe->up_dev->ud_bus->ub_lock));
1.138 mrg 873:
1.28 augustss 874: #ifdef USB_DEBUG
875: if (usbdebug > 5)
876: usbd_dump_queue(pipe);
877: #endif
1.169 skrll 878: pipe->up_repeat = 0;
879: pipe->up_aborting = 1;
880: while ((xfer = SIMPLEQ_FIRST(&pipe->up_queue)) != NULL) {
1.175 pgoyette 881: USBHIST_LOG(usbdebug, "pipe = %#jx xfer = %#jx "
882: "(methods = %#jx)", (uintptr_t)pipe, (uintptr_t)xfer,
883: (uintptr_t)pipe->up_methods, 0);
1.182 rin 884: if (xfer->ux_status == USBD_NOT_STARTED) {
885: SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next);
886: } else {
887: /* Make the HC abort it (and invoke the callback). */
888: pipe->up_methods->upm_abort(xfer);
889: /* XXX only for non-0 usbd_clear_endpoint_stall(pipe); */
890: }
1.20 augustss 891: }
1.169 skrll 892: pipe->up_aborting = 0;
893: return USBD_NORMAL_COMPLETION;
1.1 augustss 894: }
895:
1.138 mrg 896: /* Called with USB lock held. */
1.31 augustss 897: void
1.169 skrll 898: usb_transfer_complete(struct usbd_xfer *xfer)
1.1 augustss 899: {
1.169 skrll 900: struct usbd_pipe *pipe = xfer->ux_pipe;
1.172 skrll 901: struct usbd_bus *bus = pipe->up_dev->ud_bus;
1.169 skrll 902: int sync = xfer->ux_flags & USBD_SYNCHRONOUS;
1.179 manu 903: int erred;
1.169 skrll 904: int polling = bus->ub_usepolling;
905: int repeat = pipe->up_repeat;
1.31 augustss 906:
1.183 ! mrg 907: USBHIST_FUNC();
! 908: USBHIST_CALLARGS(usbdebug, "pipe = %#jx xfer = %#jx status = %jd "
1.175 pgoyette 909: "actlen = %jd", (uintptr_t)pipe, (uintptr_t)xfer, xfer->ux_status,
910: xfer->ux_actlen);
1.134 jmcneill 911:
1.169 skrll 912: KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
1.177 mrg 913: KASSERTMSG(xfer->ux_state == XFER_ONQU, "xfer %p state is %x", xfer,
914: xfer->ux_state);
1.169 skrll 915: KASSERT(pipe != NULL);
1.5 augustss 916:
1.179 manu 917: /*
918: * If device is known to miss out ack, then pretend that
919: * output timeout is a success. Userland should handle
920: * the logic to verify that the operation succeeded.
921: */
922: if (pipe->up_dev->ud_quirks &&
923: pipe->up_dev->ud_quirks->uq_flags & UQ_MISS_OUT_ACK &&
924: xfer->ux_status == USBD_TIMEOUT &&
925: !usbd_xfer_isread(xfer)) {
926: USBHIST_LOG(usbdebug, "Possible output ack miss for xfer %#jx: "
927: "hiding write timeout to %d.%s for %d bytes written",
1.180 manu 928: (uintptr_t)xfer, curlwp->l_proc->p_pid, curlwp->l_lid,
1.179 manu 929: xfer->ux_length);
930:
931: xfer->ux_status = USBD_NORMAL_COMPLETION;
932: xfer->ux_actlen = xfer->ux_length;
933: }
934:
935: erred = xfer->ux_status == USBD_CANCELLED ||
936: xfer->ux_status == USBD_TIMEOUT;
937:
1.47 augustss 938: if (!repeat) {
939: /* Remove request from queue. */
1.153 jakllsch 940:
1.169 skrll 941: KASSERTMSG(!SIMPLEQ_EMPTY(&pipe->up_queue),
1.145 skrll 942: "pipe %p is empty, but xfer %p wants to complete", pipe,
943: xfer);
1.169 skrll 944: KASSERTMSG(xfer == SIMPLEQ_FIRST(&pipe->up_queue),
945: "xfer %p is not start of queue (%p is at start)", xfer,
946: SIMPLEQ_FIRST(&pipe->up_queue));
947:
1.47 augustss 948: #ifdef DIAGNOSTIC
1.169 skrll 949: xfer->ux_state = XFER_BUSY;
1.45 augustss 950: #endif
1.169 skrll 951: SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next);
1.47 augustss 952: }
1.175 pgoyette 953: USBHIST_LOG(usbdebug, "xfer %#jx: repeat %jd new head = %#jx",
954: (uintptr_t)xfer, repeat, (uintptr_t)SIMPLEQ_FIRST(&pipe->up_queue),
955: 0);
1.31 augustss 956:
957: /* Count completed transfers. */
1.169 skrll 958: ++pipe->up_dev->ud_bus->ub_stats.uds_requests
959: [pipe->up_endpoint->ue_edesc->bmAttributes & UE_XFERTYPE];
1.1 augustss 960:
1.169 skrll 961: xfer->ux_done = 1;
962: if (!xfer->ux_status && xfer->ux_actlen < xfer->ux_length &&
963: !(xfer->ux_flags & USBD_SHORT_XFER_OK)) {
1.175 pgoyette 964: USBHIST_LOG(usbdebug, "short transfer %jd < %jd",
1.169 skrll 965: xfer->ux_actlen, xfer->ux_length, 0, 0);
966: xfer->ux_status = USBD_SHORT_XFER;
1.1 augustss 967: }
1.31 augustss 968:
1.175 pgoyette 969: USBHIST_LOG(usbdebug, "xfer %#jx doing done %#jx", (uintptr_t)xfer,
970: (uintptr_t)pipe->up_methods->upm_done, 0, 0);
1.169 skrll 971: pipe->up_methods->upm_done(xfer);
972:
973: if (xfer->ux_length != 0 && xfer->ux_buffer != xfer->ux_buf) {
974: KDASSERTMSG(xfer->ux_actlen <= xfer->ux_length,
975: "actlen %d length %d",xfer->ux_actlen, xfer->ux_length);
1.148 jmcneill 976:
1.169 skrll 977: /* Only if IN transfer */
978: if (usbd_xfer_isread(xfer)) {
979: memcpy(xfer->ux_buffer, xfer->ux_buf, xfer->ux_actlen);
1.138 mrg 980: }
1.169 skrll 981: }
982:
1.175 pgoyette 983: USBHIST_LOG(usbdebug, "xfer %#jx doing callback %#jx status %jd",
984: (uintptr_t)xfer, (uintptr_t)xfer->ux_callback, xfer->ux_status, 0);
1.169 skrll 985:
986: if (xfer->ux_callback) {
1.178 mrg 987: if (!polling) {
1.169 skrll 988: mutex_exit(pipe->up_dev->ud_bus->ub_lock);
1.178 mrg 989: if (!(pipe->up_flags & USBD_MPSAFE))
990: KERNEL_LOCK(1, curlwp);
991: }
1.169 skrll 992:
993: xfer->ux_callback(xfer, xfer->ux_priv, xfer->ux_status);
994:
1.178 mrg 995: if (!polling) {
996: if (!(pipe->up_flags & USBD_MPSAFE))
997: KERNEL_UNLOCK_ONE(curlwp);
1.169 skrll 998: mutex_enter(pipe->up_dev->ud_bus->ub_lock);
1.178 mrg 999: }
1.124 jmcneill 1000: }
1.31 augustss 1001:
1.138 mrg 1002: if (sync && !polling) {
1.175 pgoyette 1003: USBHIST_LOG(usbdebug, "<- done xfer %#jx, wakeup",
1004: (uintptr_t)xfer, 0, 0, 0);
1.169 skrll 1005: cv_broadcast(&xfer->ux_cv);
1.138 mrg 1006: }
1.31 augustss 1007:
1.169 skrll 1008: if (repeat) {
1009: xfer->ux_actlen = 0;
1010: xfer->ux_status = USBD_NOT_STARTED;
1011: } else {
1.40 augustss 1012: /* XXX should we stop the queue on all errors? */
1.169 skrll 1013: if (erred && pipe->up_iface != NULL) /* not control pipe */
1014: pipe->up_running = 0;
1.40 augustss 1015: }
1.169 skrll 1016: if (pipe->up_running && pipe->up_serialise)
1017: usbd_start_next(pipe);
1.1 augustss 1018: }
1019:
1.138 mrg 1020: /* Called with USB lock held. */
1.31 augustss 1021: usbd_status
1.169 skrll 1022: usb_insert_transfer(struct usbd_xfer *xfer)
1.1 augustss 1023: {
1.169 skrll 1024: struct usbd_pipe *pipe = xfer->ux_pipe;
1.48 augustss 1025: usbd_status err;
1.31 augustss 1026:
1.183 ! mrg 1027: USBHIST_FUNC(); USBHIST_CALLARGS(usbdebug,
! 1028: "xfer = %#jx pipe = %#jx running = %jd timeout = %jd",
! 1029: (uintptr_t)xfer, (uintptr_t)pipe,
1.175 pgoyette 1030: pipe->up_running, xfer->ux_timeout);
1.134 jmcneill 1031:
1.169 skrll 1032: KASSERT(mutex_owned(pipe->up_dev->ud_bus->ub_lock));
1.174 skrll 1033: KASSERTMSG(xfer->ux_state == XFER_BUSY, "xfer %p state is %x", xfer,
1034: xfer->ux_state);
1.134 jmcneill 1035:
1.93 augustss 1036: #ifdef DIAGNOSTIC
1.169 skrll 1037: xfer->ux_state = XFER_ONQU;
1.93 augustss 1038: #endif
1.169 skrll 1039: SIMPLEQ_INSERT_TAIL(&pipe->up_queue, xfer, ux_next);
1040: if (pipe->up_running && pipe->up_serialise)
1.48 augustss 1041: err = USBD_IN_PROGRESS;
1.37 augustss 1042: else {
1.169 skrll 1043: pipe->up_running = 1;
1.48 augustss 1044: err = USBD_NORMAL_COMPLETION;
1.37 augustss 1045: }
1.175 pgoyette 1046: USBHIST_LOG(usbdebug, "<- done xfer %#jx, err %jd", (uintptr_t)xfer,
1047: err, 0, 0);
1.169 skrll 1048: return err;
1.1 augustss 1049: }
1050:
1.138 mrg 1051: /* Called with USB lock held. */
1.31 augustss 1052: void
1.169 skrll 1053: usbd_start_next(struct usbd_pipe *pipe)
1.31 augustss 1054: {
1.169 skrll 1055: struct usbd_xfer *xfer;
1.48 augustss 1056: usbd_status err;
1.40 augustss 1057:
1.183 ! mrg 1058: USBHIST_FUNC();
1.162 skrll 1059:
1.169 skrll 1060: KASSERT(pipe != NULL);
1061: KASSERT(pipe->up_methods != NULL);
1062: KASSERT(pipe->up_methods->upm_start != NULL);
1063: KASSERT(pipe->up_serialise == true);
1.31 augustss 1064:
1.169 skrll 1065: int polling = pipe->up_dev->ud_bus->ub_usepolling;
1066: KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
1.138 mrg 1067:
1.31 augustss 1068: /* Get next request in queue. */
1.169 skrll 1069: xfer = SIMPLEQ_FIRST(&pipe->up_queue);
1.183 ! mrg 1070: USBHIST_CALLARGS(usbdebug, "pipe = %#jx, xfer = %#jx", (uintptr_t)pipe,
1.175 pgoyette 1071: (uintptr_t)xfer, 0, 0);
1.51 augustss 1072: if (xfer == NULL) {
1.169 skrll 1073: pipe->up_running = 0;
1.51 augustss 1074: } else {
1.165 skrll 1075: if (!polling)
1.169 skrll 1076: mutex_exit(pipe->up_dev->ud_bus->ub_lock);
1077: err = pipe->up_methods->upm_start(xfer);
1.165 skrll 1078: if (!polling)
1.169 skrll 1079: mutex_enter(pipe->up_dev->ud_bus->ub_lock);
1.158 skrll 1080:
1.48 augustss 1081: if (err != USBD_IN_PROGRESS) {
1.175 pgoyette 1082: USBHIST_LOG(usbdebug, "error = %jd", err, 0, 0, 0);
1.169 skrll 1083: pipe->up_running = 0;
1.31 augustss 1084: /* XXX do what? */
1085: }
1.1 augustss 1086: }
1.138 mrg 1087:
1.169 skrll 1088: KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
1.1 augustss 1089: }
1090:
1091: usbd_status
1.169 skrll 1092: usbd_do_request(struct usbd_device *dev, usb_device_request_t *req, void *data)
1.1 augustss 1093: {
1.17 augustss 1094:
1.169 skrll 1095: return usbd_do_request_flags(dev, req, data, 0, 0,
1096: USBD_DEFAULT_TIMEOUT);
1.77 augustss 1097: }
1098:
1099: usbd_status
1.169 skrll 1100: usbd_do_request_flags(struct usbd_device *dev, usb_device_request_t *req,
1101: void *data, uint16_t flags, int *actlen, uint32_t timeout)
1.77 augustss 1102: {
1.169 skrll 1103: struct usbd_xfer *xfer;
1.48 augustss 1104: usbd_status err;
1.1 augustss 1105:
1.183 ! mrg 1106: USBHIST_FUNC();
! 1107: USBHIST_CALLARGS(usbdebug, "dev=%#jx req=%jx flgas=%jx len=%jx",
! 1108: (uintptr_t)dev, (uintptr_t)req, flags, actlen);
! 1109:
1.169 skrll 1110: ASSERT_SLEEPABLE();
1.7 augustss 1111:
1.169 skrll 1112: size_t len = UGETW(req->wLength);
1113: int error = usbd_create_xfer(dev->ud_pipe0, len, 0, 0, &xfer);
1114: if (error)
1115: return error;
1116:
1117: usbd_setup_default_xfer(xfer, dev, 0, timeout, req, data,
1118: UGETW(req->wLength), flags, NULL);
1119: KASSERT(xfer->ux_pipe == dev->ud_pipe0);
1.48 augustss 1120: err = usbd_sync_transfer(xfer);
1.1 augustss 1121: #if defined(USB_DEBUG) || defined(DIAGNOSTIC)
1.169 skrll 1122: if (xfer->ux_actlen > xfer->ux_length) {
1.175 pgoyette 1123: USBHIST_LOG(usbdebug, "overrun addr = %jd type = 0x%02jx",
1.169 skrll 1124: dev->ud_addr, xfer->ux_request.bmRequestType, 0, 0);
1.175 pgoyette 1125: USBHIST_LOG(usbdebug, " req = 0x%02jx val = %jd "
1126: "index = %jd",
1.169 skrll 1127: xfer->ux_request.bRequest, UGETW(xfer->ux_request.wValue),
1128: UGETW(xfer->ux_request.wIndex), 0);
1.175 pgoyette 1129: USBHIST_LOG(usbdebug, " rlen = %jd length = %jd "
1130: "actlen = %jd",
1.169 skrll 1131: UGETW(xfer->ux_request.wLength),
1132: xfer->ux_length, xfer->ux_actlen, 0);
1.112 dogcow 1133: }
1.1 augustss 1134: #endif
1.48 augustss 1135: if (actlen != NULL)
1.169 skrll 1136: *actlen = xfer->ux_actlen;
1137:
1138: usbd_destroy_xfer(xfer);
1.15 augustss 1139:
1.132 matt 1140: if (err) {
1.175 pgoyette 1141: USBHIST_LOG(usbdebug, "returning err = %jd", err, 0, 0, 0);
1.132 matt 1142: }
1.169 skrll 1143: return err;
1.7 augustss 1144: }
1145:
1.176 khorben 1146: static void
1147: usbd_request_async_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
1148: {
1149: usbd_free_xfer(xfer);
1150: }
1151:
1152: /*
1153: * Execute a request without waiting for completion.
1154: * Can be used from interrupt context.
1155: */
1156: usbd_status
1157: usbd_request_async(struct usbd_device *dev, struct usbd_xfer *xfer,
1158: usb_device_request_t *req, void *priv, usbd_callback callback)
1159: {
1160: usbd_status err;
1161:
1162: if (callback == NULL)
1163: callback = usbd_request_async_cb;
1164:
1165: usbd_setup_default_xfer(xfer, dev, priv,
1166: USBD_DEFAULT_TIMEOUT, req, NULL, UGETW(req->wLength), 0,
1167: callback);
1168: err = usbd_transfer(xfer);
1169: if (err != USBD_IN_PROGRESS) {
1170: usbd_free_xfer(xfer);
1171: return (err);
1172: }
1173: return (USBD_NORMAL_COMPLETION);
1174: }
1175:
1.78 augustss 1176: const struct usbd_quirks *
1.169 skrll 1177: usbd_get_quirks(struct usbd_device *dev)
1.1 augustss 1178: {
1.81 augustss 1179: #ifdef DIAGNOSTIC
1180: if (dev == NULL) {
1181: printf("usbd_get_quirks: dev == NULL\n");
1182: return 0;
1183: }
1184: #endif
1.169 skrll 1185: return dev->ud_quirks;
1.1 augustss 1186: }
1187:
1188: /* XXX do periodic free() of free list */
1189:
1.6 augustss 1190: /*
1191: * Called from keyboard driver when in polling mode.
1192: */
1193: void
1.169 skrll 1194: usbd_dopoll(struct usbd_interface *iface)
1.6 augustss 1195: {
1.169 skrll 1196: iface->ui_dev->ud_bus->ub_methods->ubm_dopoll(iface->ui_dev->ud_bus);
1.8 augustss 1197: }
1198:
1.138 mrg 1199: /*
1.178 mrg 1200: * This is for keyboard driver as well, which only operates in polling
1201: * mode from the ask root, etc., prompt and from DDB.
1.138 mrg 1202: */
1.8 augustss 1203: void
1.169 skrll 1204: usbd_set_polling(struct usbd_device *dev, int on)
1.8 augustss 1205: {
1.42 augustss 1206: if (on)
1.169 skrll 1207: dev->ud_bus->ub_usepolling++;
1.42 augustss 1208: else
1.169 skrll 1209: dev->ud_bus->ub_usepolling--;
1.133 jmcneill 1210:
1211: /* Kick the host controller when switching modes */
1.169 skrll 1212: mutex_enter(dev->ud_bus->ub_lock);
1213: dev->ud_bus->ub_methods->ubm_softint(dev->ud_bus);
1214: mutex_exit(dev->ud_bus->ub_lock);
1.6 augustss 1215: }
1.12 augustss 1216:
1217:
1218: usb_endpoint_descriptor_t *
1.169 skrll 1219: usbd_get_endpoint_descriptor(struct usbd_interface *iface, uint8_t address)
1.12 augustss 1220: {
1221: struct usbd_endpoint *ep;
1222: int i;
1223:
1.169 skrll 1224: for (i = 0; i < iface->ui_idesc->bNumEndpoints; i++) {
1225: ep = &iface->ui_endpoints[i];
1226: if (ep->ue_edesc->bEndpointAddress == address)
1227: return iface->ui_endpoints[i].ue_edesc;
1.12 augustss 1228: }
1.169 skrll 1229: return NULL;
1.63 augustss 1230: }
1231:
1232: /*
1233: * usbd_ratecheck() can limit the number of error messages that occurs.
1234: * When a device is unplugged it may take up to 0.25s for the hub driver
1.169 skrll 1235: * to notice it. If the driver continuously tries to do I/O operations
1.63 augustss 1236: * this can generate a large number of messages.
1237: */
1238: int
1.74 augustss 1239: usbd_ratecheck(struct timeval *last)
1.63 augustss 1240: {
1.64 augustss 1241: static struct timeval errinterval = { 0, 250000 }; /* 0.25 s*/
1.63 augustss 1242:
1.169 skrll 1243: return ratecheck(last, &errinterval);
1.89 augustss 1244: }
1245:
1246: /*
1247: * Search for a vendor/product pair in an array. The item size is
1248: * given as an argument.
1249: */
1.90 augustss 1250: const struct usb_devno *
1251: usb_match_device(const struct usb_devno *tbl, u_int nentries, u_int sz,
1.169 skrll 1252: uint16_t vendor, uint16_t product)
1.89 augustss 1253: {
1254: while (nentries-- > 0) {
1.169 skrll 1255: uint16_t tproduct = tbl->ud_product;
1.93 augustss 1256: if (tbl->ud_vendor == vendor &&
1257: (tproduct == product || tproduct == USB_PRODUCT_ANY))
1.169 skrll 1258: return tbl;
1.95 augustss 1259: tbl = (const struct usb_devno *)((const char *)tbl + sz);
1.89 augustss 1260: }
1.169 skrll 1261: return NULL;
1.12 augustss 1262: }
1263:
1.105 augustss 1264:
1265: void
1.169 skrll 1266: usb_desc_iter_init(struct usbd_device *dev, usbd_desc_iter_t *iter)
1.105 augustss 1267: {
1268: const usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev);
1269:
1.169 skrll 1270: iter->cur = (const uByte *)cd;
1271: iter->end = (const uByte *)cd + UGETW(cd->wTotalLength);
1.105 augustss 1272: }
1273:
1274: const usb_descriptor_t *
1275: usb_desc_iter_next(usbd_desc_iter_t *iter)
1276: {
1277: const usb_descriptor_t *desc;
1278:
1279: if (iter->cur + sizeof(usb_descriptor_t) >= iter->end) {
1280: if (iter->cur != iter->end)
1281: printf("usb_desc_iter_next: bad descriptor\n");
1282: return NULL;
1283: }
1.108 christos 1284: desc = (const usb_descriptor_t *)iter->cur;
1.105 augustss 1285: if (desc->bLength == 0) {
1286: printf("usb_desc_iter_next: descriptor length = 0\n");
1287: return NULL;
1288: }
1289: iter->cur += desc->bLength;
1290: if (iter->cur > iter->end) {
1291: printf("usb_desc_iter_next: descriptor length too large\n");
1292: return NULL;
1293: }
1294: return desc;
1295: }
1296:
1297: usbd_status
1.169 skrll 1298: usbd_get_string(struct usbd_device *dev, int si, char *buf)
1.105 augustss 1299: {
1.115 pavel 1300: return usbd_get_string0(dev, si, buf, 1);
1301: }
1302:
1303: usbd_status
1.169 skrll 1304: usbd_get_string0(struct usbd_device *dev, int si, char *buf, int unicode)
1.115 pavel 1305: {
1.169 skrll 1306: int swap = dev->ud_quirks->uq_flags & UQ_SWAP_UNICODE;
1.105 augustss 1307: usb_string_descriptor_t us;
1308: char *s;
1.116 macallan 1309: int i, n;
1.169 skrll 1310: uint16_t c;
1.105 augustss 1311: usbd_status err;
1312: int size;
1313:
1.162 skrll 1314: USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
1315:
1.105 augustss 1316: buf[0] = '\0';
1317: if (si == 0)
1.169 skrll 1318: return USBD_INVAL;
1319: if (dev->ud_quirks->uq_flags & UQ_NO_STRINGS)
1320: return USBD_STALLED;
1321: if (dev->ud_langid == USBD_NOLANG) {
1.105 augustss 1322: /* Set up default language */
1323: err = usbd_get_string_desc(dev, USB_LANGUAGE_TABLE, 0, &us,
1324: &size);
1325: if (err || size < 4) {
1.162 skrll 1326: USBHIST_LOG(usbdebug, "getting lang failed, using 0",
1327: 0, 0, 0, 0);
1.169 skrll 1328: dev->ud_langid = 0; /* Well, just pick something then */
1.105 augustss 1329: } else {
1330: /* Pick the first language as the default. */
1.169 skrll 1331: dev->ud_langid = UGETW(us.bString[0]);
1.105 augustss 1332: }
1333: }
1.169 skrll 1334: err = usbd_get_string_desc(dev, si, dev->ud_langid, &us, &size);
1.105 augustss 1335: if (err)
1.169 skrll 1336: return err;
1.105 augustss 1337: s = buf;
1338: n = size / 2 - 1;
1.115 pavel 1339: if (unicode) {
1340: for (i = 0; i < n; i++) {
1341: c = UGETW(us.bString[i]);
1342: if (swap)
1343: c = (c >> 8) | (c << 8);
1.119 drochner 1344: s += wput_utf8(s, 3, c);
1.115 pavel 1345: }
1346: *s++ = 0;
1347: }
1348: #ifdef COMPAT_30
1349: else {
1.119 drochner 1350: for (i = 0; i < n; i++) {
1.115 pavel 1351: c = UGETW(us.bString[i]);
1352: if (swap)
1353: c = (c >> 8) | (c << 8);
1.119 drochner 1354: *s++ = (c < 0x80) ? c : '?';
1.107 augustss 1355: }
1.119 drochner 1356: *s++ = 0;
1.105 augustss 1357: }
1.115 pavel 1358: #endif
1.169 skrll 1359: return USBD_NORMAL_COMPLETION;
1.105 augustss 1360: }
CVSweb <webmaster@jp.NetBSD.org>
![[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 [cvs.NetBSD.org] / src / sys / dev / usb