 @@ -1,1043 +1,1043 @@
-/*	$NetBSD: ohci.c,v 1.254.2.59 2016/03/17 09:04:53 skrll Exp $	*/
+/*	$NetBSD: ohci.c,v 1.254.2.60 2016/03/24 15:30:17 skrll Exp $	*/
 /*
  * Copyright (c) 1998, 2004, 2005, 2012 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, Jared D. McNeill (jmcneill@invisible.ca)
  * and Matthew R. Green (mrg@eterna.com.au).
  * 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
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * 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.254.2.59 2016/03/17 09:04:53 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.254.2.60 2016/03/24 15:30:17 skrll Exp $");
 #include "opt_usb.h"
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/select.h>
 #include <sys/sysctl.h>
 #include <sys/systm.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>
 #include <dev/usb/usb_quirks.h>
 #include <dev/usb/ohcireg.h>
 #include <dev/usb/ohcivar.h>
 #include <dev/usb/usbroothub.h>
 #include <dev/usb/usbhist.h>
 #ifdef USB_DEBUG
 #ifndef OHCI_DEBUG
 #define ohcidebug 0
 #else
 static int ohcidebug = 10;
 SYSCTL_SETUP(sysctl_hw_ohci_setup, "sysctl hw.ohci setup")
+{
 	int err;
 	const struct sysctlnode *rnode;
 	const struct sysctlnode *cnode;
 	err = sysctl_createv(clog, 0, NULL, &rnode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "ohci",
 	    SYSCTL_DESCR("ohci global controls"),
 	    NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL);
 	if (err)
 		goto fail;
 	/* control debugging printfs */
 	err = sysctl_createv(clog, 0, &rnode, &cnode,
 	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
 	    "debug", SYSCTL_DESCR("Enable debugging output"),
 	    NULL, 0, &ohcidebug, sizeof(ohcidebug), CTL_CREATE, CTL_EOL);
 	if (err)
 		goto fail;
 	return;
 fail:
 	aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
+}
 #endif /* OHCI_DEBUG */
 #endif /* USB_DEBUG */
 #define	DPRINTF(FMT,A,B,C,D)	USBHIST_LOG(ohcidebug,FMT,A,B,C,D)
 #define	DPRINTFN(N,FMT,A,B,C,D)	USBHIST_LOGN(ohcidebug,N,FMT,A,B,C,D)
 #define	OHCIHIST_FUNC()		USBHIST_FUNC()
 #define	OHCIHIST_CALLED(name)	USBHIST_CALLED(ohcidebug)
 #if BYTE_ORDER == BIG_ENDIAN
 #define	SWAP_ENDIAN	OHCI_LITTLE_ENDIAN
 #else
 #define	SWAP_ENDIAN	OHCI_BIG_ENDIAN
 #endif
 #define	O16TOH(val)	(sc->sc_endian == SWAP_ENDIAN ? bswap16(val) : val)
 #define	O32TOH(val)	(sc->sc_endian == SWAP_ENDIAN ? bswap32(val) : val)
 #define	HTOO16(val)	O16TOH(val)
 #define	HTOO32(val)	O32TOH(val)
 struct ohci_pipe;
 Static ohci_soft_ed_t  *ohci_alloc_sed(ohci_softc_t *);
 Static void		ohci_free_sed(ohci_softc_t *, ohci_soft_ed_t *);
 Static ohci_soft_td_t  *ohci_alloc_std(ohci_softc_t *);
 Static void		ohci_free_std(ohci_softc_t *, ohci_soft_td_t *);
 Static void		ohci_free_std_locked(ohci_softc_t *, ohci_soft_td_t *);
 Static ohci_soft_itd_t *ohci_alloc_sitd(ohci_softc_t *);
 Static void		ohci_free_sitd(ohci_softc_t *,ohci_soft_itd_t *);
 Static void		ohci_free_sitd_locked(ohci_softc_t *,
 			    ohci_soft_itd_t *);
 Static usbd_status	ohci_alloc_std_chain(ohci_softc_t *, struct usbd_xfer *,
 			    int, int);
 Static void		ohci_free_stds(ohci_softc_t *, struct ohci_xfer *);
 Static void		ohci_reset_std_chain(ohci_softc_t *, struct usbd_xfer *,
 			    int, int, ohci_soft_td_t *, ohci_soft_td_t **);
 Static usbd_status	ohci_open(struct usbd_pipe *);
 Static void		ohci_poll(struct usbd_bus *);
 Static void		ohci_softintr(void *);
 Static void		ohci_waitintr(ohci_softc_t *, struct usbd_xfer *);
 Static void		ohci_rhsc(ohci_softc_t *, struct usbd_xfer *);
 Static void		ohci_rhsc_softint(void *);
 Static void		ohci_add_ed(ohci_softc_t *, ohci_soft_ed_t *,
 			    ohci_soft_ed_t *);
 Static void		ohci_rem_ed(ohci_softc_t *, 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(struct usbd_pipe *);
 Static void		ohci_device_isoc_enter(struct usbd_xfer *);
 Static struct usbd_xfer *
 			ohci_allocx(struct usbd_bus *, unsigned int);
 Static void		ohci_freex(struct usbd_bus *, struct usbd_xfer *);
 Static void		ohci_get_lock(struct usbd_bus *, kmutex_t **);
 Static int		ohci_roothub_ctrl(struct usbd_bus *,
 			    usb_device_request_t *, void *, int);
 Static usbd_status	ohci_root_intr_transfer(struct usbd_xfer *);
 Static usbd_status	ohci_root_intr_start(struct usbd_xfer *);
 Static void		ohci_root_intr_abort(struct usbd_xfer *);
 Static void		ohci_root_intr_close(struct usbd_pipe *);
 Static void		ohci_root_intr_done(struct usbd_xfer *);
 Static int		ohci_device_ctrl_init(struct usbd_xfer *);
 Static void		ohci_device_ctrl_fini(struct usbd_xfer *);
 Static usbd_status	ohci_device_ctrl_transfer(struct usbd_xfer *);
 Static usbd_status	ohci_device_ctrl_start(struct usbd_xfer *);
 Static void		ohci_device_ctrl_abort(struct usbd_xfer *);
 Static void		ohci_device_ctrl_close(struct usbd_pipe *);
 Static void		ohci_device_ctrl_done(struct usbd_xfer *);
 Static int		ohci_device_bulk_init(struct usbd_xfer *);
 Static void		ohci_device_bulk_fini(struct usbd_xfer *);
 Static usbd_status	ohci_device_bulk_transfer(struct usbd_xfer *);
 Static usbd_status	ohci_device_bulk_start(struct usbd_xfer *);
 Static void		ohci_device_bulk_abort(struct usbd_xfer *);
 Static void		ohci_device_bulk_close(struct usbd_pipe *);
 Static void		ohci_device_bulk_done(struct usbd_xfer *);
 Static int		ohci_device_intr_init(struct usbd_xfer *);
 Static void		ohci_device_intr_fini(struct usbd_xfer *);
 Static usbd_status	ohci_device_intr_transfer(struct usbd_xfer *);
 Static usbd_status	ohci_device_intr_start(struct usbd_xfer *);
 Static void		ohci_device_intr_abort(struct usbd_xfer *);
 Static void		ohci_device_intr_close(struct usbd_pipe *);
 Static void		ohci_device_intr_done(struct usbd_xfer *);
 Static int		ohci_device_isoc_init(struct usbd_xfer *);
 Static void		ohci_device_isoc_fini(struct usbd_xfer *);
 Static usbd_status	ohci_device_isoc_transfer(struct usbd_xfer *);
 Static void		ohci_device_isoc_abort(struct usbd_xfer *);
 Static void		ohci_device_isoc_close(struct usbd_pipe *);
 Static void		ohci_device_isoc_done(struct usbd_xfer *);
 Static usbd_status	ohci_device_setintr(ohci_softc_t *,
 			    struct ohci_pipe *, int);
 Static void		ohci_timeout(void *);
 Static void		ohci_timeout_task(void *);
 Static void		ohci_rhsc_enable(void *);
 Static void		ohci_close_pipe(struct usbd_pipe *, ohci_soft_ed_t *);
 Static void		ohci_abort_xfer(struct usbd_xfer *, usbd_status);
 Static void		ohci_device_clear_toggle(struct usbd_pipe *);
 Static void		ohci_noop(struct usbd_pipe *);
 #ifdef OHCI_DEBUG
 Static void		ohci_dumpregs(ohci_softc_t *);
 Static void		ohci_dump_tds(ohci_softc_t *, ohci_soft_td_t *);
 Static void		ohci_dump_td(ohci_softc_t *, ohci_soft_td_t *);
 Static void		ohci_dump_ed(ohci_softc_t *, ohci_soft_ed_t *);
 Static void		ohci_dump_itd(ohci_softc_t *, ohci_soft_itd_t *);
 Static void		ohci_dump_itds(ohci_softc_t *, ohci_soft_itd_t *);
 #endif
 #define OBARR(sc) bus_space_barrier((sc)->iot, (sc)->ioh, 0, (sc)->sc_size, \
 			BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE)
 #define OWRITE1(sc, r, x) \
  do { OBARR(sc); bus_space_write_1((sc)->iot, (sc)->ioh, (r), (x)); } while (0)
 #define OWRITE2(sc, r, x) \
  do { OBARR(sc); bus_space_write_2((sc)->iot, (sc)->ioh, (r), (x)); } while (0)
 #define OWRITE4(sc, r, x) \
  do { OBARR(sc); bus_space_write_4((sc)->iot, (sc)->ioh, (r), (x)); } while (0)
 static __inline uint32_t
 OREAD4(ohci_softc_t *sc, bus_size_t r)
