Sync with NetBSD.

1 files changed, 851 insertions, 445 deletions

diff --git a/sys/dev/usb/ohci.c b/sys/dev/usb/ohci.c
index fcabdb8c26b..d57b51f1d45 100644
--- a/sys/dev/usb/ohci.c
+++ b/sys/dev/usb/ohci.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: ohci.c,v 1.7 1999/11/07 21:30:19 fgsch Exp $	*/
-/*	$NetBSD: ohci.c,v 1.48 1999/09/15 21:14:03 augustss Exp $	*/
+/*	$OpenBSD: ohci.c,v 1.8 2000/03/26 08:39:45 aaron Exp $	*/
+/*	$NetBSD: ohci.c,v 1.78 2000/03/20 00:37:00 augustss Exp $	*/
 
 /*
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
@@ -47,19 +47,22 @@
 
 #include <sys/param.h>
 #include <sys/systm.h>
-#include <sys/kernel.h>
 #include <sys/malloc.h>
 #if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/kernel.h>
 #include <sys/device.h>
+#include <sys/select.h>
 #elif defined(__FreeBSD__)
 #include <sys/module.h>
 #include <sys/bus.h>
 #include <machine/bus_pio.h>
 #include <machine/bus_memio.h>
+#if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__)
+#include <machine/cpu.h>
+#endif
 #endif
 #include <sys/proc.h>
 #include <sys/queue.h>
-#include <sys/select.h>
 
 #include <machine/bus.h>
 #include <machine/endian.h>
@@ -75,6 +78,7 @@
 
 #if defined(__FreeBSD__)
 #include <machine/clock.h>
+
 #define delay(d)                DELAY(d)
 #endif
 
@@ -111,64 +115,77 @@ void		ohci_free_sed __P((ohci_softc_t *, ohci_soft_ed_t *));
 ohci_soft_td_t *ohci_alloc_std __P((ohci_softc_t *));
 void		ohci_free_std __P((ohci_softc_t *, ohci_soft_td_t *));
 
+ohci_soft_itd_t *ohci_alloc_sitd __P((ohci_softc_t *));
+void ohci_free_sitd __P((ohci_softc_t *, ohci_soft_itd_t *));
+
+#if 0
 void		ohci_free_std_chain __P((ohci_softc_t *, 
 					 ohci_soft_td_t *, ohci_soft_td_t *));
+#endif
 usbd_status	ohci_alloc_std_chain __P((struct ohci_pipe *, ohci_softc_t *,
-					  int, int, int, usb_dma_t *, 
+					  int, int, usbd_xfer_handle,
 					  ohci_soft_td_t *,
 					  ohci_soft_td_t **));
 
+void		ohci_shutdown __P((void *v));
 void		ohci_power __P((int, void *));
 usbd_status	ohci_open __P((usbd_pipe_handle));
 void		ohci_poll __P((struct usbd_bus *));
-void		ohci_waitintr __P((ohci_softc_t *, usbd_request_handle));
-void		ohci_rhsc __P((ohci_softc_t *, usbd_request_handle));
-void		ohci_process_done __P((ohci_softc_t *, ohci_physaddr_t));
+void		ohci_softintr __P((struct usbd_bus *));
+void		ohci_waitintr __P((ohci_softc_t *, usbd_xfer_handle));
+void		ohci_rhsc __P((ohci_softc_t *, usbd_xfer_handle));
 
-usbd_status	ohci_device_request __P((usbd_request_handle reqh));
+usbd_status	ohci_device_request __P((usbd_xfer_handle xfer));
 void		ohci_add_ed __P((ohci_soft_ed_t *, ohci_soft_ed_t *));
 void		ohci_rem_ed __P((ohci_soft_ed_t *, ohci_soft_ed_t *));
 void		ohci_hash_add_td __P((ohci_softc_t *, ohci_soft_td_t *));
 void		ohci_hash_rem_td __P((ohci_softc_t *, ohci_soft_td_t *));
 ohci_soft_td_t *ohci_hash_find_td __P((ohci_softc_t *, ohci_physaddr_t));
 
+usbd_status	ohci_setup_isoc __P((usbd_pipe_handle pipe));
+void		ohci_device_isoc_enter __P((usbd_xfer_handle));
+
 usbd_status	ohci_allocm __P((struct usbd_bus *, usb_dma_t *, u_int32_t));
 void		ohci_freem __P((struct usbd_bus *, usb_dma_t *));
 
-usbd_status	ohci_root_ctrl_transfer __P((usbd_request_handle));
-usbd_status	ohci_root_ctrl_start __P((usbd_request_handle));
-void		ohci_root_ctrl_abort __P((usbd_request_handle));
+usbd_xfer_handle ohci_allocx __P((struct usbd_bus *));
+void		ohci_freex __P((struct usbd_bus *, usbd_xfer_handle));
+
+usbd_status	ohci_root_ctrl_transfer __P((usbd_xfer_handle));
+usbd_status	ohci_root_ctrl_start __P((usbd_xfer_handle));
+void		ohci_root_ctrl_abort __P((usbd_xfer_handle));
 void		ohci_root_ctrl_close __P((usbd_pipe_handle));
+void		ohci_root_ctrl_done __P((usbd_xfer_handle));
 
-usbd_status	ohci_root_intr_transfer __P((usbd_request_handle));
-usbd_status	ohci_root_intr_start __P((usbd_request_handle));
-void		ohci_root_intr_abort __P((usbd_request_handle));
+usbd_status	ohci_root_intr_transfer __P((usbd_xfer_handle));
+usbd_status	ohci_root_intr_start __P((usbd_xfer_handle));
+void		ohci_root_intr_abort __P((usbd_xfer_handle));
 void		ohci_root_intr_close __P((usbd_pipe_handle));
-void		ohci_root_intr_done  __P((usbd_request_handle));
+void		ohci_root_intr_done  __P((usbd_xfer_handle));
 
-usbd_status	ohci_device_ctrl_transfer __P((usbd_request_handle));
-usbd_status	ohci_device_ctrl_start __P((usbd_request_handle));
-void		ohci_device_ctrl_abort __P((usbd_request_handle));
+usbd_status	ohci_device_ctrl_transfer __P((usbd_xfer_handle));
+usbd_status	ohci_device_ctrl_start __P((usbd_xfer_handle));
+void		ohci_device_ctrl_abort __P((usbd_xfer_handle));
 void		ohci_device_ctrl_close __P((usbd_pipe_handle));
-void		ohci_device_ctrl_done  __P((usbd_request_handle));
+void		ohci_device_ctrl_done  __P((usbd_xfer_handle));
 
-usbd_status	ohci_device_bulk_transfer __P((usbd_request_handle));
-usbd_status	ohci_device_bulk_start __P((usbd_request_handle));
-void		ohci_device_bulk_abort __P((usbd_request_handle));
+usbd_status	ohci_device_bulk_transfer __P((usbd_xfer_handle));
+usbd_status	ohci_device_bulk_start __P((usbd_xfer_handle));
+void		ohci_device_bulk_abort __P((usbd_xfer_handle));
 void		ohci_device_bulk_close __P((usbd_pipe_handle));
-void		ohci_device_bulk_done  __P((usbd_request_handle));
+void		ohci_device_bulk_done  __P((usbd_xfer_handle));
 
-usbd_status	ohci_device_intr_transfer __P((usbd_request_handle));
-usbd_status	ohci_device_intr_start __P((usbd_request_handle));
-void		ohci_device_intr_abort __P((usbd_request_handle));
+usbd_status	ohci_device_intr_transfer __P((usbd_xfer_handle));
+usbd_status	ohci_device_intr_start __P((usbd_xfer_handle));
+void		ohci_device_intr_abort __P((usbd_xfer_handle));
 void		ohci_device_intr_close __P((usbd_pipe_handle));
-void		ohci_device_intr_done  __P((usbd_request_handle));
+void		ohci_device_intr_done  __P((usbd_xfer_handle));
 
-usbd_status	ohci_device_isoc_transfer __P((usbd_request_handle));
-usbd_status	ohci_device_isoc_start __P((usbd_request_handle));
-void		ohci_device_isoc_abort __P((usbd_request_handle));
+usbd_status	ohci_device_isoc_transfer __P((usbd_xfer_handle));
+usbd_status	ohci_device_isoc_start __P((usbd_xfer_handle));
+void		ohci_device_isoc_abort __P((usbd_xfer_handle));
 void		ohci_device_isoc_close __P((usbd_pipe_handle));
-void		ohci_device_isoc_done  __P((usbd_request_handle));
+void		ohci_device_isoc_done  __P((usbd_xfer_handle));
 
 usbd_status	ohci_device_setintr __P((ohci_softc_t *sc, 
 					 struct ohci_pipe *pipe, int ival));
@@ -180,15 +197,14 @@ void		ohci_rhsc_able __P((ohci_softc_t *, int));
 
 void		ohci_close_pipe __P((usbd_pipe_handle pipe, 
 				     ohci_soft_ed_t *head));
-void		ohci_abort_req __P((usbd_request_handle reqh,
+void		ohci_abort_xfer __P((usbd_xfer_handle xfer,
 					usbd_status status));
-void		ohci_abort_req_end __P((void *));
+void		ohci_abort_xfer_end __P((void *));
 
 void		ohci_device_clear_toggle __P((usbd_pipe_handle pipe));
 void		ohci_noop __P((usbd_pipe_handle pipe));
 
 #ifdef OHCI_DEBUG
-ohci_softc_t   *thesc;
 void		ohci_dumpregs __P((ohci_softc_t *));
 void		ohci_dump_tds __P((ohci_soft_td_t *));
 void		ohci_dump_td __P((ohci_soft_td_t *));
@@ -209,7 +225,10 @@ static u_int8_t revbits[OHCI_NO_INTRS] =
 struct ohci_pipe {
 	struct usbd_pipe pipe;
 	ohci_soft_ed_t *sed;
-	ohci_soft_td_t *tail;
+	union {
+		ohci_soft_td_t *td;
+		ohci_soft_itd_t *itd;
+	} tail;
 	/* Info needed for different pipe kinds. */
 	union {
 		/* Control pipe */
@@ -231,6 +250,7 @@ struct ohci_pipe {
 		/* Iso pipe */
 		struct iso {
 			int xxxxx;
+			int next, inuse;
 		} iso;
 	} u;
 };
