 @@ -1,23 +1,24 @@
-/*	$NetBSD: ohci.c,v 1.218.6.1 2011/12/04 13:23:16 jmcneill Exp $	*/
+/*	$NetBSD: ohci.c,v 1.218.6.2 2011/12/04 21:02:27 jmcneill Exp $	*/
 /*	$FreeBSD: src/sys/dev/usb/ohci.c,v 1.22 1999/11/17 22:33:40 n_hibma Exp $	*/
 /*
- * Copyright (c) 1998, 2004, 2005 The NetBSD Foundation, Inc.
+ * Copyright (c) 1998, 2004, 2005, 2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (lennart@augustsson.net) at
- * Carlstedt Research & Technology.
+ * Carlstedt Research & Technology, Jared D. McNeill (jmcneill@invisible.ca)
  * and Matthew R. Green.
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 @@ -31,33 +32,33 @@
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * USB Open Host Controller driver.
+ *
  * OHCI spec: http://www.compaq.com/productinfo/development/openhci.html
  * USB spec: http://www.usb.org/developers/docs/
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.218.6.1 2011/12/04 13:23:16 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.218.6.2 2011/12/04 21:02:27 jmcneill Exp $");
 #include "opt_usb.h"
 #include <sys/param.h>
 #include <sys/systm.h>
-#include <sys/malloc.h>
+#include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/select.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/bus.h>
 #include <machine/endian.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdivar.h>
 #include <dev/usb/usb_mem.h>
 @@ -103,47 +104,50 @@ Static void		ohci_free_sitd(ohci_softc_t
 #if 0
 Static void		ohci_free_std_chain(ohci_softc_t *, ohci_soft_td_t *,
 					    ohci_soft_td_t *);
 #endif
 Static usbd_status	ohci_alloc_std_chain(struct ohci_pipe *,
 			    ohci_softc_t *, int, int, usbd_xfer_handle,
 			    ohci_soft_td_t *, ohci_soft_td_t **);
 Static usbd_status	ohci_open(usbd_pipe_handle);
 Static void		ohci_poll(struct usbd_bus *);
 Static void		ohci_softintr(void *);
 Static void		ohci_waitintr(ohci_softc_t *, usbd_xfer_handle);
 Static void		ohci_rhsc(ohci_softc_t *, usbd_xfer_handle);
 Static void		ohci_rhsc_softint(void *arg);
 Static usbd_status	ohci_device_request(usbd_xfer_handle xfer);
 Static void		ohci_add_ed(ohci_softc_t *, ohci_soft_ed_t *,
 			    ohci_soft_ed_t *);
 Static void		ohci_rem_ed(ohci_soft_ed_t *, ohci_soft_ed_t *);
 Static void		ohci_hash_add_td(ohci_softc_t *, ohci_soft_td_t *);
 Static void		ohci_hash_rem_td(ohci_softc_t *, ohci_soft_td_t *);
 Static ohci_soft_td_t  *ohci_hash_find_td(ohci_softc_t *, ohci_physaddr_t);
 Static void		ohci_hash_add_itd(ohci_softc_t *, ohci_soft_itd_t *);
 Static void		ohci_hash_rem_itd(ohci_softc_t *, ohci_soft_itd_t *);
 Static ohci_soft_itd_t  *ohci_hash_find_itd(ohci_softc_t *, ohci_physaddr_t);
 Static usbd_status	ohci_setup_isoc(usbd_pipe_handle pipe);
 Static void		ohci_device_isoc_enter(usbd_xfer_handle);
 Static usbd_status	ohci_allocm(struct usbd_bus *, usb_dma_t *, u_int32_t);
 Static void		ohci_freem(struct usbd_bus *, usb_dma_t *);
 Static usbd_xfer_handle	ohci_allocx(struct usbd_bus *);
 Static void		ohci_freex(struct usbd_bus *, usbd_xfer_handle);
 Static void		ohci_get_locks(struct usbd_bus *, kmutex_t **,
 				       kmutex_t **);
 Static usbd_status	ohci_root_ctrl_transfer(usbd_xfer_handle);
 Static usbd_status	ohci_root_ctrl_start(usbd_xfer_handle);
 Static void		ohci_root_ctrl_abort(usbd_xfer_handle);
 Static void		ohci_root_ctrl_close(usbd_pipe_handle);
 Static void		ohci_root_ctrl_done(usbd_xfer_handle);
 Static usbd_status	ohci_root_intr_transfer(usbd_xfer_handle);
 Static usbd_status	ohci_root_intr_start(usbd_xfer_handle);
 Static void		ohci_root_intr_abort(usbd_xfer_handle);
 Static void		ohci_root_intr_close(usbd_pipe_handle);
 Static void		ohci_root_intr_done(usbd_xfer_handle);
 @@ -264,27 +268,27 @@ struct ohci_pipe {
 	} u;
 };
 #define OHCI_INTR_ENDPT 1
 Static const struct usbd_bus_methods ohci_bus_methods = {
 	ohci_open,
 	ohci_softintr,
 	ohci_poll,
 	ohci_allocm,
 	ohci_freem,
 	ohci_allocx,
 	ohci_freex,
-	NULL, /* ohci_get_locks */
+	ohci_get_locks,
 };
 Static const struct usbd_pipe_methods ohci_root_ctrl_methods = {
 	ohci_root_ctrl_transfer,
 	ohci_root_ctrl_start,
 	ohci_root_ctrl_abort,
 	ohci_root_ctrl_close,
 	ohci_noop,
 	ohci_root_ctrl_done,
 };
 Static const struct usbd_pipe_methods ohci_root_intr_methods = {
 	ohci_root_intr_transfer,
 @@ -361,31 +365,38 @@ ohci_detach(struct ohci_softc *sc, int f
 	usbd_xfer_handle xfer;
 	if (sc->sc_child != NULL)
 		rv = config_detach(sc->sc_child, flags);
 	if (rv != 0)
 		return (rv);
 	callout_stop(&sc->sc_tmo_rhsc);
 	usb_delay_ms(&sc->sc_bus, 300); /* XXX let stray task complete */
 	callout_destroy(&sc->sc_tmo_rhsc);
 	softint_disestablish(sc->sc_rhsc_si);
 	cv_destroy(&sc->sc_softwake_cv);
 	mutex_destroy(&sc->sc_lock);
 	mutex_destroy(&sc->sc_intr_lock);
 	if (sc->sc_hcca != NULL)
 		usb_freemem(&sc->sc_bus, &sc->sc_hccadma);
 	while((xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers)) != NULL) {
 		SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, next);
-		free(xfer, M_USB);
+		kmem_free(xfer, sizeof(struct ohci_xfer));
+	}
 	return (rv);
+}
 ohci_soft_ed_t *
 ohci_alloc_sed(ohci_softc_t *sc)
+{
 	ohci_soft_ed_t *sed;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 @@ -416,85 +427,79 @@ void
 ohci_free_sed(ohci_softc_t *sc, ohci_soft_ed_t *sed)
+{
 	sed->next = sc->sc_freeeds;
 	sc->sc_freeeds = sed;
+}
 ohci_soft_td_t *
 ohci_alloc_std(ohci_softc_t *sc)
+{
 	ohci_soft_td_t *std;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	int s;
 	if (sc->sc_freetds == NULL) {
 		DPRINTFN(2, ("ohci_alloc_std: allocating chunk\n"));
 		err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
 			  OHCI_TD_ALIGN, &dma);
 		if (err)
 			return (NULL);
 		s = splusb();
 		for(i = 0; i < OHCI_STD_CHUNK; i++) {
 			offs = i * OHCI_STD_SIZE;
 			std = KERNADDR(&dma, offs);
 			std->physaddr = DMAADDR(&dma, offs);
 			std->dma = dma;
 			std->offs = offs;
 			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 = NULL;
 	std->xfer = NULL;
 	ohci_hash_add_td(sc, std);
 	splx(s);
 	return (std);
+}
 void
 ohci_free_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(struct ohci_pipe *opipe, ohci_softc_t *sc,
 		     int alen, int rd, usbd_xfer_handle xfer,
 		     ohci_soft_td_t *sp, ohci_soft_td_t **ep)
+{
 	ohci_soft_td_t *next, *cur;
 	ohci_physaddr_t dataphys, dataphysend;
 	u_int32_t tdflags;
 	int len, curlen;
 	usb_dma_t *dma = &xfer->dmabuf;
 	u_int16_t flags = xfer->flags;
 	DPRINTFN(alen < 4096,("ohci_alloc_std_chain: start len=%d\n", alen));
 	KASSERT(mutex_owned(&sc->sc_lock));
 	len = alen;
 	cur = sp;
 	dataphys = DMAADDR(dma, 0);
 	dataphysend = OHCI_PAGE(dataphys + len - 1);
 	usb_syncmem(dma, 0, len,
 	    rd ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	tdflags = HTOO32(
 	    (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);
 @@ -580,100 +585,100 @@ ohci_free_std_chain(ohci_softc_t *sc, oh
 	for (; std != stdend; std = p) {
 		p = std->nexttd;
 		ohci_free_std(sc, std);
+	}
+}
 #endif
 ohci_soft_itd_t *
 ohci_alloc_sitd(ohci_softc_t *sc)
+{
 	ohci_soft_itd_t *sitd;
 	usbd_status err;
-	int i, s, offs;
+	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_SITD_SIZE * OHCI_SITD_CHUNK,
 			  OHCI_ITD_ALIGN, &dma);
 		if (err)
 			return (NULL);
 		s = splusb();
 		for(i = 0; i < OHCI_SITD_CHUNK; i++) {
 			offs = i * OHCI_SITD_SIZE;
 			sitd = KERNADDR(&dma, offs);
 			sitd->physaddr = DMAADDR(&dma, offs);
 			sitd->dma = dma;
 			sitd->offs = offs;
 			sitd->nextitd = sc->sc_freeitds;
 			sc->sc_freeitds = sitd;
+		}
 		splx(s);
+	}
 	s = splusb();
 	sitd = sc->sc_freeitds;
 	sc->sc_freeitds = sitd->nextitd;
 	memset(&sitd->itd, 0, sizeof(ohci_itd_t));
 	sitd->nextitd = NULL;
 	sitd->xfer = NULL;
 	ohci_hash_add_itd(sc, sitd);
 	splx(s);
 #ifdef DIAGNOSTIC
 	sitd->isdone = 0;
 #endif
 	return (sitd);
+}
 void
 ohci_free_sitd(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
+{
 	int s;
 	DPRINTFN(10,("ohci_free_sitd: sitd=%p\n", sitd));
 #ifdef DIAGNOSTIC
 	if (!sitd->isdone) {
 		panic("ohci_free_sitd: sitd=%p not done", sitd);
 		return;
+	}
 	/* Warn double free */
 	sitd->isdone = 0;
 #endif
 	s = splusb();
 	ohci_hash_rem_itd(sc, sitd);
 	sitd->nextitd = sc->sc_freeitds;
 	sc->sc_freeitds = sitd;
 	splx(s);
+}
 usbd_status
 ohci_init(ohci_softc_t *sc)
+{
 	ohci_soft_ed_t *sed, *psed;
 	usbd_status err;
 	int i;
 	u_int32_t s, ctl, rwc, ival, hcr, fm, per, rev, desca, descb;
 	DPRINTF(("ohci_init: start\n"));
 	aprint_normal_dev(sc->sc_dev, "");
 	sc->sc_hcca = NULL;
-	callout_init(&sc->sc_tmo_rhsc, 0);
+	callout_init(&sc->sc_tmo_rhsc, CALLOUT_MPSAFE);
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_USB);
 	cv_init(&sc->sc_softwake_cv, "ohciab");
 	sc->sc_rhsc_si = softint_establish(SOFTINT_NET | SOFTINT_MPSAFE,
 	    ohci_rhsc_softint, sc);
 	for (i = 0; i < OHCI_HASH_SIZE; i++)
 		LIST_INIT(&sc->sc_hash_tds[i]);
 	for (i = 0; i < OHCI_HASH_SIZE; i++)
 		LIST_INIT(&sc->sc_hash_itds[i]);
 	SIMPLEQ_INIT(&sc->sc_free_xfers);
 	rev = OREAD4(sc, OHCI_REVISION);
 	aprint_normal("OHCI version %d.%d%s\n",
 	    OHCI_REV_HI(rev), OHCI_REV_LO(rev),
 	    OHCI_REV_LEGACY(rev) ? ", legacy support" : "");
 @@ -949,124 +954,139 @@ ohci_allocx(struct usbd_bus *bus)
 	struct ohci_softc *sc = bus->hci_private;
 	usbd_xfer_handle xfer;
 	xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers);
 	if (xfer != NULL) {
 		SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, next);
 #ifdef DIAGNOSTIC
 		if (xfer->busy_free != XFER_FREE) {
 			printf("ohci_allocx: xfer=%p not free, 0x%08x\n", xfer,
 			       xfer->busy_free);
+		}
 #endif
 	} else {
-		xfer = malloc(sizeof(struct ohci_xfer), M_USB, M_NOWAIT);
+		xfer = kmem_alloc(sizeof(struct ohci_xfer), KM_SLEEP);
+	}
 	if (xfer != NULL) {
 		memset(xfer, 0, sizeof (struct ohci_xfer));
 #ifdef DIAGNOSTIC
 		xfer->busy_free = XFER_BUSY;
 #endif
+	}
 	return (xfer);
+}
 void
 ohci_freex(struct usbd_bus *bus, usbd_xfer_handle xfer)
+{
 	struct ohci_softc *sc = bus->hci_private;
 #ifdef DIAGNOSTIC
 	if (xfer->busy_free != XFER_BUSY) {
 		printf("ohci_freex: xfer=%p not busy, 0x%08x\n", xfer,
 		       xfer->busy_free);
+	}
 	xfer->busy_free = XFER_FREE;
 #endif
 	SIMPLEQ_INSERT_HEAD(&sc->sc_free_xfers, xfer, next);
+}
 Static void
 ohci_get_locks(struct usbd_bus *bus, kmutex_t **intr, kmutex_t **thread)
+{
 	struct ohci_softc *sc = bus->hci_private;
 	*intr = &sc->sc_intr_lock;
 	*thread = &sc->sc_lock;
+}
 /*
  * Shut down the controller when the system is going down.
  */
 bool
 ohci_shutdown(device_t self, int flags)
+{
 	ohci_softc_t *sc = device_private(self);
 	DPRINTF(("ohci_shutdown: stopping the HC\n"));
 	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
 	return true;
+}
 bool
 ohci_resume(device_t dv, const pmf_qual_t *qual)
+{
 	ohci_softc_t *sc = device_private(dv);
 	uint32_t ctl;
 	int s;
-	s = splhardusb();
+	mutex_spin_enter(&sc->sc_intr_lock);
 	sc->sc_bus.use_polling++;
 	mutex_spin_exit(&sc->sc_intr_lock);
 	/* Some broken BIOSes do not recover these values */
 	OWRITE4(sc, OHCI_HCCA, DMAADDR(&sc->sc_hccadma, 0));
 	OWRITE4(sc, OHCI_CONTROL_HEAD_ED,
 	    sc->sc_ctrl_head->physaddr);
 	OWRITE4(sc, OHCI_BULK_HEAD_ED,
 	    sc->sc_bulk_head->physaddr);
 	if (sc->sc_intre)
 		OWRITE4(sc, OHCI_INTERRUPT_ENABLE, sc->sc_intre &
 		    (OHCI_ALL_INTRS | OHCI_MIE));
 	if (sc->sc_control)
 		ctl = sc->sc_control;
 	else
 		ctl = OREAD4(sc, OHCI_CONTROL);
 	ctl |= OHCI_HCFS_RESUME;
 	OWRITE4(sc, OHCI_CONTROL, ctl);
 	usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY);
 	ctl = (ctl & ~OHCI_HCFS_MASK) | OHCI_HCFS_OPERATIONAL;
 	OWRITE4(sc, OHCI_CONTROL, ctl);
 	usb_delay_ms(&sc->sc_bus, USB_RESUME_RECOVERY);
 	sc->sc_control = sc->sc_intre = 0;
 	mutex_spin_enter(&sc->sc_intr_lock);
 	sc->sc_bus.use_polling--;
-	splx(s);
+	mutex_spin_exit(&sc->sc_intr_lock);
 	return true;
+}
 bool
 ohci_suspend(device_t dv, const pmf_qual_t *qual)
+{
 	ohci_softc_t *sc = device_private(dv);
 	uint32_t ctl;
 	int s;
-	s = splhardusb();
+	mutex_spin_enter(&sc->sc_intr_lock);
 	sc->sc_bus.use_polling++;
 	mutex_spin_exit(&sc->sc_intr_lock);
 	ctl = OREAD4(sc, OHCI_CONTROL) & ~OHCI_HCFS_MASK;
 	if (sc->sc_control == 0) {
 		/*
 		 * Preserve register values, in case that BIOS
 		 * does not recover them.
 		 */
 		sc->sc_control = ctl;
 		sc->sc_intre = OREAD4(sc,
 		    OHCI_INTERRUPT_ENABLE);
+	}
 	ctl |= OHCI_HCFS_SUSPEND;
 	OWRITE4(sc, OHCI_CONTROL, ctl);
 	usb_delay_ms(&sc->sc_bus, USB_RESUME_WAIT);
 	mutex_spin_enter(&sc->sc_intr_lock);
 	sc->sc_bus.use_polling--;
-	splx(s);
+	mutex_spin_exit(&sc->sc_intr_lock);
 	return true;
+}
 #ifdef OHCI_DEBUG
 void
 ohci_dumpregs(ohci_softc_t *sc)
+{
 	DPRINTF(("ohci_dumpregs: rev=0x%08x control=0x%08x command=0x%08x\n",
 		 OREAD4(sc, OHCI_REVISION),
 		 OREAD4(sc, OHCI_CONTROL),
 		 OREAD4(sc, OHCI_COMMAND_STATUS)));
 	DPRINTF(("               intrstat=0x%08x intre=0x%08x intrd=0x%08x\n",
 @@ -1098,60 +1118,72 @@ ohci_dumpregs(ohci_softc_t *sc)
 		 OREAD4(sc, OHCI_RH_PORT_STATUS(2))));
 	DPRINTF(("         HCCA: frame_number=0x%04x done_head=0x%08x\n",
 		 O32TOH(sc->sc_hcca->hcca_frame_number),
 		 O32TOH(sc->sc_hcca->hcca_done_head)));
+}
 #endif
 Static int ohci_intr1(ohci_softc_t *);
 int
 ohci_intr(void *p)
+{
 	ohci_softc_t *sc = p;
 	int ret = 0;
-	if (sc == NULL || sc->sc_dying || !device_has_power(sc->sc_dev))
+	if (sc == NULL)
 		return (0);
 	mutex_spin_enter(&sc->sc_intr_lock);
 	if (sc->sc_dying || !device_has_power(sc->sc_dev))
 		goto done;
 	/* If we get an interrupt while polling, then just ignore it. */
 	if (sc->sc_bus.use_polling) {
 #ifdef DIAGNOSTIC
 		DPRINTFN(16, ("ohci_intr: ignored interrupt while polling\n"));
 #endif
 		/* for level triggered intrs, should do something to ack */
 		OWRITE4(sc, OHCI_INTERRUPT_STATUS,
 			OREAD4(sc, OHCI_INTERRUPT_STATUS));
 		return (0);
+	}
-	return (ohci_intr1(sc));
+	ret = ohci_intr1(sc);
 done:
 	mutex_spin_exit(&sc->sc_intr_lock);
 	return ret;
+}
 Static int
 ohci_intr1(ohci_softc_t *sc)
+{
 	u_int32_t intrs, eintrs;
 	DPRINTFN(14,("ohci_intr1: enter\n"));
 	/* In case the interrupt occurs before initialization has completed. */
 	if (sc == NULL || sc->sc_hcca == NULL) {
 #ifdef DIAGNOSTIC
 		printf("ohci_intr: sc->sc_hcca == NULL\n");
 #endif
 		return (0);
+	}
 	KASSERT(mutex_owned(&sc->sc_intr_lock));
 	intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS);
 	if (!intrs)
 		return (0);
 	OWRITE4(sc, OHCI_INTERRUPT_STATUS, intrs & ~(OHCI_MIE|OHCI_WDH)); /* Acknowledge */
 	eintrs = intrs & sc->sc_eintrs;
 	DPRINTFN(7, ("ohci_intr: sc=%p intrs=%#x(%#x) eintrs=%#x(%#x)\n",
 		     sc, (u_int)intrs, OREAD4(sc, OHCI_INTERRUPT_STATUS),
 		     (u_int)eintrs, sc->sc_eintrs));
 	if (!eintrs) {
 		return (0);
+	}
 @@ -1180,54 +1212,52 @@ ohci_intr1(ohci_softc_t *sc)
 		/* XXX process resume detect */
+	}
 	if (eintrs & OHCI_UE) {
 		printf("%s: unrecoverable error, controller halted\n",
 		       device_xname(sc->sc_dev));
 		OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
 		/* XXX what else */
+	}
 	if (eintrs & OHCI_RHSC) {
 		/*
 		 * We block the interrupt below, and reenable it later from
 		 * a timeout.
 		 */
-		ohci_rhsc(sc, sc->sc_intrxfer);
+		softint_schedule(sc->sc_rhsc_si);
 		/* Do not allow RHSC interrupts > 1 per second */
 		callout_reset(&sc->sc_tmo_rhsc, hz, ohci_rhsc_enable, sc);
+	}
 	sc->sc_bus.intr_context--;
 	if (eintrs != 0) {
 		/* Block unprocessed interrupts. */
 		OWRITE4(sc, OHCI_INTERRUPT_DISABLE, eintrs);
 		sc->sc_eintrs &= ~eintrs;
 		DPRINTFN(1, ("%s: blocking intrs 0x%x\n",
 		    device_xname(sc->sc_dev), eintrs));
+	}
 	return (1);
+}
 void
 ohci_rhsc_enable(void *v_sc)
+{
 	ohci_softc_t *sc = v_sc;
 	int s;
-	s = splhardusb();
+	DPRINTFN(1, ("%s: %s\n", __func__, device_xname(sc->sc_dev)));
 	mutex_spin_enter(&sc->sc_intr_lock);
 	sc->sc_eintrs |= OHCI_RHSC;
 	OWRITE4(sc, OHCI_INTERRUPT_ENABLE, OHCI_RHSC);
-	splx(s);
+	mutex_spin_exit(&sc->sc_intr_lock);
+}
 #ifdef OHCI_DEBUG
 const char *ohci_cc_strs[] = {
 	"NO_ERROR",
 	"CRC",
 	"BIT_STUFFING",
 	"DATA_TOGGLE_MISMATCH",
 	"STALL",
 	"DEVICE_NOT_RESPONDING",
 	"PID_CHECK_FAILURE",
 	"UNEXPECTED_PID",
 	"DATA_OVERRUN",
 @@ -1240,47 +1270,47 @@ const char *ohci_cc_strs[] = {
 	"NOT_ACCESSED",
 };
 #endif
 void
 ohci_softintr(void *v)
+{
 	struct usbd_bus *bus = v;
 	ohci_softc_t *sc = bus->hci_private;
 	ohci_soft_itd_t *sitd, *sidone, *sitdnext;
 	ohci_soft_td_t  *std,  *sdone,  *stdnext;
 	usbd_xfer_handle xfer;
 	struct ohci_pipe *opipe;
-	int len, cc, s;
+	int len, cc;
 	int i, j, actlen, iframes, uedir;
 	ohci_physaddr_t done;
 	DPRINTFN(10,("ohci_softintr: enter\n"));
 	mutex_enter(&sc->sc_lock);
 	sc->sc_bus.intr_context++;
 	s = splhardusb();
 	usb_syncmem(&sc->sc_hccadma, offsetof(struct ohci_hcca, hcca_done_head),
 	    sizeof(sc->sc_hcca->hcca_done_head),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	done = O32TOH(sc->sc_hcca->hcca_done_head) & ~OHCI_DONE_INTRS;
 	sc->sc_hcca->hcca_done_head = 0;
 	usb_syncmem(&sc->sc_hccadma, offsetof(struct ohci_hcca, hcca_done_head),
 	    sizeof(sc->sc_hcca->hcca_done_head),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	OWRITE4(sc, OHCI_INTERRUPT_STATUS, OHCI_WDH);
 	sc->sc_eintrs |= OHCI_WDH;
 	OWRITE4(sc, OHCI_INTERRUPT_ENABLE, OHCI_WDH);
 	splx(s);
 	/* Reverse the done list. */
 	for (sdone = NULL, sidone = NULL; done != 0; ) {
 		std = ohci_hash_find_td(sc, done);
 		if (std != NULL) {
 			usb_syncmem(&std->dma, std->offs, sizeof(std->td),
 			    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 			std->dnext = sdone;
 			done = O32TOH(std->td.td_nexttd);
 			sdone = std;
 			DPRINTFN(10,("add TD %p\n", std));
 			continue;
+		}
 @@ -1334,29 +1364,27 @@ ohci_softintr(void *v)
 		len = std->len;
 		if (std->td.td_cbp != 0)
 			len -= O32TOH(std->td.td_be) -
 			       O32TOH(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)
 			xfer->actlen += len;
 		cc = OHCI_TD_GET_CC(O32TOH(std->td.td_flags));
 		if (cc == OHCI_CC_NO_ERROR) {
 			if (std->flags & OHCI_CALL_DONE) {
 				xfer->status = USBD_NORMAL_COMPLETION;
 				s = splusb();
 				usb_transfer_complete(xfer);
 				splx(s);
+			}
 			ohci_free_std(sc, std);
 		} else {
 			/*
 			 * Endpoint is halted.  First unlink all the TDs
 			 * belonging to the failed transfer, and then restart
 			 * the endpoint.
 			 */
 			ohci_soft_td_t *p, *n;
 			opipe = (struct ohci_pipe *)xfer->pipe;
 			DPRINTFN(15,("ohci_process_done: error cc=%d (%s)\n",
 			  OHCI_TD_GET_CC(O32TOH(std->td.td_flags)),
 @@ -1366,29 +1394,27 @@ ohci_softintr(void *v)
 			for (p = std; p->xfer == xfer; p = n) {
 				n = p->nexttd;
 				ohci_free_std(sc, p);
+			}
 			/* clear halt */
 			opipe->sed->ed.ed_headp = HTOO32(p->physaddr);
 			OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
 			if (cc == OHCI_CC_STALL)
 				xfer->status = USBD_STALLED;
 			else
 				xfer->status = USBD_IOERROR;
 			s = splusb();
 			usb_transfer_complete(xfer);
 			splx(s);
+		}
+	}
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 10) {
 		DPRINTF(("ohci_softintr: ITD done:\n"));
 		ohci_dump_itds(sc, sidone);
+	}
 #endif
 	for (sitd = sidone; sitd != NULL; sitd = sitdnext) {
 		xfer = sitd->xfer;
 		sitdnext = sitd->dnext;
 @@ -1442,78 +1468,80 @@ ohci_softintr(void *v)
 						actlen += len;
+					}
+				}
 				if (sitd->flags & OHCI_CALL_DONE)
 					break;
 				ohci_free_sitd(sc, sitd);
+			}
 			ohci_free_sitd(sc, sitd);
 			if (uedir == UE_DIR_IN &&
 			    xfer->status == USBD_NORMAL_COMPLETION)
 				xfer->actlen = actlen;
 			xfer->hcpriv = NULL;
 			s = splusb();
 			usb_transfer_complete(xfer);
 			splx(s);
+		}
+	}
 #ifdef USB_USE_SOFTINTR
 	if (sc->sc_softwake) {
 		sc->sc_softwake = 0;
-		wakeup(&sc->sc_softwake);
+		cv_broadcast(&sc->sc_softwake_cv);
+	}
 #endif /* USB_USE_SOFTINTR */
 	sc->sc_bus.intr_context--;
 	mutex_exit(&sc->sc_lock);
 	DPRINTFN(10,("ohci_softintr: done:\n"));
+}
 void
 ohci_device_ctrl_done(usbd_xfer_handle xfer)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	int len = UGETW(xfer->request.wLength);
 	int isread = (xfer->request.bmRequestType & UT_READ);
 	DPRINTFN(10,("ohci_device_ctrl_done: xfer=%p\n", xfer));
 	KASSERT(mutex_owned(&sc->sc_lock));
 #ifdef DIAGNOSTIC
 	if (!(xfer->rqflags & URQ_REQUEST)) {
 		panic("ohci_device_ctrl_done: not a request");
+	}
 #endif
 	if (len)
 		usb_syncmem(&xfer->dmabuf, 0, len,
 		    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 	 usb_syncmem(&opipe->u.ctl.reqdma, 0,
 	     sizeof(usb_device_request_t),  BUS_DMASYNC_POSTWRITE);
+}
 void
 ohci_device_intr_done(usbd_xfer_handle xfer)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_softc_t *sc = opipe->pipe.device->bus->hci_private;
 	ohci_soft_ed_t *sed = opipe->sed;
 	ohci_soft_td_t *data, *tail;
 	int isread =
 	    (UE_GET_DIR(xfer->pipe->endpoint->edesc->bEndpointAddress) == UE_DIR_IN);
 	DPRINTFN(10,("ohci_device_intr_done: xfer=%p, actlen=%d\n",
 		     xfer, xfer->actlen));
 	KASSERT(mutex_owned(&sc->sc_lock));
 	usb_syncmem(&xfer->dmabuf, 0, xfer->length,
 	    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 	if (xfer->pipe->repeat) {
 		data = opipe->tail.td;
 		tail = ohci_alloc_std(sc); /* XXX should reuse TD */
 		if (tail == NULL) {
 			xfer->status = USBD_NOMEM;
 			return;
+		}
 		tail->xfer = NULL;
 		data->td.td_flags = HTOO32(
 			OHCI_TD_IN | OHCI_TD_NOCC |
 @@ -1535,43 +1563,63 @@ ohci_device_intr_done(usbd_xfer_handle x
 		sed->ed.ed_tailp = HTOO32(tail->physaddr);
 		usb_syncmem(&sed->dma,
 		    sed->offs + offsetof(ohci_ed_t, ed_tailp),
 		    sizeof(sed->ed.ed_tailp),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		opipe->tail.td = tail;
+	}
+}
 void
 ohci_device_bulk_done(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	int isread =
 	    (UE_GET_DIR(xfer->pipe->endpoint->edesc->bEndpointAddress) == UE_DIR_IN);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTFN(10,("ohci_device_bulk_done: xfer=%p, actlen=%d\n",
 		     xfer, xfer->actlen));
 	usb_syncmem(&xfer->dmabuf, 0, xfer->length,
 	    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
+}
 Static void
 ohci_rhsc_softint(void *arg)
+{
 	ohci_softc_t *sc = arg;
 	mutex_enter(&sc->sc_lock);
 	ohci_rhsc(sc, sc->sc_intrxfer);
 	/* Do not allow RHSC interrupts > 1 per second */
 	callout_reset(&sc->sc_tmo_rhsc, hz, ohci_rhsc_enable, sc);
 	mutex_exit(&sc->sc_lock);
+}
 void
 ohci_rhsc(ohci_softc_t *sc, usbd_xfer_handle xfer)
+{
 	usbd_pipe_handle pipe;
 	u_char *p;
 	int i, m;
 	int hstatus;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	hstatus = OREAD4(sc, OHCI_RH_STATUS);
 	DPRINTF(("ohci_rhsc: sc=%p xfer=%p hstatus=0x%08x\n",
 		 sc, xfer, hstatus));
 	if (xfer == NULL) {
 		/* Just ignore the change. */
 		return;
+	}
 	pipe = xfer->pipe;
 	p = KERNADDR(&xfer->dmabuf, 0);
 	m = min(sc->sc_noport, xfer->length * 8 - 1);
 @@ -1599,84 +1647,95 @@ ohci_root_ctrl_done(usbd_xfer_handle xfe
+}
 /*
  * Wait here until controller claims to have an interrupt.
  * Then call ohci_intr and return.  Use timeout to avoid waiting
  * too long.
  */
 void
 ohci_waitintr(ohci_softc_t *sc, usbd_xfer_handle xfer)
+{
 	int timo;
 	u_int32_t intrs;
 	mutex_enter(&sc->sc_lock);
 	xfer->status = USBD_IN_PROGRESS;
 	for (timo = xfer->timeout; timo >= 0; timo--) {
 		usb_delay_ms(&sc->sc_bus, 1);
 		if (sc->sc_dying)
 			break;
 		intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs;
 		DPRINTFN(15,("ohci_waitintr: 0x%04x\n", intrs));
 #ifdef OHCI_DEBUG
 		if (ohcidebug > 15)
 			ohci_dumpregs(sc);
 #endif
 		if (intrs) {
 			mutex_spin_enter(&sc->sc_intr_lock);
 			ohci_intr1(sc);
 			mutex_spin_exit(&sc->sc_intr_lock);
 			if (xfer->status != USBD_IN_PROGRESS)
 				return;
+		}
+	}
 	/* Timeout */
 	DPRINTF(("ohci_waitintr: timeout\n"));
 	xfer->status = USBD_TIMEOUT;
 	usb_transfer_complete(xfer);
 	/* XXX should free TD */
 	mutex_exit(&sc->sc_lock);
+}
 void
 ohci_poll(struct usbd_bus *bus)
+{
 	ohci_softc_t *sc = bus->hci_private;
 #ifdef OHCI_DEBUG
 	static int last;
 	int new;
 	new = OREAD4(sc, OHCI_INTERRUPT_STATUS);
 	if (new != last) {
 		DPRINTFN(10,("ohci_poll: intrs=0x%04x\n", new));
 		last = new;
+	}
 #endif
 	sc->sc_eintrs |= OHCI_WDH;
-	if (OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs)
+	if (OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs) {
 		mutex_spin_enter(&sc->sc_intr_lock);
 		ohci_intr1(sc);
 		mutex_spin_exit(&sc->sc_intr_lock);
+	}
+}
 usbd_status
 ohci_device_request(usbd_xfer_handle xfer)
+{
 	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 = dev->bus->hci_private;
 	int addr = dev->address;
 	ohci_soft_td_t *setup, *stat, *next, *tail;
 	ohci_soft_ed_t *sed;
 	int isread;
 	int len;
 	usbd_status err;
 	int s;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	isread = req->bmRequestType & UT_READ;
 	len = UGETW(req->wLength);
 	DPRINTFN(3,("ohci_device_control type=0x%02x, request=0x%02x, "
 		    "wValue=0x%04x, wIndex=0x%04x len=%d, addr=%d, endpt=%d\n",
 		    req->bmRequestType, req->bRequest, UGETW(req->wValue),
 		    UGETW(req->wIndex), len, addr,
 		    opipe->pipe.endpoint->edesc->bEndpointAddress));
 	setup = opipe->tail.td;
 	stat = ohci_alloc_std(sc);
 	if (stat == NULL) {
 @@ -1757,39 +1816,37 @@ ohci_device_request(usbd_xfer_handle xfe
 	stat->xfer = xfer;
 	usb_syncmem(&stat->dma, stat->offs, sizeof(stat->td),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 5) {
 		DPRINTF(("ohci_device_request:\n"));
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, setup);
+	}
 #endif
 	/* Insert ED in schedule */
 	s = splusb();
 	sed->ed.ed_tailp = HTOO32(tail->physaddr);
 	usb_syncmem(&sed->dma,
 	    sed->offs + offsetof(ohci_ed_t, ed_tailp),
 	    sizeof(sed->ed.ed_tailp),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	opipe->tail.td = tail;
 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
 	if (xfer->timeout && !sc->sc_bus.use_polling) {
 		callout_reset(&xfer->timeout_handle, mstohz(xfer->timeout),
 			    ohci_timeout, xfer);
+	}
 	splx(s);
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 20) {
 		delay(10000);
 		DPRINTF(("ohci_device_request: status=%x\n",
 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
 		ohci_dumpregs(sc);
 		printf("ctrl head:\n");
 		ohci_dump_ed(sc, sc->sc_ctrl_head);
 		printf("sed:\n");
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, setup);
+	}
 @@ -1953,33 +2010,34 @@ ohci_timeout(void *addr)
 		return;
+	}
 	/* Execute the abort in a process context. */
 	usb_init_task(&oxfer->abort_task, ohci_timeout_task, addr);
 	usb_add_task(oxfer->xfer.pipe->device, &oxfer->abort_task,
 	    USB_TASKQ_HC);
+}
 void
 ohci_timeout_task(void *addr)
+{
 	usbd_xfer_handle xfer = addr;
-	int s;
+	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	DPRINTF(("ohci_timeout_task: xfer=%p\n", xfer));
-	s = splusb();
+	KASSERT(mutex_owned(&sc->sc_lock));
 	//mutex_enter(&sc->sc_lock);
 	ohci_abort_xfer(xfer, USBD_TIMEOUT);
-	splx(s);
+	//mutex_exit(&sc->sc_lock);
+}
 #ifdef OHCI_DEBUG
 void
 ohci_dump_tds(ohci_softc_t *sc, ohci_soft_td_t *std)
+{
 	for (; std; std = std->nexttd)
 		ohci_dump_td(sc, std);
+}
 void
 ohci_dump_td(ohci_softc_t *sc, ohci_soft_td_t *std)
+{
 @@ -2060,49 +2118,51 @@ usbd_status
 ohci_open(usbd_pipe_handle pipe)
+{
 	usbd_device_handle dev = pipe->device;
 	ohci_softc_t *sc = dev->bus->hci_private;
 	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;
 	ohci_soft_itd_t *sitd;
 	ohci_physaddr_t tdphys;
 	u_int32_t fmt;
-	usbd_status err;
+	usbd_status err = USBD_NOMEM;
 	int s;
 	int ival;
 	DPRINTFN(1, ("ohci_open: pipe=%p, addr=%d, endpt=%d (%d)\n",
 		     pipe, addr, ed->bEndpointAddress, sc->sc_addr));
-	if (sc->sc_dying)
+	if (sc->sc_dying) {
-		return (USBD_IOERROR);
+		err = USBD_IOERROR;
 		goto bad0;
+	}
 	std = NULL;
 	sed = NULL;
 	if (addr == sc->sc_addr) {
 		switch (ed->bEndpointAddress) {
 		case USB_CONTROL_ENDPOINT:
 			pipe->methods = &ohci_root_ctrl_methods;
 			break;
 		case UE_DIR_IN | OHCI_INTR_ENDPT:
 			pipe->methods = &ohci_root_intr_methods;
 			break;
 		default:
-			return (USBD_INVAL);
+			err = USBD_INVAL;
 			goto bad0;
+		}
 	} else {
 		sed = ohci_alloc_sed(sc);
 		if (sed == NULL)
 			goto bad0;
 		opipe->sed = sed;
 		if (xfertype == UE_ISOCHRONOUS) {
 			sitd = ohci_alloc_sitd(sc);
 			if (sitd == NULL)
 				goto bad1;
 			opipe->tail.itd = sitd;
 			tdphys = sitd->physaddr;
 			fmt = OHCI_ED_FORMAT_ISO;
 @@ -2128,73 +2188,75 @@ ohci_open(usbd_pipe_handle pipe)
 		    (pipe->endpoint->datatoggle ? OHCI_TOGGLECARRY : 0));
 		sed->ed.ed_tailp = HTOO32(tdphys);
 		usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		switch (xfertype) {
 		case UE_CONTROL:
 			pipe->methods = &ohci_device_ctrl_methods;
 			err = usb_allocmem(&sc->sc_bus,
 				  sizeof(usb_device_request_t),
 , &opipe->u.ctl.reqdma);
 			if (err)
 				goto bad;
-			s = splusb();
+			mutex_enter(&sc->sc_lock);
 			ohci_add_ed(sc, sed, sc->sc_ctrl_head);
-			splx(s);
+			mutex_exit(&sc->sc_lock);
 			break;
 		case UE_INTERRUPT:
 			pipe->methods = &ohci_device_intr_methods;
 			ival = pipe->interval;
 			if (ival == USBD_DEFAULT_INTERVAL)
 				ival = ed->bInterval;
 			return (ohci_device_setintr(sc, opipe, ival));
 		case UE_ISOCHRONOUS:
 			pipe->methods = &ohci_device_isoc_methods;
 			return (ohci_setup_isoc(pipe));
 		case UE_BULK:
 			pipe->methods = &ohci_device_bulk_methods;
-			s = splusb();
+			mutex_enter(&sc->sc_lock);
 			ohci_add_ed(sc, sed, sc->sc_bulk_head);
-			splx(s);
+			mutex_exit(&sc->sc_lock);
 			break;
+		}
+	}
 	return (USBD_NORMAL_COMPLETION);
 	return USBD_NORMAL_COMPLETION;
  bad:
 	if (std != NULL)
 		ohci_free_std(sc, std);
  bad1:
 	if (sed != NULL)
 		ohci_free_sed(sc, sed);
  bad0:
-	return (USBD_NOMEM);
+	mutex_exit(&sc->sc_lock);
 	return err;
+}
 /*
  * Close a reqular pipe.
  * Assumes that there are no pending transactions.
  */
 void
 ohci_close_pipe(usbd_pipe_handle pipe, ohci_soft_ed_t *head)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	ohci_soft_ed_t *sed = opipe->sed;
 	int s;
-	s = splusb();
+	KASSERT(mutex_owned(&sc->sc_lock));
 #ifdef DIAGNOSTIC
 	sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
 	if ((O32TOH(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
 	    (O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK)) {
 		ohci_soft_td_t *std;
 		std = ohci_hash_find_td(sc, O32TOH(sed->ed.ed_headp));
 		printf("ohci_close_pipe: pipe not empty sed=%p hd=0x%x "
 		       "tl=0x%x pipe=%p, std=%p\n", sed,
 		       (int)O32TOH(sed->ed.ed_headp),
 		       (int)O32TOH(sed->ed.ed_tailp),
 		       pipe, std);
 #ifdef USB_DEBUG
 		usbd_dump_pipe(&opipe->pipe);
 @@ -2205,133 +2267,125 @@ ohci_close_pipe(usbd_pipe_handle pipe, o
 			ohci_dump_td(sc, std);
 #endif
 		usb_delay_ms(&sc->sc_bus, 2);
 		if ((O32TOH(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
 		    (O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK))
 			printf("ohci_close_pipe: pipe still not empty\n");
+	}
 #endif
 	ohci_rem_ed(sed, head);
 	/* Make sure the host controller is not touching this ED */
 	usb_delay_ms(&sc->sc_bus, 1);
 	pipe->endpoint->datatoggle =
 	    (O32TOH(sed->ed.ed_headp) & OHCI_TOGGLECARRY) ? 1 : 0;
 	splx(s);
 	ohci_free_sed(sc, opipe->sed);
+}
 /*
  * Abort a device request.
  * If this routine is called at splusb() it guarantees that the request
  * will be removed from the hardware scheduling and that the callback
  * for it will be called with USBD_CANCELLED status.
  * It's impossible to guarantee that the requested transfer will not
  * have happened since the hardware runs concurrently.
  * If the transaction has already happened we rely on the ordinary
  * interrupt processing to process it.
  */
 void
 ohci_abort_xfer(usbd_xfer_handle xfer, usbd_status status)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_softc_t *sc = opipe->pipe.device->bus->hci_private;
 	ohci_soft_ed_t *sed = opipe->sed;
 	ohci_soft_td_t *p, *n;
 	ohci_physaddr_t headp;
-	int s, hit;
+	int hit;
 	int wake;
 	DPRINTF(("ohci_abort_xfer: xfer=%p pipe=%p sed=%p\n", xfer, opipe,sed));
 	if (sc->sc_dying) {
 		/* If we're dying, just do the software part. */
-		s = splusb();
+		mutex_enter(&sc->sc_lock);
 		xfer->status = status;	/* make software ignore it */
-		callout_stop(&xfer->timeout_handle);
+		callout_halt(&xfer->timeout_handle, &sc->sc_lock);
 		usb_transfer_complete(xfer);
-		splx(s);
+		mutex_exit(&sc->sc_lock);
 		return;
+	}
 	if (xfer->device->bus->intr_context || !curproc)
 		panic("ohci_abort_xfer: not in process context");
 	mutex_enter(&sc->sc_lock);
 	/*
 	 * If an abort is already in progress then just wait for it to
 	 * complete and return.
 	 */
 	if (xfer->hcflags & UXFER_ABORTING) {
 		DPRINTFN(2, ("ohci_abort_xfer: already aborting\n"));
 #ifdef DIAGNOSTIC
 		if (status == USBD_TIMEOUT)
 			printf("0hci_abort_xfer: TIMEOUT while aborting\n");
 #endif
 		/* Override the status which might be USBD_TIMEOUT. */
 		xfer->status = status;
 		DPRINTFN(2, ("ohci_abort_xfer: waiting for abort to finish\n"));
 		xfer->hcflags |= UXFER_ABORTWAIT;
 		while (xfer->hcflags & UXFER_ABORTING)
-			tsleep(&xfer->hcflags, PZERO, "ohciaw", 0);
+			cv_wait(&xfer->hccv, &sc->sc_lock);
 		goto done;
 		return;
+	}
 	xfer->hcflags |= UXFER_ABORTING;
 	/*
 	 * Step 1: Make interrupt routine and hardware ignore xfer.
 	 */
 	s = splusb();
 	xfer->status = status;	/* make software ignore it */
 	callout_stop(&xfer->timeout_handle);
 	splx(s);
 	DPRINTFN(1,("ohci_abort_xfer: stop ed=%p\n", sed));
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP); /* force hardware skip */
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	/*
 	 * Step 2: Wait until we know hardware has finished any possible
 	 * use of the xfer.  Also make sure the soft interrupt routine
 	 * has run.
 	 */
 	usb_delay_ms(opipe->pipe.device->bus, 20); /* Hardware finishes in 1ms */
 	s = splusb();
 #ifdef USB_USE_SOFTINTR
 	sc->sc_softwake = 1;
 #endif /* USB_USE_SOFTINTR */
 	usb_schedsoftintr(&sc->sc_bus);
-#ifdef USB_USE_SOFTINTR
+	cv_wait(&sc->sc_softwake_cv, &sc->sc_lock);
 	tsleep(&sc->sc_softwake, PZERO, "ohciab", 0);
 #endif /* USB_USE_SOFTINTR */
 	splx(s);
 	/*
 	 * Step 3: Remove any vestiges of the xfer from the hardware.
 	 * The complication here is that the hardware may have executed
 	 * beyond the xfer we're trying to abort.  So as we're scanning
 	 * the TDs of this xfer we check if the hardware points to
 	 * any of them.
 	 */
 	s = splusb();		/* XXX why? */
 	p = xfer->hcpriv;
 #ifdef DIAGNOSTIC
 	if (p == NULL) {
 		xfer->hcflags &= ~UXFER_ABORTING; /* XXX */
 		splx(s);
 		printf("ohci_abort_xfer: hcpriv is NULL\n");
-		return;
+		goto done;
+	}
 #endif
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 1) {
 		DPRINTF(("ohci_abort_xfer: sed=\n"));
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, p);
+	}
 #endif
 	headp = O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK;
 	hit = 0;
 	for (; p->xfer == xfer; p = n) {
 		hit |= headp == p->physaddr;
 @@ -2359,29 +2413,30 @@ ohci_abort_xfer(usbd_xfer_handle xfer, u
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP); /* remove hardware skip */
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	/*
 	 * Step 5: Execute callback.
 	 */
 	wake = xfer->hcflags & UXFER_ABORTWAIT;
 	xfer->hcflags &= ~(UXFER_ABORTING | UXFER_ABORTWAIT);
 	usb_transfer_complete(xfer);
 	if (wake)
-		wakeup(&xfer->hcflags);
+		cv_broadcast(&xfer->hccv);
-	splx(s);
+done:
 	mutex_exit(&sc->sc_lock);
+}
 /*
  * Data structures and routines to emulate the root hub.
  */
 Static usb_device_descriptor_t ohci_devd = {
 	USB_DEVICE_DESCRIPTOR_SIZE,
 	UDESC_DEVICE,		/* type */
 	{0x00, 0x01},		/* USB version */
 	UDCLASS_HUB,		/* class */
 	UDSUBCLASS_HUB,		/* subclass */
 	UDPROTO_FSHUB,		/* protocol */
 ,			/* max packet */
 @@ -2425,45 +2480,48 @@ Static const usb_endpoint_descriptor_t o
 };
 Static const usb_hub_descriptor_t ohci_hubd = {
 	.bDescLength = USB_HUB_DESCRIPTOR_SIZE,
 	.bDescriptorType = UDESC_HUB,
 };
 /*
  * Simulate a hardware hub by handling all the necessary requests.
  */
 Static usbd_status
 ohci_root_ctrl_transfer(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usbd_status err;
 	/* Insert last in queue. */
 	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	if (err)
 		return (err);
 	/* Pipe isn't running, start first */
 	return (ohci_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
+}
 Static usbd_status
 ohci_root_ctrl_start(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usb_device_request_t *req;
 	void *buf = NULL;
 	int port, i;
-	int s, len, value, index, l, totlen = 0;
+	int len, value, index, l, totlen = 0;
 	usb_port_status_t ps;
 	usb_hub_descriptor_t hubd;
 	usbd_status err;
 	u_int32_t v;
 	if (sc->sc_dying)
 		return (USBD_IOERROR);
 #ifdef DIAGNOSTIC
 	if (!(xfer->rqflags & URQ_REQUEST))
 		/* XXX panic */
 		return (USBD_INVAL);
 #endif
 @@ -2744,217 +2802,235 @@ ohci_root_ctrl_start(usbd_xfer_handle xf
 		default:
 			err = USBD_IOERROR;
 			goto ret;
+		}
 		break;
 	default:
 		err = USBD_IOERROR;
 		goto ret;
+	}
 	xfer->actlen = totlen;
 	err = USBD_NORMAL_COMPLETION;
  ret:
 	xfer->status = err;
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	usb_transfer_complete(xfer);
-	splx(s);
+	mutex_exit(&sc->sc_lock);
 	return (USBD_IN_PROGRESS);
+}
 /* Abort a root control request. */
 Static void
 ohci_root_ctrl_abort(usbd_xfer_handle xfer)
+{
 	/* Nothing to do, all transfers are synchronous. */
+}
 /* Close the root pipe. */
 Static void
 ohci_root_ctrl_close(usbd_pipe_handle pipe)
+{
 	DPRINTF(("ohci_root_ctrl_close\n"));
 	/* Nothing to do. */
+}
 Static usbd_status
 ohci_root_intr_transfer(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usbd_status err;
 	/* Insert last in queue. */
 	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	if (err)
 		return (err);
 	/* Pipe isn't running, start first */
 	return (ohci_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
+}
 Static usbd_status
 ohci_root_intr_start(usbd_xfer_handle xfer)
+{
 	usbd_pipe_handle pipe = xfer->pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	if (sc->sc_dying)
 		return (USBD_IOERROR);
 	mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intrxfer == NULL);
 	sc->sc_intrxfer = xfer;
 	mutex_exit(&sc->sc_lock);
 	return (USBD_IN_PROGRESS);
+}
 /* Abort a root interrupt request. */
 Static void
 ohci_root_intr_abort(usbd_xfer_handle xfer)
+{
-	int s;
+	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	if (xfer->pipe->intrxfer == xfer) {
 		DPRINTF(("ohci_root_intr_abort: remove\n"));
 		xfer->pipe->intrxfer = NULL;
+	}
 	xfer->status = USBD_CANCELLED;
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	usb_transfer_complete(xfer);
-	splx(s);
+	mutex_exit(&sc->sc_lock);
+}
 /* Close the root pipe. */
 Static void
 ohci_root_intr_close(usbd_pipe_handle pipe)
+{
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	DPRINTF(("ohci_root_intr_close\n"));
 	sc->sc_intrxfer = NULL;
+}
 /************************/
 Static usbd_status
 ohci_device_ctrl_transfer(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usbd_status err;
 	/* Insert last in queue. */
 	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	if (err)
 		return (err);
 	/* Pipe isn't running, start first */
 	return (ohci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
+}
 Static usbd_status
 ohci_device_ctrl_start(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usbd_status err;
 	if (sc->sc_dying)
 		return (USBD_IOERROR);
 #ifdef DIAGNOSTIC
 	if (!(xfer->rqflags & URQ_REQUEST)) {
 		/* XXX panic */
 		printf("ohci_device_ctrl_transfer: not a request\n");
 		return (USBD_INVAL);
+	}
 #endif
 	mutex_enter(&sc->sc_lock);
 	err = ohci_device_request(xfer);
 	mutex_exit(&sc->sc_lock);
 	if (err)
 		return (err);
 	if (sc->sc_bus.use_polling)
 		ohci_waitintr(sc, xfer);
 	return (USBD_IN_PROGRESS);
+}
 /* Abort a device control request. */
 Static void
 ohci_device_ctrl_abort(usbd_xfer_handle xfer)
+{
 	DPRINTF(("ohci_device_ctrl_abort: xfer=%p\n", xfer));
 	ohci_abort_xfer(xfer, USBD_CANCELLED);
+}
 /* Close a device control pipe. */
 Static void
 ohci_device_ctrl_close(usbd_pipe_handle pipe)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	DPRINTF(("ohci_device_ctrl_close: pipe=%p\n", pipe));
 	mutex_enter(&sc->sc_lock);
 	ohci_close_pipe(pipe, sc->sc_ctrl_head);
 	mutex_exit(&sc->sc_lock);
 	ohci_free_std(sc, opipe->tail.td);
+}
 /************************/
 Static void
 ohci_device_clear_toggle(usbd_pipe_handle pipe)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	opipe->sed->ed.ed_headp &= HTOO32(~OHCI_TOGGLECARRY);
+}
 Static void
 ohci_noop(usbd_pipe_handle pipe)
+{
+}
 Static usbd_status
 ohci_device_bulk_transfer(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usbd_status err;
 	/* Insert last in queue. */
 	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	if (err)
 		return (err);
 	/* Pipe isn't running, start first */
 	return (ohci_device_bulk_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
+}
 Static usbd_status
 ohci_device_bulk_start(usbd_xfer_handle xfer)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	usbd_device_handle dev = opipe->pipe.device;
 	ohci_softc_t *sc = dev->bus->hci_private;
 	int addr = dev->address;
 	ohci_soft_td_t *data, *tail, *tdp;
 	ohci_soft_ed_t *sed;
-	int s, len, isread, endpt;
+	int len, isread, endpt;
 	usbd_status err;
 	if (sc->sc_dying)
 		return (USBD_IOERROR);
 #ifdef DIAGNOSTIC
 	if (xfer->rqflags & URQ_REQUEST) {
 		/* XXX panic */
 		printf("ohci_device_bulk_start: a request\n");
 		return (USBD_INVAL);
+	}
 #endif
 	mutex_enter(&sc->sc_lock);
 	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: xfer=%p len=%d isread=%d "
 		    "flags=%d endpt=%d\n", xfer, len, isread, xfer->flags,
 		    endpt));
 	opipe->u.bulk.isread = isread;
 	opipe->u.bulk.length = len;
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 @@ -2966,124 +3042,129 @@ ohci_device_bulk_start(usbd_xfer_handle
 	/* Allocate a chain of new TDs (including a new tail). */
 	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 &= HTOO32(~OHCI_TD_INTR_MASK);
 	tail->td.td_flags |= HTOO32(OHCI_TD_SET_DI(1));
 	tail->flags |= OHCI_CALL_DONE;
 	tail = tail->nexttd;	/* point at sentinel */
 	usb_syncmem(&tail->dma, tail->offs + offsetof(ohci_td_t, td_flags),
 	    sizeof(tail->td.td_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
-	if (err)
+	if (err) {
 		mutex_exit(&sc->sc_lock);
 		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",
 		    (int)O32TOH(sed->ed.ed_flags),
 		    (int)O32TOH(data->td.td_flags),
 		    (int)O32TOH(data->td.td_cbp),
 		    (int)O32TOH(data->td.td_be)));
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 5) {
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, data);
+	}
 #endif
 	/* Insert ED in schedule */
 	s = splusb();
 	for (tdp = data; tdp != tail; tdp = tdp->nexttd) {
 		tdp->xfer = xfer;
+	}
 	sed->ed.ed_tailp = HTOO32(tail->physaddr);
 	opipe->tail.td = tail;
 	sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP);
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF);
 	if (xfer->timeout && !sc->sc_bus.use_polling) {
 		callout_reset(&xfer->timeout_handle, mstohz(xfer->timeout),
 			    ohci_timeout, xfer);
+	}
 	mutex_exit(&sc->sc_lock);
 #if 0
 /* This goes wrong if we are too slow. */
 	if (ohcidebug > 10) {
 		delay(10000);
 		DPRINTF(("ohci_device_intr_transfer: status=%x\n",
 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, data);
+	}
 #endif
 	splx(s);
 	return (USBD_IN_PROGRESS);
+}
 Static void
 ohci_device_bulk_abort(usbd_xfer_handle xfer)
+{
 	DPRINTF(("ohci_device_bulk_abort: xfer=%p\n", xfer));
 	ohci_abort_xfer(xfer, USBD_CANCELLED);
+}
 /*
  * Close a device bulk pipe.
  */
 Static void
 ohci_device_bulk_close(usbd_pipe_handle pipe)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	DPRINTF(("ohci_device_bulk_close: pipe=%p\n", pipe));
 	mutex_enter(&sc->sc_lock);
 	ohci_close_pipe(pipe, sc->sc_bulk_head);
 	mutex_exit(&sc->sc_lock);
 	ohci_free_std(sc, opipe->tail.td);
+}
 /************************/
 Static usbd_status
 ohci_device_intr_transfer(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usbd_status err;
 	/* Insert last in queue. */
 	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	if (err)
 		return (err);
 	/* Pipe isn't running, start first */
 	return (ohci_device_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
+}
 Static usbd_status
 ohci_device_intr_start(usbd_xfer_handle xfer)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	usbd_device_handle dev = opipe->pipe.device;
 	ohci_softc_t *sc = dev->bus->hci_private;
 	ohci_soft_ed_t *sed = opipe->sed;
 	ohci_soft_td_t *data, *tail;
-	int s, len, isread, endpt;
+	int len, isread, endpt;
 	if (sc->sc_dying)
 		return (USBD_IOERROR);
 	DPRINTFN(3, ("ohci_device_intr_transfer: xfer=%p len=%d "
 		     "flags=%d priv=%p\n",
 		     xfer, xfer->length, xfer->flags, xfer->priv));
 #ifdef DIAGNOSTIC
 	if (xfer->rqflags & URQ_REQUEST)
 		panic("ohci_device_intr_transfer: a request");
 #endif
 @@ -3113,114 +3194,113 @@ ohci_device_intr_start(usbd_xfer_handle
 	usb_syncmem(&data->dma, data->offs, sizeof(data->td),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	xfer->hcpriv = data;
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 5) {
 		DPRINTF(("ohci_device_intr_transfer:\n"));
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, data);
+	}
 #endif
 	/* Insert ED in schedule */
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_tailp = HTOO32(tail->physaddr);
 	opipe->tail.td = tail;
 	sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP);
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 #if 0
 /*
  * This goes horribly wrong, printing thousands of descriptors,
  * because false references are followed due to the fact that the
  * TD is gone.
  */
 	if (ohcidebug > 5) {
 		usb_delay_ms(&sc->sc_bus, 5);
 		DPRINTF(("ohci_device_intr_transfer: status=%x\n",
 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, data);
+	}
 #endif
-	splx(s);
+	mutex_exit(&sc->sc_lock);
 	return (USBD_IN_PROGRESS);
+}
 /* Abort a device control request. */
 Static void
 ohci_device_intr_abort(usbd_xfer_handle xfer)
+{
 	if (xfer->pipe->intrxfer == xfer) {
 		DPRINTF(("ohci_device_intr_abort: remove\n"));
 		xfer->pipe->intrxfer = NULL;
+	}
 	ohci_abort_xfer(xfer, USBD_CANCELLED);
+}
 /* Close a device interrupt pipe. */
 Static void
 ohci_device_intr_close(usbd_pipe_handle pipe)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	int nslots = opipe->u.intr.nslots;
 	int pos = opipe->u.intr.pos;
 	int j;
 	ohci_soft_ed_t *p, *sed = opipe->sed;
 	int s;
 	DPRINTFN(1,("ohci_device_intr_close: pipe=%p nslots=%d pos=%d\n",
 		    pipe, nslots, pos));
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	usb_syncmem(&sed->dma, sed->offs,
 	    sizeof(sed->ed), BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	if ((O32TOH(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
 	    (O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK))
 		usb_delay_ms(&sc->sc_bus, 2);
 	for (p = sc->sc_eds[pos]; p && p->next != sed; p = p->next)
 		continue;
 #ifdef DIAGNOSTIC
 	if (p == NULL)
 		panic("ohci_device_intr_close: ED not found");
 #endif
 	p->next = sed->next;
 	p->ed.ed_nexted = sed->ed.ed_nexted;
 	usb_syncmem(&p->dma, p->offs + offsetof(ohci_ed_t, ed_nexted),
 	    sizeof(p->ed.ed_nexted),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
-	splx(s);
+	mutex_exit(&sc->sc_lock);
 	for (j = 0; j < nslots; j++)
 		--sc->sc_bws[(pos * nslots + j) % OHCI_NO_INTRS];
 	ohci_free_std(sc, opipe->tail.td);
 	ohci_free_sed(sc, opipe->sed);
+}
 Static usbd_status
 ohci_device_setintr(ohci_softc_t *sc, struct ohci_pipe *opipe, int ival)
+{
-	int i, j, s, best;
+	int i, j, best;
 	u_int npoll, slow, shigh, nslots;
 	u_int bestbw, bw;
 	ohci_soft_ed_t *hsed, *sed = opipe->sed;
 	DPRINTFN(2, ("ohci_setintr: pipe=%p\n", opipe));
 	if (ival == 0) {
 		printf("ohci_setintr: 0 interval\n");
 		return (USBD_INVAL);
+	}
 	npoll = OHCI_NO_INTRS;
 	while (npoll > ival)
 		npoll /= 2;
 @@ -3242,63 +3322,66 @@ ohci_device_setintr(ohci_softc_t *sc, st
 	nslots = OHCI_NO_INTRS / npoll;
 	for (best = i = slow, bestbw = ~0; i < shigh; i++) {
 		bw = 0;
 		for (j = 0; j < nslots; j++)
 			bw += sc->sc_bws[(i * nslots + j) % OHCI_NO_INTRS];
 		if (bw < bestbw) {
 			best = i;
 			bestbw = bw;
+		}
+	}
 	DPRINTFN(2, ("ohci_setintr: best=%d(%d..%d) bestbw=%d\n",
 		     best, slow, shigh, bestbw));
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	hsed = sc->sc_eds[best];
 	sed->next = hsed->next;
 	usb_syncmem(&hsed->dma, hsed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(hsed->ed.ed_flags),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_nexted = hsed->ed.ed_nexted;
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	hsed->next = sed;
 	hsed->ed.ed_nexted = HTOO32(sed->physaddr);
 	usb_syncmem(&hsed->dma, hsed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(hsed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
-	splx(s);
+	mutex_exit(&sc->sc_lock);
 	for (j = 0; j < nslots; j++)
 		++sc->sc_bws[(best * nslots + j) % OHCI_NO_INTRS];
 	opipe->u.intr.nslots = nslots;
 	opipe->u.intr.pos = best;
 	DPRINTFN(5, ("ohci_setintr: returns %p\n", opipe));
 	return (USBD_NORMAL_COMPLETION);
+}
 /***********************/
 usbd_status
 ohci_device_isoc_transfer(usbd_xfer_handle xfer)
+{
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 	usbd_status err;
 	DPRINTFN(5,("ohci_device_isoc_transfer: xfer=%p\n", xfer));
 	/* Put it on our queue, */
 	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	/* 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 start if the pipe wasn't running */
 	if (!err)
 		ohci_device_isoc_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
 @@ -3307,27 +3390,26 @@ ohci_device_isoc_transfer(usbd_xfer_hand
+}
 void
 ohci_device_isoc_enter(usbd_xfer_handle xfer)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	usbd_device_handle dev = opipe->pipe.device;
 	ohci_softc_t *sc = dev->bus->hci_private;
 	ohci_soft_ed_t *sed = opipe->sed;
 	struct iso *iso = &opipe->u.iso;
 	ohci_soft_itd_t *sitd, *nsitd;
 	ohci_physaddr_t buf, offs, noffs, bp0;
 	int i, ncur, nframes;
 	int s;
 	DPRINTFN(1,("ohci_device_isoc_enter: used=%d next=%d xfer=%p "
 		    "nframes=%d\n",
 		    iso->inuse, iso->next, xfer, xfer->nframes));
 	if (sc->sc_dying)
 		return;
 	if (iso->next == -1) {
 		/* Not in use yet, schedule it a few frames ahead. */
 		iso->next = O32TOH(sc->sc_hcca->hcca_frame_number) + 5;
 		DPRINTFN(2,("ohci_device_isoc_enter: start next=%d\n",
 			    iso->next));
 @@ -3404,153 +3486,154 @@ ohci_device_isoc_enter(usbd_xfer_handle
 	xfer->actlen = offs;	/* XXX pretend we did it all */
 	xfer->status = USBD_IN_PROGRESS;
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 5) {
 		DPRINTF(("ohci_device_isoc_enter: frame=%d\n",
 			 O32TOH(sc->sc_hcca->hcca_frame_number)));
 		ohci_dump_itds(sc, xfer->hcpriv);
 		ohci_dump_ed(sc, sed);
+	}
 #endif
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_tailp = HTOO32(nsitd->physaddr);
 	opipe->tail.itd = nsitd;
 	sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP);
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
-	splx(s);
+	mutex_exit(&sc->sc_lock);
 #ifdef OHCI_DEBUG
 	if (ohcidebug > 5) {
 		delay(150000);
 		DPRINTF(("ohci_device_isoc_enter: after frame=%d\n",
 			 O32TOH(sc->sc_hcca->hcca_frame_number)));
 		ohci_dump_itds(sc, xfer->hcpriv);
 		ohci_dump_ed(sc, sed);
+	}
 #endif
+}
 usbd_status
 ohci_device_isoc_start(usbd_xfer_handle xfer)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_softc_t *sc = opipe->pipe.device->bus->hci_private;
 	DPRINTFN(5,("ohci_device_isoc_start: xfer=%p\n", xfer));
-	if (sc->sc_dying)
+	mutex_enter(&sc->sc_lock);
 	if (sc->sc_dying) {
 		mutex_exit(&sc->sc_lock);
 		return (USBD_IOERROR);
+	}
 #ifdef DIAGNOSTIC
 	if (xfer->status != USBD_IN_PROGRESS)
 		printf("ohci_device_isoc_start: not in progress %p\n", xfer);
 #endif
 	/* XXX anything to do? */
 	return (USBD_IN_PROGRESS);
+}
 void
 ohci_device_isoc_abort(usbd_xfer_handle xfer)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
 	ohci_softc_t *sc = opipe->pipe.device->bus->hci_private;
 	ohci_soft_ed_t *sed;
 	ohci_soft_itd_t *sitd;
 	int s;
 	s = splusb();
 	DPRINTFN(1,("ohci_device_isoc_abort: xfer=%p\n", xfer));
 	KASSERT(mutex_owned(&sc->sc_lock));
 	/* Transfer is already done. */
 	if (xfer->status != USBD_NOT_STARTED &&
 	    xfer->status != USBD_IN_PROGRESS) {
 		splx(s);
 		printf("ohci_device_isoc_abort: early return\n");
-		return;
+		goto done;
+	}
 	/* Give xfer the requested abort code. */
 	xfer->status = USBD_CANCELLED;
 	sed = opipe->sed;
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP); /* force hardware skip */
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	sitd = xfer->hcpriv;
 #ifdef DIAGNOSTIC
 	if (sitd == NULL) {
 		splx(s);
 		printf("ohci_device_isoc_abort: hcpriv==0\n");
-		return;
+		goto done;
+	}
 #endif
 	for (; sitd->xfer == xfer; sitd = sitd->nextitd) {
 #ifdef DIAGNOSTIC
 		DPRINTFN(1,("abort sets done sitd=%p\n", sitd));
 		sitd->isdone = 1;
 #endif
+	}
-	splx(s);
+	mutex_exit(&sc->sc_lock);
 	usb_delay_ms(&sc->sc_bus, OHCI_ITD_NOFFSET);
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	/* Run callback. */
 	usb_transfer_complete(xfer);
 	sed->ed.ed_headp = HTOO32(sitd->physaddr); /* unlink TDs */
 	sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP); /* remove hardware skip */
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
-	splx(s);
+ done:
 	mutex_exit(&sc->sc_lock);
+}
 void
 ohci_device_isoc_done(usbd_xfer_handle xfer)
+{
 	DPRINTFN(1,("ohci_device_isoc_done: xfer=%p\n", xfer));
+}
 usbd_status
 ohci_setup_isoc(usbd_pipe_handle pipe)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	struct iso *iso = &opipe->u.iso;
 	int s;
 	iso->next = -1;
 	iso->inuse = 0;
-	s = splusb();
+	mutex_enter(&sc->sc_lock);
 	ohci_add_ed(sc, opipe->sed, sc->sc_isoc_head);
-	splx(s);
+	mutex_exit(&sc->sc_lock);
 	return (USBD_NORMAL_COMPLETION);
+}
 void
 ohci_device_isoc_close(usbd_pipe_handle pipe)
+{
 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
 	ohci_softc_t *sc = pipe->device->bus->hci_private;
 	DPRINTF(("ohci_device_isoc_close: pipe=%p\n", pipe));
 	ohci_close_pipe(pipe, sc->sc_isoc_head);
 #ifdef DIAGNOSTIC

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ohcivar.h,v 1.51 2011/05/28 15:47:17 tsutsui Exp $	*/
+/*	$NetBSD: ohcivar.h,v 1.51.8.1 2011/12/04 21:02:27 jmcneill Exp $	*/
 /*	$FreeBSD: src/sys/dev/usb/ohcivar.h,v 1.13 1999/11/17 22:33:41 n_hibma Exp $	*/
 /*
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (lennart@augustsson.net) at
  * Carlstedt Research & Technology.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -77,51 +77,54 @@ typedef struct ohci_soft_itd {
 #define OHCI_NO_EDS (2*OHCI_NO_INTRS-1)
 #define OHCI_HASH_SIZE 128
 typedef struct ohci_softc {
 	device_t sc_dev;
 	struct usbd_bus sc_bus;
 	bus_space_tag_t iot;
 	bus_space_handle_t ioh;
 	bus_size_t sc_size;
 	kmutex_t sc_lock;
 	kmutex_t sc_intr_lock;
 	void *sc_rhsc_si;
 	usb_dma_t sc_hccadma;
 	struct ohci_hcca *sc_hcca;
 	ohci_soft_ed_t *sc_eds[OHCI_NO_EDS];
 	u_int sc_bws[OHCI_NO_INTRS];
 	u_int32_t sc_eintrs;
 	ohci_soft_ed_t *sc_isoc_head;
 	ohci_soft_ed_t *sc_ctrl_head;
 	ohci_soft_ed_t *sc_bulk_head;
 	LIST_HEAD(, ohci_soft_td)  sc_hash_tds[OHCI_HASH_SIZE];
 	LIST_HEAD(, ohci_soft_itd) sc_hash_itds[OHCI_HASH_SIZE];
 	int sc_noport;
 	u_int8_t sc_addr;		/* device address */
 	u_int8_t sc_conf;		/* device configuration */
 	int sc_endian;
 #define	OHCI_LITTLE_ENDIAN	0	/* typical (uninitialized default) */
 #define	OHCI_BIG_ENDIAN		1	/* big endian OHCI? never seen it */
 #define	OHCI_HOST_ENDIAN	2	/* if OHCI always matches CPU */
 #ifdef USB_USE_SOFTINTR
 	char sc_softwake;
-#endif /* USB_USE_SOFTINTR */
+	kcondvar_t sc_softwake_cv;
 	ohci_soft_ed_t *sc_freeeds;
 	ohci_soft_td_t *sc_freetds;
 	ohci_soft_itd_t *sc_freeitds;
 	SIMPLEQ_HEAD(, usbd_xfer) sc_free_xfers; /* free xfers */
 	usbd_xfer_handle sc_intrxfer;
 	char sc_vendor[32];
 	int sc_id_vendor;
 	u_int32_t sc_control;		/* Preserved during suspend/standby */