+{
 	OBARR(sc);
 	return bus_space_read_4(sc->iot, sc->ioh, r);
+}
 /* Reverse the bits in a value 0 .. 31 */
 Static uint8_t revbits[OHCI_NO_INTRS] =
   { 0x00, 0x10, 0x08, 0x18, 0x04, 0x14, 0x0c, 0x1c,
 x02, 0x12, 0x0a, 0x1a, 0x06, 0x16, 0x0e, 0x1e,
 x01, 0x11, 0x09, 0x19, 0x05, 0x15, 0x0d, 0x1d,
 x03, 0x13, 0x0b, 0x1b, 0x07, 0x17, 0x0f, 0x1f };
 struct ohci_pipe {
 	struct usbd_pipe pipe;
 	ohci_soft_ed_t *sed;
 	union {
 		ohci_soft_td_t *td;
 		ohci_soft_itd_t *itd;
 	} tail;
 	/* Info needed for different pipe kinds. */
 	union {
 		/* Control pipe */
 		struct {
 			usb_dma_t reqdma;
 		} ctrl;
 		/* Interrupt pipe */
 		struct {
 			int nslots;
 			int pos;
 		} intr;
 		/* Isochronous pipe */
 		struct isoc {
 			int next, inuse;
 		} isoc;
 	};
 };
 Static const struct usbd_bus_methods ohci_bus_methods = {
 	.ubm_open =	ohci_open,
 	.ubm_softint =	ohci_softintr,
 	.ubm_dopoll =	ohci_poll,
 	.ubm_allocx =	ohci_allocx,
 	.ubm_freex =	ohci_freex,
 	.ubm_getlock =	ohci_get_lock,
 	.ubm_rhctrl =	ohci_roothub_ctrl,
 };
 Static const struct usbd_pipe_methods ohci_root_intr_methods = {
 	.upm_transfer =	ohci_root_intr_transfer,
 	.upm_start =	ohci_root_intr_start,
 	.upm_abort =	ohci_root_intr_abort,
 	.upm_close =	ohci_root_intr_close,
 	.upm_cleartoggle =	ohci_noop,
 	.upm_done =	ohci_root_intr_done,
 };
 Static const struct usbd_pipe_methods ohci_device_ctrl_methods = {
 	.upm_init =	ohci_device_ctrl_init,
 	.upm_fini =	ohci_device_ctrl_fini,
 	.upm_transfer =	ohci_device_ctrl_transfer,
 	.upm_start =	ohci_device_ctrl_start,
 	.upm_abort =	ohci_device_ctrl_abort,
 	.upm_close =	ohci_device_ctrl_close,
 	.upm_cleartoggle =	ohci_noop,
 	.upm_done =	ohci_device_ctrl_done,
 };
 Static const struct usbd_pipe_methods ohci_device_intr_methods = {
 	.upm_init =	ohci_device_intr_init,
 	.upm_fini =	ohci_device_intr_fini,
 	.upm_transfer =	ohci_device_intr_transfer,
 	.upm_start =	ohci_device_intr_start,
 	.upm_abort =	ohci_device_intr_abort,
 	.upm_close =	ohci_device_intr_close,
 	.upm_cleartoggle =	ohci_device_clear_toggle,
 	.upm_done =	ohci_device_intr_done,
 };
 Static const struct usbd_pipe_methods ohci_device_bulk_methods = {
 	.upm_init =	ohci_device_bulk_init,
 	.upm_fini =	ohci_device_bulk_fini,
 	.upm_transfer =	ohci_device_bulk_transfer,
 	.upm_start =	ohci_device_bulk_start,
 	.upm_abort =	ohci_device_bulk_abort,
 	.upm_close =	ohci_device_bulk_close,
 	.upm_cleartoggle =	ohci_device_clear_toggle,
 	.upm_done =	ohci_device_bulk_done,
 };
 Static const struct usbd_pipe_methods ohci_device_isoc_methods = {
 	.upm_init =	ohci_device_isoc_init,
 	.upm_fini =	ohci_device_isoc_fini,
 	.upm_transfer =	ohci_device_isoc_transfer,
 	.upm_abort =	ohci_device_isoc_abort,
 	.upm_close =	ohci_device_isoc_close,
 	.upm_cleartoggle =	ohci_noop,
 	.upm_done =	ohci_device_isoc_done,
 };
 int
 ohci_activate(device_t self, enum devact act)
+{
 	struct ohci_softc *sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		sc->sc_dying = 1;
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 void
 ohci_childdet(device_t self, device_t child)
+{
 	struct ohci_softc *sc = device_private(self);
 	KASSERT(sc->sc_child == child);
 	sc->sc_child = NULL;
+}
 int
 ohci_detach(struct ohci_softc *sc, int flags)
+{
 	int rv = 0;
 	if (sc->sc_child != NULL)
 		rv = config_detach(sc->sc_child, flags);
 	if (rv != 0)
 		return rv;
 	callout_halt(&sc->sc_tmo_rhsc, &sc->sc_lock);
 	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);
 	pool_cache_destroy(sc->sc_xferpool);
 	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;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freeeds == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
 		err = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK,
 			  OHCI_ED_ALIGN, &dma);
 		if (err)
 			return 0;
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < OHCI_SED_CHUNK; i++) {
 			offs = i * OHCI_SED_SIZE;
 			sed = KERNADDR(&dma, offs);
 			sed->physaddr = DMAADDR(&dma, offs);
 			sed->dma = dma;
 			sed->offs = offs;
 			sed->next = sc->sc_freeeds;
 			sc->sc_freeeds = sed;
+		}
+	}
 	sed = sc->sc_freeeds;
 	sc->sc_freeeds = sed->next;
 	mutex_exit(&sc->sc_lock);
 	memset(&sed->ed, 0, sizeof(ohci_ed_t));
 	sed->next = 0;
 	return sed;
+}
 static inline void
 ohci_free_sed_locked(ohci_softc_t *sc, ohci_soft_ed_t *sed)
+{
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	sed->next = sc->sc_freeeds;
 	sc->sc_freeeds = sed;
+}
 void
 ohci_free_sed(ohci_softc_t *sc, ohci_soft_ed_t *sed)
+{
 	mutex_enter(&sc->sc_lock);
 	ohci_free_sed_locked(sc, sed);
 	mutex_exit(&sc->sc_lock);
+}
 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;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freetds == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
 		err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
 			  OHCI_TD_ALIGN, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
 		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;
