Annotation of sys/dev/usb/uhci.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: uhci.c,v 1.61 2007/07/20 14:31:17 mbalmer Exp $ */
! 2: /* $NetBSD: uhci.c,v 1.172 2003/02/23 04:19:26 simonb Exp $ */
! 3: /* $FreeBSD: src/sys/dev/usb/uhci.c,v 1.33 1999/11/17 22:33:41 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: /*
! 43: * USB Universal Host Controller driver.
! 44: * Handles e.g. PIIX3 and PIIX4.
! 45: *
! 46: * UHCI spec: http://download.intel.com/technology/usb/UHCI11D.pdf
! 47: * USB spec: http://www.usb.org/developers/docs/usbspec.zip
! 48: * PIIXn spec: ftp://download.intel.com/design/intarch/datashts/29055002.pdf
! 49: * ftp://download.intel.com/design/intarch/datashts/29056201.pdf
! 50: */
! 51:
! 52: #include <sys/param.h>
! 53: #include <sys/systm.h>
! 54: #include <sys/kernel.h>
! 55: #include <sys/malloc.h>
! 56: #include <sys/device.h>
! 57: #include <sys/selinfo.h>
! 58: #include <sys/proc.h>
! 59: #include <sys/queue.h>
! 60:
! 61: #include <machine/bus.h>
! 62: #include <machine/endian.h>
! 63:
! 64: #include <dev/usb/usb.h>
! 65: #include <dev/usb/usbdi.h>
! 66: #include <dev/usb/usbdivar.h>
! 67: #include <dev/usb/usb_mem.h>
! 68: #include <dev/usb/usb_quirks.h>
! 69:
! 70: #include <dev/usb/uhcireg.h>
! 71: #include <dev/usb/uhcivar.h>
! 72:
! 73: /* Use bandwidth reclamation for control transfers. Some devices choke on it. */
! 74: /*#define UHCI_CTL_LOOP */
! 75:
! 76: struct cfdriver uhci_cd = {
! 77: NULL, "uhci", DV_DULL
! 78: };
! 79:
! 80: #ifdef UHCI_DEBUG
! 81: uhci_softc_t *thesc;
! 82: #define DPRINTF(x) if (uhcidebug) printf x
! 83: #define DPRINTFN(n,x) if (uhcidebug>(n)) printf x
! 84: int uhcidebug = 0;
! 85: int uhcinoloop = 0;
! 86: #define bitmask_snprintf(q,f,b,l) snprintf((b), (l), "%b", (q), (f))
! 87: #else
! 88: #define DPRINTF(x)
! 89: #define DPRINTFN(n,x)
! 90: #endif
! 91:
! 92: #define mstohz(ms) ((ms) * hz / 1000)
! 93:
! 94: /*
! 95: * The UHCI controller is little endian, so on big endian machines
! 96: * the data stored in memory needs to be swapped.
! 97: */
! 98:
! 99: struct uhci_pipe {
! 100: struct usbd_pipe pipe;
! 101: int nexttoggle;
! 102:
! 103: u_char aborting;
! 104: usbd_xfer_handle abortstart, abortend;
! 105:
! 106: /* Info needed for different pipe kinds. */
! 107: union {
! 108: /* Control pipe */
! 109: struct {
! 110: uhci_soft_qh_t *sqh;
! 111: usb_dma_t reqdma;
! 112: uhci_soft_td_t *setup, *stat;
! 113: u_int length;
! 114: } ctl;
! 115: /* Interrupt pipe */
! 116: struct {
! 117: int npoll;
! 118: int isread;
! 119: uhci_soft_qh_t **qhs;
! 120: } intr;
! 121: /* Bulk pipe */
! 122: struct {
! 123: uhci_soft_qh_t *sqh;
! 124: u_int length;
! 125: int isread;
! 126: } bulk;
! 127: /* Iso pipe */
! 128: struct iso {
! 129: uhci_soft_td_t **stds;
! 130: int next, inuse;
! 131: } iso;
! 132: } u;
! 133: };
! 134:
! 135: void uhci_globalreset(uhci_softc_t *);
! 136: usbd_status uhci_portreset(uhci_softc_t*, int);
! 137: void uhci_reset(uhci_softc_t *);
! 138: void uhci_shutdown(void *v);
! 139: void uhci_power(int, void *);
! 140: usbd_status uhci_run(uhci_softc_t *, int run);
! 141: uhci_soft_td_t *uhci_alloc_std(uhci_softc_t *);
! 142: void uhci_free_std(uhci_softc_t *, uhci_soft_td_t *);
! 143: uhci_soft_qh_t *uhci_alloc_sqh(uhci_softc_t *);
! 144: void uhci_free_sqh(uhci_softc_t *, uhci_soft_qh_t *);
! 145: #if 0
! 146: void uhci_enter_ctl_q(uhci_softc_t *, uhci_soft_qh_t *,
! 147: uhci_intr_info_t *);
! 148: void uhci_exit_ctl_q(uhci_softc_t *, uhci_soft_qh_t *);
! 149: #endif
! 150:
! 151: void uhci_free_std_chain(uhci_softc_t *,
! 152: uhci_soft_td_t *, uhci_soft_td_t *);
! 153: usbd_status uhci_alloc_std_chain(struct uhci_pipe *,
! 154: uhci_softc_t *, int, int, u_int16_t, usb_dma_t *,
! 155: uhci_soft_td_t **, uhci_soft_td_t **);
! 156: void uhci_poll_hub(void *);
! 157: void uhci_waitintr(uhci_softc_t *, usbd_xfer_handle);
! 158: void uhci_check_intr(uhci_softc_t *, uhci_intr_info_t *);
! 159: void uhci_idone(uhci_intr_info_t *);
! 160:
! 161: void uhci_abort_xfer(usbd_xfer_handle, usbd_status status);
! 162:
! 163: void uhci_timeout(void *);
! 164: void uhci_timeout_task(void *);
! 165: void uhci_add_ls_ctrl(uhci_softc_t *, uhci_soft_qh_t *);
! 166: void uhci_add_hs_ctrl(uhci_softc_t *, uhci_soft_qh_t *);
! 167: void uhci_add_bulk(uhci_softc_t *, uhci_soft_qh_t *);
! 168: void uhci_remove_ls_ctrl(uhci_softc_t *,uhci_soft_qh_t *);
! 169: void uhci_remove_hs_ctrl(uhci_softc_t *,uhci_soft_qh_t *);
! 170: void uhci_remove_bulk(uhci_softc_t *,uhci_soft_qh_t *);
! 171: int uhci_str(usb_string_descriptor_t *, int, char *);
! 172: void uhci_add_loop(uhci_softc_t *sc);
! 173: void uhci_rem_loop(uhci_softc_t *sc);
! 174:
! 175: usbd_status uhci_setup_isoc(usbd_pipe_handle pipe);
! 176: void uhci_device_isoc_enter(usbd_xfer_handle);
! 177:
! 178: usbd_status uhci_allocm(struct usbd_bus *, usb_dma_t *, u_int32_t);
! 179: void uhci_freem(struct usbd_bus *, usb_dma_t *);
! 180:
! 181: usbd_xfer_handle uhci_allocx(struct usbd_bus *);
! 182: void uhci_freex(struct usbd_bus *, usbd_xfer_handle);
! 183:
! 184: usbd_status uhci_device_ctrl_transfer(usbd_xfer_handle);
! 185: usbd_status uhci_device_ctrl_start(usbd_xfer_handle);
! 186: void uhci_device_ctrl_abort(usbd_xfer_handle);
! 187: void uhci_device_ctrl_close(usbd_pipe_handle);
! 188: void uhci_device_ctrl_done(usbd_xfer_handle);
! 189:
! 190: usbd_status uhci_device_intr_transfer(usbd_xfer_handle);
! 191: usbd_status uhci_device_intr_start(usbd_xfer_handle);
! 192: void uhci_device_intr_abort(usbd_xfer_handle);
! 193: void uhci_device_intr_close(usbd_pipe_handle);
! 194: void uhci_device_intr_done(usbd_xfer_handle);
! 195:
! 196: usbd_status uhci_device_bulk_transfer(usbd_xfer_handle);
! 197: usbd_status uhci_device_bulk_start(usbd_xfer_handle);
! 198: void uhci_device_bulk_abort(usbd_xfer_handle);
! 199: void uhci_device_bulk_close(usbd_pipe_handle);
! 200: void uhci_device_bulk_done(usbd_xfer_handle);
! 201:
! 202: usbd_status uhci_device_isoc_transfer(usbd_xfer_handle);
! 203: usbd_status uhci_device_isoc_start(usbd_xfer_handle);
! 204: void uhci_device_isoc_abort(usbd_xfer_handle);
! 205: void uhci_device_isoc_close(usbd_pipe_handle);
! 206: void uhci_device_isoc_done(usbd_xfer_handle);
! 207:
! 208: usbd_status uhci_root_ctrl_transfer(usbd_xfer_handle);
! 209: usbd_status uhci_root_ctrl_start(usbd_xfer_handle);
! 210: void uhci_root_ctrl_abort(usbd_xfer_handle);
! 211: void uhci_root_ctrl_close(usbd_pipe_handle);
! 212: void uhci_root_ctrl_done(usbd_xfer_handle);
! 213:
! 214: usbd_status uhci_root_intr_transfer(usbd_xfer_handle);
! 215: usbd_status uhci_root_intr_start(usbd_xfer_handle);
! 216: void uhci_root_intr_abort(usbd_xfer_handle);
! 217: void uhci_root_intr_close(usbd_pipe_handle);
! 218: void uhci_root_intr_done(usbd_xfer_handle);
! 219:
! 220: usbd_status uhci_open(usbd_pipe_handle);
! 221: void uhci_poll(struct usbd_bus *);
! 222: void uhci_softintr(void *);
! 223:
! 224: usbd_status uhci_device_request(usbd_xfer_handle xfer);
! 225:
! 226: void uhci_add_intr(uhci_softc_t *, uhci_soft_qh_t *);
! 227: void uhci_remove_intr(uhci_softc_t *, uhci_soft_qh_t *);
! 228: usbd_status uhci_device_setintr(uhci_softc_t *sc,
! 229: struct uhci_pipe *pipe, int ival);
! 230:
! 231: void uhci_device_clear_toggle(usbd_pipe_handle pipe);
! 232: void uhci_noop(usbd_pipe_handle pipe);
! 233:
! 234: __inline__ uhci_soft_qh_t *uhci_find_prev_qh(uhci_soft_qh_t *,
! 235: uhci_soft_qh_t *);
! 236:
! 237: #ifdef UHCI_DEBUG
! 238: void uhci_dump_all(uhci_softc_t *);
! 239: void uhci_dumpregs(uhci_softc_t *);
! 240: void uhci_dump_qhs(uhci_soft_qh_t *);
! 241: void uhci_dump_qh(uhci_soft_qh_t *);
! 242: void uhci_dump_tds(uhci_soft_td_t *);
! 243: void uhci_dump_td(uhci_soft_td_t *);
! 244: void uhci_dump_ii(uhci_intr_info_t *ii);
! 245: void uhci_dump(void);
! 246: #endif
! 247:
! 248: #define UBARR(sc) bus_space_barrier((sc)->iot, (sc)->ioh, 0, (sc)->sc_size, \
! 249: BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE)
! 250: #define UWRITE1(sc, r, x) \
! 251: do { UBARR(sc); bus_space_write_1((sc)->iot, (sc)->ioh, (r), (x)); \
! 252: } while (/*CONSTCOND*/0)
! 253: #define UWRITE2(sc, r, x) \
! 254: do { UBARR(sc); bus_space_write_2((sc)->iot, (sc)->ioh, (r), (x)); \
! 255: } while (/*CONSTCOND*/0)
! 256: #define UWRITE4(sc, r, x) \
! 257: do { UBARR(sc); bus_space_write_4((sc)->iot, (sc)->ioh, (r), (x)); \
! 258: } while (/*CONSTCOND*/0)
! 259: #define UREAD1(sc, r) (UBARR(sc), bus_space_read_1((sc)->iot, (sc)->ioh, (r)))
! 260: #define UREAD2(sc, r) (UBARR(sc), bus_space_read_2((sc)->iot, (sc)->ioh, (r)))
! 261: #define UREAD4(sc, r) (UBARR(sc), bus_space_read_4((sc)->iot, (sc)->ioh, (r)))
! 262:
! 263: #define UHCICMD(sc, cmd) UWRITE2(sc, UHCI_CMD, cmd)
! 264: #define UHCISTS(sc) UREAD2(sc, UHCI_STS)
! 265:
! 266: #define UHCI_RESET_TIMEOUT 100 /* ms, reset timeout */
! 267:
! 268: #define UHCI_CURFRAME(sc) (UREAD2(sc, UHCI_FRNUM) & UHCI_FRNUM_MASK)
! 269:
! 270: #define UHCI_INTR_ENDPT 1
! 271:
! 272: struct usbd_bus_methods uhci_bus_methods = {
! 273: uhci_open,
! 274: uhci_softintr,
! 275: uhci_poll,
! 276: uhci_allocm,
! 277: uhci_freem,
! 278: uhci_allocx,
! 279: uhci_freex,
! 280: };
! 281:
! 282: struct usbd_pipe_methods uhci_root_ctrl_methods = {
! 283: uhci_root_ctrl_transfer,
! 284: uhci_root_ctrl_start,
! 285: uhci_root_ctrl_abort,
! 286: uhci_root_ctrl_close,
! 287: uhci_noop,
! 288: uhci_root_ctrl_done,
! 289: };
! 290:
! 291: struct usbd_pipe_methods uhci_root_intr_methods = {
! 292: uhci_root_intr_transfer,
! 293: uhci_root_intr_start,
! 294: uhci_root_intr_abort,
! 295: uhci_root_intr_close,
! 296: uhci_noop,
! 297: uhci_root_intr_done,
! 298: };
! 299:
! 300: struct usbd_pipe_methods uhci_device_ctrl_methods = {
! 301: uhci_device_ctrl_transfer,
! 302: uhci_device_ctrl_start,
! 303: uhci_device_ctrl_abort,
! 304: uhci_device_ctrl_close,
! 305: uhci_noop,
! 306: uhci_device_ctrl_done,
! 307: };
! 308:
! 309: struct usbd_pipe_methods uhci_device_intr_methods = {
! 310: uhci_device_intr_transfer,
! 311: uhci_device_intr_start,
! 312: uhci_device_intr_abort,
! 313: uhci_device_intr_close,
! 314: uhci_device_clear_toggle,
! 315: uhci_device_intr_done,
! 316: };
! 317:
! 318: struct usbd_pipe_methods uhci_device_bulk_methods = {
! 319: uhci_device_bulk_transfer,
! 320: uhci_device_bulk_start,
! 321: uhci_device_bulk_abort,
! 322: uhci_device_bulk_close,
! 323: uhci_device_clear_toggle,
! 324: uhci_device_bulk_done,
! 325: };
! 326:
! 327: struct usbd_pipe_methods uhci_device_isoc_methods = {
! 328: uhci_device_isoc_transfer,
! 329: uhci_device_isoc_start,
! 330: uhci_device_isoc_abort,
! 331: uhci_device_isoc_close,
! 332: uhci_noop,
! 333: uhci_device_isoc_done,
! 334: };
! 335:
! 336: #define uhci_add_intr_info(sc, ii) \
! 337: LIST_INSERT_HEAD(&(sc)->sc_intrhead, (ii), list)
! 338: #define uhci_del_intr_info(ii) \
! 339: do { \
! 340: LIST_REMOVE((ii), list); \
! 341: (ii)->list.le_prev = NULL; \
! 342: } while (0)
! 343: #define uhci_active_intr_info(ii) ((ii)->list.le_prev != NULL)
! 344:
! 345: __inline__ uhci_soft_qh_t *
! 346: uhci_find_prev_qh(uhci_soft_qh_t *pqh, uhci_soft_qh_t *sqh)
! 347: {
! 348: DPRINTFN(15,("uhci_find_prev_qh: pqh=%p sqh=%p\n", pqh, sqh));
! 349:
! 350: for (; pqh->hlink != sqh; pqh = pqh->hlink) {
! 351: #if defined(DIAGNOSTIC) || defined(UHCI_DEBUG)
! 352: if (letoh32(pqh->qh.qh_hlink) & UHCI_PTR_T) {
! 353: printf("uhci_find_prev_qh: QH not found\n");
! 354: return (NULL);
! 355: }
! 356: #endif
! 357: }
! 358: return (pqh);
! 359: }
! 360:
! 361: void
! 362: uhci_globalreset(uhci_softc_t *sc)
! 363: {
! 364: UHCICMD(sc, UHCI_CMD_GRESET); /* global reset */
! 365: usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); /* wait a little */
! 366: UHCICMD(sc, 0); /* do nothing */
! 367: }
! 368:
! 369: usbd_status
! 370: uhci_init(uhci_softc_t *sc)
! 371: {
! 372: usbd_status err;
! 373: int i, j;
! 374: uhci_soft_qh_t *clsqh, *chsqh, *bsqh, *sqh, *lsqh;
! 375: uhci_soft_td_t *std;
! 376:
! 377: DPRINTFN(1,("uhci_init: start\n"));
! 378:
! 379: #ifdef UHCI_DEBUG
! 380: thesc = sc;
! 381:
! 382: if (uhcidebug > 2)
! 383: uhci_dumpregs(sc);
! 384: #endif
! 385:
! 386: /* Save SOF over HC reset. */
! 387: sc->sc_saved_sof = UREAD1(sc, UHCI_SOF);
! 388:
! 389: UWRITE2(sc, UHCI_INTR, 0); /* disable interrupts */
! 390: uhci_globalreset(sc); /* reset the controller */
! 391: uhci_reset(sc);
! 392:
! 393: /* Restore saved SOF. */
! 394: UWRITE1(sc, UHCI_SOF, sc->sc_saved_sof);
! 395:
! 396: /* Allocate and initialize real frame array. */
! 397: err = usb_allocmem(&sc->sc_bus,
! 398: UHCI_FRAMELIST_COUNT * sizeof(uhci_physaddr_t),
! 399: UHCI_FRAMELIST_ALIGN, &sc->sc_dma);
! 400: if (err)
! 401: return (err);
! 402: sc->sc_pframes = KERNADDR(&sc->sc_dma, 0);
! 403: UWRITE2(sc, UHCI_FRNUM, 0); /* set frame number to 0 */
! 404: UWRITE4(sc, UHCI_FLBASEADDR, DMAADDR(&sc->sc_dma, 0)); /* set frame list*/
! 405:
! 406: /*
! 407: * Allocate a TD, inactive, that hangs from the last QH.
! 408: * This is to avoid a bug in the PIIX that makes it run berserk
! 409: * otherwise.
! 410: */
! 411: std = uhci_alloc_std(sc);
! 412: if (std == NULL)
! 413: return (USBD_NOMEM);
! 414: std->link.std = NULL;
! 415: std->td.td_link = htole32(UHCI_PTR_T);
! 416: std->td.td_status = htole32(0); /* inactive */
! 417: std->td.td_token = htole32(0);
! 418: std->td.td_buffer = htole32(0);
! 419:
! 420: /* Allocate the dummy QH marking the end and used for looping the QHs.*/
! 421: lsqh = uhci_alloc_sqh(sc);
! 422: if (lsqh == NULL)
! 423: return (USBD_NOMEM);
! 424: lsqh->hlink = NULL;
! 425: lsqh->qh.qh_hlink = htole32(UHCI_PTR_T); /* end of QH chain */
! 426: lsqh->elink = std;
! 427: lsqh->qh.qh_elink = htole32(std->physaddr | UHCI_PTR_TD);
! 428: sc->sc_last_qh = lsqh;
! 429:
! 430: /* Allocate the dummy QH where bulk traffic will be queued. */
! 431: bsqh = uhci_alloc_sqh(sc);
! 432: if (bsqh == NULL)
! 433: return (USBD_NOMEM);
! 434: bsqh->hlink = lsqh;
! 435: bsqh->qh.qh_hlink = htole32(lsqh->physaddr | UHCI_PTR_QH);
! 436: bsqh->elink = NULL;
! 437: bsqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 438: sc->sc_bulk_start = sc->sc_bulk_end = bsqh;
! 439:
! 440: /* Allocate dummy QH where high speed control traffic will be queued. */
! 441: chsqh = uhci_alloc_sqh(sc);
! 442: if (chsqh == NULL)
! 443: return (USBD_NOMEM);
! 444: chsqh->hlink = bsqh;
! 445: chsqh->qh.qh_hlink = htole32(bsqh->physaddr | UHCI_PTR_QH);
! 446: chsqh->elink = NULL;
! 447: chsqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 448: sc->sc_hctl_start = sc->sc_hctl_end = chsqh;
! 449:
! 450: /* Allocate dummy QH where control traffic will be queued. */
! 451: clsqh = uhci_alloc_sqh(sc);
! 452: if (clsqh == NULL)
! 453: return (USBD_NOMEM);
! 454: clsqh->hlink = bsqh;
! 455: clsqh->qh.qh_hlink = htole32(chsqh->physaddr | UHCI_PTR_QH);
! 456: clsqh->elink = NULL;
! 457: clsqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 458: sc->sc_lctl_start = sc->sc_lctl_end = clsqh;
! 459:
! 460: /*
! 461: * Make all (virtual) frame list pointers point to the interrupt
! 462: * queue heads and the interrupt queue heads at the control
! 463: * queue head and point the physical frame list to the virtual.
! 464: */
! 465: for(i = 0; i < UHCI_VFRAMELIST_COUNT; i++) {
! 466: std = uhci_alloc_std(sc);
! 467: sqh = uhci_alloc_sqh(sc);
! 468: if (std == NULL || sqh == NULL)
! 469: return (USBD_NOMEM);
! 470: std->link.sqh = sqh;
! 471: std->td.td_link = htole32(sqh->physaddr | UHCI_PTR_QH);
! 472: std->td.td_status = htole32(UHCI_TD_IOS); /* iso, inactive */
! 473: std->td.td_token = htole32(0);
! 474: std->td.td_buffer = htole32(0);
! 475: sqh->hlink = clsqh;
! 476: sqh->qh.qh_hlink = htole32(clsqh->physaddr | UHCI_PTR_QH);
! 477: sqh->elink = NULL;
! 478: sqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 479: sc->sc_vframes[i].htd = std;
! 480: sc->sc_vframes[i].etd = std;
! 481: sc->sc_vframes[i].hqh = sqh;
! 482: sc->sc_vframes[i].eqh = sqh;
! 483: for (j = i;
! 484: j < UHCI_FRAMELIST_COUNT;
! 485: j += UHCI_VFRAMELIST_COUNT)
! 486: sc->sc_pframes[j] = htole32(std->physaddr);
! 487: }
! 488:
! 489: LIST_INIT(&sc->sc_intrhead);
! 490:
! 491: SIMPLEQ_INIT(&sc->sc_free_xfers);
! 492:
! 493: timeout_set(&sc->sc_poll_handle, NULL, NULL);
! 494:
! 495: /* Set up the bus struct. */
! 496: sc->sc_bus.methods = &uhci_bus_methods;
! 497: sc->sc_bus.pipe_size = sizeof(struct uhci_pipe);
! 498:
! 499: sc->sc_suspend = PWR_RESUME;
! 500: sc->sc_powerhook = powerhook_establish(uhci_power, sc);
! 501: sc->sc_shutdownhook = shutdownhook_establish(uhci_shutdown, sc);
! 502:
! 503: UHCICMD(sc, UHCI_CMD_MAXP); /* Assume 64 byte packets at frame end */
! 504:
! 505: DPRINTFN(1,("uhci_init: enabling\n"));
! 506: UWRITE2(sc, UHCI_INTR, UHCI_INTR_TOCRCIE | UHCI_INTR_RIE |
! 507: UHCI_INTR_IOCE | UHCI_INTR_SPIE); /* enable interrupts */
! 508:
! 509: return (uhci_run(sc, 1)); /* and here we go... */
! 510: }
! 511:
! 512: int
! 513: uhci_activate(struct device *self, enum devact act)
! 514: {
! 515: struct uhci_softc *sc = (struct uhci_softc *)self;
! 516: int rv = 0;
! 517:
! 518: switch (act) {
! 519: case DVACT_ACTIVATE:
! 520: break;
! 521:
! 522: case DVACT_DEACTIVATE:
! 523: if (sc->sc_child != NULL)
! 524: rv = config_deactivate(sc->sc_child);
! 525: break;
! 526: }
! 527: return (rv);
! 528: }
! 529:
! 530: int
! 531: uhci_detach(struct uhci_softc *sc, int flags)
! 532: {
! 533: usbd_xfer_handle xfer;
! 534: int rv = 0;
! 535:
! 536: if (sc->sc_child != NULL)
! 537: rv = config_detach(sc->sc_child, flags);
! 538:
! 539: if (rv != 0)
! 540: return (rv);
! 541:
! 542: if (sc->sc_powerhook != NULL)
! 543: powerhook_disestablish(sc->sc_powerhook);
! 544: if (sc->sc_shutdownhook != NULL)
! 545: shutdownhook_disestablish(sc->sc_shutdownhook);
! 546:
! 547: /* Free all xfers associated with this HC. */
! 548: for (;;) {
! 549: xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers);
! 550: if (xfer == NULL)
! 551: break;
! 552: SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, next);
! 553: free(xfer, M_USB);
! 554: }
! 555:
! 556: /* XXX free other data structures XXX */
! 557:
! 558: return (rv);
! 559: }
! 560:
! 561: usbd_status
! 562: uhci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size)
! 563: {
! 564: struct uhci_softc *sc = (struct uhci_softc *)bus;
! 565: u_int32_t n;
! 566:
! 567: /*
! 568: * XXX
! 569: * Since we are allocating a buffer we can assume that we will
! 570: * need TDs for it. Since we don't want to allocate those from
! 571: * an interrupt context, we allocate them here and free them again.
! 572: * This is no guarantee that we'll get the TDs next time...
! 573: */
! 574: n = size / 8;
! 575: if (n > 16) {
! 576: u_int32_t i;
! 577: uhci_soft_td_t **stds;
! 578: DPRINTF(("uhci_allocm: get %d TDs\n", n));
! 579: stds = malloc(sizeof(uhci_soft_td_t *) * n, M_TEMP,
! 580: M_NOWAIT);
! 581: if (stds == NULL)
! 582: panic("uhci_allocm");
! 583: memset(stds, 0, sizeof(uhci_soft_td_t *) * n);
! 584: for(i=0; i < n; i++)
! 585: stds[i] = uhci_alloc_std(sc);
! 586: for(i=0; i < n; i++)
! 587: if (stds[i] != NULL)
! 588: uhci_free_std(sc, stds[i]);
! 589: free(stds, M_TEMP);
! 590: }
! 591:
! 592: return (usb_allocmem(&sc->sc_bus, size, 0, dma));
! 593: }
! 594:
! 595: void
! 596: uhci_freem(struct usbd_bus *bus, usb_dma_t *dma)
! 597: {
! 598: usb_freemem(&((struct uhci_softc *)bus)->sc_bus, dma);
! 599: }
! 600:
! 601: usbd_xfer_handle
! 602: uhci_allocx(struct usbd_bus *bus)
! 603: {
! 604: struct uhci_softc *sc = (struct uhci_softc *)bus;
! 605: usbd_xfer_handle xfer;
! 606:
! 607: xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers);
! 608: if (xfer != NULL) {
! 609: SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, next);
! 610: #ifdef DIAGNOSTIC
! 611: if (xfer->busy_free != XFER_FREE) {
! 612: printf("uhci_allocx: xfer=%p not free, 0x%08x\n", xfer,
! 613: xfer->busy_free);
! 614: }
! 615: #endif
! 616: } else {
! 617: xfer = malloc(sizeof(struct uhci_xfer), M_USB, M_NOWAIT);
! 618: }
! 619: if (xfer != NULL) {
! 620: memset(xfer, 0, sizeof (struct uhci_xfer));
! 621: UXFER(xfer)->iinfo.sc = sc;
! 622: #ifdef DIAGNOSTIC
! 623: UXFER(xfer)->iinfo.isdone = 1;
! 624: xfer->busy_free = XFER_BUSY;
! 625: #endif
! 626: }
! 627: return (xfer);
! 628: }
! 629:
! 630: void
! 631: uhci_freex(struct usbd_bus *bus, usbd_xfer_handle xfer)
! 632: {
! 633: struct uhci_softc *sc = (struct uhci_softc *)bus;
! 634:
! 635: #ifdef DIAGNOSTIC
! 636: if (xfer->busy_free != XFER_BUSY) {
! 637: printf("uhci_freex: xfer=%p not busy, 0x%08x\n", xfer,
! 638: xfer->busy_free);
! 639: return;
! 640: }
! 641: xfer->busy_free = XFER_FREE;
! 642: if (!UXFER(xfer)->iinfo.isdone) {
! 643: printf("uhci_freex: !isdone\n");
! 644: return;
! 645: }
! 646: #endif
! 647: SIMPLEQ_INSERT_HEAD(&sc->sc_free_xfers, xfer, next);
! 648: }
! 649:
! 650: /*
! 651: * Shut down the controller when the system is going down.
! 652: */
! 653: void
! 654: uhci_shutdown(void *v)
! 655: {
! 656: uhci_softc_t *sc = v;
! 657:
! 658: DPRINTF(("uhci_shutdown: stopping the HC\n"));
! 659: uhci_run(sc, 0); /* stop the controller */
! 660: }
! 661:
! 662: /*
! 663: * Handle suspend/resume.
! 664: *
! 665: * We need to switch to polling mode here, because this routine is
! 666: * called from an interrupt context. This is all right since we
! 667: * are almost suspended anyway.
! 668: */
! 669: void
! 670: uhci_power(int why, void *v)
! 671: {
! 672: uhci_softc_t *sc = v;
! 673: int cmd;
! 674: int s;
! 675:
! 676: s = splhardusb();
! 677: cmd = UREAD2(sc, UHCI_CMD);
! 678:
! 679: DPRINTF(("uhci_power: sc=%p, why=%d (was %d), cmd=0x%x\n",
! 680: sc, why, sc->sc_suspend, cmd));
! 681:
! 682: switch (why) {
! 683: case PWR_SUSPEND:
! 684: case PWR_STANDBY:
! 685: #ifdef UHCI_DEBUG
! 686: if (uhcidebug > 2)
! 687: uhci_dumpregs(sc);
! 688: #endif
! 689: if (sc->sc_intr_xfer != NULL)
! 690: timeout_del(&sc->sc_poll_handle);
! 691: sc->sc_bus.use_polling++;
! 692: uhci_run(sc, 0); /* stop the controller */
! 693:
! 694: /* save some state if BIOS doesn't */
! 695: sc->sc_saved_frnum = UREAD2(sc, UHCI_FRNUM);
! 696:
! 697: UWRITE2(sc, UHCI_INTR, 0); /* disable intrs */
! 698:
! 699: UHCICMD(sc, cmd | UHCI_CMD_EGSM); /* enter global suspend */
! 700: usb_delay_ms(&sc->sc_bus, USB_RESUME_WAIT);
! 701: sc->sc_suspend = why;
! 702: sc->sc_bus.use_polling--;
! 703: DPRINTF(("uhci_power: cmd=0x%x\n", UREAD2(sc, UHCI_CMD)));
! 704: break;
! 705: case PWR_RESUME:
! 706: #ifdef DIAGNOSTIC
! 707: if (sc->sc_suspend == PWR_RESUME)
! 708: printf("uhci_power: weird, resume without suspend.\n");
! 709: #endif
! 710: sc->sc_bus.use_polling++;
! 711: sc->sc_suspend = why;
! 712: if (cmd & UHCI_CMD_RS)
! 713: uhci_run(sc, 0); /* in case BIOS has started it */
! 714:
! 715: /* restore saved state */
! 716: UWRITE4(sc, UHCI_FLBASEADDR, DMAADDR(&sc->sc_dma, 0));
! 717: UWRITE2(sc, UHCI_FRNUM, sc->sc_saved_frnum);
! 718: UWRITE1(sc, UHCI_SOF, sc->sc_saved_sof);
! 719:
! 720: UHCICMD(sc, cmd | UHCI_CMD_FGR); /* force global resume */
! 721: usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY);
! 722: UHCICMD(sc, cmd & ~UHCI_CMD_EGSM); /* back to normal */
! 723: UHCICMD(sc, UHCI_CMD_MAXP);
! 724: UWRITE2(sc, UHCI_INTR, UHCI_INTR_TOCRCIE | UHCI_INTR_RIE |
! 725: UHCI_INTR_IOCE | UHCI_INTR_SPIE); /* re-enable intrs */
! 726: uhci_run(sc, 1); /* and start traffic again */
! 727: usb_delay_ms(&sc->sc_bus, USB_RESUME_RECOVERY);
! 728: sc->sc_bus.use_polling--;
! 729: if (sc->sc_intr_xfer != NULL) {
! 730: timeout_del(&sc->sc_poll_handle);
! 731: timeout_set(&sc->sc_poll_handle, uhci_poll_hub,
! 732: sc->sc_intr_xfer);
! 733: timeout_add(&sc->sc_poll_handle, sc->sc_ival);
! 734: }
! 735: #ifdef UHCI_DEBUG
! 736: if (uhcidebug > 2)
! 737: uhci_dumpregs(sc);
! 738: #endif
! 739: break;
! 740: }
! 741: splx(s);
! 742: }
! 743:
! 744: #ifdef UHCI_DEBUG
! 745: void
! 746: uhci_dumpregs(uhci_softc_t *sc)
! 747: {
! 748: DPRINTFN(-1,("%s regs: cmd=%04x, sts=%04x, intr=%04x, frnum=%04x, "
! 749: "flbase=%08x, sof=%04x, portsc1=%04x, portsc2=%04x\n",
! 750: sc->sc_bus.bdev.dv_xname,
! 751: UREAD2(sc, UHCI_CMD),
! 752: UREAD2(sc, UHCI_STS),
! 753: UREAD2(sc, UHCI_INTR),
! 754: UREAD2(sc, UHCI_FRNUM),
! 755: UREAD4(sc, UHCI_FLBASEADDR),
! 756: UREAD1(sc, UHCI_SOF),
! 757: UREAD2(sc, UHCI_PORTSC1),
! 758: UREAD2(sc, UHCI_PORTSC2)));
! 759: }
! 760:
! 761: void
! 762: uhci_dump_td(uhci_soft_td_t *p)
! 763: {
! 764: char sbuf[128], sbuf2[128];
! 765:
! 766: DPRINTFN(-1,("TD(%p) at %08lx = link=0x%08lx status=0x%08lx "
! 767: "token=0x%08lx buffer=0x%08lx\n",
! 768: p, (long)p->physaddr,
! 769: (long)letoh32(p->td.td_link),
! 770: (long)letoh32(p->td.td_status),
! 771: (long)letoh32(p->td.td_token),
! 772: (long)letoh32(p->td.td_buffer)));
! 773:
! 774: bitmask_snprintf((u_int32_t)letoh32(p->td.td_link), "\20\1T\2Q\3VF",
! 775: sbuf, sizeof(sbuf));
! 776: bitmask_snprintf((u_int32_t)letoh32(p->td.td_status),
! 777: "\20\22BITSTUFF\23CRCTO\24NAK\25BABBLE\26DBUFFER\27"
! 778: "STALLED\30ACTIVE\31IOC\32ISO\33LS\36SPD",
! 779: sbuf2, sizeof(sbuf2));
! 780:
! 781: DPRINTFN(-1,(" %s %s,errcnt=%d,actlen=%d pid=%02x,addr=%d,endpt=%d,"
! 782: "D=%d,maxlen=%d\n", sbuf, sbuf2,
! 783: UHCI_TD_GET_ERRCNT(letoh32(p->td.td_status)),
! 784: UHCI_TD_GET_ACTLEN(letoh32(p->td.td_status)),
! 785: UHCI_TD_GET_PID(letoh32(p->td.td_token)),
! 786: UHCI_TD_GET_DEVADDR(letoh32(p->td.td_token)),
! 787: UHCI_TD_GET_ENDPT(letoh32(p->td.td_token)),
! 788: UHCI_TD_GET_DT(letoh32(p->td.td_token)),
! 789: UHCI_TD_GET_MAXLEN(letoh32(p->td.td_token))));
! 790: }
! 791:
! 792: void
! 793: uhci_dump_qh(uhci_soft_qh_t *sqh)
! 794: {
! 795: DPRINTFN(-1,("QH(%p) at %08x: hlink=%08x elink=%08x\n", sqh,
! 796: (int)sqh->physaddr, letoh32(sqh->qh.qh_hlink),
! 797: letoh32(sqh->qh.qh_elink)));
! 798: }
! 799:
! 800:
! 801: void
! 802: uhci_dump(void)
! 803: {
! 804: uhci_dump_all(thesc);
! 805: }
! 806:
! 807: void
! 808: uhci_dump_all(uhci_softc_t *sc)
! 809: {
! 810: uhci_dumpregs(sc);
! 811: printf("intrs=%d\n", sc->sc_bus.no_intrs);
! 812: /*printf("framelist[i].link = %08x\n", sc->sc_framelist[0].link);*/
! 813: uhci_dump_qh(sc->sc_lctl_start);
! 814: }
! 815:
! 816:
! 817: void
! 818: uhci_dump_qhs(uhci_soft_qh_t *sqh)
! 819: {
! 820: uhci_dump_qh(sqh);
! 821:
! 822: /* uhci_dump_qhs displays all the QHs and TDs from the given QH onwards
! 823: * Traverses sideways first, then down.
! 824: *
! 825: * QH1
! 826: * QH2
! 827: * No QH
! 828: * TD2.1
! 829: * TD2.2
! 830: * TD1.1
! 831: * etc.
! 832: *
! 833: * TD2.x being the TDs queued at QH2 and QH1 being referenced from QH1.
! 834: */
! 835:
! 836:
! 837: if (sqh->hlink != NULL && !(letoh32(sqh->qh.qh_hlink) & UHCI_PTR_T))
! 838: uhci_dump_qhs(sqh->hlink);
! 839: else
! 840: DPRINTF(("No QH\n"));
! 841:
! 842: if (sqh->elink != NULL && !(letoh32(sqh->qh.qh_elink) & UHCI_PTR_T))
! 843: uhci_dump_tds(sqh->elink);
! 844: else
! 845: DPRINTF(("No TD\n"));
! 846: }
! 847:
! 848: void
! 849: uhci_dump_tds(uhci_soft_td_t *std)
! 850: {
! 851: uhci_soft_td_t *td;
! 852:
! 853: for(td = std; td != NULL; td = td->link.std) {
! 854: uhci_dump_td(td);
! 855:
! 856: /* Check whether the link pointer in this TD marks
! 857: * the link pointer as end of queue. This avoids
! 858: * printing the free list in case the queue/TD has
! 859: * already been moved there (seatbelt).
! 860: */
! 861: if (letoh32(td->td.td_link) & UHCI_PTR_T ||
! 862: letoh32(td->td.td_link) == 0)
! 863: break;
! 864: }
! 865: }
! 866:
! 867: void
! 868: uhci_dump_ii(uhci_intr_info_t *ii)
! 869: {
! 870: usbd_pipe_handle pipe;
! 871: usb_endpoint_descriptor_t *ed;
! 872: usbd_device_handle dev;
! 873:
! 874: #ifdef DIAGNOSTIC
! 875: #define DONE ii->isdone
! 876: #else
! 877: #define DONE 0
! 878: #endif
! 879: if (ii == NULL) {
! 880: printf("ii NULL\n");
! 881: return;
! 882: }
! 883: if (ii->xfer == NULL) {
! 884: printf("ii %p: done=%d xfer=NULL\n",
! 885: ii, DONE);
! 886: return;
! 887: }
! 888: pipe = ii->xfer->pipe;
! 889: if (pipe == NULL) {
! 890: printf("ii %p: done=%d xfer=%p pipe=NULL\n",
! 891: ii, DONE, ii->xfer);
! 892: return;
! 893: }
! 894: if (pipe->endpoint == NULL) {
! 895: printf("ii %p: done=%d xfer=%p pipe=%p pipe->endpoint=NULL\n",
! 896: ii, DONE, ii->xfer, pipe);
! 897: return;
! 898: }
! 899: if (pipe->device == NULL) {
! 900: printf("ii %p: done=%d xfer=%p pipe=%p pipe->device=NULL\n",
! 901: ii, DONE, ii->xfer, pipe);
! 902: return;
! 903: }
! 904: ed = pipe->endpoint->edesc;
! 905: dev = pipe->device;
! 906: printf("ii %p: done=%d xfer=%p dev=%p vid=0x%04x pid=0x%04x addr=%d pipe=%p ep=0x%02x attr=0x%02x\n",
! 907: ii, DONE, ii->xfer, dev,
! 908: UGETW(dev->ddesc.idVendor),
! 909: UGETW(dev->ddesc.idProduct),
! 910: dev->address, pipe,
! 911: ed->bEndpointAddress, ed->bmAttributes);
! 912: #undef DONE
! 913: }
! 914:
! 915: void uhci_dump_iis(struct uhci_softc *sc);
! 916: void
! 917: uhci_dump_iis(struct uhci_softc *sc)
! 918: {
! 919: uhci_intr_info_t *ii;
! 920:
! 921: printf("intr_info list:\n");
! 922: for (ii = LIST_FIRST(&sc->sc_intrhead); ii; ii = LIST_NEXT(ii, list))
! 923: uhci_dump_ii(ii);
! 924: }
! 925:
! 926: void iidump(void);
! 927: void iidump(void) { uhci_dump_iis(thesc); }
! 928:
! 929: #endif
! 930:
! 931: /*
! 932: * This routine is executed periodically and simulates interrupts
! 933: * from the root controller interrupt pipe for port status change.
! 934: */
! 935: void
! 936: uhci_poll_hub(void *addr)
! 937: {
! 938: usbd_xfer_handle xfer = addr;
! 939: usbd_pipe_handle pipe = xfer->pipe;
! 940: uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus;
! 941: int s;
! 942: u_char *p;
! 943:
! 944: DPRINTFN(20, ("uhci_poll_hub\n"));
! 945:
! 946: timeout_del(&sc->sc_poll_handle);
! 947: timeout_set(&sc->sc_poll_handle, uhci_poll_hub, xfer);
! 948: timeout_add(&sc->sc_poll_handle, sc->sc_ival);
! 949:
! 950: p = KERNADDR(&xfer->dmabuf, 0);
! 951: p[0] = 0;
! 952: if (UREAD2(sc, UHCI_PORTSC1) & (UHCI_PORTSC_CSC|UHCI_PORTSC_OCIC))
! 953: p[0] |= 1<<1;
! 954: if (UREAD2(sc, UHCI_PORTSC2) & (UHCI_PORTSC_CSC|UHCI_PORTSC_OCIC))
! 955: p[0] |= 1<<2;
! 956: if (p[0] == 0)
! 957: /* No change, try again in a while */
! 958: return;
! 959:
! 960: xfer->actlen = 1;
! 961: xfer->status = USBD_NORMAL_COMPLETION;
! 962: s = splusb();
! 963: xfer->device->bus->intr_context++;
! 964: usb_transfer_complete(xfer);
! 965: xfer->device->bus->intr_context--;
! 966: splx(s);
! 967: }
! 968:
! 969: void
! 970: uhci_root_intr_done(usbd_xfer_handle xfer)
! 971: {
! 972: }
! 973:
! 974: void
! 975: uhci_root_ctrl_done(usbd_xfer_handle xfer)
! 976: {
! 977: }
! 978:
! 979: /*
! 980: * Let the last QH loop back to the high speed control transfer QH.
! 981: * This is what intel calls "bandwidth reclamation" and improves
! 982: * USB performance a lot for some devices.
! 983: * If we are already looping, just count it.
! 984: */
! 985: void
! 986: uhci_add_loop(uhci_softc_t *sc) {
! 987: #ifdef UHCI_DEBUG
! 988: if (uhcinoloop)
! 989: return;
! 990: #endif
! 991: if (++sc->sc_loops == 1) {
! 992: DPRINTFN(5,("uhci_start_loop: add\n"));
! 993: /* Note, we don't loop back the soft pointer. */
! 994: sc->sc_last_qh->qh.qh_hlink =
! 995: htole32(sc->sc_hctl_start->physaddr | UHCI_PTR_QH);
! 996: }
! 997: }
! 998:
! 999: void
! 1000: uhci_rem_loop(uhci_softc_t *sc) {
! 1001: #ifdef UHCI_DEBUG
! 1002: if (uhcinoloop)
! 1003: return;
! 1004: #endif
! 1005: if (--sc->sc_loops == 0) {
! 1006: DPRINTFN(5,("uhci_end_loop: remove\n"));
! 1007: sc->sc_last_qh->qh.qh_hlink = htole32(UHCI_PTR_T);
! 1008: }
! 1009: }
! 1010:
! 1011: /* Add high speed control QH, called at splusb(). */
! 1012: void
! 1013: uhci_add_hs_ctrl(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 1014: {
! 1015: uhci_soft_qh_t *eqh;
! 1016:
! 1017: SPLUSBCHECK;
! 1018:
! 1019: DPRINTFN(10, ("uhci_add_ctrl: sqh=%p\n", sqh));
! 1020: eqh = sc->sc_hctl_end;
! 1021: sqh->hlink = eqh->hlink;
! 1022: sqh->qh.qh_hlink = eqh->qh.qh_hlink;
! 1023: eqh->hlink = sqh;
! 1024: eqh->qh.qh_hlink = htole32(sqh->physaddr | UHCI_PTR_QH);
! 1025: sc->sc_hctl_end = sqh;
! 1026: #ifdef UHCI_CTL_LOOP
! 1027: uhci_add_loop(sc);
! 1028: #endif
! 1029: }
! 1030:
! 1031: /* Remove high speed control QH, called at splusb(). */
! 1032: void
! 1033: uhci_remove_hs_ctrl(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 1034: {
! 1035: uhci_soft_qh_t *pqh;
! 1036:
! 1037: SPLUSBCHECK;
! 1038:
! 1039: DPRINTFN(10, ("uhci_remove_hs_ctrl: sqh=%p\n", sqh));
! 1040: #ifdef UHCI_CTL_LOOP
! 1041: uhci_rem_loop(sc);
! 1042: #endif
! 1043: /*
! 1044: * The T bit should be set in the elink of the QH so that the HC
! 1045: * doesn't follow the pointer. This condition may fail if the
! 1046: * the transferred packet was short so that the QH still points
! 1047: * at the last used TD.
! 1048: * In this case we set the T bit and wait a little for the HC
! 1049: * to stop looking at the TD.
! 1050: */
! 1051: if (!(sqh->qh.qh_elink & htole32(UHCI_PTR_T))) {
! 1052: sqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 1053: delay(UHCI_QH_REMOVE_DELAY);
! 1054: }
! 1055:
! 1056: pqh = uhci_find_prev_qh(sc->sc_hctl_start, sqh);
! 1057: pqh->hlink = sqh->hlink;
! 1058: pqh->qh.qh_hlink = sqh->qh.qh_hlink;
! 1059: delay(UHCI_QH_REMOVE_DELAY);
! 1060: if (sc->sc_hctl_end == sqh)
! 1061: sc->sc_hctl_end = pqh;
! 1062: }
! 1063:
! 1064: /* Add low speed control QH, called at splusb(). */
! 1065: void
! 1066: uhci_add_ls_ctrl(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 1067: {
! 1068: uhci_soft_qh_t *eqh;
! 1069:
! 1070: SPLUSBCHECK;
! 1071:
! 1072: DPRINTFN(10, ("uhci_add_ls_ctrl: sqh=%p\n", sqh));
! 1073: eqh = sc->sc_lctl_end;
! 1074: sqh->hlink = eqh->hlink;
! 1075: sqh->qh.qh_hlink = eqh->qh.qh_hlink;
! 1076: eqh->hlink = sqh;
! 1077: eqh->qh.qh_hlink = htole32(sqh->physaddr | UHCI_PTR_QH);
! 1078: sc->sc_lctl_end = sqh;
! 1079: }
! 1080:
! 1081: /* Remove low speed control QH, called at splusb(). */
! 1082: void
! 1083: uhci_remove_ls_ctrl(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 1084: {
! 1085: uhci_soft_qh_t *pqh;
! 1086:
! 1087: SPLUSBCHECK;
! 1088:
! 1089: DPRINTFN(10, ("uhci_remove_ls_ctrl: sqh=%p\n", sqh));
! 1090: /* See comment in uhci_remove_hs_ctrl() */
! 1091: if (!(sqh->qh.qh_elink & htole32(UHCI_PTR_T))) {
! 1092: sqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 1093: delay(UHCI_QH_REMOVE_DELAY);
! 1094: }
! 1095: pqh = uhci_find_prev_qh(sc->sc_lctl_start, sqh);
! 1096: pqh->hlink = sqh->hlink;
! 1097: pqh->qh.qh_hlink = sqh->qh.qh_hlink;
! 1098: delay(UHCI_QH_REMOVE_DELAY);
! 1099: if (sc->sc_lctl_end == sqh)
! 1100: sc->sc_lctl_end = pqh;
! 1101: }
! 1102:
! 1103: /* Add bulk QH, called at splusb(). */
! 1104: void
! 1105: uhci_add_bulk(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 1106: {
! 1107: uhci_soft_qh_t *eqh;
! 1108:
! 1109: SPLUSBCHECK;
! 1110:
! 1111: DPRINTFN(10, ("uhci_add_bulk: sqh=%p\n", sqh));
! 1112: eqh = sc->sc_bulk_end;
! 1113: sqh->hlink = eqh->hlink;
! 1114: sqh->qh.qh_hlink = eqh->qh.qh_hlink;
! 1115: eqh->hlink = sqh;
! 1116: eqh->qh.qh_hlink = htole32(sqh->physaddr | UHCI_PTR_QH);
! 1117: sc->sc_bulk_end = sqh;
! 1118: uhci_add_loop(sc);
! 1119: }
! 1120:
! 1121: /* Remove bulk QH, called at splusb(). */
! 1122: void
! 1123: uhci_remove_bulk(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 1124: {
! 1125: uhci_soft_qh_t *pqh;
! 1126:
! 1127: SPLUSBCHECK;
! 1128:
! 1129: DPRINTFN(10, ("uhci_remove_bulk: sqh=%p\n", sqh));
! 1130: uhci_rem_loop(sc);
! 1131: /* See comment in uhci_remove_hs_ctrl() */
! 1132: if (!(sqh->qh.qh_elink & htole32(UHCI_PTR_T))) {
! 1133: sqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 1134: delay(UHCI_QH_REMOVE_DELAY);
! 1135: }
! 1136: pqh = uhci_find_prev_qh(sc->sc_bulk_start, sqh);
! 1137: pqh->hlink = sqh->hlink;
! 1138: pqh->qh.qh_hlink = sqh->qh.qh_hlink;
! 1139: delay(UHCI_QH_REMOVE_DELAY);
! 1140: if (sc->sc_bulk_end == sqh)
! 1141: sc->sc_bulk_end = pqh;
! 1142: }
! 1143:
! 1144: int uhci_intr1(uhci_softc_t *);
! 1145:
! 1146: int
! 1147: uhci_intr(void *arg)
! 1148: {
! 1149: uhci_softc_t *sc = arg;
! 1150:
! 1151: if (sc->sc_dying)
! 1152: return (0);
! 1153:
! 1154: if (sc->sc_bus.use_polling) {
! 1155: #ifdef DIAGNOSTIC
! 1156: DPRINTFN(16, ("uhci_intr: ignored interrupt while polling\n"));
! 1157: #endif
! 1158: return (0);
! 1159: }
! 1160: return (uhci_intr1(sc));
! 1161: }
! 1162:
! 1163: int
! 1164: uhci_intr1(uhci_softc_t *sc)
! 1165: {
! 1166: int status;
! 1167: int ack;
! 1168:
! 1169: status = UREAD2(sc, UHCI_STS) & UHCI_STS_ALLINTRS;
! 1170: if (status == 0) /* The interrupt was not for us. */
! 1171: return (0);
! 1172:
! 1173: #ifdef UHCI_DEBUG
! 1174: if (uhcidebug > 15) {
! 1175: DPRINTF(("%s: uhci_intr1\n", sc->sc_bus.bdev.dv_xname));
! 1176: uhci_dumpregs(sc);
! 1177: }
! 1178: #endif
! 1179:
! 1180: if (sc->sc_suspend != PWR_RESUME) {
! 1181: printf("%s: interrupt while not operating ignored\n",
! 1182: sc->sc_bus.bdev.dv_xname);
! 1183: UWRITE2(sc, UHCI_STS, status); /* acknowledge the ints */
! 1184: return (0);
! 1185: }
! 1186:
! 1187: ack = 0;
! 1188: if (status & UHCI_STS_USBINT)
! 1189: ack |= UHCI_STS_USBINT;
! 1190: if (status & UHCI_STS_USBEI)
! 1191: ack |= UHCI_STS_USBEI;
! 1192: if (status & UHCI_STS_RD) {
! 1193: ack |= UHCI_STS_RD;
! 1194: #ifdef UHCI_DEBUG
! 1195: printf("%s: resume detect\n", sc->sc_bus.bdev.dv_xname);
! 1196: #endif
! 1197: }
! 1198: if (status & UHCI_STS_HSE) {
! 1199: ack |= UHCI_STS_HSE;
! 1200: printf("%s: host system error\n", sc->sc_bus.bdev.dv_xname);
! 1201: }
! 1202: if (status & UHCI_STS_HCPE) {
! 1203: ack |= UHCI_STS_HCPE;
! 1204: printf("%s: host controller process error\n",
! 1205: sc->sc_bus.bdev.dv_xname);
! 1206: }
! 1207: if (status & UHCI_STS_HCH) {
! 1208: /* no acknowledge needed */
! 1209: if (!sc->sc_dying) {
! 1210: printf("%s: host controller halted\n",
! 1211: sc->sc_bus.bdev.dv_xname);
! 1212: #ifdef UHCI_DEBUG
! 1213: uhci_dump_all(sc);
! 1214: #endif
! 1215: }
! 1216: sc->sc_dying = 1;
! 1217: }
! 1218:
! 1219: if (!ack)
! 1220: return (0); /* nothing to acknowledge */
! 1221: UWRITE2(sc, UHCI_STS, ack); /* acknowledge the ints */
! 1222:
! 1223: sc->sc_bus.no_intrs++;
! 1224: usb_schedsoftintr(&sc->sc_bus);
! 1225:
! 1226: DPRINTFN(15, ("%s: uhci_intr: exit\n", sc->sc_bus.bdev.dv_xname));
! 1227:
! 1228: return (1);
! 1229: }
! 1230:
! 1231: void
! 1232: uhci_softintr(void *v)
! 1233: {
! 1234: uhci_softc_t *sc = v;
! 1235: uhci_intr_info_t *ii, *nextii;
! 1236:
! 1237: DPRINTFN(10,("%s: uhci_softintr (%d)\n", sc->sc_bus.bdev.dv_xname,
! 1238: sc->sc_bus.intr_context));
! 1239:
! 1240: sc->sc_bus.intr_context++;
! 1241:
! 1242: /*
! 1243: * Interrupts on UHCI really suck. When the host controller
! 1244: * interrupts because a transfer is completed there is no
! 1245: * way of knowing which transfer it was. You can scan down
! 1246: * the TDs and QHs of the previous frame to limit the search,
! 1247: * but that assumes that the interrupt was not delayed by more
! 1248: * than 1 ms, which may not always be true (e.g. after debug
! 1249: * output on a slow console).
! 1250: * We scan all interrupt descriptors to see if any have
! 1251: * completed.
! 1252: */
! 1253: for (ii = LIST_FIRST(&sc->sc_intrhead); ii; ii = nextii) {
! 1254: nextii = LIST_NEXT(ii, list);
! 1255: uhci_check_intr(sc, ii);
! 1256: }
! 1257:
! 1258: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 1259: if (sc->sc_softwake) {
! 1260: sc->sc_softwake = 0;
! 1261: wakeup(&sc->sc_softwake);
! 1262: }
! 1263: #endif /* __HAVE_GENERIC_SOFT_INTERRUPTS */
! 1264:
! 1265: sc->sc_bus.intr_context--;
! 1266: }
! 1267:
! 1268: /* Check for an interrupt. */
! 1269: void
! 1270: uhci_check_intr(uhci_softc_t *sc, uhci_intr_info_t *ii)
! 1271: {
! 1272: uhci_soft_td_t *std, *lstd;
! 1273: u_int32_t status;
! 1274:
! 1275: DPRINTFN(15, ("uhci_check_intr: ii=%p\n", ii));
! 1276: #ifdef DIAGNOSTIC
! 1277: if (ii == NULL) {
! 1278: printf("uhci_check_intr: no ii? %p\n", ii);
! 1279: return;
! 1280: }
! 1281: #endif
! 1282: if (ii->xfer->status == USBD_CANCELLED ||
! 1283: ii->xfer->status == USBD_TIMEOUT) {
! 1284: DPRINTF(("uhci_check_intr: aborted xfer=%p\n", ii->xfer));
! 1285: return;
! 1286: }
! 1287:
! 1288: if (ii->stdstart == NULL)
! 1289: return;
! 1290: lstd = ii->stdend;
! 1291: #ifdef DIAGNOSTIC
! 1292: if (lstd == NULL) {
! 1293: printf("uhci_check_intr: std==0\n");
! 1294: return;
! 1295: }
! 1296: #endif
! 1297: /*
! 1298: * If the last TD is still active we need to check whether there
! 1299: * is an error somewhere in the middle, or whether there was a
! 1300: * short packet (SPD and not ACTIVE).
! 1301: */
! 1302: if (letoh32(lstd->td.td_status) & UHCI_TD_ACTIVE) {
! 1303: DPRINTFN(12, ("uhci_check_intr: active ii=%p\n", ii));
! 1304: for (std = ii->stdstart; std != lstd; std = std->link.std) {
! 1305: status = letoh32(std->td.td_status);
! 1306: /* If there's an active TD the xfer isn't done. */
! 1307: if (status & UHCI_TD_ACTIVE)
! 1308: break;
! 1309: /* Any kind of error makes the xfer done. */
! 1310: if (status & UHCI_TD_STALLED)
! 1311: goto done;
! 1312: /* We want short packets, and it is short: it's done */
! 1313: if ((status & UHCI_TD_SPD) &&
! 1314: UHCI_TD_GET_ACTLEN(status) <
! 1315: UHCI_TD_GET_MAXLEN(letoh32(std->td.td_token)))
! 1316: goto done;
! 1317: }
! 1318: DPRINTFN(12, ("uhci_check_intr: ii=%p std=%p still active\n",
! 1319: ii, ii->stdstart));
! 1320: return;
! 1321: }
! 1322: done:
! 1323: DPRINTFN(12, ("uhci_check_intr: ii=%p done\n", ii));
! 1324: timeout_del(&ii->xfer->timeout_handle);
! 1325: uhci_idone(ii);
! 1326: }
! 1327:
! 1328: /* Called at splusb() */
! 1329: void
! 1330: uhci_idone(uhci_intr_info_t *ii)
! 1331: {
! 1332: usbd_xfer_handle xfer = ii->xfer;
! 1333: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 1334: uhci_soft_td_t *std;
! 1335: u_int32_t status = 0, nstatus;
! 1336: int actlen;
! 1337:
! 1338: DPRINTFN(12, ("uhci_idone: ii=%p\n", ii));
! 1339: #ifdef DIAGNOSTIC
! 1340: {
! 1341: int s = splhigh();
! 1342: if (ii->isdone) {
! 1343: splx(s);
! 1344: #ifdef UHCI_DEBUG
! 1345: printf("uhci_idone: ii is done!\n ");
! 1346: uhci_dump_ii(ii);
! 1347: #else
! 1348: printf("uhci_idone: ii=%p is done!\n", ii);
! 1349: #endif
! 1350: return;
! 1351: }
! 1352: ii->isdone = 1;
! 1353: splx(s);
! 1354: }
! 1355: #endif
! 1356:
! 1357: if (xfer->nframes != 0) {
! 1358: /* Isoc transfer, do things differently. */
! 1359: uhci_soft_td_t **stds = upipe->u.iso.stds;
! 1360: int i, n, nframes, len;
! 1361:
! 1362: DPRINTFN(5,("uhci_idone: ii=%p isoc ready\n", ii));
! 1363:
! 1364: nframes = xfer->nframes;
! 1365: actlen = 0;
! 1366: n = UXFER(xfer)->curframe;
! 1367: for (i = 0; i < nframes; i++) {
! 1368: std = stds[n];
! 1369: #ifdef UHCI_DEBUG
! 1370: if (uhcidebug > 5) {
! 1371: DPRINTFN(-1,("uhci_idone: isoc TD %d\n", i));
! 1372: uhci_dump_td(std);
! 1373: }
! 1374: #endif
! 1375: if (++n >= UHCI_VFRAMELIST_COUNT)
! 1376: n = 0;
! 1377: status = letoh32(std->td.td_status);
! 1378: len = UHCI_TD_GET_ACTLEN(status);
! 1379: xfer->frlengths[i] = len;
! 1380: actlen += len;
! 1381: }
! 1382: upipe->u.iso.inuse -= nframes;
! 1383: xfer->actlen = actlen;
! 1384: xfer->status = USBD_NORMAL_COMPLETION;
! 1385: goto end;
! 1386: }
! 1387:
! 1388: #ifdef UHCI_DEBUG
! 1389: DPRINTFN(10, ("uhci_idone: ii=%p, xfer=%p, pipe=%p ready\n",
! 1390: ii, xfer, upipe));
! 1391: if (uhcidebug > 10)
! 1392: uhci_dump_tds(ii->stdstart);
! 1393: #endif
! 1394:
! 1395: /* The transfer is done, compute actual length and status. */
! 1396: actlen = 0;
! 1397: for (std = ii->stdstart; std != NULL; std = std->link.std) {
! 1398: nstatus = letoh32(std->td.td_status);
! 1399: if (nstatus & UHCI_TD_ACTIVE)
! 1400: break;
! 1401:
! 1402: status = nstatus;
! 1403: if (UHCI_TD_GET_PID(letoh32(std->td.td_token)) !=
! 1404: UHCI_TD_PID_SETUP)
! 1405: actlen += UHCI_TD_GET_ACTLEN(status);
! 1406: else {
! 1407: /*
! 1408: * UHCI will report CRCTO in addition to a STALL or NAK
! 1409: * for a SETUP transaction. See section 3.2.2, "TD
! 1410: * CONTROL AND STATUS".
! 1411: */
! 1412: if (status & (UHCI_TD_STALLED | UHCI_TD_NAK))
! 1413: status &= ~UHCI_TD_CRCTO;
! 1414: }
! 1415: }
! 1416: /* If there are left over TDs we need to update the toggle. */
! 1417: if (std != NULL)
! 1418: upipe->nexttoggle = UHCI_TD_GET_DT(letoh32(std->td.td_token));
! 1419:
! 1420: status &= UHCI_TD_ERROR;
! 1421: DPRINTFN(10, ("uhci_idone: actlen=%d, status=0x%x\n",
! 1422: actlen, status));
! 1423: xfer->actlen = actlen;
! 1424: if (status != 0) {
! 1425: #ifdef UHCI_DEBUG
! 1426: char sbuf[128];
! 1427:
! 1428: bitmask_snprintf((u_int32_t)status,
! 1429: "\20\22BITSTUFF\23CRCTO\24NAK\25"
! 1430: "BABBLE\26DBUFFER\27STALLED\30ACTIVE",
! 1431: sbuf, sizeof(sbuf));
! 1432:
! 1433: DPRINTFN((status == UHCI_TD_STALLED)*10,
! 1434: ("uhci_idone: error, addr=%d, endpt=0x%02x, "
! 1435: "status 0x%s\n",
! 1436: xfer->pipe->device->address,
! 1437: xfer->pipe->endpoint->edesc->bEndpointAddress,
! 1438: sbuf));
! 1439: #endif
! 1440:
! 1441: if (status == UHCI_TD_STALLED)
! 1442: xfer->status = USBD_STALLED;
! 1443: else
! 1444: xfer->status = USBD_IOERROR; /* more info XXX */
! 1445: } else {
! 1446: xfer->status = USBD_NORMAL_COMPLETION;
! 1447: }
! 1448:
! 1449: end:
! 1450: usb_transfer_complete(xfer);
! 1451: DPRINTFN(12, ("uhci_idone: ii=%p done\n", ii));
! 1452: }
! 1453:
! 1454: /*
! 1455: * Called when a request does not complete.
! 1456: */
! 1457: void
! 1458: uhci_timeout(void *addr)
! 1459: {
! 1460: uhci_intr_info_t *ii = addr;
! 1461: struct uhci_xfer *uxfer = UXFER(ii->xfer);
! 1462: struct uhci_pipe *upipe = (struct uhci_pipe *)uxfer->xfer.pipe;
! 1463: uhci_softc_t *sc = (uhci_softc_t *)upipe->pipe.device->bus;
! 1464:
! 1465: DPRINTF(("uhci_timeout: uxfer=%p\n", uxfer));
! 1466:
! 1467: if (sc->sc_dying) {
! 1468: uhci_abort_xfer(&uxfer->xfer, USBD_TIMEOUT);
! 1469: return;
! 1470: }
! 1471:
! 1472: /* Execute the abort in a process context. */
! 1473: usb_init_task(&uxfer->abort_task, uhci_timeout_task, ii->xfer);
! 1474: usb_add_task(uxfer->xfer.pipe->device, &uxfer->abort_task);
! 1475: }
! 1476:
! 1477: void
! 1478: uhci_timeout_task(void *addr)
! 1479: {
! 1480: usbd_xfer_handle xfer = addr;
! 1481: int s;
! 1482:
! 1483: DPRINTF(("uhci_timeout_task: xfer=%p\n", xfer));
! 1484:
! 1485: s = splusb();
! 1486: uhci_abort_xfer(xfer, USBD_TIMEOUT);
! 1487: splx(s);
! 1488: }
! 1489:
! 1490: /*
! 1491: * Wait here until controller claims to have an interrupt.
! 1492: * Then call uhci_intr and return. Use timeout to avoid waiting
! 1493: * too long.
! 1494: * Only used during boot when interrupts are not enabled yet.
! 1495: */
! 1496: void
! 1497: uhci_waitintr(uhci_softc_t *sc, usbd_xfer_handle xfer)
! 1498: {
! 1499: int timo = xfer->timeout;
! 1500: uhci_intr_info_t *ii;
! 1501:
! 1502: DPRINTFN(10,("uhci_waitintr: timeout = %dms\n", timo));
! 1503:
! 1504: xfer->status = USBD_IN_PROGRESS;
! 1505: for (; timo >= 0; timo--) {
! 1506: usb_delay_ms(&sc->sc_bus, 1);
! 1507: DPRINTFN(20,("uhci_waitintr: 0x%04x\n", UREAD2(sc, UHCI_STS)));
! 1508: if (UREAD2(sc, UHCI_STS) & UHCI_STS_ALLINTRS) {
! 1509: uhci_intr1(sc);
! 1510: if (xfer->status != USBD_IN_PROGRESS)
! 1511: return;
! 1512: }
! 1513: }
! 1514:
! 1515: /* Timeout */
! 1516: DPRINTF(("uhci_waitintr: timeout\n"));
! 1517: for (ii = LIST_FIRST(&sc->sc_intrhead);
! 1518: ii != NULL && ii->xfer != xfer;
! 1519: ii = LIST_NEXT(ii, list))
! 1520: ;
! 1521: #ifdef DIAGNOSTIC
! 1522: if (ii == NULL)
! 1523: panic("uhci_waitintr: lost intr_info");
! 1524: #endif
! 1525: uhci_idone(ii);
! 1526: }
! 1527:
! 1528: void
! 1529: uhci_poll(struct usbd_bus *bus)
! 1530: {
! 1531: uhci_softc_t *sc = (uhci_softc_t *)bus;
! 1532:
! 1533: if (UREAD2(sc, UHCI_STS) & UHCI_STS_ALLINTRS)
! 1534: uhci_intr1(sc);
! 1535: }
! 1536:
! 1537: void
! 1538: uhci_reset(uhci_softc_t *sc)
! 1539: {
! 1540: int n;
! 1541:
! 1542: UHCICMD(sc, UHCI_CMD_HCRESET);
! 1543: /* The reset bit goes low when the controller is done. */
! 1544: for (n = 0; n < UHCI_RESET_TIMEOUT &&
! 1545: (UREAD2(sc, UHCI_CMD) & UHCI_CMD_HCRESET); n++)
! 1546: usb_delay_ms(&sc->sc_bus, 1);
! 1547: if (n >= UHCI_RESET_TIMEOUT)
! 1548: printf("%s: controller did not reset\n",
! 1549: sc->sc_bus.bdev.dv_xname);
! 1550: }
! 1551:
! 1552: usbd_status
! 1553: uhci_run(uhci_softc_t *sc, int run)
! 1554: {
! 1555: int s, n, running;
! 1556: u_int16_t cmd;
! 1557:
! 1558: run = run != 0;
! 1559: s = splhardusb();
! 1560: DPRINTF(("uhci_run: setting run=%d\n", run));
! 1561: cmd = UREAD2(sc, UHCI_CMD);
! 1562: if (run)
! 1563: cmd |= UHCI_CMD_RS;
! 1564: else
! 1565: cmd &= ~UHCI_CMD_RS;
! 1566: UHCICMD(sc, cmd);
! 1567: for(n = 0; n < 10; n++) {
! 1568: running = !(UREAD2(sc, UHCI_STS) & UHCI_STS_HCH);
! 1569: /* return when we've entered the state we want */
! 1570: if (run == running) {
! 1571: splx(s);
! 1572: DPRINTF(("uhci_run: done cmd=0x%x sts=0x%x\n",
! 1573: UREAD2(sc, UHCI_CMD), UREAD2(sc, UHCI_STS)));
! 1574: return (USBD_NORMAL_COMPLETION);
! 1575: }
! 1576: usb_delay_ms(&sc->sc_bus, 1);
! 1577: }
! 1578: splx(s);
! 1579: printf("%s: cannot %s\n", sc->sc_bus.bdev.dv_xname,
! 1580: run ? "start" : "stop");
! 1581: return (USBD_IOERROR);
! 1582: }
! 1583:
! 1584: /*
! 1585: * Memory management routines.
! 1586: * uhci_alloc_std allocates TDs
! 1587: * uhci_alloc_sqh allocates QHs
! 1588: * These two routines do their own free list management,
! 1589: * partly for speed, partly because allocating DMAable memory
! 1590: * has page size granularaity so much memory would be wasted if
! 1591: * only one TD/QH (32 bytes) was placed in each allocated chunk.
! 1592: */
! 1593:
! 1594: uhci_soft_td_t *
! 1595: uhci_alloc_std(uhci_softc_t *sc)
! 1596: {
! 1597: uhci_soft_td_t *std;
! 1598: usbd_status err;
! 1599: int i, offs;
! 1600: usb_dma_t dma;
! 1601:
! 1602: if (sc->sc_freetds == NULL) {
! 1603: DPRINTFN(2,("uhci_alloc_std: allocating chunk\n"));
! 1604: err = usb_allocmem(&sc->sc_bus, UHCI_STD_SIZE * UHCI_STD_CHUNK,
! 1605: UHCI_TD_ALIGN, &dma);
! 1606: if (err)
! 1607: return (0);
! 1608: for(i = 0; i < UHCI_STD_CHUNK; i++) {
! 1609: offs = i * UHCI_STD_SIZE;
! 1610: std = KERNADDR(&dma, offs);
! 1611: std->physaddr = DMAADDR(&dma, offs);
! 1612: std->link.std = sc->sc_freetds;
! 1613: sc->sc_freetds = std;
! 1614: }
! 1615: }
! 1616: std = sc->sc_freetds;
! 1617: sc->sc_freetds = std->link.std;
! 1618: memset(&std->td, 0, sizeof(uhci_td_t));
! 1619: return std;
! 1620: }
! 1621:
! 1622: void
! 1623: uhci_free_std(uhci_softc_t *sc, uhci_soft_td_t *std)
! 1624: {
! 1625: #ifdef DIAGNOSTIC
! 1626: #define TD_IS_FREE 0x12345678
! 1627: if (letoh32(std->td.td_token) == TD_IS_FREE) {
! 1628: printf("uhci_free_std: freeing free TD %p\n", std);
! 1629: return;
! 1630: }
! 1631: std->td.td_token = htole32(TD_IS_FREE);
! 1632: #endif
! 1633: std->link.std = sc->sc_freetds;
! 1634: sc->sc_freetds = std;
! 1635: }
! 1636:
! 1637: uhci_soft_qh_t *
! 1638: uhci_alloc_sqh(uhci_softc_t *sc)
! 1639: {
! 1640: uhci_soft_qh_t *sqh;
! 1641: usbd_status err;
! 1642: int i, offs;
! 1643: usb_dma_t dma;
! 1644:
! 1645: if (sc->sc_freeqhs == NULL) {
! 1646: DPRINTFN(2, ("uhci_alloc_sqh: allocating chunk\n"));
! 1647: err = usb_allocmem(&sc->sc_bus, UHCI_SQH_SIZE * UHCI_SQH_CHUNK,
! 1648: UHCI_QH_ALIGN, &dma);
! 1649: if (err)
! 1650: return (0);
! 1651: for(i = 0; i < UHCI_SQH_CHUNK; i++) {
! 1652: offs = i * UHCI_SQH_SIZE;
! 1653: sqh = KERNADDR(&dma, offs);
! 1654: sqh->physaddr = DMAADDR(&dma, offs);
! 1655: sqh->hlink = sc->sc_freeqhs;
! 1656: sc->sc_freeqhs = sqh;
! 1657: }
! 1658: }
! 1659: sqh = sc->sc_freeqhs;
! 1660: sc->sc_freeqhs = sqh->hlink;
! 1661: memset(&sqh->qh, 0, sizeof(uhci_qh_t));
! 1662: return (sqh);
! 1663: }
! 1664:
! 1665: void
! 1666: uhci_free_sqh(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 1667: {
! 1668: sqh->hlink = sc->sc_freeqhs;
! 1669: sc->sc_freeqhs = sqh;
! 1670: }
! 1671:
! 1672: void
! 1673: uhci_free_std_chain(uhci_softc_t *sc, uhci_soft_td_t *std,
! 1674: uhci_soft_td_t *stdend)
! 1675: {
! 1676: uhci_soft_td_t *p;
! 1677:
! 1678: for (; std != stdend; std = p) {
! 1679: p = std->link.std;
! 1680: uhci_free_std(sc, std);
! 1681: }
! 1682: }
! 1683:
! 1684: usbd_status
! 1685: uhci_alloc_std_chain(struct uhci_pipe *upipe, uhci_softc_t *sc, int len,
! 1686: int rd, u_int16_t flags, usb_dma_t *dma,
! 1687: uhci_soft_td_t **sp, uhci_soft_td_t **ep)
! 1688: {
! 1689: uhci_soft_td_t *p, *lastp;
! 1690: uhci_physaddr_t lastlink;
! 1691: int i, ntd, l, tog, maxp;
! 1692: u_int32_t status;
! 1693: int addr = upipe->pipe.device->address;
! 1694: int endpt = upipe->pipe.endpoint->edesc->bEndpointAddress;
! 1695:
! 1696: DPRINTFN(8, ("uhci_alloc_std_chain: addr=%d endpt=%d len=%d speed=%d "
! 1697: "flags=0x%x\n", addr, UE_GET_ADDR(endpt), len,
! 1698: upipe->pipe.device->speed, flags));
! 1699: maxp = UGETW(upipe->pipe.endpoint->edesc->wMaxPacketSize);
! 1700: if (maxp == 0) {
! 1701: printf("uhci_alloc_std_chain: maxp=0\n");
! 1702: return (USBD_INVAL);
! 1703: }
! 1704: ntd = (len + maxp - 1) / maxp;
! 1705: if ((flags & USBD_FORCE_SHORT_XFER) && len % maxp == 0)
! 1706: ntd++;
! 1707: DPRINTFN(10, ("uhci_alloc_std_chain: maxp=%d ntd=%d\n", maxp, ntd));
! 1708: if (ntd == 0) {
! 1709: *sp = *ep = 0;
! 1710: DPRINTFN(-1,("uhci_alloc_std_chain: ntd=0\n"));
! 1711: return (USBD_NORMAL_COMPLETION);
! 1712: }
! 1713: tog = upipe->nexttoggle;
! 1714: if (ntd % 2 == 0)
! 1715: tog ^= 1;
! 1716: upipe->nexttoggle = tog ^ 1;
! 1717: lastp = NULL;
! 1718: lastlink = UHCI_PTR_T;
! 1719: ntd--;
! 1720: status = UHCI_TD_ZERO_ACTLEN(UHCI_TD_SET_ERRCNT(3) | UHCI_TD_ACTIVE);
! 1721: if (upipe->pipe.device->speed == USB_SPEED_LOW)
! 1722: status |= UHCI_TD_LS;
! 1723: if (flags & USBD_SHORT_XFER_OK)
! 1724: status |= UHCI_TD_SPD;
! 1725: for (i = ntd; i >= 0; i--) {
! 1726: p = uhci_alloc_std(sc);
! 1727: if (p == NULL) {
! 1728: uhci_free_std_chain(sc, lastp, NULL);
! 1729: return (USBD_NOMEM);
! 1730: }
! 1731: p->link.std = lastp;
! 1732: p->td.td_link = htole32(lastlink | UHCI_PTR_VF | UHCI_PTR_TD);
! 1733: lastp = p;
! 1734: lastlink = p->physaddr;
! 1735: p->td.td_status = htole32(status);
! 1736: if (i == ntd) {
! 1737: /* last TD */
! 1738: l = len % maxp;
! 1739: if (l == 0 && !(flags & USBD_FORCE_SHORT_XFER))
! 1740: l = maxp;
! 1741: *ep = p;
! 1742: } else
! 1743: l = maxp;
! 1744: p->td.td_token =
! 1745: htole32(rd ? UHCI_TD_IN (l, endpt, addr, tog) :
! 1746: UHCI_TD_OUT(l, endpt, addr, tog));
! 1747: p->td.td_buffer = htole32(DMAADDR(dma, i * maxp));
! 1748: tog ^= 1;
! 1749: }
! 1750: *sp = lastp;
! 1751: DPRINTFN(10, ("uhci_alloc_std_chain: nexttog=%d\n",
! 1752: upipe->nexttoggle));
! 1753: return (USBD_NORMAL_COMPLETION);
! 1754: }
! 1755:
! 1756: void
! 1757: uhci_device_clear_toggle(usbd_pipe_handle pipe)
! 1758: {
! 1759: struct uhci_pipe *upipe = (struct uhci_pipe *)pipe;
! 1760: upipe->nexttoggle = 0;
! 1761: }
! 1762:
! 1763: void
! 1764: uhci_noop(usbd_pipe_handle pipe)
! 1765: {
! 1766: }
! 1767:
! 1768: usbd_status
! 1769: uhci_device_bulk_transfer(usbd_xfer_handle xfer)
! 1770: {
! 1771: usbd_status err;
! 1772:
! 1773: /* Insert last in queue. */
! 1774: err = usb_insert_transfer(xfer);
! 1775: if (err)
! 1776: return (err);
! 1777:
! 1778: /*
! 1779: * Pipe isn't running (otherwise err would be USBD_INPROG),
! 1780: * so start it first.
! 1781: */
! 1782: return (uhci_device_bulk_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
! 1783: }
! 1784:
! 1785: usbd_status
! 1786: uhci_device_bulk_start(usbd_xfer_handle xfer)
! 1787: {
! 1788: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 1789: usbd_device_handle dev = upipe->pipe.device;
! 1790: uhci_softc_t *sc = (uhci_softc_t *)dev->bus;
! 1791: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 1792: uhci_soft_td_t *data, *dataend;
! 1793: uhci_soft_qh_t *sqh;
! 1794: usbd_status err;
! 1795: int len, isread, endpt;
! 1796: int s;
! 1797:
! 1798: DPRINTFN(3, ("uhci_device_bulk_start: xfer=%p len=%d flags=%d ii=%p\n",
! 1799: xfer, xfer->length, xfer->flags, ii));
! 1800:
! 1801: if (sc->sc_dying)
! 1802: return (USBD_IOERROR);
! 1803:
! 1804: #ifdef DIAGNOSTIC
! 1805: if (xfer->rqflags & URQ_REQUEST)
! 1806: panic("uhci_device_bulk_transfer: a request");
! 1807: #endif
! 1808:
! 1809: len = xfer->length;
! 1810: endpt = upipe->pipe.endpoint->edesc->bEndpointAddress;
! 1811: isread = UE_GET_DIR(endpt) == UE_DIR_IN;
! 1812: sqh = upipe->u.bulk.sqh;
! 1813:
! 1814: upipe->u.bulk.isread = isread;
! 1815: upipe->u.bulk.length = len;
! 1816:
! 1817: err = uhci_alloc_std_chain(upipe, sc, len, isread, xfer->flags,
! 1818: &xfer->dmabuf, &data, &dataend);
! 1819: if (err)
! 1820: return (err);
! 1821: dataend->td.td_status |= htole32(UHCI_TD_IOC);
! 1822:
! 1823: #ifdef UHCI_DEBUG
! 1824: if (uhcidebug > 8) {
! 1825: DPRINTF(("uhci_device_bulk_transfer: data(1)\n"));
! 1826: uhci_dump_tds(data);
! 1827: }
! 1828: #endif
! 1829:
! 1830: /* Set up interrupt info. */
! 1831: ii->xfer = xfer;
! 1832: ii->stdstart = data;
! 1833: ii->stdend = dataend;
! 1834: #ifdef DIAGNOSTIC
! 1835: if (!ii->isdone) {
! 1836: printf("uhci_device_bulk_transfer: not done, ii=%p\n", ii);
! 1837: }
! 1838: ii->isdone = 0;
! 1839: #endif
! 1840:
! 1841: sqh->elink = data;
! 1842: sqh->qh.qh_elink = htole32(data->physaddr | UHCI_PTR_TD);
! 1843:
! 1844: s = splusb();
! 1845: uhci_add_bulk(sc, sqh);
! 1846: uhci_add_intr_info(sc, ii);
! 1847:
! 1848: if (xfer->timeout && !sc->sc_bus.use_polling) {
! 1849: timeout_del(&xfer->timeout_handle);
! 1850: timeout_set(&xfer->timeout_handle, uhci_timeout, ii);
! 1851: timeout_add(&xfer->timeout_handle, mstohz(xfer->timeout));
! 1852: }
! 1853: xfer->status = USBD_IN_PROGRESS;
! 1854: splx(s);
! 1855:
! 1856: #ifdef UHCI_DEBUG
! 1857: if (uhcidebug > 10) {
! 1858: DPRINTF(("uhci_device_bulk_transfer: data(2)\n"));
! 1859: uhci_dump_tds(data);
! 1860: }
! 1861: #endif
! 1862:
! 1863: if (sc->sc_bus.use_polling)
! 1864: uhci_waitintr(sc, xfer);
! 1865:
! 1866: return (USBD_IN_PROGRESS);
! 1867: }
! 1868:
! 1869: /* Abort a device bulk request. */
! 1870: void
! 1871: uhci_device_bulk_abort(usbd_xfer_handle xfer)
! 1872: {
! 1873: DPRINTF(("uhci_device_bulk_abort:\n"));
! 1874: uhci_abort_xfer(xfer, USBD_CANCELLED);
! 1875: }
! 1876:
! 1877: /*
! 1878: * Abort a device request.
! 1879: * If this routine is called at splusb() it guarantees that the request
! 1880: * will be removed from the hardware scheduling and that the callback
! 1881: * for it will be called with USBD_CANCELLED status.
! 1882: * It's impossible to guarantee that the requested transfer will not
! 1883: * have happened since the hardware runs concurrently.
! 1884: * If the transaction has already happened we rely on the ordinary
! 1885: * interrupt processing to process it.
! 1886: */
! 1887: void
! 1888: uhci_abort_xfer(usbd_xfer_handle xfer, usbd_status status)
! 1889: {
! 1890: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 1891: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 1892: uhci_softc_t *sc = (uhci_softc_t *)upipe->pipe.device->bus;
! 1893: uhci_soft_td_t *std;
! 1894: int s;
! 1895:
! 1896: DPRINTFN(1,("uhci_abort_xfer: xfer=%p, status=%d\n", xfer, status));
! 1897:
! 1898: if (sc->sc_dying) {
! 1899: /* If we're dying, just do the software part. */
! 1900: s = splusb();
! 1901: xfer->status = status; /* make software ignore it */
! 1902: timeout_del(&xfer->timeout_handle);
! 1903: usb_transfer_complete(xfer);
! 1904: splx(s);
! 1905: return;
! 1906: }
! 1907:
! 1908: if (xfer->device->bus->intr_context || !curproc)
! 1909: panic("uhci_abort_xfer: not in process context");
! 1910:
! 1911: /*
! 1912: * Step 1: Make interrupt routine and hardware ignore xfer.
! 1913: */
! 1914: s = splusb();
! 1915: xfer->status = status; /* make software ignore it */
! 1916: timeout_del(&xfer->timeout_handle);
! 1917: DPRINTFN(1,("uhci_abort_xfer: stop ii=%p\n", ii));
! 1918: for (std = ii->stdstart; std != NULL; std = std->link.std)
! 1919: std->td.td_status &= htole32(~(UHCI_TD_ACTIVE | UHCI_TD_IOC));
! 1920: splx(s);
! 1921:
! 1922: /*
! 1923: * Step 2: Wait until we know hardware has finished any possible
! 1924: * use of the xfer. Also make sure the soft interrupt routine
! 1925: * has run.
! 1926: */
! 1927: usb_delay_ms(upipe->pipe.device->bus, 2); /* Hardware finishes in 1ms */
! 1928: s = splusb();
! 1929: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 1930: sc->sc_softwake = 1;
! 1931: #endif /* __HAVE_GENERIC_SOFT_INTERRUPTS */
! 1932: usb_schedsoftintr(&sc->sc_bus);
! 1933: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 1934: DPRINTFN(1,("uhci_abort_xfer: tsleep\n"));
! 1935: tsleep(&sc->sc_softwake, PZERO, "uhciab", 0);
! 1936: #endif /* __HAVE_GENERIC_SOFT_INTERRUPTS */
! 1937: splx(s);
! 1938:
! 1939: /*
! 1940: * Step 3: Execute callback.
! 1941: */
! 1942: DPRINTFN(1,("uhci_abort_xfer: callback\n"));
! 1943: s = splusb();
! 1944: #ifdef DIAGNOSTIC
! 1945: ii->isdone = 1;
! 1946: #endif
! 1947: usb_transfer_complete(xfer);
! 1948: splx(s);
! 1949: }
! 1950:
! 1951: /* Close a device bulk pipe. */
! 1952: void
! 1953: uhci_device_bulk_close(usbd_pipe_handle pipe)
! 1954: {
! 1955: struct uhci_pipe *upipe = (struct uhci_pipe *)pipe;
! 1956: usbd_device_handle dev = upipe->pipe.device;
! 1957: uhci_softc_t *sc = (uhci_softc_t *)dev->bus;
! 1958:
! 1959: uhci_free_sqh(sc, upipe->u.bulk.sqh);
! 1960: pipe->endpoint->savedtoggle = upipe->nexttoggle;
! 1961: }
! 1962:
! 1963: usbd_status
! 1964: uhci_device_ctrl_transfer(usbd_xfer_handle xfer)
! 1965: {
! 1966: usbd_status err;
! 1967:
! 1968: /* Insert last in queue. */
! 1969: err = usb_insert_transfer(xfer);
! 1970: if (err)
! 1971: return (err);
! 1972:
! 1973: /*
! 1974: * Pipe isn't running (otherwise err would be USBD_INPROG),
! 1975: * so start it first.
! 1976: */
! 1977: return (uhci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
! 1978: }
! 1979:
! 1980: usbd_status
! 1981: uhci_device_ctrl_start(usbd_xfer_handle xfer)
! 1982: {
! 1983: uhci_softc_t *sc = (uhci_softc_t *)xfer->pipe->device->bus;
! 1984: usbd_status err;
! 1985:
! 1986: if (sc->sc_dying)
! 1987: return (USBD_IOERROR);
! 1988:
! 1989: #ifdef DIAGNOSTIC
! 1990: if (!(xfer->rqflags & URQ_REQUEST))
! 1991: panic("uhci_device_ctrl_transfer: not a request");
! 1992: #endif
! 1993:
! 1994: err = uhci_device_request(xfer);
! 1995: if (err)
! 1996: return (err);
! 1997:
! 1998: if (sc->sc_bus.use_polling)
! 1999: uhci_waitintr(sc, xfer);
! 2000: return (USBD_IN_PROGRESS);
! 2001: }
! 2002:
! 2003: usbd_status
! 2004: uhci_device_intr_transfer(usbd_xfer_handle xfer)
! 2005: {
! 2006: usbd_status err;
! 2007:
! 2008: /* Insert last in queue. */
! 2009: err = usb_insert_transfer(xfer);
! 2010: if (err)
! 2011: return (err);
! 2012:
! 2013: /*
! 2014: * Pipe isn't running (otherwise err would be USBD_INPROG),
! 2015: * so start it first.
! 2016: */
! 2017: return (uhci_device_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
! 2018: }
! 2019:
! 2020: usbd_status
! 2021: uhci_device_intr_start(usbd_xfer_handle xfer)
! 2022: {
! 2023: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2024: usbd_device_handle dev = upipe->pipe.device;
! 2025: uhci_softc_t *sc = (uhci_softc_t *)dev->bus;
! 2026: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 2027: uhci_soft_td_t *data, *dataend;
! 2028: uhci_soft_qh_t *sqh;
! 2029: usbd_status err;
! 2030: int isread, endpt;
! 2031: int i, s;
! 2032:
! 2033: if (sc->sc_dying)
! 2034: return (USBD_IOERROR);
! 2035:
! 2036: DPRINTFN(3,("uhci_device_intr_transfer: xfer=%p len=%d flags=%d\n",
! 2037: xfer, xfer->length, xfer->flags));
! 2038:
! 2039: #ifdef DIAGNOSTIC
! 2040: if (xfer->rqflags & URQ_REQUEST)
! 2041: panic("uhci_device_intr_transfer: a request");
! 2042: #endif
! 2043:
! 2044: endpt = upipe->pipe.endpoint->edesc->bEndpointAddress;
! 2045: isread = UE_GET_DIR(endpt) == UE_DIR_IN;
! 2046:
! 2047: upipe->u.intr.isread = isread;
! 2048:
! 2049: err = uhci_alloc_std_chain(upipe, sc, xfer->length, isread,
! 2050: xfer->flags, &xfer->dmabuf, &data,
! 2051: &dataend);
! 2052:
! 2053: if (err)
! 2054: return (err);
! 2055: dataend->td.td_status |= htole32(UHCI_TD_IOC);
! 2056:
! 2057: #ifdef UHCI_DEBUG
! 2058: if (uhcidebug > 10) {
! 2059: DPRINTF(("uhci_device_intr_transfer: data(1)\n"));
! 2060: uhci_dump_tds(data);
! 2061: uhci_dump_qh(upipe->u.intr.qhs[0]);
! 2062: }
! 2063: #endif
! 2064:
! 2065: s = splusb();
! 2066: /* Set up interrupt info. */
! 2067: ii->xfer = xfer;
! 2068: ii->stdstart = data;
! 2069: ii->stdend = dataend;
! 2070: #ifdef DIAGNOSTIC
! 2071: if (!ii->isdone) {
! 2072: printf("uhci_device_intr_transfer: not done, ii=%p\n", ii);
! 2073: }
! 2074: ii->isdone = 0;
! 2075: #endif
! 2076:
! 2077: DPRINTFN(10,("uhci_device_intr_transfer: qhs[0]=%p\n",
! 2078: upipe->u.intr.qhs[0]));
! 2079: for (i = 0; i < upipe->u.intr.npoll; i++) {
! 2080: sqh = upipe->u.intr.qhs[i];
! 2081: sqh->elink = data;
! 2082: sqh->qh.qh_elink = htole32(data->physaddr | UHCI_PTR_TD);
! 2083: }
! 2084: uhci_add_intr_info(sc, ii);
! 2085: xfer->status = USBD_IN_PROGRESS;
! 2086: splx(s);
! 2087:
! 2088: #ifdef UHCI_DEBUG
! 2089: if (uhcidebug > 10) {
! 2090: DPRINTF(("uhci_device_intr_transfer: data(2)\n"));
! 2091: uhci_dump_tds(data);
! 2092: uhci_dump_qh(upipe->u.intr.qhs[0]);
! 2093: }
! 2094: #endif
! 2095:
! 2096: return (USBD_IN_PROGRESS);
! 2097: }
! 2098:
! 2099: /* Abort a device control request. */
! 2100: void
! 2101: uhci_device_ctrl_abort(usbd_xfer_handle xfer)
! 2102: {
! 2103: DPRINTF(("uhci_device_ctrl_abort:\n"));
! 2104: uhci_abort_xfer(xfer, USBD_CANCELLED);
! 2105: }
! 2106:
! 2107: /* Close a device control pipe. */
! 2108: void
! 2109: uhci_device_ctrl_close(usbd_pipe_handle pipe)
! 2110: {
! 2111: }
! 2112:
! 2113: /* Abort a device interrupt request. */
! 2114: void
! 2115: uhci_device_intr_abort(usbd_xfer_handle xfer)
! 2116: {
! 2117: DPRINTFN(1,("uhci_device_intr_abort: xfer=%p\n", xfer));
! 2118: if (xfer->pipe->intrxfer == xfer) {
! 2119: DPRINTFN(1,("uhci_device_intr_abort: remove\n"));
! 2120: xfer->pipe->intrxfer = NULL;
! 2121: }
! 2122: uhci_abort_xfer(xfer, USBD_CANCELLED);
! 2123: }
! 2124:
! 2125: /* Close a device interrupt pipe. */
! 2126: void
! 2127: uhci_device_intr_close(usbd_pipe_handle pipe)
! 2128: {
! 2129: struct uhci_pipe *upipe = (struct uhci_pipe *)pipe;
! 2130: uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus;
! 2131: int i, npoll;
! 2132: int s;
! 2133:
! 2134: /* Unlink descriptors from controller data structures. */
! 2135: npoll = upipe->u.intr.npoll;
! 2136: s = splusb();
! 2137: for (i = 0; i < npoll; i++)
! 2138: uhci_remove_intr(sc, upipe->u.intr.qhs[i]);
! 2139: splx(s);
! 2140:
! 2141: /*
! 2142: * We now have to wait for any activity on the physical
! 2143: * descriptors to stop.
! 2144: */
! 2145: usb_delay_ms(&sc->sc_bus, 2);
! 2146:
! 2147: for(i = 0; i < npoll; i++)
! 2148: uhci_free_sqh(sc, upipe->u.intr.qhs[i]);
! 2149: free(upipe->u.intr.qhs, M_USBHC);
! 2150:
! 2151: /* XXX free other resources */
! 2152: }
! 2153:
! 2154: usbd_status
! 2155: uhci_device_request(usbd_xfer_handle xfer)
! 2156: {
! 2157: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2158: usb_device_request_t *req = &xfer->request;
! 2159: usbd_device_handle dev = upipe->pipe.device;
! 2160: uhci_softc_t *sc = (uhci_softc_t *)dev->bus;
! 2161: int addr = dev->address;
! 2162: int endpt = upipe->pipe.endpoint->edesc->bEndpointAddress;
! 2163: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 2164: uhci_soft_td_t *setup, *data, *stat, *next, *dataend;
! 2165: uhci_soft_qh_t *sqh;
! 2166: int len;
! 2167: u_int32_t ls;
! 2168: usbd_status err;
! 2169: int isread;
! 2170: int s;
! 2171:
! 2172: DPRINTFN(3,("uhci_device_control type=0x%02x, request=0x%02x, "
! 2173: "wValue=0x%04x, wIndex=0x%04x len=%d, addr=%d, endpt=%d\n",
! 2174: req->bmRequestType, req->bRequest, UGETW(req->wValue),
! 2175: UGETW(req->wIndex), UGETW(req->wLength),
! 2176: addr, endpt));
! 2177:
! 2178: ls = dev->speed == USB_SPEED_LOW ? UHCI_TD_LS : 0;
! 2179: isread = req->bmRequestType & UT_READ;
! 2180: len = UGETW(req->wLength);
! 2181:
! 2182: setup = upipe->u.ctl.setup;
! 2183: stat = upipe->u.ctl.stat;
! 2184: sqh = upipe->u.ctl.sqh;
! 2185:
! 2186: /* Set up data transaction */
! 2187: if (len != 0) {
! 2188: upipe->nexttoggle = 1;
! 2189: err = uhci_alloc_std_chain(upipe, sc, len, isread, xfer->flags,
! 2190: &xfer->dmabuf, &data, &dataend);
! 2191: if (err)
! 2192: return (err);
! 2193: next = data;
! 2194: dataend->link.std = stat;
! 2195: dataend->td.td_link = htole32(stat->physaddr | UHCI_PTR_VF | UHCI_PTR_TD);
! 2196: } else {
! 2197: next = stat;
! 2198: }
! 2199: upipe->u.ctl.length = len;
! 2200:
! 2201: memcpy(KERNADDR(&upipe->u.ctl.reqdma, 0), req, sizeof *req);
! 2202:
! 2203: setup->link.std = next;
! 2204: setup->td.td_link = htole32(next->physaddr | UHCI_PTR_VF | UHCI_PTR_TD);
! 2205: setup->td.td_status = htole32(UHCI_TD_SET_ERRCNT(3) | ls |
! 2206: UHCI_TD_ACTIVE);
! 2207: setup->td.td_token = htole32(UHCI_TD_SETUP(sizeof *req, endpt, addr));
! 2208: setup->td.td_buffer = htole32(DMAADDR(&upipe->u.ctl.reqdma, 0));
! 2209:
! 2210: stat->link.std = NULL;
! 2211: stat->td.td_link = htole32(UHCI_PTR_T);
! 2212: stat->td.td_status = htole32(UHCI_TD_SET_ERRCNT(3) | ls |
! 2213: UHCI_TD_ACTIVE | UHCI_TD_IOC);
! 2214: stat->td.td_token =
! 2215: htole32(isread ? UHCI_TD_OUT(0, endpt, addr, 1) :
! 2216: UHCI_TD_IN (0, endpt, addr, 1));
! 2217: stat->td.td_buffer = htole32(0);
! 2218:
! 2219: #ifdef UHCI_DEBUG
! 2220: if (uhcidebug > 10) {
! 2221: DPRINTF(("uhci_device_request: before transfer\n"));
! 2222: uhci_dump_tds(setup);
! 2223: }
! 2224: #endif
! 2225:
! 2226: /* Set up interrupt info. */
! 2227: ii->xfer = xfer;
! 2228: ii->stdstart = setup;
! 2229: ii->stdend = stat;
! 2230: #ifdef DIAGNOSTIC
! 2231: if (!ii->isdone) {
! 2232: printf("uhci_device_request: not done, ii=%p\n", ii);
! 2233: }
! 2234: ii->isdone = 0;
! 2235: #endif
! 2236:
! 2237: sqh->elink = setup;
! 2238: sqh->qh.qh_elink = htole32(setup->physaddr | UHCI_PTR_TD);
! 2239:
! 2240: s = splusb();
! 2241: if (dev->speed == USB_SPEED_LOW)
! 2242: uhci_add_ls_ctrl(sc, sqh);
! 2243: else
! 2244: uhci_add_hs_ctrl(sc, sqh);
! 2245: uhci_add_intr_info(sc, ii);
! 2246: #ifdef UHCI_DEBUG
! 2247: if (uhcidebug > 12) {
! 2248: uhci_soft_td_t *std;
! 2249: uhci_soft_qh_t *xqh;
! 2250: uhci_soft_qh_t *sxqh;
! 2251: int maxqh = 0;
! 2252: uhci_physaddr_t link;
! 2253: DPRINTF(("uhci_enter_ctl_q: follow from [0]\n"));
! 2254: for (std = sc->sc_vframes[0].htd, link = 0;
! 2255: (link & UHCI_PTR_QH) == 0;
! 2256: std = std->link.std) {
! 2257: link = letoh32(std->td.td_link);
! 2258: uhci_dump_td(std);
! 2259: }
! 2260: sxqh = (uhci_soft_qh_t *)std;
! 2261: uhci_dump_qh(sxqh);
! 2262: for (xqh = sxqh;
! 2263: xqh != NULL;
! 2264: xqh = (maxqh++ == 5 || xqh->hlink == sxqh ||
! 2265: xqh->hlink == xqh ? NULL : xqh->hlink)) {
! 2266: uhci_dump_qh(xqh);
! 2267: }
! 2268: DPRINTF(("Enqueued QH:\n"));
! 2269: uhci_dump_qh(sqh);
! 2270: uhci_dump_tds(sqh->elink);
! 2271: }
! 2272: #endif
! 2273: if (xfer->timeout && !sc->sc_bus.use_polling) {
! 2274: timeout_del(&xfer->timeout_handle);
! 2275: timeout_set(&xfer->timeout_handle, uhci_timeout, ii);
! 2276: timeout_add(&xfer->timeout_handle, mstohz(xfer->timeout));
! 2277: }
! 2278: xfer->status = USBD_IN_PROGRESS;
! 2279: splx(s);
! 2280:
! 2281: return (USBD_NORMAL_COMPLETION);
! 2282: }
! 2283:
! 2284: usbd_status
! 2285: uhci_device_isoc_transfer(usbd_xfer_handle xfer)
! 2286: {
! 2287: usbd_status err;
! 2288:
! 2289: DPRINTFN(5,("uhci_device_isoc_transfer: xfer=%p\n", xfer));
! 2290:
! 2291: /* Put it on our queue, */
! 2292: err = usb_insert_transfer(xfer);
! 2293:
! 2294: /* bail out on error, */
! 2295: if (err && err != USBD_IN_PROGRESS)
! 2296: return (err);
! 2297:
! 2298: /* XXX should check inuse here */
! 2299:
! 2300: /* insert into schedule, */
! 2301: uhci_device_isoc_enter(xfer);
! 2302:
! 2303: /* and start if the pipe wasn't running */
! 2304: if (!err)
! 2305: uhci_device_isoc_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
! 2306:
! 2307: return (err);
! 2308: }
! 2309:
! 2310: void
! 2311: uhci_device_isoc_enter(usbd_xfer_handle xfer)
! 2312: {
! 2313: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2314: usbd_device_handle dev = upipe->pipe.device;
! 2315: uhci_softc_t *sc = (uhci_softc_t *)dev->bus;
! 2316: struct iso *iso = &upipe->u.iso;
! 2317: uhci_soft_td_t *std;
! 2318: u_int32_t buf, len, status;
! 2319: int s, i, next, nframes;
! 2320:
! 2321: DPRINTFN(5,("uhci_device_isoc_enter: used=%d next=%d xfer=%p "
! 2322: "nframes=%d\n",
! 2323: iso->inuse, iso->next, xfer, xfer->nframes));
! 2324:
! 2325: if (sc->sc_dying)
! 2326: return;
! 2327:
! 2328: if (xfer->status == USBD_IN_PROGRESS) {
! 2329: /* This request has already been entered into the frame list */
! 2330: printf("uhci_device_isoc_enter: xfer=%p in frame list\n", xfer);
! 2331: /* XXX */
! 2332: }
! 2333:
! 2334: #ifdef DIAGNOSTIC
! 2335: if (iso->inuse >= UHCI_VFRAMELIST_COUNT)
! 2336: printf("uhci_device_isoc_enter: overflow!\n");
! 2337: #endif
! 2338:
! 2339: next = iso->next;
! 2340: if (next == -1) {
! 2341: /* Not in use yet, schedule it a few frames ahead. */
! 2342: next = (UREAD2(sc, UHCI_FRNUM) + 3) % UHCI_VFRAMELIST_COUNT;
! 2343: DPRINTFN(2,("uhci_device_isoc_enter: start next=%d\n", next));
! 2344: }
! 2345:
! 2346: xfer->status = USBD_IN_PROGRESS;
! 2347: UXFER(xfer)->curframe = next;
! 2348:
! 2349: buf = DMAADDR(&xfer->dmabuf, 0);
! 2350: status = UHCI_TD_ZERO_ACTLEN(UHCI_TD_SET_ERRCNT(0) |
! 2351: UHCI_TD_ACTIVE |
! 2352: UHCI_TD_IOS);
! 2353: nframes = xfer->nframes;
! 2354: s = splusb();
! 2355: for (i = 0; i < nframes; i++) {
! 2356: std = iso->stds[next];
! 2357: if (++next >= UHCI_VFRAMELIST_COUNT)
! 2358: next = 0;
! 2359: len = xfer->frlengths[i];
! 2360: std->td.td_buffer = htole32(buf);
! 2361: if (i == nframes - 1)
! 2362: status |= UHCI_TD_IOC;
! 2363: std->td.td_status = htole32(status);
! 2364: std->td.td_token &= htole32(~UHCI_TD_MAXLEN_MASK);
! 2365: std->td.td_token |= htole32(UHCI_TD_SET_MAXLEN(len));
! 2366: #ifdef UHCI_DEBUG
! 2367: if (uhcidebug > 5) {
! 2368: DPRINTFN(5,("uhci_device_isoc_enter: TD %d\n", i));
! 2369: uhci_dump_td(std);
! 2370: }
! 2371: #endif
! 2372: buf += len;
! 2373: }
! 2374: iso->next = next;
! 2375: iso->inuse += xfer->nframes;
! 2376:
! 2377: splx(s);
! 2378: }
! 2379:
! 2380: usbd_status
! 2381: uhci_device_isoc_start(usbd_xfer_handle xfer)
! 2382: {
! 2383: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2384: uhci_softc_t *sc = (uhci_softc_t *)upipe->pipe.device->bus;
! 2385: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 2386: uhci_soft_td_t *end;
! 2387: int s, i;
! 2388:
! 2389: DPRINTFN(5,("uhci_device_isoc_start: xfer=%p\n", xfer));
! 2390:
! 2391: if (sc->sc_dying)
! 2392: return (USBD_IOERROR);
! 2393:
! 2394: #ifdef DIAGNOSTIC
! 2395: if (xfer->status != USBD_IN_PROGRESS)
! 2396: printf("uhci_device_isoc_start: not in progress %p\n", xfer);
! 2397: #endif
! 2398:
! 2399: /* Find the last TD */
! 2400: i = UXFER(xfer)->curframe + xfer->nframes;
! 2401: if (i >= UHCI_VFRAMELIST_COUNT)
! 2402: i -= UHCI_VFRAMELIST_COUNT;
! 2403: end = upipe->u.iso.stds[i];
! 2404:
! 2405: #ifdef DIAGNOSTIC
! 2406: if (end == NULL) {
! 2407: printf("uhci_device_isoc_start: end == NULL\n");
! 2408: return (USBD_INVAL);
! 2409: }
! 2410: #endif
! 2411:
! 2412: s = splusb();
! 2413:
! 2414: /* Set up interrupt info. */
! 2415: ii->xfer = xfer;
! 2416: ii->stdstart = end;
! 2417: ii->stdend = end;
! 2418: #ifdef DIAGNOSTIC
! 2419: if (!ii->isdone)
! 2420: printf("uhci_device_isoc_start: not done, ii=%p\n", ii);
! 2421: ii->isdone = 0;
! 2422: #endif
! 2423: uhci_add_intr_info(sc, ii);
! 2424:
! 2425: splx(s);
! 2426:
! 2427: return (USBD_IN_PROGRESS);
! 2428: }
! 2429:
! 2430: void
! 2431: uhci_device_isoc_abort(usbd_xfer_handle xfer)
! 2432: {
! 2433: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2434: uhci_soft_td_t **stds = upipe->u.iso.stds;
! 2435: uhci_soft_td_t *std;
! 2436: int i, n, s, nframes, maxlen, len;
! 2437:
! 2438: s = splusb();
! 2439:
! 2440: /* Transfer is already done. */
! 2441: if (xfer->status != USBD_NOT_STARTED &&
! 2442: xfer->status != USBD_IN_PROGRESS) {
! 2443: splx(s);
! 2444: return;
! 2445: }
! 2446:
! 2447: /* Give xfer the requested abort code. */
! 2448: xfer->status = USBD_CANCELLED;
! 2449:
! 2450: /* make hardware ignore it, */
! 2451: nframes = xfer->nframes;
! 2452: n = UXFER(xfer)->curframe;
! 2453: maxlen = 0;
! 2454: for (i = 0; i < nframes; i++) {
! 2455: std = stds[n];
! 2456: std->td.td_status &= htole32(~(UHCI_TD_ACTIVE | UHCI_TD_IOC));
! 2457: len = UHCI_TD_GET_MAXLEN(letoh32(std->td.td_token));
! 2458: if (len > maxlen)
! 2459: maxlen = len;
! 2460: if (++n >= UHCI_VFRAMELIST_COUNT)
! 2461: n = 0;
! 2462: }
! 2463:
! 2464: /* and wait until we are sure the hardware has finished. */
! 2465: delay(maxlen);
! 2466:
! 2467: #ifdef DIAGNOSTIC
! 2468: UXFER(xfer)->iinfo.isdone = 1;
! 2469: #endif
! 2470: /* Run callback and remove from interrupt list. */
! 2471: usb_transfer_complete(xfer);
! 2472:
! 2473: splx(s);
! 2474: }
! 2475:
! 2476: void
! 2477: uhci_device_isoc_close(usbd_pipe_handle pipe)
! 2478: {
! 2479: struct uhci_pipe *upipe = (struct uhci_pipe *)pipe;
! 2480: usbd_device_handle dev = upipe->pipe.device;
! 2481: uhci_softc_t *sc = (uhci_softc_t *)dev->bus;
! 2482: uhci_soft_td_t *std, *vstd;
! 2483: struct iso *iso;
! 2484: int i, s;
! 2485:
! 2486: /*
! 2487: * Make sure all TDs are marked as inactive.
! 2488: * Wait for completion.
! 2489: * Unschedule.
! 2490: * Deallocate.
! 2491: */
! 2492: iso = &upipe->u.iso;
! 2493:
! 2494: for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++)
! 2495: iso->stds[i]->td.td_status &= htole32(~UHCI_TD_ACTIVE);
! 2496: usb_delay_ms(&sc->sc_bus, 2); /* wait for completion */
! 2497:
! 2498: s = splusb();
! 2499: for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++) {
! 2500: std = iso->stds[i];
! 2501: for (vstd = sc->sc_vframes[i].htd;
! 2502: vstd != NULL && vstd->link.std != std;
! 2503: vstd = vstd->link.std)
! 2504: ;
! 2505: if (vstd == NULL) {
! 2506: /*panic*/
! 2507: printf("uhci_device_isoc_close: %p not found\n", std);
! 2508: splx(s);
! 2509: return;
! 2510: }
! 2511: vstd->link = std->link;
! 2512: vstd->td.td_link = std->td.td_link;
! 2513: uhci_free_std(sc, std);
! 2514: }
! 2515: splx(s);
! 2516:
! 2517: free(iso->stds, M_USBHC);
! 2518: }
! 2519:
! 2520: usbd_status
! 2521: uhci_setup_isoc(usbd_pipe_handle pipe)
! 2522: {
! 2523: struct uhci_pipe *upipe = (struct uhci_pipe *)pipe;
! 2524: usbd_device_handle dev = upipe->pipe.device;
! 2525: uhci_softc_t *sc = (uhci_softc_t *)dev->bus;
! 2526: int addr = upipe->pipe.device->address;
! 2527: int endpt = upipe->pipe.endpoint->edesc->bEndpointAddress;
! 2528: int rd = UE_GET_DIR(endpt) == UE_DIR_IN;
! 2529: uhci_soft_td_t *std, *vstd;
! 2530: u_int32_t token;
! 2531: struct iso *iso;
! 2532: int i, s;
! 2533:
! 2534: iso = &upipe->u.iso;
! 2535: iso->stds = malloc(UHCI_VFRAMELIST_COUNT * sizeof (uhci_soft_td_t *),
! 2536: M_USBHC, M_WAITOK);
! 2537:
! 2538: token = rd ? UHCI_TD_IN (0, endpt, addr, 0) :
! 2539: UHCI_TD_OUT(0, endpt, addr, 0);
! 2540:
! 2541: /* Allocate the TDs and mark as inactive; */
! 2542: for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++) {
! 2543: std = uhci_alloc_std(sc);
! 2544: if (std == 0)
! 2545: goto bad;
! 2546: std->td.td_status = htole32(UHCI_TD_IOS); /* iso, inactive */
! 2547: std->td.td_token = htole32(token);
! 2548: iso->stds[i] = std;
! 2549: }
! 2550:
! 2551: /* Insert TDs into schedule. */
! 2552: s = splusb();
! 2553: for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++) {
! 2554: std = iso->stds[i];
! 2555: vstd = sc->sc_vframes[i].htd;
! 2556: std->link = vstd->link;
! 2557: std->td.td_link = vstd->td.td_link;
! 2558: vstd->link.std = std;
! 2559: vstd->td.td_link = htole32(std->physaddr | UHCI_PTR_TD);
! 2560: }
! 2561: splx(s);
! 2562:
! 2563: iso->next = -1;
! 2564: iso->inuse = 0;
! 2565:
! 2566: return (USBD_NORMAL_COMPLETION);
! 2567:
! 2568: bad:
! 2569: while (--i >= 0)
! 2570: uhci_free_std(sc, iso->stds[i]);
! 2571: free(iso->stds, M_USBHC);
! 2572: return (USBD_NOMEM);
! 2573: }
! 2574:
! 2575: void
! 2576: uhci_device_isoc_done(usbd_xfer_handle xfer)
! 2577: {
! 2578: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 2579:
! 2580: DPRINTFN(4, ("uhci_isoc_done: length=%d\n", xfer->actlen));
! 2581:
! 2582: if (ii->xfer != xfer)
! 2583: /* Not on interrupt list, ignore it. */
! 2584: return;
! 2585:
! 2586: if (!uhci_active_intr_info(ii))
! 2587: return;
! 2588:
! 2589: #ifdef DIAGNOSTIC
! 2590: if (xfer->busy_free == XFER_FREE) {
! 2591: printf("uhci_device_isoc_done: xfer=%p is free\n", xfer);
! 2592: return;
! 2593: }
! 2594:
! 2595: if (ii->stdend == NULL) {
! 2596: printf("uhci_device_isoc_done: xfer=%p stdend==NULL\n", xfer);
! 2597: #ifdef UHCI_DEBUG
! 2598: uhci_dump_ii(ii);
! 2599: #endif
! 2600: return;
! 2601: }
! 2602: #endif
! 2603:
! 2604: /* Turn off the interrupt since it is active even if the TD is not. */
! 2605: ii->stdend->td.td_status &= htole32(~UHCI_TD_IOC);
! 2606:
! 2607: uhci_del_intr_info(ii); /* remove from active list */
! 2608: }
! 2609:
! 2610: void
! 2611: uhci_device_intr_done(usbd_xfer_handle xfer)
! 2612: {
! 2613: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 2614: uhci_softc_t *sc = ii->sc;
! 2615: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2616: uhci_soft_qh_t *sqh;
! 2617: int i, npoll;
! 2618:
! 2619: DPRINTFN(5, ("uhci_device_intr_done: length=%d\n", xfer->actlen));
! 2620:
! 2621: npoll = upipe->u.intr.npoll;
! 2622: for(i = 0; i < npoll; i++) {
! 2623: sqh = upipe->u.intr.qhs[i];
! 2624: sqh->elink = NULL;
! 2625: sqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 2626: }
! 2627: uhci_free_std_chain(sc, ii->stdstart, NULL);
! 2628:
! 2629: /* XXX Wasteful. */
! 2630: if (xfer->pipe->repeat) {
! 2631: uhci_soft_td_t *data, *dataend;
! 2632:
! 2633: DPRINTFN(5,("uhci_device_intr_done: requeing\n"));
! 2634:
! 2635: /* This alloc cannot fail since we freed the chain above. */
! 2636: uhci_alloc_std_chain(upipe, sc, xfer->length,
! 2637: upipe->u.intr.isread, xfer->flags,
! 2638: &xfer->dmabuf, &data, &dataend);
! 2639: dataend->td.td_status |= htole32(UHCI_TD_IOC);
! 2640:
! 2641: #ifdef UHCI_DEBUG
! 2642: if (uhcidebug > 10) {
! 2643: DPRINTF(("uhci_device_intr_done: data(1)\n"));
! 2644: uhci_dump_tds(data);
! 2645: uhci_dump_qh(upipe->u.intr.qhs[0]);
! 2646: }
! 2647: #endif
! 2648:
! 2649: ii->stdstart = data;
! 2650: ii->stdend = dataend;
! 2651: #ifdef DIAGNOSTIC
! 2652: if (!ii->isdone) {
! 2653: printf("uhci_device_intr_done: not done, ii=%p\n", ii);
! 2654: }
! 2655: ii->isdone = 0;
! 2656: #endif
! 2657: for (i = 0; i < npoll; i++) {
! 2658: sqh = upipe->u.intr.qhs[i];
! 2659: sqh->elink = data;
! 2660: sqh->qh.qh_elink = htole32(data->physaddr | UHCI_PTR_TD);
! 2661: }
! 2662: xfer->status = USBD_IN_PROGRESS;
! 2663: /* The ii is already on the examined list, just leave it. */
! 2664: } else {
! 2665: DPRINTFN(5,("uhci_device_intr_done: removing\n"));
! 2666: if (uhci_active_intr_info(ii))
! 2667: uhci_del_intr_info(ii);
! 2668: }
! 2669: }
! 2670:
! 2671: /* Deallocate request data structures */
! 2672: void
! 2673: uhci_device_ctrl_done(usbd_xfer_handle xfer)
! 2674: {
! 2675: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 2676: uhci_softc_t *sc = ii->sc;
! 2677: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2678:
! 2679: #ifdef DIAGNOSTIC
! 2680: if (!(xfer->rqflags & URQ_REQUEST))
! 2681: panic("uhci_device_ctrl_done: not a request");
! 2682: #endif
! 2683:
! 2684: if (!uhci_active_intr_info(ii))
! 2685: return;
! 2686:
! 2687: uhci_del_intr_info(ii); /* remove from active list */
! 2688:
! 2689: if (upipe->pipe.device->speed == USB_SPEED_LOW)
! 2690: uhci_remove_ls_ctrl(sc, upipe->u.ctl.sqh);
! 2691: else
! 2692: uhci_remove_hs_ctrl(sc, upipe->u.ctl.sqh);
! 2693:
! 2694: if (upipe->u.ctl.length != 0)
! 2695: uhci_free_std_chain(sc, ii->stdstart->link.std, ii->stdend);
! 2696:
! 2697: DPRINTFN(5, ("uhci_device_ctrl_done: length=%d\n", xfer->actlen));
! 2698: }
! 2699:
! 2700: /* Deallocate request data structures */
! 2701: void
! 2702: uhci_device_bulk_done(usbd_xfer_handle xfer)
! 2703: {
! 2704: uhci_intr_info_t *ii = &UXFER(xfer)->iinfo;
! 2705: uhci_softc_t *sc = ii->sc;
! 2706: struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe;
! 2707:
! 2708: DPRINTFN(5,("uhci_device_bulk_done: xfer=%p ii=%p sc=%p upipe=%p\n",
! 2709: xfer, ii, sc, upipe));
! 2710:
! 2711: if (!uhci_active_intr_info(ii))
! 2712: return;
! 2713:
! 2714: uhci_del_intr_info(ii); /* remove from active list */
! 2715:
! 2716: uhci_remove_bulk(sc, upipe->u.bulk.sqh);
! 2717:
! 2718: uhci_free_std_chain(sc, ii->stdstart, NULL);
! 2719:
! 2720: DPRINTFN(5, ("uhci_device_bulk_done: length=%d\n", xfer->actlen));
! 2721: }
! 2722:
! 2723: /* Add interrupt QH, called with vflock. */
! 2724: void
! 2725: uhci_add_intr(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 2726: {
! 2727: struct uhci_vframe *vf = &sc->sc_vframes[sqh->pos];
! 2728: uhci_soft_qh_t *eqh;
! 2729:
! 2730: DPRINTFN(4, ("uhci_add_intr: n=%d sqh=%p\n", sqh->pos, sqh));
! 2731:
! 2732: eqh = vf->eqh;
! 2733: sqh->hlink = eqh->hlink;
! 2734: sqh->qh.qh_hlink = eqh->qh.qh_hlink;
! 2735: eqh->hlink = sqh;
! 2736: eqh->qh.qh_hlink = htole32(sqh->physaddr | UHCI_PTR_QH);
! 2737: vf->eqh = sqh;
! 2738: vf->bandwidth++;
! 2739: }
! 2740:
! 2741: /* Remove interrupt QH. */
! 2742: void
! 2743: uhci_remove_intr(uhci_softc_t *sc, uhci_soft_qh_t *sqh)
! 2744: {
! 2745: struct uhci_vframe *vf = &sc->sc_vframes[sqh->pos];
! 2746: uhci_soft_qh_t *pqh;
! 2747:
! 2748: DPRINTFN(4, ("uhci_remove_intr: n=%d sqh=%p\n", sqh->pos, sqh));
! 2749:
! 2750: /* See comment in uhci_remove_ctrl() */
! 2751: if (!(sqh->qh.qh_elink & htole32(UHCI_PTR_T))) {
! 2752: sqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 2753: delay(UHCI_QH_REMOVE_DELAY);
! 2754: }
! 2755:
! 2756: pqh = uhci_find_prev_qh(vf->hqh, sqh);
! 2757: pqh->hlink = sqh->hlink;
! 2758: pqh->qh.qh_hlink = sqh->qh.qh_hlink;
! 2759: delay(UHCI_QH_REMOVE_DELAY);
! 2760: if (vf->eqh == sqh)
! 2761: vf->eqh = pqh;
! 2762: vf->bandwidth--;
! 2763: }
! 2764:
! 2765: usbd_status
! 2766: uhci_device_setintr(uhci_softc_t *sc, struct uhci_pipe *upipe, int ival)
! 2767: {
! 2768: uhci_soft_qh_t *sqh;
! 2769: int i, npoll, s;
! 2770: u_int bestbw, bw, bestoffs, offs;
! 2771:
! 2772: DPRINTFN(2, ("uhci_device_setintr: pipe=%p\n", upipe));
! 2773: if (ival == 0) {
! 2774: printf("uhci_device_setintr: 0 interval\n");
! 2775: return (USBD_INVAL);
! 2776: }
! 2777:
! 2778: if (ival > UHCI_VFRAMELIST_COUNT)
! 2779: ival = UHCI_VFRAMELIST_COUNT;
! 2780: npoll = (UHCI_VFRAMELIST_COUNT + ival - 1) / ival;
! 2781: DPRINTFN(2, ("uhci_device_setintr: ival=%d npoll=%d\n", ival, npoll));
! 2782:
! 2783: upipe->u.intr.npoll = npoll;
! 2784: upipe->u.intr.qhs =
! 2785: malloc(npoll * sizeof(uhci_soft_qh_t *), M_USBHC, M_WAITOK);
! 2786:
! 2787: /*
! 2788: * Figure out which offset in the schedule that has most
! 2789: * bandwidth left over.
! 2790: */
! 2791: #define MOD(i) ((i) & (UHCI_VFRAMELIST_COUNT-1))
! 2792: for (bestoffs = offs = 0, bestbw = ~0; offs < ival; offs++) {
! 2793: for (bw = i = 0; i < npoll; i++)
! 2794: bw += sc->sc_vframes[MOD(i * ival + offs)].bandwidth;
! 2795: if (bw < bestbw) {
! 2796: bestbw = bw;
! 2797: bestoffs = offs;
! 2798: }
! 2799: }
! 2800: DPRINTFN(1, ("uhci_device_setintr: bw=%d offs=%d\n", bestbw, bestoffs));
! 2801:
! 2802: for(i = 0; i < npoll; i++) {
! 2803: upipe->u.intr.qhs[i] = sqh = uhci_alloc_sqh(sc);
! 2804: sqh->elink = NULL;
! 2805: sqh->qh.qh_elink = htole32(UHCI_PTR_T);
! 2806: sqh->pos = MOD(i * ival + bestoffs);
! 2807: }
! 2808: #undef MOD
! 2809:
! 2810: s = splusb();
! 2811: /* Enter QHs into the controller data structures. */
! 2812: for(i = 0; i < npoll; i++)
! 2813: uhci_add_intr(sc, upipe->u.intr.qhs[i]);
! 2814: splx(s);
! 2815:
! 2816: DPRINTFN(5, ("uhci_device_setintr: returns %p\n", upipe));
! 2817: return (USBD_NORMAL_COMPLETION);
! 2818: }
! 2819:
! 2820: /* Open a new pipe. */
! 2821: usbd_status
! 2822: uhci_open(usbd_pipe_handle pipe)
! 2823: {
! 2824: uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus;
! 2825: struct uhci_pipe *upipe = (struct uhci_pipe *)pipe;
! 2826: usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc;
! 2827: usbd_status err;
! 2828: int ival;
! 2829:
! 2830: DPRINTFN(1, ("uhci_open: pipe=%p, addr=%d, endpt=%d (%d)\n",
! 2831: pipe, pipe->device->address,
! 2832: ed->bEndpointAddress, sc->sc_addr));
! 2833:
! 2834: upipe->aborting = 0;
! 2835: upipe->nexttoggle = pipe->endpoint->savedtoggle;
! 2836:
! 2837: if (pipe->device->address == sc->sc_addr) {
! 2838: switch (ed->bEndpointAddress) {
! 2839: case USB_CONTROL_ENDPOINT:
! 2840: pipe->methods = &uhci_root_ctrl_methods;
! 2841: break;
! 2842: case UE_DIR_IN | UHCI_INTR_ENDPT:
! 2843: pipe->methods = &uhci_root_intr_methods;
! 2844: break;
! 2845: default:
! 2846: return (USBD_INVAL);
! 2847: }
! 2848: } else {
! 2849: switch (ed->bmAttributes & UE_XFERTYPE) {
! 2850: case UE_CONTROL:
! 2851: pipe->methods = &uhci_device_ctrl_methods;
! 2852: upipe->u.ctl.sqh = uhci_alloc_sqh(sc);
! 2853: if (upipe->u.ctl.sqh == NULL)
! 2854: goto bad;
! 2855: upipe->u.ctl.setup = uhci_alloc_std(sc);
! 2856: if (upipe->u.ctl.setup == NULL) {
! 2857: uhci_free_sqh(sc, upipe->u.ctl.sqh);
! 2858: goto bad;
! 2859: }
! 2860: upipe->u.ctl.stat = uhci_alloc_std(sc);
! 2861: if (upipe->u.ctl.stat == NULL) {
! 2862: uhci_free_sqh(sc, upipe->u.ctl.sqh);
! 2863: uhci_free_std(sc, upipe->u.ctl.setup);
! 2864: goto bad;
! 2865: }
! 2866: err = usb_allocmem(&sc->sc_bus,
! 2867: sizeof(usb_device_request_t),
! 2868: 0, &upipe->u.ctl.reqdma);
! 2869: if (err) {
! 2870: uhci_free_sqh(sc, upipe->u.ctl.sqh);
! 2871: uhci_free_std(sc, upipe->u.ctl.setup);
! 2872: uhci_free_std(sc, upipe->u.ctl.stat);
! 2873: goto bad;
! 2874: }
! 2875: break;
! 2876: case UE_INTERRUPT:
! 2877: pipe->methods = &uhci_device_intr_methods;
! 2878: ival = pipe->interval;
! 2879: if (ival == USBD_DEFAULT_INTERVAL)
! 2880: ival = ed->bInterval;
! 2881: return (uhci_device_setintr(sc, upipe, ival));
! 2882: case UE_ISOCHRONOUS:
! 2883: pipe->methods = &uhci_device_isoc_methods;
! 2884: return (uhci_setup_isoc(pipe));
! 2885: case UE_BULK:
! 2886: pipe->methods = &uhci_device_bulk_methods;
! 2887: upipe->u.bulk.sqh = uhci_alloc_sqh(sc);
! 2888: if (upipe->u.bulk.sqh == NULL)
! 2889: goto bad;
! 2890: break;
! 2891: }
! 2892: }
! 2893: return (USBD_NORMAL_COMPLETION);
! 2894:
! 2895: bad:
! 2896: return (USBD_NOMEM);
! 2897: }
! 2898:
! 2899: /*
! 2900: * Data structures and routines to emulate the root hub.
! 2901: */
! 2902: usb_device_descriptor_t uhci_devd = {
! 2903: USB_DEVICE_DESCRIPTOR_SIZE,
! 2904: UDESC_DEVICE, /* type */
! 2905: {0x00, 0x01}, /* USB version */
! 2906: UDCLASS_HUB, /* class */
! 2907: UDSUBCLASS_HUB, /* subclass */
! 2908: UDPROTO_FSHUB, /* protocol */
! 2909: 64, /* max packet */
! 2910: {0},{0},{0x00,0x01}, /* device id */
! 2911: 1,2,0, /* string indices */
! 2912: 1 /* # of configurations */
! 2913: };
! 2914:
! 2915: usb_config_descriptor_t uhci_confd = {
! 2916: USB_CONFIG_DESCRIPTOR_SIZE,
! 2917: UDESC_CONFIG,
! 2918: {USB_CONFIG_DESCRIPTOR_SIZE +
! 2919: USB_INTERFACE_DESCRIPTOR_SIZE +
! 2920: USB_ENDPOINT_DESCRIPTOR_SIZE},
! 2921: 1,
! 2922: 1,
! 2923: 0,
! 2924: UC_SELF_POWERED,
! 2925: 0 /* max power */
! 2926: };
! 2927:
! 2928: usb_interface_descriptor_t uhci_ifcd = {
! 2929: USB_INTERFACE_DESCRIPTOR_SIZE,
! 2930: UDESC_INTERFACE,
! 2931: 0,
! 2932: 0,
! 2933: 1,
! 2934: UICLASS_HUB,
! 2935: UISUBCLASS_HUB,
! 2936: UIPROTO_FSHUB,
! 2937: 0
! 2938: };
! 2939:
! 2940: usb_endpoint_descriptor_t uhci_endpd = {
! 2941: USB_ENDPOINT_DESCRIPTOR_SIZE,
! 2942: UDESC_ENDPOINT,
! 2943: UE_DIR_IN | UHCI_INTR_ENDPT,
! 2944: UE_INTERRUPT,
! 2945: {8},
! 2946: 255
! 2947: };
! 2948:
! 2949: usb_hub_descriptor_t uhci_hubd_piix = {
! 2950: USB_HUB_DESCRIPTOR_SIZE,
! 2951: UDESC_HUB,
! 2952: 2,
! 2953: { UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL, 0 },
! 2954: 50, /* power on to power good */
! 2955: 0,
! 2956: { 0x00 }, /* both ports are removable */
! 2957: };
! 2958:
! 2959: int
! 2960: uhci_str(usb_string_descriptor_t *p, int l, char *s)
! 2961: {
! 2962: int i;
! 2963:
! 2964: if (l == 0)
! 2965: return (0);
! 2966: p->bLength = 2 * strlen(s) + 2;
! 2967: if (l == 1)
! 2968: return (1);
! 2969: p->bDescriptorType = UDESC_STRING;
! 2970: l -= 2;
! 2971: for (i = 0; s[i] && l > 1; i++, l -= 2)
! 2972: USETW2(p->bString[i], 0, s[i]);
! 2973: return (2*i+2);
! 2974: }
! 2975:
! 2976: /*
! 2977: * The USB hub protocol requires that SET_FEATURE(PORT_RESET) also
! 2978: * enables the port, and also states that SET_FEATURE(PORT_ENABLE)
! 2979: * should not be used by the USB subsystem. As we cannot issue a
! 2980: * SET_FEATURE(PORT_ENABLE) externally, we must ensure that the port
! 2981: * will be enabled as part of the reset.
! 2982: *
! 2983: * On the VT83C572, the port cannot be successfully enabled until the
! 2984: * outstanding "port enable change" and "connection status change"
! 2985: * events have been reset.
! 2986: */
! 2987: usbd_status
! 2988: uhci_portreset(uhci_softc_t *sc, int index)
! 2989: {
! 2990: int lim, port, x;
! 2991:
! 2992: if (index == 1)
! 2993: port = UHCI_PORTSC1;
! 2994: else if (index == 2)
! 2995: port = UHCI_PORTSC2;
! 2996: else
! 2997: return (USBD_IOERROR);
! 2998:
! 2999: x = URWMASK(UREAD2(sc, port));
! 3000: UWRITE2(sc, port, x | UHCI_PORTSC_PR);
! 3001:
! 3002: usb_delay_ms(&sc->sc_bus, USB_PORT_ROOT_RESET_DELAY);
! 3003:
! 3004: DPRINTFN(3,("uhci port %d reset, status0 = 0x%04x\n",
! 3005: index, UREAD2(sc, port)));
! 3006:
! 3007: x = URWMASK(UREAD2(sc, port));
! 3008: UWRITE2(sc, port, x & ~UHCI_PORTSC_PR);
! 3009:
! 3010: delay(100);
! 3011:
! 3012: DPRINTFN(3,("uhci port %d reset, status1 = 0x%04x\n",
! 3013: index, UREAD2(sc, port)));
! 3014:
! 3015: x = URWMASK(UREAD2(sc, port));
! 3016: UWRITE2(sc, port, x | UHCI_PORTSC_PE);
! 3017:
! 3018: for (lim = 10; --lim > 0;) {
! 3019: usb_delay_ms(&sc->sc_bus, USB_PORT_RESET_DELAY);
! 3020:
! 3021: x = UREAD2(sc, port);
! 3022:
! 3023: DPRINTFN(3,("uhci port %d iteration %u, status = 0x%04x\n",
! 3024: index, lim, x));
! 3025:
! 3026: if (!(x & UHCI_PORTSC_CCS)) {
! 3027: /*
! 3028: * No device is connected (or was disconnected
! 3029: * during reset). Consider the port reset.
! 3030: * The delay must be long enough to ensure on
! 3031: * the initial iteration that the device
! 3032: * connection will have been registered. 50ms
! 3033: * appears to be sufficient, but 20ms is not.
! 3034: */
! 3035: DPRINTFN(3,("uhci port %d loop %u, device detached\n",
! 3036: index, lim));
! 3037: break;
! 3038: }
! 3039:
! 3040: if (x & (UHCI_PORTSC_POEDC | UHCI_PORTSC_CSC)) {
! 3041: /*
! 3042: * Port enabled changed and/or connection
! 3043: * status changed were set. Reset either or
! 3044: * both raised flags (by writing a 1 to that
! 3045: * bit), and wait again for state to settle.
! 3046: */
! 3047: UWRITE2(sc, port, URWMASK(x) |
! 3048: (x & (UHCI_PORTSC_POEDC | UHCI_PORTSC_CSC)));
! 3049: continue;
! 3050: }
! 3051:
! 3052: if (x & UHCI_PORTSC_PE)
! 3053: /* Port is enabled */
! 3054: break;
! 3055:
! 3056: UWRITE2(sc, port, URWMASK(x) | UHCI_PORTSC_PE);
! 3057: }
! 3058:
! 3059: DPRINTFN(3,("uhci port %d reset, status2 = 0x%04x\n",
! 3060: index, UREAD2(sc, port)));
! 3061:
! 3062: if (lim <= 0) {
! 3063: DPRINTFN(1,("uhci port %d reset timed out\n", index));
! 3064: return (USBD_TIMEOUT);
! 3065: }
! 3066:
! 3067: sc->sc_isreset = 1;
! 3068: return (USBD_NORMAL_COMPLETION);
! 3069: }
! 3070:
! 3071: /*
! 3072: * Simulate a hardware hub by handling all the necessary requests.
! 3073: */
! 3074: usbd_status
! 3075: uhci_root_ctrl_transfer(usbd_xfer_handle xfer)
! 3076: {
! 3077: usbd_status err;
! 3078:
! 3079: /* Insert last in queue. */
! 3080: err = usb_insert_transfer(xfer);
! 3081: if (err)
! 3082: return (err);
! 3083:
! 3084: /*
! 3085: * Pipe isn't running (otherwise err would be USBD_INPROG),
! 3086: * so start it first.
! 3087: */
! 3088: return (uhci_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
! 3089: }
! 3090:
! 3091: usbd_status
! 3092: uhci_root_ctrl_start(usbd_xfer_handle xfer)
! 3093: {
! 3094: uhci_softc_t *sc = (uhci_softc_t *)xfer->pipe->device->bus;
! 3095: usb_device_request_t *req;
! 3096: void *buf = NULL;
! 3097: int port, x;
! 3098: int s, len, value, index, status, change, l, totlen = 0;
! 3099: usb_port_status_t ps;
! 3100: usbd_status err;
! 3101:
! 3102: if (sc->sc_dying)
! 3103: return (USBD_IOERROR);
! 3104:
! 3105: #ifdef DIAGNOSTIC
! 3106: if (!(xfer->rqflags & URQ_REQUEST))
! 3107: panic("uhci_root_ctrl_transfer: not a request");
! 3108: #endif
! 3109: req = &xfer->request;
! 3110:
! 3111: DPRINTFN(2,("uhci_root_ctrl_control type=0x%02x request=%02x\n",
! 3112: req->bmRequestType, req->bRequest));
! 3113:
! 3114: len = UGETW(req->wLength);
! 3115: value = UGETW(req->wValue);
! 3116: index = UGETW(req->wIndex);
! 3117:
! 3118: if (len != 0)
! 3119: buf = KERNADDR(&xfer->dmabuf, 0);
! 3120:
! 3121: #define C(x,y) ((x) | ((y) << 8))
! 3122: switch(C(req->bRequest, req->bmRequestType)) {
! 3123: case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE):
! 3124: case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE):
! 3125: case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT):
! 3126: /*
! 3127: * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops
! 3128: * for the integrated root hub.
! 3129: */
! 3130: break;
! 3131: case C(UR_GET_CONFIG, UT_READ_DEVICE):
! 3132: if (len > 0) {
! 3133: *(u_int8_t *)buf = sc->sc_conf;
! 3134: totlen = 1;
! 3135: }
! 3136: break;
! 3137: case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
! 3138: DPRINTFN(2,("uhci_root_ctrl_control wValue=0x%04x\n", value));
! 3139: switch(value >> 8) {
! 3140: case UDESC_DEVICE:
! 3141: if ((value & 0xff) != 0) {
! 3142: err = USBD_IOERROR;
! 3143: goto ret;
! 3144: }
! 3145: totlen = l = min(len, USB_DEVICE_DESCRIPTOR_SIZE);
! 3146: USETW(uhci_devd.idVendor, sc->sc_id_vendor);
! 3147: memcpy(buf, &uhci_devd, l);
! 3148: break;
! 3149: case UDESC_CONFIG:
! 3150: if ((value & 0xff) != 0) {
! 3151: err = USBD_IOERROR;
! 3152: goto ret;
! 3153: }
! 3154: totlen = l = min(len, USB_CONFIG_DESCRIPTOR_SIZE);
! 3155: memcpy(buf, &uhci_confd, l);
! 3156: buf = (char *)buf + l;
! 3157: len -= l;
! 3158: l = min(len, USB_INTERFACE_DESCRIPTOR_SIZE);
! 3159: totlen += l;
! 3160: memcpy(buf, &uhci_ifcd, l);
! 3161: buf = (char *)buf + l;
! 3162: len -= l;
! 3163: l = min(len, USB_ENDPOINT_DESCRIPTOR_SIZE);
! 3164: totlen += l;
! 3165: memcpy(buf, &uhci_endpd, l);
! 3166: break;
! 3167: case UDESC_STRING:
! 3168: if (len == 0)
! 3169: break;
! 3170: *(u_int8_t *)buf = 0;
! 3171: totlen = 1;
! 3172: switch (value & 0xff) {
! 3173: case 0: /* Language table */
! 3174: totlen = uhci_str(buf, len, "\001");
! 3175: break;
! 3176: case 1: /* Vendor */
! 3177: totlen = uhci_str(buf, len, sc->sc_vendor);
! 3178: break;
! 3179: case 2: /* Product */
! 3180: totlen = uhci_str(buf, len, "UHCI root hub");
! 3181: break;
! 3182: }
! 3183: break;
! 3184: default:
! 3185: err = USBD_IOERROR;
! 3186: goto ret;
! 3187: }
! 3188: break;
! 3189: case C(UR_GET_INTERFACE, UT_READ_INTERFACE):
! 3190: if (len > 0) {
! 3191: *(u_int8_t *)buf = 0;
! 3192: totlen = 1;
! 3193: }
! 3194: break;
! 3195: case C(UR_GET_STATUS, UT_READ_DEVICE):
! 3196: if (len > 1) {
! 3197: USETW(((usb_status_t *)buf)->wStatus,UDS_SELF_POWERED);
! 3198: totlen = 2;
! 3199: }
! 3200: break;
! 3201: case C(UR_GET_STATUS, UT_READ_INTERFACE):
! 3202: case C(UR_GET_STATUS, UT_READ_ENDPOINT):
! 3203: if (len > 1) {
! 3204: USETW(((usb_status_t *)buf)->wStatus, 0);
! 3205: totlen = 2;
! 3206: }
! 3207: break;
! 3208: case C(UR_SET_ADDRESS, UT_WRITE_DEVICE):
! 3209: if (value >= USB_MAX_DEVICES) {
! 3210: err = USBD_IOERROR;
! 3211: goto ret;
! 3212: }
! 3213: sc->sc_addr = value;
! 3214: break;
! 3215: case C(UR_SET_CONFIG, UT_WRITE_DEVICE):
! 3216: if (value != 0 && value != 1) {
! 3217: err = USBD_IOERROR;
! 3218: goto ret;
! 3219: }
! 3220: sc->sc_conf = value;
! 3221: break;
! 3222: case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE):
! 3223: break;
! 3224: case C(UR_SET_FEATURE, UT_WRITE_DEVICE):
! 3225: case C(UR_SET_FEATURE, UT_WRITE_INTERFACE):
! 3226: case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT):
! 3227: err = USBD_IOERROR;
! 3228: goto ret;
! 3229: case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE):
! 3230: break;
! 3231: case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT):
! 3232: break;
! 3233: /* Hub requests */
! 3234: case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE):
! 3235: break;
! 3236: case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER):
! 3237: DPRINTFN(3, ("uhci_root_ctrl_control: UR_CLEAR_PORT_FEATURE "
! 3238: "port=%d feature=%d\n",
! 3239: index, value));
! 3240: if (index == 1)
! 3241: port = UHCI_PORTSC1;
! 3242: else if (index == 2)
! 3243: port = UHCI_PORTSC2;
! 3244: else {
! 3245: err = USBD_IOERROR;
! 3246: goto ret;
! 3247: }
! 3248: switch(value) {
! 3249: case UHF_PORT_ENABLE:
! 3250: x = URWMASK(UREAD2(sc, port));
! 3251: UWRITE2(sc, port, x & ~UHCI_PORTSC_PE);
! 3252: break;
! 3253: case UHF_PORT_SUSPEND:
! 3254: x = URWMASK(UREAD2(sc, port));
! 3255: UWRITE2(sc, port, x & ~UHCI_PORTSC_SUSP);
! 3256: break;
! 3257: case UHF_PORT_RESET:
! 3258: x = URWMASK(UREAD2(sc, port));
! 3259: UWRITE2(sc, port, x & ~UHCI_PORTSC_PR);
! 3260: break;
! 3261: case UHF_C_PORT_CONNECTION:
! 3262: x = URWMASK(UREAD2(sc, port));
! 3263: UWRITE2(sc, port, x | UHCI_PORTSC_CSC);
! 3264: break;
! 3265: case UHF_C_PORT_ENABLE:
! 3266: x = URWMASK(UREAD2(sc, port));
! 3267: UWRITE2(sc, port, x | UHCI_PORTSC_POEDC);
! 3268: break;
! 3269: case UHF_C_PORT_OVER_CURRENT:
! 3270: x = URWMASK(UREAD2(sc, port));
! 3271: UWRITE2(sc, port, x | UHCI_PORTSC_OCIC);
! 3272: break;
! 3273: case UHF_C_PORT_RESET:
! 3274: sc->sc_isreset = 0;
! 3275: err = USBD_NORMAL_COMPLETION;
! 3276: goto ret;
! 3277: case UHF_PORT_CONNECTION:
! 3278: case UHF_PORT_OVER_CURRENT:
! 3279: case UHF_PORT_POWER:
! 3280: case UHF_PORT_LOW_SPEED:
! 3281: case UHF_C_PORT_SUSPEND:
! 3282: default:
! 3283: err = USBD_IOERROR;
! 3284: goto ret;
! 3285: }
! 3286: break;
! 3287: case C(UR_GET_BUS_STATE, UT_READ_CLASS_OTHER):
! 3288: if (index == 1)
! 3289: port = UHCI_PORTSC1;
! 3290: else if (index == 2)
! 3291: port = UHCI_PORTSC2;
! 3292: else {
! 3293: err = USBD_IOERROR;
! 3294: goto ret;
! 3295: }
! 3296: if (len > 0) {
! 3297: *(u_int8_t *)buf =
! 3298: (UREAD2(sc, port) & UHCI_PORTSC_LS) >>
! 3299: UHCI_PORTSC_LS_SHIFT;
! 3300: totlen = 1;
! 3301: }
! 3302: break;
! 3303: case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE):
! 3304: if ((value & 0xff) != 0) {
! 3305: err = USBD_IOERROR;
! 3306: goto ret;
! 3307: }
! 3308: l = min(len, USB_HUB_DESCRIPTOR_SIZE);
! 3309: totlen = l;
! 3310: memcpy(buf, &uhci_hubd_piix, l);
! 3311: break;
! 3312: case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE):
! 3313: if (len != 4) {
! 3314: err = USBD_IOERROR;
! 3315: goto ret;
! 3316: }
! 3317: memset(buf, 0, len);
! 3318: totlen = len;
! 3319: break;
! 3320: case C(UR_GET_STATUS, UT_READ_CLASS_OTHER):
! 3321: if (index == 1)
! 3322: port = UHCI_PORTSC1;
! 3323: else if (index == 2)
! 3324: port = UHCI_PORTSC2;
! 3325: else {
! 3326: err = USBD_IOERROR;
! 3327: goto ret;
! 3328: }
! 3329: if (len != 4) {
! 3330: err = USBD_IOERROR;
! 3331: goto ret;
! 3332: }
! 3333: x = UREAD2(sc, port);
! 3334: status = change = 0;
! 3335: if (x & UHCI_PORTSC_CCS)
! 3336: status |= UPS_CURRENT_CONNECT_STATUS;
! 3337: if (x & UHCI_PORTSC_CSC)
! 3338: change |= UPS_C_CONNECT_STATUS;
! 3339: if (x & UHCI_PORTSC_PE)
! 3340: status |= UPS_PORT_ENABLED;
! 3341: if (x & UHCI_PORTSC_POEDC)
! 3342: change |= UPS_C_PORT_ENABLED;
! 3343: if (x & UHCI_PORTSC_OCI)
! 3344: status |= UPS_OVERCURRENT_INDICATOR;
! 3345: if (x & UHCI_PORTSC_OCIC)
! 3346: change |= UPS_C_OVERCURRENT_INDICATOR;
! 3347: if (x & UHCI_PORTSC_SUSP)
! 3348: status |= UPS_SUSPEND;
! 3349: if (x & UHCI_PORTSC_LSDA)
! 3350: status |= UPS_LOW_SPEED;
! 3351: status |= UPS_PORT_POWER;
! 3352: if (sc->sc_isreset)
! 3353: change |= UPS_C_PORT_RESET;
! 3354: USETW(ps.wPortStatus, status);
! 3355: USETW(ps.wPortChange, change);
! 3356: l = min(len, sizeof ps);
! 3357: memcpy(buf, &ps, l);
! 3358: totlen = l;
! 3359: break;
! 3360: case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE):
! 3361: err = USBD_IOERROR;
! 3362: goto ret;
! 3363: case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE):
! 3364: break;
! 3365: case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER):
! 3366: if (index == 1)
! 3367: port = UHCI_PORTSC1;
! 3368: else if (index == 2)
! 3369: port = UHCI_PORTSC2;
! 3370: else {
! 3371: err = USBD_IOERROR;
! 3372: goto ret;
! 3373: }
! 3374: switch(value) {
! 3375: case UHF_PORT_ENABLE:
! 3376: x = URWMASK(UREAD2(sc, port));
! 3377: UWRITE2(sc, port, x | UHCI_PORTSC_PE);
! 3378: break;
! 3379: case UHF_PORT_SUSPEND:
! 3380: x = URWMASK(UREAD2(sc, port));
! 3381: UWRITE2(sc, port, x | UHCI_PORTSC_SUSP);
! 3382: break;
! 3383: case UHF_PORT_RESET:
! 3384: err = uhci_portreset(sc, index);
! 3385: goto ret;
! 3386: case UHF_PORT_POWER:
! 3387: /* Pretend we turned on power */
! 3388: err = USBD_NORMAL_COMPLETION;
! 3389: goto ret;
! 3390: case UHF_C_PORT_CONNECTION:
! 3391: case UHF_C_PORT_ENABLE:
! 3392: case UHF_C_PORT_OVER_CURRENT:
! 3393: case UHF_PORT_CONNECTION:
! 3394: case UHF_PORT_OVER_CURRENT:
! 3395: case UHF_PORT_LOW_SPEED:
! 3396: case UHF_C_PORT_SUSPEND:
! 3397: case UHF_C_PORT_RESET:
! 3398: default:
! 3399: err = USBD_IOERROR;
! 3400: goto ret;
! 3401: }
! 3402: break;
! 3403: default:
! 3404: err = USBD_IOERROR;
! 3405: goto ret;
! 3406: }
! 3407: xfer->actlen = totlen;
! 3408: err = USBD_NORMAL_COMPLETION;
! 3409: ret:
! 3410: xfer->status = err;
! 3411: s = splusb();
! 3412: usb_transfer_complete(xfer);
! 3413: splx(s);
! 3414: return (USBD_IN_PROGRESS);
! 3415: }
! 3416:
! 3417: /* Abort a root control request. */
! 3418: void
! 3419: uhci_root_ctrl_abort(usbd_xfer_handle xfer)
! 3420: {
! 3421: /* Nothing to do, all transfers are synchronous. */
! 3422: }
! 3423:
! 3424: /* Close the root pipe. */
! 3425: void
! 3426: uhci_root_ctrl_close(usbd_pipe_handle pipe)
! 3427: {
! 3428: DPRINTF(("uhci_root_ctrl_close\n"));
! 3429: }
! 3430:
! 3431: /* Abort a root interrupt request. */
! 3432: void
! 3433: uhci_root_intr_abort(usbd_xfer_handle xfer)
! 3434: {
! 3435: uhci_softc_t *sc = (uhci_softc_t *)xfer->pipe->device->bus;
! 3436:
! 3437: timeout_del(&sc->sc_poll_handle);
! 3438: sc->sc_intr_xfer = NULL;
! 3439:
! 3440: if (xfer->pipe->intrxfer == xfer) {
! 3441: DPRINTF(("uhci_root_intr_abort: remove\n"));
! 3442: xfer->pipe->intrxfer = 0;
! 3443: }
! 3444: xfer->status = USBD_CANCELLED;
! 3445: #ifdef DIAGNOSTIC
! 3446: UXFER(xfer)->iinfo.isdone = 1;
! 3447: #endif
! 3448: usb_transfer_complete(xfer);
! 3449: }
! 3450:
! 3451: usbd_status
! 3452: uhci_root_intr_transfer(usbd_xfer_handle xfer)
! 3453: {
! 3454: usbd_status err;
! 3455:
! 3456: /* Insert last in queue. */
! 3457: err = usb_insert_transfer(xfer);
! 3458: if (err)
! 3459: return (err);
! 3460:
! 3461: /* Pipe isn't running (otherwise err would be USBD_INPROG),
! 3462: * start first
! 3463: */
! 3464: return (uhci_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
! 3465: }
! 3466:
! 3467: /* Start a transfer on the root interrupt pipe */
! 3468: usbd_status
! 3469: uhci_root_intr_start(usbd_xfer_handle xfer)
! 3470: {
! 3471: usbd_pipe_handle pipe = xfer->pipe;
! 3472: uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus;
! 3473:
! 3474: DPRINTFN(3, ("uhci_root_intr_start: xfer=%p len=%d flags=%d\n",
! 3475: xfer, xfer->length, xfer->flags));
! 3476:
! 3477: if (sc->sc_dying)
! 3478: return (USBD_IOERROR);
! 3479:
! 3480: sc->sc_ival = mstohz(xfer->pipe->endpoint->edesc->bInterval);
! 3481: timeout_del(&sc->sc_poll_handle);
! 3482: timeout_set(&sc->sc_poll_handle, uhci_poll_hub, xfer);
! 3483: timeout_add(&sc->sc_poll_handle, sc->sc_ival);
! 3484: sc->sc_intr_xfer = xfer;
! 3485: return (USBD_IN_PROGRESS);
! 3486: }
! 3487:
! 3488: /* Close the root interrupt pipe. */
! 3489: void
! 3490: uhci_root_intr_close(usbd_pipe_handle pipe)
! 3491: {
! 3492: uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus;
! 3493:
! 3494: timeout_del(&sc->sc_poll_handle);
! 3495: sc->sc_intr_xfer = NULL;
! 3496: DPRINTF(("uhci_root_intr_close\n"));
! 3497: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to uhci.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb