sys/bus/usb/uhci.c

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