+		}
+	}
 	std = sc->sc_freetds;
 	sc->sc_freetds = std->nexttd;
 	mutex_exit(&sc->sc_lock);
 	memset(&std->td, 0, sizeof(ohci_td_t));
 	std->nexttd = NULL;
 	std->xfer = NULL;
 	return std;
+}
 void
 ohci_free_std_locked(ohci_softc_t *sc, ohci_soft_td_t *std)
+{
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	std->nexttd = sc->sc_freetds;
 	sc->sc_freetds = std;
+}
 void
 ohci_free_std(ohci_softc_t *sc, ohci_soft_td_t *std)
+{
 	mutex_enter(&sc->sc_lock);
 	ohci_free_std_locked(sc, std);
 	mutex_exit(&sc->sc_lock);
+}
 Static usbd_status
 ohci_alloc_std_chain(ohci_softc_t *sc, struct usbd_xfer *xfer, int alen, int rd)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	ohci_soft_td_t *next, *cur;
 	ohci_physaddr_t dataphys, dataphysend;
 	uint32_t tdflags;
 	int len = alen;
 	int curlen;
 	usb_dma_t *dma = &xfer->ux_dmabuf;
 	uint16_t flags = xfer->ux_flags;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(8, "addr=%d endpt=%d len=%d speed=%d",
 	    pipe->up_dev->ud_addr,
 	    UE_GET_ADDR(pipe->up_endpoint->ue_edesc->bEndpointAddress),
 	    alen, pipe->up_dev->ud_speed);
 	ASSERT_SLEEPABLE();
 	size_t nstd = (flags & USBD_FORCE_SHORT_XFER) ? 1 : 0;
 	nstd += ((len + OHCI_PAGE_SIZE - 1) / OHCI_PAGE_SIZE);
 	ox->ox_stds = kmem_zalloc(sizeof(ohci_soft_td_t *) * nstd,
 	    KM_SLEEP);
 	ox->ox_nstd = nstd;
 	int mps = UGETW(pipe->up_endpoint->ue_edesc->wMaxPacketSize);
 	DPRINTFN(8, "xfer %p nstd %d mps %d", xfer, nstd, mps, 0);
 	len = alen;
 	cur = ohci_alloc_std(sc);
 	if (cur == NULL)
 		goto nomem;
 	dataphys = DMAADDR(dma, 0);
 	dataphysend = OHCI_PAGE(dataphys + len - 1);
 	tdflags = HTOO32(
 	    (rd ? OHCI_TD_IN : OHCI_TD_OUT) |
 	    OHCI_TD_NOCC | OHCI_TD_TOGGLE_CARRY | OHCI_TD_NOINTR);
 	for (size_t j = 0;;) {
 		ox->ox_stds[j++] = cur;
 		next = ohci_alloc_std(sc);
 		if (next == NULL)
 			goto nomem;
 		/* The OHCI hardware can handle at most one page crossing. */
 		if (OHCI_PAGE(dataphys) == dataphysend ||
 		    OHCI_PAGE(dataphys) + OHCI_PAGE_SIZE == dataphysend) {
 			/* we can handle it in this TD */
 			curlen = len;
 		} else {
 			/* 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 % mps;
 			KASSERT(curlen != 0);
+		}
 		DPRINTFN(4, "dataphys=0x%08x dataphysend=0x%08x "
 		    "len=%d curlen=%d",  dataphys, dataphysend, len, curlen);
 		len -= curlen;
 		cur->td.td_flags = tdflags;
 		cur->td.td_cbp = HTOO32(dataphys);
 		cur->td.td_nexttd = HTOO32(next->physaddr);
 		cur->td.td_be = HTOO32(dataphys + curlen - 1);
 		cur->nexttd = next;
 		cur->len = curlen;
 		cur->flags = OHCI_ADD_LEN;
 		cur->xfer = xfer;
 		DPRINTFN(10, "cbp=0x%08x be=0x%08x", dataphys,
 		    dataphys + curlen - 1, 0, 0);
 		if (len == 0)
 			break;
 		DPRINTFN(10, "extend chain", 0, 0, 0, 0);
 		dataphys += curlen;
 		cur = next;
+	}
 	if (!rd && (flags & USBD_FORCE_SHORT_XFER) &&
 	    alen % mps == 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->td.td_nexttd = HTOO32(next->physaddr);
 		cur->td.td_be = ~0;
 		cur->nexttd = next;
 		cur->len = 0;
 		cur->flags = 0;
 		cur->xfer = xfer;
 		DPRINTFN(2, "add 0 xfer", 0, 0, 0, 0);
+	}
 	return USBD_NORMAL_COMPLETION;
  nomem:
 	ohci_free_stds(sc, ox);
 	return USBD_NOMEM;
+}
 Static void
 ohci_free_stds(ohci_softc_t *sc, struct ohci_xfer *ox)
+{
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTF("ox=%p", ox, 0, 0, 0);
 	mutex_enter(&sc->sc_lock);
 	for (size_t i = 0; i < ox->ox_nstd; i++) {
 		ohci_soft_td_t *std = ox->ox_stds[i];
 		if (std == NULL)
 			break;
 		ohci_free_std_locked(sc, std);
+	}
 	mutex_exit(&sc->sc_lock);
+}
 void
 ohci_reset_std_chain(ohci_softc_t *sc, struct usbd_xfer *xfer,
     int alen, int rd, ohci_soft_td_t *sp, ohci_soft_td_t **ep)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	ohci_soft_td_t *next, *cur;
 	ohci_physaddr_t dataphys, dataphysend;
 	uint32_t tdflags;
 	int len, curlen;
 	usb_dma_t *dma = &xfer->ux_dmabuf;
 	uint16_t flags = xfer->ux_flags;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTF("start len=%d", alen, 0, 0, 0);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTFN(8, "addr=%d endpt=%d len=%d speed=%d",
 	    xfer->ux_pipe->up_dev->ud_addr,
 	    UE_GET_ADDR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress),
 	    alen, xfer->ux_pipe->up_dev->ud_speed);
 	KASSERT(sp);
 	int mps = UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize);
 	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) |
 	    OHCI_TD_NOCC | OHCI_TD_TOGGLE_CARRY | OHCI_TD_NOINTR);
 	for (size_t j = 1;;) {
 		if (j == ox->ox_nstd)
 			next = NULL;
 		else
 			next = ox->ox_stds[j++];
 		KASSERT(next != cur);
 		/* The OHCI hardware can handle at most one page crossing. */
 		if (OHCI_PAGE(dataphys) == dataphysend ||
 		    OHCI_PAGE(dataphys) + OHCI_PAGE_SIZE == dataphysend) {
 			/* we can handle it in this TD */
 			curlen = len;
 		} else {
 			/* 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 % mps;
 			KASSERT(curlen != 0);
+		}
 		DPRINTFN(4, "dataphys=0x%08x dataphysend=0x%08x "
 		    "len=%d curlen=%d",  dataphys, dataphysend, len, curlen);
 		len -= curlen;
 		cur->td.td_flags = tdflags;
 		cur->td.td_cbp = HTOO32(dataphys);
 		cur->td.td_be = HTOO32(dataphys + curlen - 1);
 		cur->td.td_nexttd = (next != NULL) ? HTOO32(next->physaddr) : 0;
 		cur->nexttd = next;
 		cur->len = curlen;
 		cur->flags = OHCI_ADD_LEN;
 		cur->xfer = xfer;
 	 	ohci_hash_add_td(sc, cur);
 		usb_syncmem(&cur->dma, cur->offs, sizeof(cur->td),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		DPRINTFN(10, "cbp=0x%08x be=0x%08x", dataphys,
 		    dataphys + curlen - 1, 0, 0);
 		if (len == 0)
 			break;
 		KASSERT(next != NULL);
 		DPRINTFN(10, "extend chain", 0, 0, 0, 0);
 		dataphys += curlen;
 		cur = next;
+	}
 	cur->td.td_flags |=
 	    (xfer->ux_flags & USBD_SHORT_XFER_OK ? OHCI_TD_R : 0);
 	if (!rd &&
 	    (flags & USBD_FORCE_SHORT_XFER) &&
 	    alen % mps == 0) {
 		/* Force a 0 length transfer at the end. */
 		KASSERT(next != NULL);
 		cur = next;
 		cur->td.td_flags = tdflags;
 		cur->td.td_cbp = 0; /* indicate 0 length packet */
 		cur->td.td_nexttd = HTOO32(next->physaddr);
 		cur->td.td_be = ~0;
 		cur->nexttd = NULL;
 		cur->len = 0;
 		cur->flags = 0;
 		cur->xfer = xfer;
 	 	ohci_hash_add_td(sc, cur);
 		usb_syncmem(&cur->dma, cur->offs, sizeof(cur->td),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		DPRINTFN(2, "add 0 xfer", 0, 0, 0, 0);
+	}
 	*ep = cur;
+}
 ohci_soft_itd_t *
 ohci_alloc_sitd(ohci_softc_t *sc)
+{
 	ohci_soft_itd_t *sitd;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freeitds == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
 		err = usb_allocmem(&sc->sc_bus, OHCI_SITD_SIZE * OHCI_SITD_CHUNK,
 			  OHCI_ITD_ALIGN, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
 		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;
+		}
+	}
 	sitd = sc->sc_freeitds;
 	sc->sc_freeitds = sitd->nextitd;
 	mutex_exit(&sc->sc_lock);
 	memset(&sitd->itd, 0, sizeof(ohci_itd_t));
 	sitd->nextitd = NULL;
 	sitd->xfer = NULL;
 #ifdef DIAGNOSTIC
 	sitd->isdone = true;
 #endif
 	return sitd;
+}
 Static void
 ohci_free_sitd_locked(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
+{
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(10, "sitd=%p", sitd, 0, 0, 0);
 	KASSERT(sitd->isdone);
 #ifdef DIAGNOSTIC
 	/* Warn double free */
 	sitd->isdone = false;
 #endif
 	sitd->nextitd = sc->sc_freeitds;
 	sc->sc_freeitds = sitd;
+}
 void
 ohci_free_sitd(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
+{
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	ohci_free_sitd_locked(sc, sitd);
 	mutex_exit(&sc->sc_lock);
+}
 int
 ohci_init(ohci_softc_t *sc)
+{
 	ohci_soft_ed_t *sed, *psed;
 	usbd_status err;
 	int i;
 	uint32_t s, ctl, rwc, ival, hcr, fm, per, rev, desca /*, descb */;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	aprint_normal_dev(sc->sc_dev, "");
 	sc->sc_hcca = NULL;
 	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]);
 	sc->sc_xferpool = pool_cache_init(sizeof(struct ohci_xfer), 0, 0, 0,
 	    "ohcixfer", NULL, IPL_USB, NULL, NULL, NULL);
 	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" : "");
 	if (OHCI_REV_HI(rev) != 1 || OHCI_REV_LO(rev) != 0) {
 		aprint_error_dev(sc->sc_dev, "unsupported OHCI revision\n");
 		sc->sc_bus.ub_revision = USBREV_UNKNOWN;
 		return -1;
+	}
 	sc->sc_bus.ub_revision = USBREV_1_0;
 	sc->sc_bus.ub_usedma = true;
 	/* XXX determine alignment by R/W */
 	/* Allocate the HCCA area. */
 	err = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE,
 			 OHCI_HCCA_ALIGN, &sc->sc_hccadma);
 	if (err) {
 		sc->sc_hcca = NULL;
 		return err;
+	}
 	sc->sc_hcca = KERNADDR(&sc->sc_hccadma, 0);
 	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 == NULL) {
 		err = ENOMEM;
 		goto bad1;
+	}
 	sc->sc_ctrl_head->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
 	/* Allocate dummy ED that starts the bulk list. */
 	sc->sc_bulk_head = ohci_alloc_sed(sc);
 	if (sc->sc_bulk_head == NULL) {
 		err = ENOMEM;
 		goto bad2;
+	}
 	sc->sc_bulk_head->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
 	usb_syncmem(&sc->sc_bulk_head->dma, sc->sc_bulk_head->offs,
 	    sizeof(sc->sc_bulk_head->ed),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	/* Allocate dummy ED that starts the isochronous list. */
 	sc->sc_isoc_head = ohci_alloc_sed(sc);
 	if (sc->sc_isoc_head == NULL) {
 		err = ENOMEM;
 		goto bad3;
+	}
 	sc->sc_isoc_head->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
 	usb_syncmem(&sc->sc_isoc_head->dma, sc->sc_isoc_head->offs,
 	    sizeof(sc->sc_isoc_head->ed),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	/* 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 == NULL) {
 			while (--i >= 0)
 				ohci_free_sed(sc, sc->sc_eds[i]);
 			err = ENOMEM;
 			goto bad4;
+		}
 		/* All ED fields are set to 0. */
 		sc->sc_eds[i] = sed;
 		sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
 		if (i != 0)
 			psed = sc->sc_eds[(i-1) / 2];
 		else
 			psed= sc->sc_isoc_head;
 		sed->next = psed;
 		sed->ed.ed_nexted = HTOO32(psed->physaddr);
 		usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
+	}
 	/*
 	 * Fill HCCA interrupt table.  The bit reversal is to get
 	 * the tree set up properly to spread the interrupts.
 	 */
 	for (i = 0; i < OHCI_NO_INTRS; i++)
 		sc->sc_hcca->hcca_interrupt_table[revbits[i]] =
 		    HTOO32(sc->sc_eds[OHCI_NO_EDS-OHCI_NO_INTRS+i]->physaddr);
 	usb_syncmem(&sc->sc_hccadma, 0, OHCI_HCCA_SIZE,
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 #ifdef OHCI_DEBUG
 	DPRINTFN(15, "--- dump start ---", 0, 0, 0 ,0);
 	if (ohcidebug >= 15) {
 		for (i = 0; i < OHCI_NO_EDS; i++) {
 			DPRINTFN(15, "ed#%d ", i, 0, 0, 0);
 			ohci_dump_ed(sc, sc->sc_eds[i]);
+		}
 		DPRINTFN(15, "iso", 0, 0, 0 ,0);
 		ohci_dump_ed(sc, sc->sc_isoc_head);
+	}
 	DPRINTFN(15, "--- dump end ---", 0, 0, 0 ,0);
 #endif
 	/* Preserve values programmed by SMM/BIOS but lost over reset. */
 	ctl = OREAD4(sc, OHCI_CONTROL);
 	rwc = ctl & OHCI_RWC;
 	fm = OREAD4(sc, OHCI_FM_INTERVAL);
 	desca = OREAD4(sc, OHCI_RH_DESCRIPTOR_A);
 	/* descb = OREAD4(sc, OHCI_RH_DESCRIPTOR_B); */
 	/* Determine in what context we are running. */
 	if (ctl & OHCI_IR) {
 		/* SMM active, request change */
 		DPRINTF("SMM active, request owner change", 0, 0, 0, 0);
 		if ((sc->sc_intre & (OHCI_OC | OHCI_MIE)) ==
 		    (OHCI_OC | OHCI_MIE))
 			OWRITE4(sc, OHCI_INTERRUPT_ENABLE, OHCI_MIE);
 		s = OREAD4(sc, OHCI_COMMAND_STATUS);
 		OWRITE4(sc, OHCI_COMMAND_STATUS, s | OHCI_OCR);
 		for (i = 0; i < 100 && (ctl & OHCI_IR); i++) {
 			usb_delay_ms(&sc->sc_bus, 1);
 			ctl = OREAD4(sc, OHCI_CONTROL);
+		}
 		OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_MIE);
 		if ((ctl & OHCI_IR) == 0) {
 			aprint_error_dev(sc->sc_dev,
 			    "SMM does not respond, resetting\n");
 			OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET | rwc);
 			goto reset;
+		}
 #if 0
 /* Don't bother trying to reuse the BIOS init, we'll reset it anyway. */
 	} else if ((ctl & OHCI_HCFS_MASK) != OHCI_HCFS_RESET) {
 		/* BIOS started controller. */
 		DPRINTF("BIOS active", 0, 0, 0, 0);
 		if ((ctl & OHCI_HCFS_MASK) != OHCI_HCFS_OPERATIONAL) {
 			OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_OPERATIONAL | rwc);
 			usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY);
+		}
 #endif
 	} else {
 		DPRINTF("cold started", 0 ,0 ,0 ,0);
 	reset:
 		/* Controller was cold started. */
 		usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY);
+	}
 	/*
 	 * This reset should not be necessary according to the OHCI spec, but
 	 * without it some controllers do not start.
 	 */
 	DPRINTF("sc %p: resetting", sc, 0, 0, 0);
 	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET | rwc);
 	usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY);
 	/* We now own the host controller and the bus has been reset. */
 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_HCR); /* Reset HC */
 	/* Nominal time for a reset is 10 us. */
 	for (i = 0; i < 10; i++) {
 		delay(10);
 		hcr = OREAD4(sc, OHCI_COMMAND_STATUS) & OHCI_HCR;
 		if (!hcr)
 			break;
+	}
 	if (hcr) {
 		aprint_error_dev(sc->sc_dev, "reset timeout\n");
 		err = EIO;
 		goto bad5;
+	}
 #ifdef OHCI_DEBUG
 	if (ohcidebug >= 15)
 		ohci_dumpregs(sc);
 #endif
 	/* The controller is now in SUSPEND state, we have 2ms to finish. */
 	/* Set up HC registers. */
 	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);
 	/* disable all interrupts and then switch on all desired interrupts */
 	OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS);
 	/* 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 |
 @@ -2732,1061 +2732,1061 @@ ohci_device_ctrl_init(struct usbd_xfer *
 			goto bad3;
+		}
+	}
 	return 0;
  bad3:
 	ohci_free_std(sc, stat);
  bad2:
 	ohci_free_std(sc, setup);
  bad1:
 	return err;
+}
 void
 ohci_device_ctrl_fini(struct usbd_xfer *xfer)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(8, "xfer %p nstd %d", xfer, ox->ox_nstd, 0, 0);
 	mutex_enter(&sc->sc_lock);
 	if (ox->ox_setup != opipe->tail.td) {
 		ohci_free_std_locked(sc, ox->ox_setup);
+	}
 	for (size_t i = 0; i < ox->ox_nstd; i++) {
 		ohci_soft_td_t *std = ox->ox_stds[i];
 		if (std == NULL)
 			break;
 		ohci_free_std_locked(sc, std);
+	}
 	ohci_free_std_locked(sc, ox->ox_stat);
 	mutex_exit(&sc->sc_lock);
 	if (ox->ox_nstd) {
 		const size_t sz = sizeof(ohci_soft_td_t *) * ox->ox_nstd;
 		kmem_free(ox->ox_stds, sz);
+	}
+}
 Static usbd_status
 ohci_device_ctrl_transfer(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	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->ux_pipe->up_queue));
+}
 Static usbd_status
 ohci_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	usb_device_request_t *req = &xfer->ux_request;
 	struct usbd_device *dev __diagused = opipe->pipe.up_dev;
 	ohci_soft_td_t *setup, *stat, *next, *tail;
 	ohci_soft_ed_t *sed;
 	int isread;
 	int len;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(xfer->ux_rqflags & URQ_REQUEST);
 	isread = req->bmRequestType & UT_READ;
 	len = UGETW(req->wLength);
 	DPRINTF("xfer=%p len=%d, addr=%d, endpt=%d", xfer, len, dev->ud_addr,
 	    opipe->pipe.up_endpoint->ue_edesc->bEndpointAddress);
 	DPRINTF("type=0x%02x, request=0x%02x, wValue=0x%04x, wIndex=0x%04x",
 	    req->bmRequestType, req->bRequest, UGETW(req->wValue),
 	    UGETW(req->wIndex));
 	/* Need to take lock here for pipe->tail.td */
 	mutex_enter(&sc->sc_lock);
 	/*
 	 * Use the pipe "tail" TD as our first and loan our first TD to the
 	 * next transfer
 	 */
 	setup = opipe->tail.td;
 	opipe->tail.td = ox->ox_setup;
 	ox->ox_setup = setup;
 	stat = ox->ox_stat;
 	/* point at sentinel */
 	tail = opipe->tail.td;
 	sed = opipe->sed;
 	KASSERTMSG(OHCI_ED_GET_FA(O32TOH(sed->ed.ed_flags)) == dev->ud_addr,
 	    "address ED %d pipe %d\n",
 	    OHCI_ED_GET_FA(O32TOH(sed->ed.ed_flags)), dev->ud_addr);
 	KASSERTMSG(OHCI_ED_GET_MAXP(O32TOH(sed->ed.ed_flags)) ==
 	    UGETW(opipe->pipe.up_endpoint->ue_edesc->wMaxPacketSize),
 	    "MPL ED %d pipe %d\n",
 	    OHCI_ED_GET_MAXP(O32TOH(sed->ed.ed_flags)),
 	    UGETW(opipe->pipe.up_endpoint->ue_edesc->wMaxPacketSize));
 	/* next will point to data if len != 0 */
 	next = stat;
 	/* Set up data transaction */
 	if (len != 0) {
 		ohci_soft_td_t *std;
 		ohci_soft_td_t *end;
 		next = ox->ox_stds[0];
 		ohci_reset_std_chain(sc, xfer, len, isread, next, &end);
 		end->td.td_nexttd = HTOO32(stat->physaddr);
 		end->nexttd = stat;
 		usb_syncmem(&end->dma,
 		    end->offs + offsetof(ohci_td_t, td_nexttd),
 		    sizeof(end->td.td_nexttd),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		usb_syncmem(&xfer->ux_dmabuf, 0, len,
 		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 		std = ox->ox_stds[0];
 		/* Start toggle at 1 and then use the carried toggle. */
 		std->td.td_flags &= HTOO32(~OHCI_TD_TOGGLE_MASK);
 		std->td.td_flags |= HTOO32(OHCI_TD_TOGGLE_1);
 		usb_syncmem(&std->dma,
 		    std->offs + offsetof(ohci_td_t, td_flags),
 		    sizeof(std->td.td_flags),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
+	}
 	DPRINTFN(8, "setup %p data %p stat %p tail %p", setup,
 	    (len != 0 ? ox->ox_stds[0] : NULL), stat, tail);
 	KASSERT(opipe->tail.td == tail);
 	memcpy(KERNADDR(&opipe->ctrl.reqdma, 0), req, sizeof(*req));
 	usb_syncmem(&opipe->ctrl.reqdma, 0, sizeof(*req), BUS_DMASYNC_PREWRITE);
 	setup->td.td_flags = HTOO32(OHCI_TD_SETUP | OHCI_TD_NOCC |
 				     OHCI_TD_TOGGLE_0 | OHCI_TD_NOINTR);
 	setup->td.td_cbp = HTOO32(DMAADDR(&opipe->ctrl.reqdma, 0));
 	setup->td.td_nexttd = HTOO32(next->physaddr);
 	setup->td.td_be = HTOO32(O32TOH(setup->td.td_cbp) + sizeof(*req) - 1);
 	setup->nexttd = next;
 	setup->len = 0;
 	setup->xfer = xfer;
 	setup->flags = 0;
 	ohci_hash_add_td(sc, setup);
 	xfer->ux_hcpriv = setup;
 	usb_syncmem(&setup->dma, setup->offs, sizeof(setup->td),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	stat->td.td_flags = HTOO32(
 		(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->td.td_nexttd = HTOO32(tail->physaddr);
 	stat->td.td_be = 0;
 	stat->nexttd = tail;
 	stat->flags = OHCI_CALL_DONE;
 	stat->len = 0;
 	stat->xfer = xfer;
 	ohci_hash_add_td(sc, stat);
 	usb_syncmem(&stat->dma, stat->offs, sizeof(stat->td),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	memset(&tail->td, 0, sizeof(tail->td));
 	tail->nexttd = NULL;
 	tail->xfer = NULL;
 	usb_syncmem(&tail->dma, tail->offs, sizeof(tail->td),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 #ifdef OHCI_DEBUG
 	USBHIST_LOGN(ohcidebug, 5, "--- dump start ---", 0, 0, 0, 0);
 	if (ohcidebug >= 5) {
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, setup);
+	}
 	USBHIST_LOGN(ohcidebug, 5, "--- dump end ---", 0, 0, 0, 0);
 #endif
 	/* Insert ED in schedule */
 	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);
 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
 	if (xfer->ux_timeout && !sc->sc_bus.ub_usepolling) {
 		callout_reset(&xfer->ux_callout, mstohz(xfer->ux_timeout),
 			    ohci_timeout, xfer);
+	}
 	DPRINTF("done", 0, 0, 0, 0);
 	mutex_exit(&sc->sc_lock);
 	if (sc->sc_bus.ub_usepolling)
 		ohci_waitintr(sc, xfer);
 	return USBD_IN_PROGRESS;
+}
 /* Abort a device control request. */
 Static void
 ohci_device_ctrl_abort(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc __diagused = OHCI_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTF("xfer=%p", xfer, 0, 0, 0);
 	ohci_abort_xfer(xfer, USBD_CANCELLED);
+}
 /* Close a device control pipe. */
 Static void
 ohci_device_ctrl_close(struct usbd_pipe *pipe)
+{
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(pipe);
 	ohci_softc_t *sc = OHCI_PIPE2SC(pipe);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTF("pipe=%p", pipe, 0, 0, 0);
 	ohci_close_pipe(pipe, sc->sc_ctrl_head);
 	ohci_free_std_locked(sc, opipe->tail.td);
+}
 /************************/
 Static void
 ohci_device_clear_toggle(struct usbd_pipe *pipe)
+{
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(pipe);
 	ohci_softc_t *sc = OHCI_PIPE2SC(pipe);
 	opipe->sed->ed.ed_headp &= HTOO32(~OHCI_TOGGLECARRY);
+}
 Static void
 ohci_noop(struct usbd_pipe *pipe)
+{
+}
 Static int
 ohci_device_bulk_init(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	int len = xfer->ux_bufsize;
 	int endpt = xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress;;
 	int isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	int err;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	DPRINTFN(4, "xfer=%p len=%d isread=%d flags=%d", xfer, len, isread,
 	    xfer->ux_flags);
 	DPRINTFN(4, "endpt=%d", endpt, 0, 0, 0);
 	/* Allocate a chain of new TDs (including a new tail). */
 	err = ohci_alloc_std_chain(sc, xfer, len, isread);
 	if (err)
 		return err;
 	return 0;
+}
 Static void
 ohci_device_bulk_fini(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(8, "xfer %p nstd %d", xfer, ox->ox_nstd, 0, 0);
 	mutex_enter(&sc->sc_lock);
 	for (size_t i = 0; i < ox->ox_nstd; i++) {
 		ohci_soft_td_t *std = ox->ox_stds[i];
 		if (std == NULL)
 			break;
 		if (std != opipe->tail.td)
 			ohci_free_std_locked(sc, std);
+	}
 	mutex_exit(&sc->sc_lock);
 	if (ox->ox_nstd) {
 		const size_t sz = sizeof(ohci_soft_td_t *) * ox->ox_nstd;
 		kmem_free(ox->ox_stds, sz);
+	}
+}
 Static usbd_status
 ohci_device_bulk_transfer(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	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->ux_pipe->up_queue));
+}
 Static usbd_status
 ohci_device_bulk_start(struct usbd_xfer *xfer)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	ohci_soft_td_t *last;
 	ohci_soft_td_t *data, *tail, *tdp;
 	ohci_soft_ed_t *sed;
 	int len, isread, endpt;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	len = xfer->ux_length;
 	endpt = xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	sed = opipe->sed;
 	DPRINTFN(4, "xfer=%p len=%d isread=%d flags=%d", xfer, len, isread,
 	    xfer->ux_flags);
 	DPRINTFN(4, "endpt=%d", endpt, 0, 0, 0);
 	mutex_enter(&sc->sc_lock);
 	/*
 	 * Use the pipe "tail" TD as our first and loan our first TD to the
 	 * next transfer
 	 */
 	data = opipe->tail.td;
 	opipe->tail.td = ox->ox_stds[0];
 	ox->ox_stds[0] = data;
 	ohci_reset_std_chain(sc, xfer, len, isread, data, &last);
 	/* point at sentinel */
 	tail = opipe->tail.td;
 	memset(&tail->td, 0, sizeof(tail->td));
 	tail->nexttd = NULL;
 	tail->xfer = NULL;
 	usb_syncmem(&tail->dma, tail->offs, sizeof(tail->td),
 	    BUS_DMASYNC_PREWRITE);
 	xfer->ux_hcpriv = data;
 	DPRINTFN(8, "xfer %p data %p tail %p", xfer, ox->ox_stds[0], tail, 0);
 	KASSERT(opipe->tail.td == tail);
 	/* We want interrupt at the end of the transfer. */
 	last->td.td_flags &= HTOO32(~OHCI_TD_INTR_MASK);
 	last->td.td_flags |= HTOO32(OHCI_TD_SET_DI(1));
 	last->td.td_nexttd = HTOO32(tail->physaddr);
 	last->nexttd = tail;
 	last->flags |= OHCI_CALL_DONE;
 	usb_syncmem(&last->dma, last->offs, sizeof(last->td),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	DPRINTFN(4, "ed_flags=0x%08x td_flags=0x%08x "
 		    "td_cbp=0x%08x td_be=0x%08x",
 		    (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
 	DPRINTFN(5, "--- dump start ---", 0, 0, 0, 0);
 	if (ohcidebug >= 5) {
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, data);
+	}
 	DPRINTFN(5, "--- dump end ---", 0, 0, 0, 0);
 #endif
 	/* Insert ED in schedule */
 	for (tdp = data; tdp != tail; tdp = tdp->nexttd) {
 		KASSERT(tdp->xfer == xfer);
+	}
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_tailp = HTOO32(tail->physaddr);
 	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->ux_timeout && !sc->sc_bus.ub_usepolling) {
 		callout_reset(&xfer->ux_callout, mstohz(xfer->ux_timeout),
 			    ohci_timeout, xfer);
+	}
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 Static void
 ohci_device_bulk_abort(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc __diagused = OHCI_XFER2SC(xfer);
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTF("xfer=%p", xfer, 0, 0, 0);
 	ohci_abort_xfer(xfer, USBD_CANCELLED);
+}
 /*
  * Close a device bulk pipe.
  */
 Static void
 ohci_device_bulk_close(struct usbd_pipe *pipe)
+{
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(pipe);
 	ohci_softc_t *sc = OHCI_PIPE2SC(pipe);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTF("pipe=%p", pipe, 0, 0, 0);
 	ohci_close_pipe(pipe, sc->sc_bulk_head);
 	ohci_free_std_locked(sc, opipe->tail.td);
+}
 /************************/
 Static int
 ohci_device_intr_init(struct usbd_xfer *xfer)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	int len = xfer->ux_bufsize;
 	int endpt = xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress;;
 	int isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	int err;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	KASSERT(len != 0);
 	DPRINTFN(4, "xfer=%p len=%d isread=%d flags=%d", xfer, len, isread,
 	    xfer->ux_flags);
 	DPRINTFN(4, "endpt=%d", endpt, 0, 0, 0);
 	ox->ox_nstd = 0;
 	err = ohci_alloc_std_chain(sc, xfer, len, isread);
 	if (err) {
 		return err;
+	}
 	return 0;
+}
 Static void
 ohci_device_intr_fini(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(8, "xfer %p nstd %d", xfer, ox->ox_nstd, 0, 0);
 	mutex_enter(&sc->sc_lock);
 	for (size_t i = 0; i < ox->ox_nstd; i++) {
 		ohci_soft_td_t *std = ox->ox_stds[i];
 		if (std != NULL)
 			break;
 		if (std != opipe->tail.td)
 			ohci_free_std_locked(sc, std);
+	}
 	mutex_exit(&sc->sc_lock);
 	if (ox->ox_nstd) {
 		const size_t sz = sizeof(ohci_soft_td_t *) * ox->ox_nstd;
 		kmem_free(ox->ox_stds, sz);
+	}
+}
 Static usbd_status
 ohci_device_intr_transfer(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	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->ux_pipe->up_queue));
+}
 Static usbd_status
 ohci_device_intr_start(struct usbd_xfer *xfer)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	ohci_soft_ed_t *sed = opipe->sed;
 	ohci_soft_td_t *data, *last, *tail;
 	int len, isread, endpt;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	DPRINTFN(3, "xfer=%p len=%d flags=%d priv=%p", xfer, xfer->ux_length,
 	    xfer->ux_flags, xfer->ux_priv);
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	len = xfer->ux_length;
 	endpt = xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	mutex_enter(&sc->sc_lock);
 	/*
 	 * Use the pipe "tail" TD as our first and loan our first TD to the
 	 * next transfer.
 	 */
 	data = opipe->tail.td;
 	opipe->tail.td = ox->ox_stds[0];
 	ox->ox_stds[0] = data;
 	ohci_reset_std_chain(sc, xfer, len, isread, data, &last);
 	/* point at sentinel */
 	tail = opipe->tail.td;
 	memset(&tail->td, 0, sizeof(tail->td));
 	tail->nexttd = NULL;
 	tail->xfer = NULL;
 	usb_syncmem(&tail->dma, tail->offs, sizeof(tail->td),
 	    BUS_DMASYNC_PREWRITE);
 	xfer->ux_hcpriv = data;
 	DPRINTFN(8, "data %p tail %p", ox->ox_stds[0], tail, 0, 0);
 	KASSERT(opipe->tail.td == tail);
 	/* We want interrupt at the end of the transfer. */
 	last->td.td_flags &= HTOO32(~OHCI_TD_INTR_MASK);
 	last->td.td_flags |= HTOO32(OHCI_TD_SET_DI(1));
 	last->td.td_nexttd = HTOO32(tail->physaddr);
 	last->nexttd = tail;
 	last->flags |= OHCI_CALL_DONE;
 	usb_syncmem(&last->dma, last->offs, sizeof(last->td),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 #ifdef OHCI_DEBUG
 	DPRINTFN(5, "--- dump start ---", 0, 0, 0, 0);
 	if (ohcidebug >= 5) {
 		ohci_dump_ed(sc, sed);
 		ohci_dump_tds(sc, data);
+	}
 	DPRINTFN(5, "--- dump end ---", 0, 0, 0, 0);
 #endif
 	/* Insert ED in schedule */
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_tailp = HTOO32(tail->physaddr);
 	sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP);
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 /* Abort a device interrupt request. */
 Static void
 ohci_device_intr_abort(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc __diagused = OHCI_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	KASSERT(xfer->ux_pipe->up_intrxfer == xfer);
 	ohci_abort_xfer(xfer, USBD_CANCELLED);
+}
 /* Close a device interrupt pipe. */
 Static void
 ohci_device_intr_close(struct usbd_pipe *pipe)
+{
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(pipe);
 	ohci_softc_t *sc = OHCI_PIPE2SC(pipe);
 	int nslots = opipe->intr.nslots;
 	int pos = opipe->intr.pos;
 	int j;
 	ohci_soft_ed_t *p, *sed = opipe->sed;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTFN(1, "pipe=%p nslots=%d pos=%d", pipe, nslots, pos, 0);
 	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_locked(&sc->sc_bus, 2, &sc->sc_lock);
 	for (p = sc->sc_eds[pos]; p && p->next != sed; p = p->next)
 		continue;
 	KASSERT(p);
 	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);
 	for (j = 0; j < nslots; j++)
 		--sc->sc_bws[(pos * nslots + j) % OHCI_NO_INTRS];
 	ohci_free_std_locked(sc, opipe->tail.td);
 	ohci_free_sed_locked(sc, opipe->sed);
+}
 Static usbd_status
 ohci_device_setintr(ohci_softc_t *sc, struct ohci_pipe *opipe, int ival)
+{
 	int i, j, best;
 	u_int npoll, slow, shigh, nslots;
 	u_int bestbw, bw;
 	ohci_soft_ed_t *hsed, *sed = opipe->sed;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(2, "pipe=%p", opipe, 0, 0, 0);
 	if (ival == 0) {
 		printf("ohci_setintr: 0 interval\n");
 		return USBD_INVAL;
+	}
 	npoll = OHCI_NO_INTRS;
 	while (npoll > ival)
 		npoll /= 2;
 	DPRINTFN(2, "ival=%d npoll=%d", ival, npoll, 0, 0);
 	/*
 	 * We now know which level in the tree the ED must go into.
 	 * Figure out which slot has most bandwidth left over.
 	 * Slots to examine:
 	 * npoll
 	 * 1	0
 	 * 2	1 2
 	 * 4	3 4 5 6
 	 * 8	7 8 9 10 11 12 13 14
 	 * N    (N-1) .. (N-1+N-1)
 	 */
 	slow = npoll-1;
 	shigh = slow + npoll;
 	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, "best=%d(%d..%d) bestbw=%d", best, slow, shigh, bestbw);
 	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);
 	mutex_exit(&sc->sc_lock);
 	for (j = 0; j < nslots; j++)
 		++sc->sc_bws[(best * nslots + j) % OHCI_NO_INTRS];
 	opipe->intr.nslots = nslots;
 	opipe->intr.pos = best;
 	DPRINTFN(5, "returns %p", opipe, 0, 0, 0);
 	return USBD_NORMAL_COMPLETION;
+}
 /***********************/
 Static int
 ohci_device_isoc_init(struct usbd_xfer *xfer)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	ohci_soft_itd_t *sitd;
 	size_t i;
 	int err;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(1, "xfer %p len %d flags %d", xfer, xfer->ux_length,
 	    xfer->ux_flags, 0);
 	const size_t nfsitd =
 	    (xfer->ux_nframes + OHCI_ITD_NOFFSET - 1) / OHCI_ITD_NOFFSET;
 	const size_t nbsitd = xfer->ux_bufsize / OHCI_PAGE_SIZE;
 	const size_t nsitd = MAX(nfsitd, nbsitd) + 1;
 	ox->ox_sitds = kmem_zalloc(sizeof(ohci_soft_itd_t *) * nsitd,
 	    KM_SLEEP);
 	ox->ox_nsitd = nsitd;
 	for (i = 0; i < nsitd; i++) {
 		/* Allocate next ITD */
 		sitd = ohci_alloc_sitd(sc);
 		if (sitd == NULL) {
 			err = ENOMEM;
 			goto fail;
+		}
 		ox->ox_sitds[i] = sitd;
 		sitd->xfer = xfer;
 		sitd->flags = 0;
+	}
 	return 0;
 fail:
 	for (; i > 0;) {
 		ohci_free_sitd(sc, ox->ox_sitds[--i]);
+	}
 	return err;