@@ -239,9 +259,12 @@ struct ohci_pipe {
 
 struct usbd_bus_methods ohci_bus_methods = {
 	ohci_open,
+	ohci_softintr,
 	ohci_poll,
 	ohci_allocm,
 	ohci_freem,
+	ohci_allocx,
+	ohci_freex,
 };
 
 struct usbd_pipe_methods ohci_root_ctrl_methods = {	
@@ -250,7 +273,7 @@ struct usbd_pipe_methods ohci_root_ctrl_methods = {
 	ohci_root_ctrl_abort,
 	ohci_root_ctrl_close,
 	ohci_noop,
-	0,
+	ohci_root_ctrl_done,
 };
 
 struct usbd_pipe_methods ohci_root_intr_methods = {	
@@ -289,7 +312,6 @@ struct usbd_pipe_methods ohci_device_bulk_methods = {
 	ohci_device_bulk_done,
 };
 
-#if 0
 struct usbd_pipe_methods ohci_device_isoc_methods = {
 	ohci_device_isoc_transfer,
 	ohci_device_isoc_start,
@@ -298,8 +320,8 @@ struct usbd_pipe_methods ohci_device_isoc_methods = {
 	ohci_noop,
 	ohci_device_isoc_done,
 };
-#endif
 
+#if defined(__NetBSD__) || defined(__OpenBSD__)
 int
 ohci_activate(self, act)
 	device_ptr_t self;
@@ -335,25 +357,28 @@ ohci_detach(sc, flags)
 		return (rv);
 
 	powerhook_disestablish(sc->sc_powerhook);
+	shutdownhook_disestablish(sc->sc_shutdownhook);
+
 	/* free data structures XXX */
 
 	return (rv);
 }
+#endif
 
 ohci_soft_ed_t *
 ohci_alloc_sed(sc)
 	ohci_softc_t *sc;
 {
 	ohci_soft_ed_t *sed;
-	usbd_status r;
+	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 
-	if (!sc->sc_freeeds) {
+	if (sc->sc_freeeds == NULL) {
 		DPRINTFN(2, ("ohci_alloc_sed: allocating chunk\n"));
-		r = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK,
+		err = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK,
 				 OHCI_ED_ALIGN, &dma);
-		if (r != USBD_NORMAL_COMPLETION)
+		if (err)
 			return (0);
 		for(i = 0; i < OHCI_SED_CHUNK; i++) {
 			offs = i * OHCI_SED_SIZE;
@@ -384,16 +409,18 @@ ohci_alloc_std(sc)
 	ohci_softc_t *sc;
 {
 	ohci_soft_td_t *std;
-	usbd_status r;
+	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
+	int s;
 
-	if (!sc->sc_freetds) {
+	if (sc->sc_freetds == NULL) {
 		DPRINTFN(2, ("ohci_alloc_std: allocating chunk\n"));
-		r = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
+		err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
 				 OHCI_TD_ALIGN, &dma);
-		if (r != USBD_NORMAL_COMPLETION)
+		if (err)
 			return (0);
+		s = splusb();
 		for(i = 0; i < OHCI_STD_CHUNK; i++) {
 			offs = i * OHCI_STD_SIZE;
 			std = (ohci_soft_td_t *)((char *)KERNADDR(&dma) +offs);
@@ -401,11 +428,18 @@ ohci_alloc_std(sc)
 			std->nexttd = sc->sc_freetds;
 			sc->sc_freetds = std;
 		}
+		splx(s);
 	}
+
+	s = splusb();
 	std = sc->sc_freetds;
 	sc->sc_freetds = std->nexttd;
 	memset(&std->td, 0, sizeof(ohci_td_t));
 	std->nexttd = 0;
+
+	ohci_hash_add_td(sc, std);
+	splx(s);
+
 	return (std);
 }
 
@@ -414,33 +448,46 @@ ohci_free_std(sc, std)
 	ohci_softc_t *sc;
 	ohci_soft_td_t *std;
 {
+	int s;
+
+	s = splusb();
+	ohci_hash_rem_td(sc, std);
+
 	std->nexttd = sc->sc_freetds;
 	sc->sc_freetds = std;
+	splx(s);
 }
 
 usbd_status
-ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep)
-	struct ohci_pipe *upipe;
+ohci_alloc_std_chain(opipe, sc, alen, rd, xfer, sp, ep)
+	struct ohci_pipe *opipe;
 	ohci_softc_t *sc;
-	int len, rd, shortok;
-	usb_dma_t *dma;
+	int alen, rd;
+	usbd_xfer_handle xfer;
 	ohci_soft_td_t *sp, **ep;
 {
 	ohci_soft_td_t *next, *cur;
 	ohci_physaddr_t dataphys, dataphysend;
-	u_int32_t intr;
-	int curlen;
+	u_int32_t tdflags;
+	int len, curlen;
+	usb_dma_t *dma = &xfer->dmabuf;
+	u_int16_t flags = xfer->flags;
 
-	DPRINTFN(len >= 4096,("ohci_alloc_std_chain: start len=%d\n", len));
+	DPRINTFN(alen < 4096,("ohci_alloc_std_chain: start len=%d\n", alen));
+
+	len = alen;
 	cur = sp;
 	dataphys = DMAADDR(dma);
 	dataphysend = OHCI_PAGE(dataphys + len - 1);
+	tdflags = LE(
+	    (rd ? OHCI_TD_IN : OHCI_TD_OUT) |
+	    (flags & USBD_SHORT_XFER_OK ? OHCI_TD_R : 0) |
+	    OHCI_TD_NOCC | OHCI_TD_TOGGLE_CARRY | OHCI_TD_NOINTR);
+
 	for (;;) {
 		next = ohci_alloc_std(sc);
-		if (next == 0) {
-			/* XXX free chain */
-			return (USBD_NOMEM);
-		}
+		if (next == NULL)
+			goto nomem;
 
 		/* The OHCI hardware can handle at most one page crossing. */
 		if (OHCI_PAGE(dataphys) == dataphysend ||
@@ -451,6 +498,12 @@ ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep)
 			/* must use multiple TDs, fill as much as possible. */
 			curlen = 2 * OHCI_PAGE_SIZE - 
 				 (dataphys & (OHCI_PAGE_SIZE-1));
+			/* the length must be a multiple of the max size */
+			curlen -= curlen % UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize);
+#ifdef DIAGNOSTIC
+			if (curlen == 0)
+				panic("ohci_alloc_std: curlen == 0\n");
+#endif
 		}
 		DPRINTFN(4,("ohci_alloc_std_chain: dataphys=0x%08x "
 			    "dataphysend=0x%08x len=%d curlen=%d\n",
@@ -458,17 +511,14 @@ ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep)
 			    len, curlen));
 		len -= curlen;
 
-		intr = len == 0 ? OHCI_TD_SET_DI(1) : OHCI_TD_NOINTR;
-		cur->td.td_flags = LE(
-			(rd ? OHCI_TD_IN : OHCI_TD_OUT) | OHCI_TD_NOCC |
-			intr | OHCI_TD_TOGGLE_CARRY |
-			(shortok ? OHCI_TD_R : 0));
+		cur->td.td_flags = tdflags;
 		cur->td.td_cbp = LE(dataphys);
 		cur->nexttd = next;
 		cur->td.td_nexttd = LE(next->physaddr);
 		cur->td.td_be = LE(dataphys + curlen - 1);
 		cur->len = curlen;
 		cur->flags = OHCI_ADD_LEN;
+		cur->xfer = xfer;
 		DPRINTFN(10,("ohci_alloc_std_chain: cbp=0x%08x be=0x%08x\n",
 			    dataphys, dataphys + curlen - 1));
 		if (len == 0)
@@ -477,12 +527,35 @@ ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep)
 		dataphys += curlen;
 		cur = next;
 	}
-	cur->flags = OHCI_CALL_DONE | OHCI_ADD_LEN;
-	*ep = next;
+	if ((flags & USBD_FORCE_SHORT_XFER) &&
+	    alen % UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize) == 0) {
+		/* Force a 0 length transfer at the end. */
+
+		cur = next;
+		next = ohci_alloc_std(sc);
+		if (next == NULL)
+			goto nomem;
+
+		cur->td.td_flags = tdflags;
+		cur->td.td_cbp = 0; /* indicate 0 length packet */
+		cur->nexttd = next;
+		cur->td.td_nexttd = LE(next->physaddr);
+		cur->td.td_be = ~0;
+		cur->len = 0;
+		cur->flags = 0;
+		cur->xfer = xfer;
+		DPRINTFN(2,("ohci_alloc_std_chain: add 0 xfer\n"));
+	}
+	*ep = cur;
 
 	return (USBD_NORMAL_COMPLETION);
+
+nomem:
+	/* XXX free chain */
+	return (USBD_NOMEM);
 }
 
+#if 0
 void
 ohci_free_std_chain(sc, std, stdend)
 	ohci_softc_t *sc;
@@ -496,84 +569,131 @@ ohci_free_std_chain(sc, std, stdend)
 		ohci_free_std(sc, std);
 	}
 }
+#endif
+
+ohci_soft_itd_t *
+ohci_alloc_sitd(sc)
+	ohci_softc_t *sc;
+{
+	ohci_soft_itd_t *sitd;
+	usbd_status err;
+	int i, offs;
+	usb_dma_t dma;
+
+	if (sc->sc_freeitds == NULL) {
+		DPRINTFN(2, ("ohci_alloc_sitd: allocating chunk\n"));
+		err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
+			  OHCI_TD_ALIGN, &dma);
+		if (err)
+			return (0);
+		for (i = 0; i < OHCI_STD_CHUNK; i++) {
+			offs = i * OHCI_STD_SIZE;
+			sitd = (ohci_soft_itd_t *)((char*)KERNADDR(&dma)+offs);
+			sitd->physaddr = DMAADDR(&dma) + offs;
+			sitd->nextitd = sc->sc_freeitds;
+			sc->sc_freeitds = sitd;
+		}
+	}
+	sitd = sc->sc_freeitds;
+	sc->sc_freeitds = sitd->nextitd;
+	memset(&sitd->itd, 0, sizeof(ohci_itd_t));
+	sitd->nextitd = 0;
+	return (sitd);
+}
+
+void
+ohci_free_sitd(sc, sitd)
+	ohci_softc_t *sc;
+	ohci_soft_itd_t *sitd;
+{
+	sitd->nextitd = sc->sc_freeitds;
+	sc->sc_freeitds = sitd;
+}
 
 usbd_status
 ohci_init(sc)
 	ohci_softc_t *sc;
 {
 	ohci_soft_ed_t *sed, *psed;
-	usbd_status r;
-	int rev;
+	usbd_status err;
 	int i;
-	u_int32_t s, ctl, ival, hcr, fm, per;
+	u_int32_t s, ctl, ival, hcr, fm, per, rev, desca;
 
 	DPRINTF(("ohci_init: start\n"));
-	rev = OREAD4(sc, OHCI_REVISION);
 #if defined(__OpenBSD__)
-	printf(" version %d.%d%s", 
+	printf(",");
 #else
-	printf("%s: OHCI version %d.%d%s\n", USBDEVNAME(sc->sc_bus.bdev),
+	printf("%s:", USBDEVNAME(sc->sc_bus.bdev));
 #endif
-	       OHCI_REV_HI(rev), OHCI_REV_LO(rev),
+	rev = OREAD4(sc, OHCI_REVISION);
+	printf(" OHCI version %d.%d%s\n", OHCI_REV_HI(rev), OHCI_REV_LO(rev),
 	       OHCI_REV_LEGACY(rev) ? ", legacy support" : "");
 	if (OHCI_REV_HI(rev) != 1 || OHCI_REV_LO(rev) != 0) {
-#if defined(__OpenBSD__)
-		printf(": unsupported\n");
-#else
 		printf("%s: unsupported OHCI revision\n", 
 		       USBDEVNAME(sc->sc_bus.bdev));
-#endif
+		sc->sc_bus.usbrev = USBREV_UNKNOWN;
 		return (USBD_INVAL);
-#if defined(__OpenBSD__)
-	} else {
-		printf("\n");
-#endif
 	}
+	sc->sc_bus.usbrev = USBREV_1_0;
 
 	for (i = 0; i < OHCI_HASH_SIZE; i++)
 		LIST_INIT(&sc->sc_hash_tds[i]);
 
+	SIMPLEQ_INIT(&sc->sc_free_xfers);
+
+	/* XXX determine alignment by R/W */
 	/* Allocate the HCCA area. */
-	r = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE, 
+	err = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE, 
 			 OHCI_HCCA_ALIGN, &sc->sc_hccadma);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
+	if (err)
+		return (err);
 	sc->sc_hcca = (struct ohci_hcca *)KERNADDR(&sc->sc_hccadma);
 	memset(sc->sc_hcca, 0, OHCI_HCCA_SIZE);
 
 	sc->sc_eintrs = OHCI_NORMAL_INTRS;
 
+	/* Allocate dummy ED that starts the control list. */
 	sc->sc_ctrl_head = ohci_alloc_sed(sc);
-	if (!sc->sc_ctrl_head) {
-		r = USBD_NOMEM;
+	if (sc->sc_ctrl_head == NULL) {
+		err = USBD_NOMEM;
 		goto bad1;
 	}
 	sc->sc_ctrl_head->ed.ed_flags |= LE(OHCI_ED_SKIP);
 
+	/* Allocate dummy ED that starts the bulk list. */
 	sc->sc_bulk_head = ohci_alloc_sed(sc);
-	if (!sc->sc_bulk_head) {
-		r = USBD_NOMEM;
+	if (sc->sc_bulk_head == NULL) {
+		err = USBD_NOMEM;
 		goto bad2;
 	}
 	sc->sc_bulk_head->ed.ed_flags |= LE(OHCI_ED_SKIP);
 
+	/* Allocate dummy ED that starts the isochronous list. */
+	sc->sc_isoc_head = ohci_alloc_sed(sc);
+	if (sc->sc_isoc_head == NULL) {
+		err = USBD_NOMEM;
+		goto bad3;
+	}
+	sc->sc_isoc_head->ed.ed_flags |= LE(OHCI_ED_SKIP);
+
 	/* Allocate all the dummy EDs that make up the interrupt tree. */
 	for (i = 0; i < OHCI_NO_EDS; i++) {
 		sed = ohci_alloc_sed(sc);
-		if (!sed) {
+		if (sed == NULL) {
 			while (--i >= 0)
 				ohci_free_sed(sc, sc->sc_eds[i]);
-			r = USBD_NOMEM;
-			goto bad3;
+			err = USBD_NOMEM;
+			goto bad4;
 		}
 		/* All ED fields are set to 0. */
 		sc->sc_eds[i] = sed;
 		sed->ed.ed_flags |= LE(OHCI_ED_SKIP);
-		if (i != 0) {
+		if (i != 0)
 			psed = sc->sc_eds[(i-1) / 2];
-			sed->next = psed;
-			sed->ed.ed_nexted = LE(psed->physaddr);
-		}
+		else
+			psed = sc->sc_isoc_head;
+		sed->next = psed;
+		sed->ed.ed_nexted = LE(psed->physaddr);
 	}
 	/* 
 	 * Fill HCCA interrupt table.  The bit reversal is to get
@@ -583,6 +703,17 @@ ohci_init(sc)
 		sc->sc_hcca->hcca_interrupt_table[revbits[i]] = 
 			LE(sc->sc_eds[OHCI_NO_EDS-OHCI_NO_INTRS+i]->physaddr);
 
+#ifdef OHCI_DEBUG
+	if (ohcidebug > 15) {
+		for (i = 0; i < OHCI_NO_EDS; i++) {
+			printf("ed#%d ", i);
+			ohci_dump_ed(sc->sc_eds[i]);
+		}
+		printf("iso ");
+		ohci_dump_ed(sc->sc_isoc_head);
+	}
+#endif
+
 	/* Determine in what context we are running. */
 	ctl = OREAD4(sc, OHCI_CONTROL);
 	if (ctl & OHCI_IR) {
@@ -591,7 +722,7 @@ ohci_init(sc)
 		s = OREAD4(sc, OHCI_COMMAND_STATUS);
 		OWRITE4(sc, OHCI_COMMAND_STATUS, s | OHCI_OCR);
 		for (i = 0; i < 100 && (ctl & OHCI_IR); i++) {
-			delay(1000);
+			usb_delay_ms(&sc->sc_bus, 1);
 			ctl = OREAD4(sc, OHCI_CONTROL);
 		}
 		if ((ctl & OHCI_IR) == 0) {
@@ -605,13 +736,13 @@ ohci_init(sc)
 		DPRINTF(("ohci_init: BIOS active\n"));
 		if ((ctl & OHCI_HCFS_MASK) != OHCI_HCFS_OPERATIONAL) {
 			OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_OPERATIONAL);
-			delay(USB_RESUME_DELAY * 1000);
+			usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY);
 		}
 	} else {
 		DPRINTF(("ohci_init: cold started\n"));
 	reset:
 		/* Controller was cold started. */
-		delay(USB_BUS_RESET_DELAY * 1000);
+		usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY);
 	}
 
 	/*
@@ -620,7 +751,7 @@ ohci_init(sc)
 	 */
 	DPRINTF(("%s: resetting\n", USBDEVNAME(sc->sc_bus.bdev)));
 	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
-	delay(USB_BUS_RESET_DELAY * 1000);
+	usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY);
 
 	/* We now own the host controller and the bus has been reset. */
 	ival = OHCI_GET_IVAL(OREAD4(sc, OHCI_FM_INTERVAL));
@@ -635,23 +766,24 @@ ohci_init(sc)
 	}
 	if (hcr) {
 		printf("%s: reset timeout\n", USBDEVNAME(sc->sc_bus.bdev));
-		r = USBD_IOERROR;
-		goto bad3;
+		err = USBD_IOERROR;
+		goto bad5;
 	}
 #ifdef OHCI_DEBUG
-	thesc = sc;
 	if (ohcidebug > 15)
 		ohci_dumpregs(sc);
 #endif
 
-	/* The controller is now in suspend state, we have 2ms to finish. */
+	/* The controller is now in SUSPEND state, we have 2ms to finish. */
 
 	/* Set up HC registers. */
 	OWRITE4(sc, OHCI_HCCA, DMAADDR(&sc->sc_hccadma));
 	OWRITE4(sc, OHCI_CONTROL_HEAD_ED, sc->sc_ctrl_head->physaddr);
 	OWRITE4(sc, OHCI_BULK_HEAD_ED, sc->sc_bulk_head->physaddr);
+	/* disable all interrupts and then switch on all desired interrupts */
 	OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS);
 	OWRITE4(sc, OHCI_INTERRUPT_ENABLE, sc->sc_eintrs | OHCI_MIE);
+	/* switch on desired functional features */
 	ctl = OREAD4(sc, OHCI_CONTROL);
 	ctl &= ~(OHCI_CBSR_MASK | OHCI_LES | OHCI_HCFS_MASK | OHCI_IR);
 	ctl |= OHCI_PLE | OHCI_IE | OHCI_CLE | OHCI_BLE |
@@ -670,7 +802,12 @@ ohci_init(sc)
 	per = OHCI_PERIODIC(ival); /* 90% periodic */
 	OWRITE4(sc, OHCI_PERIODIC_START, per);
 
-	OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC);	/* Enable port power */
+	/* Fiddle the No OverCurrent Protection bit to avoid chip bug. */
+	desca = OREAD4(sc, OHCI_RH_DESCRIPTOR_A);
+	OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca | OHCI_NOCP);
+	OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC); /* Enable port power */
+	usb_delay_ms(&sc->sc_bus, 5);
+	OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca);
 
 	sc->sc_noport = OHCI_GET_NDP(OREAD4(sc, OHCI_RH_DESCRIPTOR_A));
 
@@ -684,16 +821,22 @@ ohci_init(sc)
 	sc->sc_bus.pipe_size = sizeof(struct ohci_pipe);
 
 	sc->sc_powerhook = powerhook_establish(ohci_power, sc);
+	sc->sc_shutdownhook = shutdownhook_establish(ohci_shutdown, sc);
 
 	return (USBD_NORMAL_COMPLETION);
 
+ bad5:
+	for (i = 0; i < OHCI_NO_EDS; i++)
+		ohci_free_sed(sc, sc->sc_eds[i]);
+ bad4:
+	ohci_free_sed(sc, sc->sc_isoc_head);
  bad3:
 	ohci_free_sed(sc, sc->sc_ctrl_head);
  bad2:
 	ohci_free_sed(sc, sc->sc_bulk_head);
  bad1:
 	usb_freemem(&sc->sc_bus, &sc->sc_hccadma);
-	return (r);
+	return (err);
 }
 
 usbd_status
@@ -721,7 +864,49 @@ ohci_freem(bus, dma)
 	usb_freemem(&sc->sc_bus, dma);
 }
 
-#if defined(__NetBSD__) || defined(__OpenBSD__)
+usbd_xfer_handle
+ohci_allocx(bus)
+	struct usbd_bus *bus;
+{
+	struct ohci_softc *sc = (struct ohci_softc *)bus;
+	usbd_xfer_handle xfer;
+
+	xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers);
+	if (xfer != NULL)
+		SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, xfer, next);	
+	else
+		xfer = malloc(sizeof(*xfer), M_USB, M_NOWAIT);
+	if (xfer != NULL)
+		memset(xfer, 0, sizeof *xfer);
+	return (xfer);
+}
+
+void ohci_freex(bus, xfer)
+	struct usbd_bus *bus;
+	usbd_xfer_handle xfer;
+{
+	struct ohci_softc *sc = (struct ohci_softc *)bus;
+
+	SIMPLEQ_INSERT_HEAD(&sc->sc_free_xfers, xfer, next);
+}
+
+void
+ohci_shutdown(v)
+	void *v;
+{
+	ohci_softc_t *sc = v;
+
+	DPRINTF(("ohci_shutdown: stopping the HC\n"));
+	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
+}
+
+/*
+ * Handle suspend/resume.
+ *
+ * We need to switch to polling mode here, because this routine is
+ * called from an interrupt context.  This is all right since we
+ * are almost suspended anyway.
+ */
 void
 ohci_power(why, v)
 	int why;
@@ -735,12 +920,8 @@ ohci_power(why, v)
 	ohci_dumpregs(sc);
 #endif
 }
-#endif /* defined(__NetBSD__) || defined(__OpenBSD__) */
 
 #ifdef OHCI_DEBUG
-void ohcidump(void);
-void ohcidump(void) { ohci_dumpregs(thesc); }
-
 void
 ohci_dumpregs(sc)
 	ohci_softc_t *sc;
@@ -782,11 +963,29 @@ ohci_dumpregs(sc)
 }
 #endif
 
+int ohci_intr1 __P((ohci_softc_t *));
+
 int
 ohci_intr(p)
 	void *p;
 {
 	ohci_softc_t *sc = p;
+
+	/* If we get an interrupt while polling, then just ignore it. */
+	if (sc->sc_bus.use_polling) {
+#ifdef DIAGNOSTIC
+		printf("ohci_intr: ignored interrupt while polling\n");
+#endif
+		return (0);
+	}
+
+	return (ohci_intr1(sc));
+}
+
+int
+ohci_intr1(sc)
+	ohci_softc_t *sc;
+{
 	u_int32_t intrs, eintrs;
 	ohci_physaddr_t done;
 
@@ -808,8 +1007,10 @@ ohci_intr(p)
 			intrs |= OREAD4(sc, OHCI_INTERRUPT_STATUS);
 	} else
 		intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS);
+
 	if (!intrs)
 		return (0);
+
 	intrs &= ~OHCI_MIE;
 	OWRITE4(sc, OHCI_INTERRUPT_STATUS, intrs); /* Acknowledge */
 	eintrs = intrs & sc->sc_eintrs;
@@ -818,7 +1019,7 @@ ohci_intr(p)
 
 	sc->sc_bus.intr_context++;
 	sc->sc_bus.no_intrs++;
-	DPRINTFN(7, ("ohci_intr: sc=%p intrs=%x(%x) eintr=%x\n", 
+	DPRINTFN(7, ("ohci_intr: sc=%p intrs=0x%x(0x%x) eintr=0x%x\n", 
 		     sc, (u_int)intrs, OREAD4(sc, OHCI_INTERRUPT_STATUS),
 		     (u_int)eintrs));
 
@@ -828,7 +1029,21 @@ ohci_intr(p)
 		intrs &= ~OHCI_SO;
 	}
 	if (eintrs & OHCI_WDH) {
-		ohci_process_done(sc, done &~ OHCI_DONE_INTRS);
+		done &= ~OHCI_DONE_INTRS;
+		if (sc->sc_done == 0)
+			sc->sc_done = done;
+		else {
+			/* Tack on at end of the sc_dne. */
+			ohci_physaddr_t ldone;
+			ohci_soft_td_t *std;
+
+			for (ldone = sc->sc_done; ldone != 0;
+			     ldone = LE(std->td.td_nexttd))
+				std = ohci_hash_find_td(sc, ldone);
+			std->td.td_nexttd = LE(done);
+		}
+		sc->sc_hcca->hcca_done_head = 0;
+		usb_schedsoftintr(&sc->sc_bus);
 		intrs &= ~OHCI_WDH;
 	}
 	if (eintrs & OHCI_RD) {
@@ -842,7 +1057,7 @@ ohci_intr(p)
 		/* XXX what else */
 	}
 	if (eintrs & OHCI_RHSC) {
-		ohci_rhsc(sc, sc->sc_intrreqh);
+		ohci_rhsc(sc, sc->sc_intrxfer);
 		intrs &= ~OHCI_RHSC;
 
 		/* 
@@ -890,23 +1105,34 @@ char *ohci_cc_strs[] = {
 	"DATA_UNDERRUN",
 	"BUFFER_OVERRUN",
 	"BUFFER_UNDERRUN",
+	"reserved",
+	"reserved",
+	"NOT ACCESSED",
 	"NOT_ACCESSED",
 };
 #endif
 
 void
-ohci_process_done(sc, done)
-	ohci_softc_t *sc;
-	ohci_physaddr_t done;
+ohci_softintr(bus)
+	struct usbd_bus *bus;
 {
+	ohci_softc_t *sc = (ohci_softc_t *)bus;
+	ohci_physaddr_t done;
 	ohci_soft_td_t *std, *sdone, *stdnext;
-	usbd_request_handle reqh;
-	int len, cc;
+	usbd_xfer_handle xfer;
+	int len, cc, s;
+
+	sc->sc_bus.intr_context++;
+
+	s = splhardusb();
+	done = sc->sc_done;
+	sc->sc_done = 0;
+	splx(s);
 
 	DPRINTFN(10,("ohci_process_done: done=0x%08lx\n", (u_long)done));
 
 	/* Reverse the done list. */
-	for (sdone = 0; done; done = LE(std->td.td_nexttd)) {
+	for (sdone = NULL; done != 0; done = LE(std->td.td_nexttd)) {
 		std = ohci_hash_find_td(sc, done);
 		std->dnext = sdone;
 		sdone = std;
@@ -920,29 +1146,30 @@ ohci_process_done(sc, done)
 #endif
 
 	for (std = sdone; std; std = stdnext) {
-		reqh = std->reqh;
+		xfer = std->xfer;
 		stdnext = std->dnext;
-		DPRINTFN(10, ("ohci_process_done: std=%p reqh=%p hcpriv=%p\n",
-				std, reqh, reqh->hcpriv));
+		DPRINTFN(10, ("ohci_process_done: std=%p xfer=%p hcpriv=%p\n",
+				std, xfer, xfer ? xfer->hcpriv : 0));
 		cc = OHCI_TD_GET_CC(LE(std->td.td_flags));
-		usb_untimeout(ohci_timeout, reqh, reqh->timo_handle);
-		if (reqh->status == USBD_CANCELLED ||
-		    reqh->status == USBD_TIMEOUT) {
+		usb_untimeout(ohci_timeout, xfer, xfer->timo_handle);
+		if (xfer->status == USBD_CANCELLED ||
+		    xfer->status == USBD_TIMEOUT) {
 			DPRINTF(("ohci_process_done: cancel/timeout %p\n",
-				 reqh));
+				 xfer));
 			/* Handled by abort routine. */
 		} else if (cc == OHCI_CC_NO_ERROR) {
 			len = std->len;
 			if (std->td.td_cbp != 0)
 				len -= LE(std->td.td_be) -
 				       LE(std->td.td_cbp) + 1;
+			DPRINTFN(10, ("ohci_process_done: len=%d, flags=0x%x\n",
+				      len, std->flags));
 			if (std->flags & OHCI_ADD_LEN)
-				reqh->actlen += len;
+				xfer->actlen += len;
 			if (std->flags & OHCI_CALL_DONE) {
-				reqh->status = USBD_NORMAL_COMPLETION;
-				usb_transfer_complete(reqh);
+				xfer->status = USBD_NORMAL_COMPLETION;
+				usb_transfer_complete(xfer);
 			}
-			ohci_hash_rem_td(sc, std);
 			ohci_free_std(sc, std);
 		} else {
 			/*
@@ -952,16 +1179,15 @@ ohci_process_done(sc, done)
 			 */
 			ohci_soft_td_t *p, *n;
 			struct ohci_pipe *opipe = 
-				(struct ohci_pipe *)reqh->pipe;
+				(struct ohci_pipe *)xfer->pipe;
 
-			DPRINTFN(-1,("ohci_process_done: error cc=%d (%s)\n",
+			DPRINTF(("ohci_process_done: error cc=%d (%s)\n",
 			 OHCI_TD_GET_CC(LE(std->td.td_flags)),
 			 ohci_cc_strs[OHCI_TD_GET_CC(LE(std->td.td_flags))]));
 
 			/* remove TDs */
-			for (p = std; p->reqh == reqh; p = n) {
+			for (p = std; p->xfer == xfer; p = n) {
 				n = p->nexttd;
-				ohci_hash_rem_td(sc, p);
 				ohci_free_std(sc, p);
 			}
 
@@ -970,87 +1196,87 @@ ohci_process_done(sc, done)
 			OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
 
 			if (cc == OHCI_CC_STALL)
-				reqh->status = USBD_STALLED;
+				xfer->status = USBD_STALLED;
 			else
-				reqh->status = USBD_IOERROR;
-			usb_transfer_complete(reqh);
+				xfer->status = USBD_IOERROR;
+			usb_transfer_complete(xfer);
 		}
 	}
+
+	sc->sc_bus.intr_context--;
 }
 
 void
-ohci_device_ctrl_done(reqh)
-	usbd_request_handle reqh;
+ohci_device_ctrl_done(xfer)
+	usbd_xfer_handle xfer;
 {
-	DPRINTFN(10,("ohci_ctrl_done: reqh=%p\n", reqh));
+	DPRINTFN(10,("ohci_ctrl_done: xfer=%p\n", xfer));
 
 #ifdef DIAGNOSTIC
-	if (!(reqh->rqflags & URQ_REQUEST)) {
+	if (!(xfer->rqflags & URQ_REQUEST)) {
 		panic("ohci_ctrl_done: not a request\n");
 	}
 #endif
-	reqh->hcpriv = 0;
+	xfer->hcpriv = NULL;
 }
 
 void
-ohci_device_intr_done(reqh)
-	usbd_request_handle reqh;
+ohci_device_intr_done(xfer)
+	usbd_xfer_handle xfer;
 {
-	struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe;
+	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus;
 	ohci_soft_ed_t *sed = opipe->sed;
 	ohci_soft_td_t *data, *tail;
 
+	DPRINTFN(10,("ohci_intr_done: xfer=%p, actlen=%d\n", 
+		     xfer, xfer->actlen));
 
-	DPRINTFN(10,("ohci_intr_done: reqh=%p, actlen=%d\n", 
-		     reqh, reqh->actlen));
+	xfer->hcpriv = NULL;
 
-	reqh->hcpriv = 0;
-
-	if (reqh->pipe->repeat) {
-		data = opipe->tail;
+	if (xfer->pipe->repeat) {
+		data = opipe->tail.td;
 		tail = ohci_alloc_std(sc); /* XXX should reuse TD */
-		if (!tail) {
-			reqh->status = USBD_NOMEM;
+		if (tail == NULL) {
+			xfer->status = USBD_NOMEM;
 			return;
 		}
-		tail->reqh = 0;
+		tail->xfer = NULL;
 		
 		data->td.td_flags = LE(
 			OHCI_TD_IN | OHCI_TD_NOCC | 
 			OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY);
-		if (reqh->flags & USBD_SHORT_XFER_OK)
+		if (xfer->flags & USBD_SHORT_XFER_OK)
 			data->td.td_flags |= LE(OHCI_TD_R);
-		data->td.td_cbp = LE(DMAADDR(&reqh->dmabuf));
+		data->td.td_cbp = LE(DMAADDR(&xfer->dmabuf));
 		data->nexttd = tail;
 		data->td.td_nexttd = LE(tail->physaddr);
-		data->td.td_be = LE(LE(data->td.td_cbp) + reqh->length - 1);
-		data->len = reqh->length;
-		data->reqh = reqh;
+		data->td.td_be = LE(LE(data->td.td_cbp) + xfer->length - 1);
+		data->len = xfer->length;
+		data->xfer = xfer;
 		data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN;
-		reqh->hcpriv = data;
-		reqh->actlen = 0;
+		xfer->hcpriv = data;
+		xfer->actlen = 0;
 
-		ohci_hash_add_td(sc, data);
 		sed->ed.ed_tailp = LE(tail->physaddr);
-		opipe->tail = tail;
+		opipe->tail.td = tail;
 	}
 }
 
 void
-ohci_device_bulk_done(reqh)
-	usbd_request_handle reqh;
+ohci_device_bulk_done(xfer)
+	usbd_xfer_handle xfer;
 {
-	DPRINTFN(10,("ohci_bulk_done: reqh=%p, actlen=%d\n", 
-		     reqh, reqh->actlen));
+	DPRINTFN(10,("ohci_bulk_done: xfer=%p, actlen=%d\n", 
+		     xfer, xfer->actlen));
 
-	reqh->hcpriv = 0;
+	xfer->hcpriv = 0;
 }
 
 void
-ohci_rhsc(sc, reqh)
+ohci_rhsc(sc, xfer)
 	ohci_softc_t *sc;
-	usbd_request_handle reqh;
+	usbd_xfer_handle xfer;
 {
 	usbd_pipe_handle pipe;
 	struct ohci_pipe *opipe;
@@ -1059,36 +1285,43 @@ ohci_rhsc(sc, reqh)
 	int hstatus;
 
 	hstatus = OREAD4(sc, OHCI_RH_STATUS);
-	DPRINTF(("ohci_rhsc: sc=%p reqh=%p hstatus=0x%08x\n", 
-		 sc, reqh, hstatus));
+	DPRINTF(("ohci_rhsc: sc=%p xfer=%p hstatus=0x%08x\n", 
+		 sc, xfer, hstatus));
 
-	if (reqh == 0) {
+	if (xfer == 0) {
 		/* Just ignore the change. */
 		return;
 	}
 
-	pipe = reqh->pipe;
+	pipe = xfer->pipe;
 	opipe = (struct ohci_pipe *)pipe;
 
-	p = KERNADDR(&reqh->dmabuf);
-	m = min(sc->sc_noport, reqh->length * 8 - 1);
-	memset(p, 0, reqh->length);
+	p = KERNADDR(&xfer->dmabuf);
+	m = min(sc->sc_noport, xfer->length * 8 - 1);
+	memset(p, 0, xfer->length);
 	for (i = 1; i <= m; i++) {
 		if (OREAD4(sc, OHCI_RH_PORT_STATUS(i)) >> 16)
 			p[i/8] |= 1 << (i%8);
 	}
 	DPRINTF(("ohci_rhsc: change=0x%02x\n", *p));
-	reqh->actlen = reqh->length;
-	reqh->status = USBD_NORMAL_COMPLETION;
+	xfer->actlen = xfer->length;
+	xfer->status = USBD_NORMAL_COMPLETION;
+
+	usb_transfer_complete(xfer);
+}
 
-	usb_transfer_complete(reqh);
+void
+ohci_root_intr_done(xfer)
+	usbd_xfer_handle xfer;
+{
+	xfer->hcpriv = NULL;
 }
 
 void
-ohci_root_intr_done(reqh)
-	usbd_request_handle reqh;
+ohci_root_ctrl_done(xfer)
+	usbd_xfer_handle xfer;
 {
-	reqh->hcpriv = 0;
+	xfer->hcpriv = NULL;
 }
 
 /*
@@ -1097,15 +1330,15 @@ ohci_root_intr_done(reqh)
  * too long.
  */
 void
-ohci_waitintr(sc, reqh)
+ohci_waitintr(sc, xfer)
 	ohci_softc_t *sc;
-	usbd_request_handle reqh;
+	usbd_xfer_handle xfer;
 {
-	int timo = reqh->timeout;
+	int timo = xfer->timeout;
 	int usecs;
 	u_int32_t intrs;
 
-	reqh->status = USBD_IN_PROGRESS;
+	xfer->status = USBD_IN_PROGRESS;
 	for (usecs = timo * 1000000 / hz; usecs > 0; usecs -= 1000) {
 		usb_delay_ms(&sc->sc_bus, 1);
 		intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs;
@@ -1115,16 +1348,16 @@ ohci_waitintr(sc, reqh)
 			ohci_dumpregs(sc);
 #endif
 		if (intrs) {
-			ohci_intr(sc);
-			if (reqh->status != USBD_IN_PROGRESS)
+			ohci_intr1(sc);
+			if (xfer->status != USBD_IN_PROGRESS)
 				return;
 		}
 	}
 
 	/* Timeout */
 	DPRINTF(("ohci_waitintr: timeout\n"));
-	reqh->status = USBD_TIMEOUT;
-	usb_transfer_complete(reqh);
+	xfer->status = USBD_TIMEOUT;
+	usb_transfer_complete(xfer);
 	/* XXX should free TD */
 }
 
@@ -1135,23 +1368,23 @@ ohci_poll(bus)
 	ohci_softc_t *sc = (ohci_softc_t *)bus;
 
 	if (OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs)
-		ohci_intr(sc);
+		ohci_intr1(sc);
 }
 
 usbd_status
-ohci_device_request(reqh)
-	usbd_request_handle reqh;
+ohci_device_request(xfer)
+	usbd_xfer_handle xfer;
 {
-	struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe;
-	usb_device_request_t *req = &reqh->request;
+	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
+	usb_device_request_t *req = &xfer->request;
 	usbd_device_handle dev = opipe->pipe.device;
 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
 	int addr = dev->address;
-	ohci_soft_td_t *setup, *data = 0, *stat, *next, *tail;
+	ohci_soft_td_t *setup, *stat, *next, *tail;
 	ohci_soft_ed_t *sed;
 	int isread;
 	int len;
-	usbd_status r;
+	usbd_status err;
 	int s;
 
 	isread = req->bmRequestType & UT_READ;
@@ -1163,54 +1396,44 @@ ohci_device_request(reqh)
 		    UGETW(req->wIndex), len, addr, 
 		    opipe->pipe.endpoint->edesc->bEndpointAddress));
 
-	setup = opipe->tail;
+	setup = opipe->tail.td;
 	stat = ohci_alloc_std(sc);
-	if (!stat) {
-		r = USBD_NOMEM;
+	if (stat == NULL) {
+		err = USBD_NOMEM;
 		goto bad1;
 	}
 	tail = ohci_alloc_std(sc);
-	if (!tail) {
-		r = USBD_NOMEM;
+	if (tail == NULL) {
+		err = USBD_NOMEM;
 		goto bad2;
 	}
-	tail->reqh = 0;
+	tail->xfer = NULL;
 
 	sed = opipe->sed;
 	opipe->u.ctl.length = len;
 
 	/* Update device address and length since they may have changed. */
 	/* XXX This only needs to be done once, but it's too early in open. */
+	/* XXXX Should not touch ED here! */
 	sed->ed.ed_flags = LE(
 	 (LE(sed->ed.ed_flags) & ~(OHCI_ED_ADDRMASK | OHCI_ED_MAXPMASK)) |
 	 OHCI_ED_SET_FA(addr) |
 	 OHCI_ED_SET_MAXP(UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize)));
 
+	next = stat;
+
 	/* Set up data transaction */
 	if (len != 0) {
-		data = ohci_alloc_std(sc);
-		if (!data) {
-			r = USBD_NOMEM;
+		ohci_soft_td_t *std = stat;
+
+		err = ohci_alloc_std_chain(opipe, sc, len, isread, xfer,
+			    std, &stat);
+		stat = stat->nexttd; /* point at free TD */
+		if (err)
 			goto bad3;
-		}
-		data->td.td_flags = LE(
-			(isread ? OHCI_TD_IN : OHCI_TD_OUT) | OHCI_TD_NOCC |
-			OHCI_TD_TOGGLE_1 | OHCI_TD_NOINTR |
-			(reqh->flags & USBD_SHORT_XFER_OK ? OHCI_TD_R : 0));
-		data->td.td_cbp = LE(DMAADDR(&reqh->dmabuf));
-		data->nexttd = stat;
-		data->td.td_nexttd = LE(stat->physaddr);
-		data->td.td_be = LE(LE(data->td.td_cbp) + len - 1);
-		data->len = len;
-		data->reqh = reqh;
-		data->flags = OHCI_ADD_LEN;
-
-		next = data;
-		stat->flags = OHCI_CALL_DONE;
-	} else {
-		next = stat;
-		/* XXX ADD_LEN? */
-		stat->flags = OHCI_CALL_DONE | OHCI_ADD_LEN;
+		/* Start toggle at 1 and then use the carried toggle. */
+		std->td.td_flags &= LE(~OHCI_TD_TOGGLE_MASK);
+		std->td.td_flags |= LE(OHCI_TD_TOGGLE_1);
 	}
 
 	memcpy(KERNADDR(&opipe->u.ctl.reqdma), req, sizeof *req);
@@ -1221,20 +1444,21 @@ ohci_device_request(reqh)
 	setup->nexttd = next;
 	setup->td.td_nexttd = LE(next->physaddr);
 	setup->td.td_be = LE(LE(setup->td.td_cbp) + sizeof *req - 1);
-	setup->len = 0;		/* XXX The number of byte we count */
-	setup->reqh = reqh;
+	setup->len = 0;
+	setup->xfer = xfer;
 	setup->flags = 0;
-	reqh->hcpriv = setup;
+	xfer->hcpriv = setup;
 
 	stat->td.td_flags = LE(
-		(isread ? OHCI_TD_OUT : OHCI_TD_IN) | OHCI_TD_NOCC |
-		OHCI_TD_TOGGLE_1 | OHCI_TD_SET_DI(1));
+		(isread ? OHCI_TD_OUT : OHCI_TD_IN) |
+		OHCI_TD_NOCC | OHCI_TD_TOGGLE_1 | OHCI_TD_SET_DI(1));
 	stat->td.td_cbp = 0;
 	stat->nexttd = tail;
 	stat->td.td_nexttd = LE(tail->physaddr);
 	stat->td.td_be = 0;
+	stat->flags = OHCI_CALL_DONE;
 	stat->len = 0;
-	stat->reqh = reqh;
+	stat->xfer = xfer;
 
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 5) {
@@ -1246,22 +1470,18 @@ ohci_device_request(reqh)
 
 	/* Insert ED in schedule */
 	s = splusb();
-	ohci_hash_add_td(sc, setup);
-	if (len != 0)
-		ohci_hash_add_td(sc, data);
-	ohci_hash_add_td(sc, stat);
 	sed->ed.ed_tailp = LE(tail->physaddr);
-	opipe->tail = tail;
+	opipe->tail.td = tail;
 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
-	if (reqh->timeout && !sc->sc_bus.use_polling) {
-                usb_timeout(ohci_timeout, reqh,
-			    MS_TO_TICKS(reqh->timeout), reqh->timo_handle);
+	if (xfer->timeout && !sc->sc_bus.use_polling) {
+                usb_timeout(ohci_timeout, xfer,
+			    MS_TO_TICKS(xfer->timeout), xfer->timo_handle);
 	}
 	splx(s);
 
-#ifdef OHCI_DEBUG
-	if (ohcidebug > 5) {
-		delay(5000);
+#if 0
+	if (ohcidebug > 10) {
+		delay(10000);
 		DPRINTF(("ohci_device_request: status=%x\n",
 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
 		ohci_dump_ed(sed);
@@ -1276,7 +1496,7 @@ ohci_device_request(reqh)
  bad2:
 	ohci_free_std(sc, stat);
  bad1:
-	return (r);
+	return (err);
 }
 
 /*
@@ -1307,9 +1527,9 @@ ohci_rem_ed(sed, head)
 	SPLUSBCHECK;
 
 	/* XXX */
-	for (p = head; p && p->next != sed; p = p->next)
+	for (p = head; p != NULL && p->next != sed; p = p->next)
 		;
-	if (!p)
+	if (p == NULL)
 		panic("ohci_rem_ed: ED not found\n");
 	p->next = sed->next;
 	p->ed.ed_nexted = sed->ed.ed_nexted;
@@ -1359,7 +1579,7 @@ ohci_hash_find_td(sc, a)
 	ohci_soft_td_t *std;
 
 	for (std = LIST_FIRST(&sc->sc_hash_tds[h]); 
-	     std != 0; 
+	     std != NULL; 
 	     std = LIST_NEXT(std, hnext))
 		if (std->physaddr == a)
 			return (std);
@@ -1370,15 +1590,15 @@ void
 ohci_timeout(addr)
 	void *addr;
 {
-	usbd_request_handle reqh = addr;
+	usbd_xfer_handle xfer = addr;
 	int s;
 
-	DPRINTF(("ohci_timeout: reqh=%p\n", reqh));
+	DPRINTF(("ohci_timeout: xfer=%p\n", xfer));
 
 	s = splusb();
-	reqh->device->bus->intr_context++;
-	ohci_abort_req(reqh, USBD_TIMEOUT);
-	reqh->device->bus->intr_context--;
+	xfer->device->bus->intr_context++;
+	ohci_abort_xfer(xfer, USBD_TIMEOUT);
+	xfer->device->bus->intr_context--;
 	splx(s);
 }
 
@@ -1411,8 +1631,8 @@ void
 ohci_dump_ed(sed)
 	ohci_soft_ed_t *sed;
 {
-	DPRINTF(("ED(%p) at %08lx: addr=%d endpt=%d maxp=%d %b\ntailp=0x%08lx "
-		 "headp=%b nexted=0x%08lx\n",
+	DPRINTF(("ED(%p) at 0x%08lx: addr=%d endpt=%d maxp=%d %b\ntailp=0x%08lx "
+		 "headsflags=%b headp=%b nexted=0x%08lx\n",
 		 sed, (u_long)sed->physaddr, 
 		 OHCI_ED_GET_FA(LE(sed->ed.ed_flags)),
 		 OHCI_ED_GET_EN(LE(sed->ed.ed_flags)),
@@ -1422,6 +1642,7 @@ ohci_dump_ed(sed)
 		 (u_long)LE(sed->ed.ed_tailp),
 		 (u_long)LE(sed->ed.ed_headp),
 		 "\20\1HALT\2CARRY",
+		 (u_long)LE(sed->ed.ed_headp),
 		 (u_long)LE(sed->ed.ed_nexted)));
 }
 #endif
@@ -1435,10 +1656,15 @@ ohci_open(pipe)
 	usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc;
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	u_int8_t addr = dev->address;
+	u_int8_t xfertype = ed->bmAttributes & UE_XFERTYPE;
 	ohci_soft_ed_t *sed;
 	ohci_soft_td_t *std;
-	usbd_status r;
+	ohci_soft_itd_t *sitd;
+	ohci_physaddr_t tdphys;
+	u_int32_t fmt;
+	usbd_status err;
 	int s;
+	int ival;
 
 	DPRINTFN(1, ("ohci_open: pipe=%p, addr=%d, endpt=%d (%d)\n",
 		     pipe, addr, ed->bEndpointAddress, sc->sc_addr));
@@ -1455,30 +1681,43 @@ ohci_open(pipe)
 		}
 	} else {
 		sed = ohci_alloc_sed(sc);
-		if (sed == 0)
+		if (sed == NULL)
 			goto bad0;
-	        std = ohci_alloc_std(sc);
-		if (std == 0)
-			goto bad1;
 		opipe->sed = sed;
-		opipe->tail = std;
+		if (xfertype == UE_ISOCHRONOUS) {
+			sitd = ohci_alloc_sitd(sc);
+			if (sitd == NULL) {
+				ohci_free_sitd(sc, sitd);
+				goto bad1;
+			}
+			opipe->tail.itd = sitd;
+			tdphys = LE(sitd->physaddr);
+			fmt = OHCI_ED_FORMAT_ISO;
+		} else {
+			std = ohci_alloc_std(sc);
+			if (std == NULL) {
+				ohci_free_std(sc, std);
+				goto bad1;
+			}
+			opipe->tail.td = std;
+			tdphys = LE(std->physaddr);
+			fmt = OHCI_ED_FORMAT_GEN;
+		}
 		sed->ed.ed_flags = LE(
 			OHCI_ED_SET_FA(addr) | 
 			OHCI_ED_SET_EN(ed->bEndpointAddress) |
 			OHCI_ED_DIR_TD | 
-			(dev->lowspeed ? OHCI_ED_SPEED : 0) | 
-			((ed->bmAttributes & UE_XFERTYPE) == UE_ISOCHRONOUS ?
-			 OHCI_ED_FORMAT_ISO : OHCI_ED_FORMAT_GEN) |
+			(dev->lowspeed ? OHCI_ED_SPEED : 0) | fmt |
 			OHCI_ED_SET_MAXP(UGETW(ed->wMaxPacketSize)));
-		sed->ed.ed_headp = sed->ed.ed_tailp = LE(std->physaddr);
+		sed->ed.ed_headp = sed->ed.ed_tailp = tdphys;
 
-		switch (ed->bmAttributes & UE_XFERTYPE) {
+		switch (xfertype) {
 		case UE_CONTROL:
 			pipe->methods = &ohci_device_ctrl_methods;
-			r = usb_allocmem(&sc->sc_bus, 
+			err = usb_allocmem(&sc->sc_bus, 
 					 sizeof(usb_device_request_t), 
 					 0, &opipe->u.ctl.reqdma);
-			if (r != USBD_NORMAL_COMPLETION)
+			if (err)
 				goto bad;
 			s = splusb();
 			ohci_add_ed(sed, sc->sc_ctrl_head);
@@ -1486,10 +1725,13 @@ ohci_open(pipe)
 			break;
 		case UE_INTERRUPT:
 			pipe->methods = &ohci_device_intr_methods;
-			return (ohci_device_setintr(sc, opipe, ed->bInterval));
+			ival = pipe->interval;
+			if (ival == USBD_DEFAULT_INTERVAL)
+				ival = ed->bInterval;
+			return (ohci_device_setintr(sc, opipe, ival));
 		case UE_ISOCHRONOUS:
-			printf("ohci_open: open iso unimplemented\n");
-			return (USBD_INVAL);
+			pipe->methods = &ohci_device_isoc_methods;
+			return (ohci_setup_isoc(pipe));
 		case UE_BULK:
 			pipe->methods = &ohci_device_bulk_methods;
 			s = splusb();
@@ -1526,12 +1768,12 @@ ohci_close_pipe(pipe, head)
 	s = splusb();
 #ifdef DIAGNOSTIC
 	sed->ed.ed_flags |= LE(OHCI_ED_SKIP);
-	if ((sed->ed.ed_tailp & LE(OHCI_TAILMASK)) != 
-	    (sed->ed.ed_headp & LE(OHCI_TAILMASK))) {
+	if ((sed->ed.ed_tailp & LE(OHCI_HEADMASK)) != 
+	    (sed->ed.ed_headp & LE(OHCI_HEADMASK))) {
 		ohci_physaddr_t td = sed->ed.ed_headp;
 		ohci_soft_td_t *std;
 		for (std = LIST_FIRST(&sc->sc_hash_tds[HASH(td)]); 
-		     std != 0; 
+		     std != NULL;
 		     std = LIST_NEXT(std, hnext))
 		    if (std->physaddr == td)
 			break;
@@ -1540,14 +1782,13 @@ ohci_close_pipe(pipe, head)
 		       (int)LE(sed->ed.ed_headp), (int)LE(sed->ed.ed_tailp),
 		       pipe, std);
 		usb_delay_ms(&sc->sc_bus, 2);
-		if ((sed->ed.ed_tailp & LE(OHCI_TAILMASK)) != 
-		    (sed->ed.ed_headp & LE(OHCI_TAILMASK)))
+		if ((sed->ed.ed_tailp & LE(OHCI_HEADMASK)) !=
+		    (sed->ed.ed_headp & LE(OHCI_HEADMASK)))
 			printf("ohci_close_pipe: pipe still not empty\n");
 	}
 #endif
 	ohci_rem_ed(sed, head);
 	splx(s);
-	ohci_free_std(sc, opipe->tail);
 	ohci_free_sed(sc, opipe->sed);
 }
 
@@ -1562,38 +1803,47 @@ ohci_close_pipe(pipe, head)
  * interrupt processing to process it.
  */
 void
-ohci_abort_req(reqh, status)
-	usbd_request_handle reqh;
+ohci_abort_xfer(xfer, status)
+	usbd_xfer_handle xfer;
 	usbd_status status;
 {
-	struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe;
+	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_soft_ed_t *sed;
 
-	DPRINTF(("ohci_abort_req: reqh=%p pipe=%p\n", reqh, opipe));
+	DPRINTF(("ohci_abort_xfer: xfer=%p pipe=%p\n", xfer, opipe));
 
-	reqh->status = status;
+	xfer->status = status;
 
-	usb_untimeout(ohci_timeout, reqh, reqh->timo_handle);
+	usb_untimeout(ohci_timeout, xfer, xfer->timo_handle);
 
 	sed = opipe->sed;
-	DPRINTFN(1,("ohci_abort_req: stop ed=%p\n", sed));
+	DPRINTFN(1,("ohci_abort_xfer: stop ed=%p\n", sed));
 	sed->ed.ed_flags |= LE(OHCI_ED_SKIP); /* force hardware skip */
 
-	if (reqh->device->bus->intr_context) {
+#if 1
+	if (xfer->device->bus->intr_context) {
 		/* We have no process context, so we can't use tsleep(). */
-		timeout(ohci_abort_req_end, reqh, hz / USB_FRAMES_PER_SECOND);
+		timeout(ohci_abort_xfer_end, xfer, hz / USB_FRAMES_PER_SECOND);
 	} else {
+#if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__)
+		KASSERT(intr_nesting_level == 0,
+			("ohci_abort_req in interrupt context"));
+#endif
 		usb_delay_ms(opipe->pipe.device->bus, 1);
-		ohci_abort_req_end(reqh);
+		ohci_abort_xfer_end(xfer);
 	}
+#else
+	delay(1000);
+	ohci_abort_xfer_end(xfer);
+#endif
 }
 
 void
-ohci_abort_req_end(v)
+ohci_abort_xfer_end(v)
 	void *v;
 {
-	usbd_request_handle reqh = v;
-	struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe;
+	usbd_xfer_handle xfer = v;
+	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus;
 	ohci_soft_ed_t *sed;
 	ohci_soft_td_t *p, *n;
@@ -1601,26 +1851,25 @@ ohci_abort_req_end(v)
 
 	s = splusb();
 
-	p = reqh->hcpriv;
+	p = xfer->hcpriv;
 #ifdef DIAGNOSTIC
-	if (!p) {
-		printf("ohci_abort_req: hcpriv==0\n");
+	if (p == NULL) {
+		printf("ohci_abort_xfer: hcpriv==0\n");
 		return;
 	}
 #endif
-	for (; p->reqh == reqh; p = n) {
+	for (; p->xfer == xfer; p = n) {
 		n = p->nexttd;
-		ohci_hash_rem_td(sc, p);
 		ohci_free_std(sc, p);
 	}
 
 	sed = opipe->sed;
-	DPRINTFN(2,("ohci_abort_req: set hd=%x, tl=%x\n",
+	DPRINTFN(2,("ohci_abort_xfer: set hd=%x, tl=%x\n",
 		    (int)LE(p->physaddr), (int)LE(sed->ed.ed_tailp)));
 	sed->ed.ed_headp = p->physaddr; /* unlink TDs */
 	sed->ed.ed_flags &= LE(~OHCI_ED_SKIP); /* remove hardware skip */
 
-	usb_transfer_complete(reqh);
+	usb_transfer_complete(xfer);
 
 	splx(s);
 }
@@ -1632,8 +1881,8 @@ usb_device_descriptor_t ohci_devd = {
 	USB_DEVICE_DESCRIPTOR_SIZE,
 	UDESC_DEVICE,		/* type */
 	{0x00, 0x01},		/* USB version */
-	UCLASS_HUB,		/* class */
-	USUBCLASS_HUB,		/* subclass */
+	UDCLASS_HUB,		/* class */
+	UDSUBCLASS_HUB,		/* subclass */
 	0,			/* protocol */
 	64,			/* max packet */
 	{0},{0},{0x00,0x01},	/* device id */
@@ -1660,8 +1909,8 @@ usb_interface_descriptor_t ohci_ifcd = {
 	0,
 	0,
 	1,
-	UCLASS_HUB,
-	USUBCLASS_HUB,
+	UICLASS_HUB,
+	UISUBCLASS_HUB,
 	0,
 	0
 };
@@ -1709,40 +1958,40 @@ ohci_str(p, l, s)
  * Simulate a hardware hub by handling all the necessary requests.
  */
 usbd_status
-ohci_root_ctrl_transfer(reqh)
-	usbd_request_handle reqh;
+ohci_root_ctrl_transfer(xfer)
+	usbd_xfer_handle xfer;
 {
-	usbd_status r;
+	usbd_status err;
 
 	/* Insert last in queue. */
-	r = usb_insert_transfer(reqh);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
+	err = usb_insert_transfer(xfer);
+	if (err)
+		return (err);
 
 	/* Pipe isn't running, start first */
-	return (ohci_root_ctrl_start(SIMPLEQ_FIRST(&reqh->pipe->queue)));
+	return (ohci_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
 }
 
 usbd_status
-ohci_root_ctrl_start(reqh)
-	usbd_request_handle reqh;
+ohci_root_ctrl_start(xfer)
+	usbd_xfer_handle xfer;
 {
-	ohci_softc_t *sc = (ohci_softc_t *)reqh->pipe->device->bus;
+	ohci_softc_t *sc = (ohci_softc_t *)xfer->pipe->device->bus;
 	usb_device_request_t *req;
 	void *buf = NULL;
 	int port, i;
 	int s, len, value, index, l, totlen = 0;
 	usb_port_status_t ps;
 	usb_hub_descriptor_t hubd;
-	usbd_status r;
+	usbd_status err;
 	u_int32_t v;
 
 #ifdef DIAGNOSTIC
-	if (!(reqh->rqflags & URQ_REQUEST))
+	if (!(xfer->rqflags & URQ_REQUEST))
 		/* XXX panic */
 		return (USBD_INVAL);
 #endif
-	req = &reqh->request;
+	req = &xfer->request;
 
 	DPRINTFN(4,("ohci_root_ctrl_control type=0x%02x request=%02x\n", 
 		    req->bmRequestType, req->bRequest));
@@ -1752,7 +2001,7 @@ ohci_root_ctrl_start(reqh)
 	index = UGETW(req->wIndex);
 
 	if (len != 0)
-		buf = KERNADDR(&reqh->dmabuf);
+		buf = KERNADDR(&xfer->dmabuf);
 
 #define C(x,y) ((x) | ((y) << 8))
 	switch(C(req->bRequest, req->bmRequestType)) {
@@ -1775,7 +2024,7 @@ ohci_root_ctrl_start(reqh)
 		switch(value >> 8) {
 		case UDESC_DEVICE:
 			if ((value & 0xff) != 0) {
-				r = USBD_IOERROR;
+				err = USBD_IOERROR;
 				goto ret;
 			}
 			totlen = l = min(len, USB_DEVICE_DESCRIPTOR_SIZE);
@@ -1784,7 +2033,7 @@ ohci_root_ctrl_start(reqh)
 			break;
 		case UDESC_CONFIG:
 			if ((value & 0xff) != 0) {
-				r = USBD_IOERROR;
+				err = USBD_IOERROR;
 				goto ret;
 			}
 			totlen = l = min(len, USB_CONFIG_DESCRIPTOR_SIZE);
@@ -1815,7 +2064,7 @@ ohci_root_ctrl_start(reqh)
 			}
 			break;
 		default:
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		break;
@@ -1840,14 +2089,14 @@ ohci_root_ctrl_start(reqh)
 		break;
 	case C(UR_SET_ADDRESS, UT_WRITE_DEVICE):
 		if (value >= USB_MAX_DEVICES) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		sc->sc_addr = value;
 		break;
 	case C(UR_SET_CONFIG, UT_WRITE_DEVICE):
 		if (value != 0 && value != 1) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		sc->sc_conf = value;
@@ -1857,7 +2106,7 @@ ohci_root_ctrl_start(reqh)
 	case C(UR_SET_FEATURE, UT_WRITE_DEVICE):
 	case C(UR_SET_FEATURE, UT_WRITE_INTERFACE):
 	case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT):
-		r = USBD_IOERROR;
+		err = USBD_IOERROR;
 		goto ret;
 	case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE):
 		break;
@@ -1871,7 +2120,7 @@ ohci_root_ctrl_start(reqh)
 			     "port=%d feature=%d\n",
 			     index, value));
 		if (index < 1 || index > sc->sc_noport) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		port = OHCI_RH_PORT_STATUS(index);
@@ -1901,7 +2150,7 @@ ohci_root_ctrl_start(reqh)
 			OWRITE4(sc, port, UPS_C_PORT_RESET << 16);
 			break;
 		default:
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		switch(value) {
@@ -1920,7 +2169,7 @@ ohci_root_ctrl_start(reqh)
 		break;
 	case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE):
 		if (value != 0) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		v = OREAD4(sc, OHCI_RH_DESCRIPTOR_A);
@@ -1942,7 +2191,7 @@ ohci_root_ctrl_start(reqh)
 		break;
 	case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE):
 		if (len != 4) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		memset(buf, 0, len); /* ? XXX */
@@ -1952,11 +2201,11 @@ ohci_root_ctrl_start(reqh)
 		DPRINTFN(8,("ohci_root_ctrl_transfer: get port status i=%d\n",
 			    index));
 		if (index < 1 || index > sc->sc_noport) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		if (len != 4) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		v = OREAD4(sc, OHCI_RH_PORT_STATUS(index));
@@ -1969,13 +2218,13 @@ ohci_root_ctrl_start(reqh)
 		totlen = l;
 		break;
 	case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE):
-		r = USBD_IOERROR;
+		err = USBD_IOERROR;
 		goto ret;
 	case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE):
 		break;
 	case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER):
 		if (index < 1 || index > sc->sc_noport) {
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		port = OHCI_RH_PORT_STATUS(index);
@@ -2004,28 +2253,28 @@ ohci_root_ctrl_start(reqh)
 			OWRITE4(sc, port, UPS_PORT_POWER);
 			break;
 		default:
-			r = USBD_IOERROR;
+			err = USBD_IOERROR;
 			goto ret;
 		}
 		break;
 	default:
-		r = USBD_IOERROR;
+		err = USBD_IOERROR;
 		goto ret;
 	}
-	reqh->actlen = totlen;
-	r = USBD_NORMAL_COMPLETION;
+	xfer->actlen = totlen;
+	err = USBD_NORMAL_COMPLETION;
  ret:
-	reqh->status = r;
+	xfer->status = err;
 	s = splusb();
-	usb_transfer_complete(reqh);
+	usb_transfer_complete(xfer);
 	splx(s);
 	return (USBD_IN_PROGRESS);
 }
 
 /* Abort a root control request. */
 void
-ohci_root_ctrl_abort(reqh)
-	usbd_request_handle reqh;
+ohci_root_ctrl_abort(xfer)
+	usbd_xfer_handle xfer;
 {
 	/* Nothing to do, all transfers are synchronous. */
 }
@@ -2040,43 +2289,47 @@ ohci_root_ctrl_close(pipe)
 }
 
 usbd_status
-ohci_root_intr_transfer(reqh)
-	usbd_request_handle reqh;
+ohci_root_intr_transfer(xfer)
+	usbd_xfer_handle xfer;
 {
-	usbd_status r;
+	usbd_status err;
 
 	/* Insert last in queue. */
-	r = usb_insert_transfer(reqh);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
+	err = usb_insert_transfer(xfer);
+	if (err)
+		return (err);
 
 	/* Pipe isn't running, start first */
-	return (ohci_root_intr_start(SIMPLEQ_FIRST(&reqh->pipe->queue)));
+	return (ohci_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
 }
 
 usbd_status
-ohci_root_intr_start(reqh)
-	usbd_request_handle reqh;
+ohci_root_intr_start(xfer)
+	usbd_xfer_handle xfer;
 {
-	usbd_pipe_handle pipe = reqh->pipe;
+	usbd_pipe_handle pipe = xfer->pipe;
 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
 
-	sc->sc_intrreqh = reqh;
+	sc->sc_intrxfer = xfer;
 
 	return (USBD_IN_PROGRESS);
 }
 
 /* Abort a root interrupt request. */
 void
-ohci_root_intr_abort(reqh)
-	usbd_request_handle reqh;
+ohci_root_intr_abort(xfer)
+	usbd_xfer_handle xfer;
 {
-	if (reqh->pipe->intrreqh == reqh) {
+	int s;
+
+	if (xfer->pipe->intrxfer == xfer) {
 		DPRINTF(("ohci_root_intr_abort: remove\n"));
-		reqh->pipe->intrreqh = 0;
+		xfer->pipe->intrxfer = NULL;
 	}
-	reqh->status = USBD_CANCELLED;
-	usb_transfer_complete(reqh);
+	xfer->status = USBD_CANCELLED;
+	s = splusb();
+	usb_transfer_complete(xfer);
+	splx(s);
 }
 
 /* Close the root pipe. */
@@ -2088,57 +2341,57 @@ ohci_root_intr_close(pipe)
 	
 	DPRINTF(("ohci_root_intr_close\n"));
 
-	sc->sc_intrreqh = 0;
+	sc->sc_intrxfer = NULL;
 }
 
 /************************/
 
 usbd_status
-ohci_device_ctrl_transfer(reqh)
-	usbd_request_handle reqh;
+ohci_device_ctrl_transfer(xfer)
+	usbd_xfer_handle xfer;
 {
-	usbd_status r;
+	usbd_status err;
 
 	/* Insert last in queue. */
-	r = usb_insert_transfer(reqh);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
+	err = usb_insert_transfer(xfer);
+	if (err)
+		return (err);
 
 	/* Pipe isn't running, start first */
-	return (ohci_device_ctrl_start(SIMPLEQ_FIRST(&reqh->pipe->queue)));
+	return (ohci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
 }
 
 usbd_status
-ohci_device_ctrl_start(reqh)
-	usbd_request_handle reqh;
+ohci_device_ctrl_start(xfer)
+	usbd_xfer_handle xfer;
 {
-	ohci_softc_t *sc = (ohci_softc_t *)reqh->pipe->device->bus;
-	usbd_status r;
+	ohci_softc_t *sc = (ohci_softc_t *)xfer->pipe->device->bus;
+	usbd_status err;
 
 #ifdef DIAGNOSTIC
-	if (!(reqh->rqflags & URQ_REQUEST)) {
+	if (!(xfer->rqflags & URQ_REQUEST)) {
 		/* XXX panic */
 		printf("ohci_device_ctrl_transfer: not a request\n");
 		return (USBD_INVAL);
 	}
 #endif
 
-	r = ohci_device_request(reqh);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
+	err = ohci_device_request(xfer);
+	if (err)
+		return (err);
 
 	if (sc->sc_bus.use_polling)
-		ohci_waitintr(sc, reqh);
+		ohci_waitintr(sc, xfer);
 	return (USBD_IN_PROGRESS);
 }
 
 /* Abort a device control request. */
 void
-ohci_device_ctrl_abort(reqh)
-	usbd_request_handle reqh;
+ohci_device_ctrl_abort(xfer)
+	usbd_xfer_handle xfer;
 {
-	DPRINTF(("ohci_device_ctrl_abort: reqh=%p\n", reqh));
-	ohci_abort_req(reqh, USBD_CANCELLED);
+	DPRINTF(("ohci_device_ctrl_abort: xfer=%p\n", xfer));
+	ohci_abort_xfer(xfer, USBD_CANCELLED);
 }
 
 /* Close a device control pipe. */
@@ -2146,10 +2399,12 @@ void
 ohci_device_ctrl_close(pipe)
 	usbd_pipe_handle pipe;
 {
+	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
 
 	DPRINTF(("ohci_device_ctrl_close: pipe=%p\n", pipe));
 	ohci_close_pipe(pipe, sc->sc_ctrl_head);
+	ohci_free_std(sc, opipe->tail.td);
 }
 
 /************************/
@@ -2160,7 +2415,7 @@ ohci_device_clear_toggle(pipe)
 {
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 
-	opipe->sed->ed.ed_tailp &= LE(~OHCI_TOGGLECARRY);
+	opipe->sed->ed.ed_headp &= LE(~OHCI_TOGGLECARRY);
 }
 
 void
@@ -2170,48 +2425,48 @@ ohci_noop(pipe)
 }
 
 usbd_status
-ohci_device_bulk_transfer(reqh)
-	usbd_request_handle reqh;
+ohci_device_bulk_transfer(xfer)
+	usbd_xfer_handle xfer;
 {
-	usbd_status r;
+	usbd_status err;
 
 	/* Insert last in queue. */
-	r = usb_insert_transfer(reqh);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
+	err = usb_insert_transfer(xfer);
+	if (err)
+		return (err);
 
 	/* Pipe isn't running, start first */
-	return (ohci_device_bulk_start(SIMPLEQ_FIRST(&reqh->pipe->queue)));
+	return (ohci_device_bulk_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
 }
 
 usbd_status
-ohci_device_bulk_start(reqh)
-	usbd_request_handle reqh;
+ohci_device_bulk_start(xfer)
+	usbd_xfer_handle xfer;
 {
-	struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe;
+	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	usbd_device_handle dev = opipe->pipe.device;
 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
 	int addr = dev->address;
 	ohci_soft_td_t *data, *tail, *tdp;
 	ohci_soft_ed_t *sed;
 	int s, len, isread, endpt;
-	usbd_status r;
+	usbd_status err;
 
 #ifdef DIAGNOSTIC
-	if (reqh->rqflags & URQ_REQUEST) {
+	if (xfer->rqflags & URQ_REQUEST) {
 		/* XXX panic */
 		printf("ohci_device_bulk_start: a request\n");
 		return (USBD_INVAL);
 	}
 #endif
 
-	len = reqh->length;
-	endpt = reqh->pipe->endpoint->edesc->bEndpointAddress;
+	len = xfer->length;
+	endpt = xfer->pipe->endpoint->edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	sed = opipe->sed;
 
-	DPRINTFN(4,("ohci_device_bulk_start: reqh=%p len=%d isread=%d "
-		    "flags=%d endpt=%d\n", reqh, len, isread, reqh->flags,
+	DPRINTFN(4,("ohci_device_bulk_start: xfer=%p len=%d isread=%d "
+		    "flags=%d endpt=%d\n", xfer, len, isread, xfer->flags,
 		    endpt));
 
 	opipe->u.bulk.isread = isread;
@@ -2223,15 +2478,18 @@ ohci_device_bulk_start(reqh)
 		OHCI_ED_SET_FA(addr));
 
 	/* Allocate a chain of new TDs (including a new tail). */
-	data = opipe->tail;
-	r = ohci_alloc_std_chain(opipe, sc, len, isread, 
-				 reqh->flags & USBD_SHORT_XFER_OK,
-				 &reqh->dmabuf, data, &tail);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
-
-	tail->reqh = 0;
-	reqh->hcpriv = data;
+	data = opipe->tail.td;
+	err = ohci_alloc_std_chain(opipe, sc, len, isread,  xfer, data, &tail);
+	/* We want interrupt at the end of the transfer. */
+	tail->td.td_flags &= LE(~OHCI_TD_INTR_MASK);
+	tail->td.td_flags |= LE(OHCI_TD_SET_DI(1));
+	tail->flags |= OHCI_CALL_DONE;
+	tail = tail->nexttd;	/* point at sentinel */
+	if (err)
+		return (err);
+
+	tail->xfer = NULL;
+	xfer->hcpriv = data;
 
 	DPRINTFN(4,("ohci_device_bulk_start: ed_flags=0x%08x td_flags=0x%08x "
 		    "td_cbp=0x%08x td_be=0x%08x\n",
@@ -2239,7 +2497,7 @@ ohci_device_bulk_start(reqh)
 		    (int)LE(data->td.td_cbp), (int)LE(data->td.td_be)));
 
 #ifdef OHCI_DEBUG
-	if (ohcidebug > 4) {
+	if (ohcidebug > 5) {
 		ohci_dump_ed(sed);
 		ohci_dump_tds(data);
 	}
@@ -2248,22 +2506,21 @@ ohci_device_bulk_start(reqh)
 	/* Insert ED in schedule */
 	s = splusb();
 	for (tdp = data; tdp != tail; tdp = tdp->nexttd) {
-		tdp->reqh = reqh;
-		ohci_hash_add_td(sc, tdp);
+		tdp->xfer = xfer;
 	}
 	sed->ed.ed_tailp = LE(tail->physaddr);
-	opipe->tail = tail;
+	opipe->tail.td = tail;
 	sed->ed.ed_flags &= LE(~OHCI_ED_SKIP);
 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF);
-	if (reqh->timeout && !sc->sc_bus.use_polling) {
-                usb_timeout(ohci_timeout, reqh,
-			    MS_TO_TICKS(reqh->timeout), reqh->timo_handle);
+	if (xfer->timeout && !sc->sc_bus.use_polling) {
+                usb_timeout(ohci_timeout, xfer,
+			    MS_TO_TICKS(xfer->timeout), xfer->timo_handle);
 	}
 
 #if 0
 /* This goes wrong if we are too slow. */
-	if (ohcidebug > 5) {
-		delay(5000);
+	if (ohcidebug > 10) {
+		delay(10000);
 		DPRINTF(("ohci_device_intr_transfer: status=%x\n",
 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
 		ohci_dump_ed(sed);
@@ -2277,11 +2534,11 @@ ohci_device_bulk_start(reqh)
 }
 
 void
-ohci_device_bulk_abort(reqh)
-	usbd_request_handle reqh;
+ohci_device_bulk_abort(xfer)
+	usbd_xfer_handle xfer;
 {
-	DPRINTF(("ohci_device_bulk_abort: reqh=%p\n", reqh));
-	ohci_abort_req(reqh, USBD_CANCELLED);
+	DPRINTF(("ohci_device_bulk_abort: xfer=%p\n", xfer));
+	ohci_abort_xfer(xfer, USBD_CANCELLED);
 }
 
 /* 
@@ -2291,34 +2548,36 @@ void
 ohci_device_bulk_close(pipe)
 	usbd_pipe_handle pipe;
 {
+	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
 
 	DPRINTF(("ohci_device_bulk_close: pipe=%p\n", pipe));
 	ohci_close_pipe(pipe, sc->sc_bulk_head);
+	ohci_free_std(sc, opipe->tail.td);
 }
 
 /************************/
 
 usbd_status
-ohci_device_intr_transfer(reqh)
-	usbd_request_handle reqh;
+ohci_device_intr_transfer(xfer)
+	usbd_xfer_handle xfer;
 {
-	usbd_status r;
+	usbd_status err;
 
 	/* Insert last in queue. */
-	r = usb_insert_transfer(reqh);
-	if (r != USBD_NORMAL_COMPLETION)
-		return (r);
+	err = usb_insert_transfer(xfer);
+	if (err)
+		return (err);
 
 	/* Pipe isn't running, start first */
-	return (ohci_device_intr_start(SIMPLEQ_FIRST(&reqh->pipe->queue)));
+	return (ohci_device_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
 }
 
 usbd_status
-ohci_device_intr_start(reqh)
-	usbd_request_handle reqh;
+ohci_device_intr_start(xfer)
+	usbd_xfer_handle xfer;
 {
-	struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe;
+	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	usbd_device_handle dev = opipe->pipe.device;
 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
 	ohci_soft_ed_t *sed = opipe->sed;
@@ -2326,36 +2585,36 @@ ohci_device_intr_start(reqh)
 	int len;
 	int s;
 
-	DPRINTFN(3, ("ohci_device_intr_transfer: reqh=%p len=%d "
+	DPRINTFN(3, ("ohci_device_intr_transfer: xfer=%p len=%d "
 		     "flags=%d priv=%p\n",
-		     reqh, reqh->length, reqh->flags, reqh->priv));
+		     xfer, xfer->length, xfer->flags, xfer->priv));
 
 #ifdef DIAGNOSTIC
-	if (reqh->rqflags & URQ_REQUEST)
+	if (xfer->rqflags & URQ_REQUEST)
 		panic("ohci_device_intr_transfer: a request\n");
 #endif
 
-	len = reqh->length;
+	len = xfer->length;
 
-	data = opipe->tail;
+	data = opipe->tail.td;
 	tail = ohci_alloc_std(sc);
-	if (!tail)
+	if (tail == NULL)
 		return (USBD_NOMEM);
-	tail->reqh = 0;
+	tail->xfer = NULL;
 
 	data->td.td_flags = LE(
 		OHCI_TD_IN | OHCI_TD_NOCC | 
 		OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY);
-	if (reqh->flags & USBD_SHORT_XFER_OK)
+	if (xfer->flags & USBD_SHORT_XFER_OK)
 		data->td.td_flags |= LE(OHCI_TD_R);
-	data->td.td_cbp = LE(DMAADDR(&reqh->dmabuf));
+	data->td.td_cbp = LE(DMAADDR(&xfer->dmabuf));
 	data->nexttd = tail;
 	data->td.td_nexttd = LE(tail->physaddr);
 	data->td.td_be = LE(LE(data->td.td_cbp) + len - 1);
 	data->len = len;
-	data->reqh = reqh;
+	data->xfer = xfer;
 	data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN;
-	reqh->hcpriv = data;
+	xfer->hcpriv = data;
 
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 5) {
@@ -2367,9 +2626,8 @@ ohci_device_intr_start(reqh)
 
 	/* Insert ED in schedule */
 	s = splusb();
-	ohci_hash_add_td(sc, data);
 	sed->ed.ed_tailp = LE(tail->physaddr);
-	opipe->tail = tail;
+	opipe->tail.td = tail;
 	sed->ed.ed_flags &= LE(~OHCI_ED_SKIP);
 
 #if 0
@@ -2379,7 +2637,7 @@ ohci_device_intr_start(reqh)
  * TD is gone.
  */
 	if (ohcidebug > 5) {
-		delay(5000);
+		usb_delay_ms(&sc->sc_bus, 5);
 		DPRINTF(("ohci_device_intr_transfer: status=%x\n",
 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
 		ohci_dump_ed(sed);
@@ -2393,14 +2651,14 @@ ohci_device_intr_start(reqh)
 
 /* Abort a device control request. */
 void
-ohci_device_intr_abort(reqh)
-	usbd_request_handle reqh;
+ohci_device_intr_abort(xfer)
+	usbd_xfer_handle xfer;
 {
-	if (reqh->pipe->intrreqh == reqh) {
+	if (xfer->pipe->intrxfer == xfer) {
 		DPRINTF(("ohci_device_intr_abort: remove\n"));
-		reqh->pipe->intrreqh = 0;
+		xfer->pipe->intrxfer = NULL;
 	}
-	ohci_abort_req(reqh, USBD_CANCELLED);
+	ohci_abort_xfer(xfer, USBD_CANCELLED);
 }
 
 /* Close a device interrupt pipe. */
@@ -2420,14 +2678,16 @@ ohci_device_intr_close(pipe)
 		    pipe, nslots, pos));
 	s = splusb();
 	sed->ed.ed_flags |= LE(OHCI_ED_SKIP);
-	if ((sed->ed.ed_tailp & LE(OHCI_TAILMASK)) != 
-	    (sed->ed.ed_headp & LE(OHCI_TAILMASK)))
+	if ((sed->ed.ed_tailp & LE(OHCI_HEADMASK)) != 
+	    (sed->ed.ed_headp & LE(OHCI_HEADMASK)))
 		usb_delay_ms(&sc->sc_bus, 2);
 
 	for (p = sc->sc_eds[pos]; p && p->next != sed; p = p->next)
 		;
-	if (!p)
+#ifdef DIAGNOSTIC
+	if (p == NULL)
 		panic("ohci_device_intr_close: ED not found\n");
+#endif
 	p->next = sed->next;
 	p->ed.ed_nexted = sed->ed.ed_nexted;
 	splx(s);
@@ -2435,7 +2695,7 @@ ohci_device_intr_close(pipe)
 	for (j = 0; j < nslots; j++)
 		--sc->sc_bws[(pos * nslots + j) % OHCI_NO_INTRS];
 
-	ohci_free_std(sc, opipe->tail);
+	ohci_free_std(sc, opipe->tail.td);
 	ohci_free_sed(sc, opipe->sed);
 }
 
@@ -2504,3 +2764,149 @@ ohci_device_setintr(sc, opipe, ival)
 	return (USBD_NORMAL_COMPLETION);
 }
 
+/***********************/
+
+usbd_status
+ohci_device_isoc_transfer(xfer)
+	usbd_xfer_handle xfer;
+{
+	usbd_status err;
+
+	DPRINTFN(5,("ohci_device_isoc_transfer: xfer=%p\n", xfer));
+
+	/* Put it on our queue, */
+	err = usb_insert_transfer(xfer);
+
+	/* bail out on error, */
+	if (err && err != USBD_IN_PROGRESS)
+		return (err);
+
+	/* XXX should check inuse here */
+
+	/* insert into schedule */
+	ohci_device_isoc_enter(xfer);
+
+	/* and put on interrupt list if the pipe wasn't running */
+	if (!err)
+		ohci_device_isoc_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
+
+	return (err);
+}
+
+void
+ohci_device_isoc_enter(xfer)
+	usbd_xfer_handle xfer;
+{
+	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
+	usbd_device_handle dev = opipe->pipe.device;
+	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
+	ohci_soft_ed_t *sed = opipe->sed;
+	struct iso *iso = &opipe->u.iso;
+	ohci_soft_itd_t *sitd, *nsitd;
+	ohci_physaddr_t buf, offs;
+	int i, ncur, nframes;
+	int ncross;
+	int s;
+
+	s = splusb();
+	sitd = opipe->tail.itd;
+	buf = DMAADDR(&xfer->dmabuf);
+	sitd->itd.itd_bp0 = LE(buf & OHCI_ITD_PAGE_MASK);
+	nframes = xfer->nframes;
+	offs = buf & OHCI_ITD_OFFSET_MASK;
+	ncross = 0;
+	for (i = ncur = 0; i < nframes; i ++, ncur++) {
+		if (ncur == OHCI_ITD_NOFFSET || /* all offsets used */
+		    ncross > 1) {		/* too many page crossings */
+			nsitd = ohci_alloc_sitd(sc);
+			if (nsitd == NULL) {
+				/* XXX what now? */
+				return;
+			}
+			sitd->nextitd = nsitd;
+			sitd->itd.itd_nextitd = LE(nsitd->physaddr);
+			sitd->itd.itd_flags = LE(
+				OHCI_ITD_NOCC |
+				OHCI_ITD_SET_SF(iso->next) |
+				OHCI_ITD_NOINTR |
+				OHCI_ITD_SET_FC(OHCI_ITD_NOFFSET));
+			sitd->itd.itd_be = LE(LE(sitd->itd.itd_bp0) + offs - 1);
+			nsitd->itd.itd_bp0 = LE((buf + offs) & OHCI_ITD_PAGE_MASK);
+			sitd = nsitd;
+			iso->next = iso->next + ncur;
+			ncur = 0;
+			ncross = 0;
+		}
+		/* XXX byte order */
+		sitd->itd.itd_offset[i] =
+		    offs | (ncross == 1 ? OHCI_ITD_PAGE_SELECT : 0);
+		offs += xfer->frlengths[i];
+		/* XXX update ncross */
+	}
+	nsitd = ohci_alloc_sitd(sc);
+	if (nsitd == NULL) {
+		/* XXX what now? */
+		return;
+	}
+	sitd->nextitd = nsitd;
+	sitd->itd.itd_nextitd = LE(nsitd->physaddr);
+	sitd->itd.itd_flags = LE(
+		OHCI_ITD_NOCC |
+		OHCI_ITD_SET_SF(iso->next) |
+		OHCI_ITD_SET_DI(0) |
+		OHCI_ITD_SET_FC(ncur));
+	sitd->itd.itd_be = LE(LE(sitd->itd.itd_bp0) + offs - 1);
+	iso->next = iso->next + ncur;
+
+	opipe->tail.itd = nsitd;
+	sed->ed.ed_tailp = LE(nsitd->physaddr);
+	/* XXX update ED */
+	splx(s);
+}
+
+usbd_status
+ohci_device_isoc_start(xfer)
+	usbd_xfer_handle xfer;
+{
+	printf("ohci_device_isoc_start: not implemented\n");
+	return (USBD_INVAL);
+}
+
+void
+ohci_device_isoc_abort(xfer)
+	usbd_xfer_handle xfer;
+{
+}
+
+void
+ohci_device_isoc_done(xfer)
+	usbd_xfer_handle xfer;
+{
+	printf("ohci_device_isoc_done: not implemented\n");
+}
+
+usbd_status
+ohci_setup_isoc(pipe)
+	usbd_pipe_handle pipe;
+{
+	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
+	struct iso *iso = &opipe->u.iso;
+
+	iso->next = -1;
+	iso->inuse = 0;
+
+	return (USBD_NORMAL_COMPLETION);
+}
+
+void
+ohci_device_isoc_close(pipe)
+	usbd_pipe_handle pipe;
+{
+	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
+	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
+
+	DPRINTF(("ohci_device_isoc_close: pipe=%p\n", pipe));
+	ohci_close_pipe(pipe, sc->sc_isoc_head);
+	ohci_free_sitd(sc, opipe->tail.itd);
+}
+