+}
 Static void
 ohci_device_isoc_fini(struct usbd_xfer *xfer)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	for (size_t i = 0; i < ox->ox_nsitd; i++) {
 		if (ox->ox_sitds[i] != opipe->tail.itd) {
 			ohci_free_sitd_locked(sc, ox->ox_sitds[i]);
+		}
+	}
 	mutex_exit(&sc->sc_lock);
 	if (ox->ox_nsitd) {
 		const size_t sz = sizeof(ohci_soft_itd_t *) * ox->ox_nsitd;
 		kmem_free(ox->ox_sitds, sz);
+	}
+}
 usbd_status
 ohci_device_isoc_transfer(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	usbd_status __diagused err;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(5, "xfer=%p", xfer, 0, 0, 0);
 	/* Put it on our queue, */
 	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	KASSERT(err == USBD_NORMAL_COMPLETION);
 	/* insert into schedule, */
 	ohci_device_isoc_enter(xfer);
 	/* and start if the pipe wasn't running */
 	return USBD_IN_PROGRESS;
+}
 void
 ohci_device_isoc_enter(struct usbd_xfer *xfer)
+{
 	struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	ohci_soft_ed_t *sed = opipe->sed;
 	ohci_soft_itd_t *sitd, *nsitd, *tail;
 	ohci_physaddr_t buf, offs, noffs, bp0;
 	int i, ncur, nframes;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(5, "xfer=%p", xfer, 0, 0, 0);
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_dying) {
 		mutex_exit(&sc->sc_lock);
 		return;
+	}
 	struct isoc *isoc = &opipe->isoc;
 	DPRINTFN(1, "used=%d next=%d xfer=%p nframes=%d",
 	     isoc->inuse, isoc->next, xfer, xfer->ux_nframes);
 	if (isoc->next == -1) {
 		/* Not in use yet, schedule it a few frames ahead. */
 		isoc->next = O32TOH(sc->sc_hcca->hcca_frame_number) + 5;
 		DPRINTFN(2,"start next=%d", isoc->next, 0, 0, 0);
+	}
 	sitd = opipe->tail.itd;
 	opipe->tail.itd = ox->ox_sitds[0];
 	ox->ox_sitds[0] = sitd;
 	buf = DMAADDR(&xfer->ux_dmabuf, 0);
 	bp0 = OHCI_PAGE(buf);
 	offs = OHCI_PAGE_OFFSET(buf);
 	nframes = xfer->ux_nframes;
 	xfer->ux_hcpriv = sitd;
 	size_t j = 1;
 	for (i = ncur = 0; i < nframes; i++, ncur++) {
 		noffs = offs + xfer->ux_frlengths[i];
 		if (ncur == OHCI_ITD_NOFFSET ||	/* all offsets used */
 		    OHCI_PAGE(buf + noffs) > bp0 + OHCI_PAGE_SIZE) { /* too many page crossings */
 			/* Allocate next ITD */
 			nsitd = ox->ox_sitds[j++];
 			KASSERT(nsitd != NULL);
 			KASSERT(j < ox->ox_nsitd);
 			/* Fill current ITD */
 			sitd->itd.itd_flags = HTOO32(
 				OHCI_ITD_NOCC |
 				OHCI_ITD_SET_SF(isoc->next) |
 				OHCI_ITD_SET_DI(6) | /* delay intr a little */
 				OHCI_ITD_SET_FC(ncur));
 			sitd->itd.itd_bp0 = HTOO32(bp0);
 			sitd->itd.itd_nextitd = HTOO32(nsitd->physaddr);
 			sitd->itd.itd_be = HTOO32(bp0 + offs - 1);
 			sitd->nextitd = nsitd;
 			sitd->xfer = xfer;
 			sitd->flags = 0;
 #ifdef DIAGNOSTIC
 			sitd->isdone = false;
 #endif
 			ohci_hash_add_itd(sc, sitd);
 			usb_syncmem(&sitd->dma, sitd->offs, sizeof(sitd->itd),
 			    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 			sitd = nsitd;
 			isoc->next = isoc->next + ncur;
 			bp0 = OHCI_PAGE(buf + offs);
 			ncur = 0;
+		}
 		sitd->itd.itd_offset[ncur] = HTOO16(OHCI_ITD_MK_OFFS(offs));
 		offs = noffs;
+	}
 	KASSERT(j <= ox->ox_nsitd);
 	/* point at sentinel */
 	tail = opipe->tail.itd;
 	memset(&tail->itd, 0, sizeof(tail->itd));
 	tail->nextitd = NULL;
  	tail->xfer = NULL;
 	usb_syncmem(&tail->dma, tail->offs, sizeof(tail->itd),
 	    BUS_DMASYNC_PREWRITE);
 	/* Fixup last used ITD */
 	sitd->itd.itd_flags = HTOO32(
 		OHCI_ITD_NOCC |
 		OHCI_ITD_SET_SF(isoc->next) |
 		OHCI_ITD_SET_DI(0) |
 		OHCI_ITD_SET_FC(ncur));
 	sitd->itd.itd_bp0 = HTOO32(bp0);
 	sitd->itd.itd_nextitd = HTOO32(tail->physaddr);
 	sitd->itd.itd_be = HTOO32(bp0 + offs - 1);
 	sitd->nextitd = tail;
 	sitd->xfer = xfer;
 	sitd->flags = OHCI_CALL_DONE;
 #ifdef DIAGNOSTIC
 	sitd->isdone = false;
 #endif
 	ohci_hash_add_itd(sc, sitd);
 	usb_syncmem(&sitd->dma, sitd->offs, sizeof(sitd->itd),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	isoc->next = isoc->next + ncur;
 	isoc->inuse += nframes;
 	/* XXX pretend we did it all */
 	xfer->ux_actlen = offs;
 	xfer->ux_status = USBD_IN_PROGRESS;
 #ifdef OHCI_DEBUG
 	if (ohcidebug >= 5) {
 		DPRINTF("frame=%d", O32TOH(sc->sc_hcca->hcca_frame_number),
 , 0, 0);
 		ohci_dump_itds(sc, xfer->ux_hcpriv);
 		ohci_dump_ed(sc, sed);
+	}
 #endif
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->ed.ed_tailp = HTOO32(tail->physaddr);
 	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);
 	mutex_exit(&sc->sc_lock);
+}
 void
 ohci_device_isoc_abort(struct usbd_xfer *xfer)
+{
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(xfer->ux_pipe);
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	ohci_soft_ed_t *sed;
 	ohci_soft_itd_t *sitd;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(1, "xfer=%p", xfer, 0, 0, 0);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	/* Transfer is already done. */
 	if (xfer->ux_status != USBD_NOT_STARTED &&
 	    xfer->ux_status != USBD_IN_PROGRESS) {
 		printf("ohci_device_isoc_abort: early return\n");
 		goto done;
+	}
 	/* Give xfer the requested abort code. */
 	xfer->ux_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->ux_hcpriv;
 	KASSERT(sitd);
 	usb_delay_ms_locked(&sc->sc_bus, OHCI_ITD_NOFFSET, &sc->sc_lock);
 	for (; sitd->xfer == xfer; sitd = sitd->nextitd) {
 		ohci_hash_rem_itd(sc, sitd);
 #ifdef DIAGNOSTIC
 		DPRINTFN(1, "abort sets done sitd=%p", sitd, 0, 0, 0);
 		sitd->isdone = true;
 #endif
+	}
 	usb_delay_ms_locked(&sc->sc_bus, OHCI_ITD_NOFFSET, &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);
  done:
 	KASSERT(mutex_owned(&sc->sc_lock));
+}
 void
 ohci_device_isoc_done(struct usbd_xfer *xfer)
+{
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(1, "xfer=%p", xfer, 0, 0, 0);
+}
 usbd_status
 ohci_setup_isoc(struct usbd_pipe *pipe)
+{
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(pipe);
 	ohci_softc_t *sc = OHCI_PIPE2SC(pipe);
 	struct isoc *isoc = &opipe->isoc;
 	isoc->next = -1;
 	isoc->inuse = 0;
 	mutex_enter(&sc->sc_lock);
 	ohci_add_ed(sc, opipe->sed, sc->sc_isoc_head);
 	mutex_exit(&sc->sc_lock);
 	return USBD_NORMAL_COMPLETION;
+}
 void
 ohci_device_isoc_close(struct usbd_pipe *pipe)
+{
 	struct ohci_pipe *opipe = OHCI_PIPE2OPIPE(pipe);
 	ohci_softc_t *sc = OHCI_PIPE2SC(pipe);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTF("pipe=%p", pipe, 0, 0, 0);
 	ohci_close_pipe(pipe, sc->sc_isoc_head);
 #ifdef DIAGNOSTIC
 	opipe->tail.itd->isdone = true;
 #endif
 	ohci_free_sitd_locked(sc, opipe->tail.itd);
+}