 @@ -1,14 +1,14 @@
-/*	$NetBSD: ohci.c,v 1.218.6.2.2.3 2011/12/08 08:52:25 mrg Exp $	*/
+/*	$NetBSD: ohci.c,v 1.218.6.2.2.4 2011/12/08 09:09:30 mrg 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, 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, 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.
+ *
 @@ -32,27 +32,27 @@
  * 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.2.2.3 2011/12/08 08:52:25 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.218.6.2.2.4 2011/12/08 09:09:30 mrg Exp $");
 #include "opt_usb.h"
 #include <sys/param.h>
 #include <sys/systm.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>
 @@ -110,27 +110,28 @@ Static usbd_status	ohci_alloc_std_chain(
 			    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_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(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 *);
 @@ -261,88 +262,88 @@ struct ohci_pipe {
 			u_int length;
 			int isread;
 		} bulk;
 		/* Iso pipe */
 		struct iso {
 			int next, inuse;
 		} iso;
 	} u;
 };
 #define OHCI_INTR_ENDPT 1
 Static const struct usbd_bus_methods ohci_bus_methods = {
-	ohci_open,
+	.open_pipe =	ohci_open,
-	ohci_softintr,
+	.soft_intr =	ohci_softintr,
-	ohci_poll,
+	.do_poll =	ohci_poll,
-	ohci_allocm,
+	.allocm =	ohci_allocm,
-	ohci_freem,
+	.freem =	ohci_freem,
-	ohci_allocx,
+	.allocx =	ohci_allocx,
-	ohci_freex,
+	.freex =	ohci_freex,
-	ohci_get_locks,
+	.get_locks =	ohci_get_locks,
 };
 Static const struct usbd_pipe_methods ohci_root_ctrl_methods = {
-	ohci_root_ctrl_transfer,
+	.transfer =	ohci_root_ctrl_transfer,
-	ohci_root_ctrl_start,
+	.start =	ohci_root_ctrl_start,
-	ohci_root_ctrl_abort,
+	.abort =	ohci_root_ctrl_abort,
-	ohci_root_ctrl_close,
+	.close =	ohci_root_ctrl_close,
-	ohci_noop,
+	.cleartoggle =	ohci_noop,
-	ohci_root_ctrl_done,
+	.done =		ohci_root_ctrl_done,
 };
 Static const struct usbd_pipe_methods ohci_root_intr_methods = {
-	ohci_root_intr_transfer,
+	.transfer =	ohci_root_intr_transfer,
-	ohci_root_intr_start,
+	.start =	ohci_root_intr_start,
-	ohci_root_intr_abort,
+	.abort =	ohci_root_intr_abort,
-	ohci_root_intr_close,
+	.close =	ohci_root_intr_close,
-	ohci_noop,
+	.cleartoggle =	ohci_noop,
-	ohci_root_intr_done,
+	.done =		ohci_root_intr_done,
 };
 Static const struct usbd_pipe_methods ohci_device_ctrl_methods = {
-	ohci_device_ctrl_transfer,
+	.transfer =	ohci_device_ctrl_transfer,
-	ohci_device_ctrl_start,
+	.start =	ohci_device_ctrl_start,
-	ohci_device_ctrl_abort,
+	.abort =	ohci_device_ctrl_abort,
-	ohci_device_ctrl_close,
+	.close =	ohci_device_ctrl_close,
-	ohci_noop,
+	.cleartoggle =	ohci_noop,
-	ohci_device_ctrl_done,
+	.done =		ohci_device_ctrl_done,
 };
 Static const struct usbd_pipe_methods ohci_device_intr_methods = {
-	ohci_device_intr_transfer,
+	.transfer =	ohci_device_intr_transfer,
-	ohci_device_intr_start,
+	.start =	ohci_device_intr_start,
-	ohci_device_intr_abort,
+	.abort =	ohci_device_intr_abort,
-	ohci_device_intr_close,
+	.close =	ohci_device_intr_close,
-	ohci_device_clear_toggle,
+	.cleartoggle =	ohci_device_clear_toggle,
-	ohci_device_intr_done,
+	.done =		ohci_device_intr_done,
 };
 Static const struct usbd_pipe_methods ohci_device_bulk_methods = {
-	ohci_device_bulk_transfer,
+	.transfer =	ohci_device_bulk_transfer,
-	ohci_device_bulk_start,
+	.start =	ohci_device_bulk_start,
-	ohci_device_bulk_abort,
+	.abort =	ohci_device_bulk_abort,
-	ohci_device_bulk_close,
+	.close =	ohci_device_bulk_close,
-	ohci_device_clear_toggle,
+	.cleartoggle =	ohci_device_clear_toggle,
-	ohci_device_bulk_done,
+	.done =		ohci_device_bulk_done,
 };
 Static const struct usbd_pipe_methods ohci_device_isoc_methods = {
-	ohci_device_isoc_transfer,
+	.transfer =	ohci_device_isoc_transfer,
-	ohci_device_isoc_start,
+	.start =	ohci_device_isoc_start,
-	ohci_device_isoc_abort,
+	.abort =	ohci_device_isoc_abort,
-	ohci_device_isoc_close,
+	.close =	ohci_device_isoc_close,
-	ohci_noop,
+	.cleartoggle =	ohci_noop,
-	ohci_device_isoc_done,
+	.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;
 @@ -1487,27 +1488,29 @@ ohci_softintr(void *v)
 		cv_broadcast(&sc->sc_softwake_cv);
+	}
 	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;
 #ifdef DIAGNOSTIC
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 #endif
 	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)
 @@ -1563,27 +1566,29 @@ 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)
+{
 #ifdef DIAGNOSTIC
 	ohci_softc_t *sc = xfer->pipe->device->bus->hci_private;
 #endif
 	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)
 @@ -1855,56 +1860,57 @@ ohci_device_request(usbd_xfer_handle xfe
 	return (USBD_NORMAL_COMPLETION);
  bad3:
 	ohci_free_std(sc, tail);
  bad2:
 	ohci_free_std(sc, stat);
  bad1:
 	return (err);
+}
 /*
  * Add an ED to the schedule.  Called at splusb().
  */
-void
+Static void
 ohci_add_ed(ohci_softc_t *sc, ohci_soft_ed_t *sed, ohci_soft_ed_t *head)
+{
 	DPRINTFN(8,("ohci_add_ed: sed=%p head=%p\n", sed, head));
-	SPLUSBCHECK;
+	KASSERT(mutex_owned(&sc->sc_lock));
 	usb_syncmem(&head->dma, head->offs + offsetof(ohci_ed_t, ed_nexted),
 	    sizeof(head->ed.ed_nexted),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	sed->next = head->next;
 	sed->ed.ed_nexted = head->ed.ed_nexted;
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_nexted),
 	    sizeof(sed->ed.ed_nexted),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	head->next = sed;
 	head->ed.ed_nexted = HTOO32(sed->physaddr);
 	usb_syncmem(&head->dma, head->offs + offsetof(ohci_ed_t, ed_nexted),
 	    sizeof(head->ed.ed_nexted),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
+}
 /*
  * Remove an ED from the schedule.  Called at splusb().
  */
-void
+Static void
-ohci_rem_ed(ohci_soft_ed_t *sed, ohci_soft_ed_t *head)
+ohci_rem_ed(ohci_softc_t *sc, ohci_soft_ed_t *sed, ohci_soft_ed_t *head)
+{
 	ohci_soft_ed_t *p;
-	SPLUSBCHECK;
+	//KASSERT(mutex_owned(&sc->sc_lock));
 	/* XXX */
 	for (p = head; p != NULL && p->next != sed; p = p->next)
+		;
 	if (p == NULL)
 		panic("ohci_rem_ed: ED not found");
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_nexted),
 	    sizeof(sed->ed.ed_nexted),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	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),
 @@ -1918,73 +1924,74 @@ ohci_rem_ed(ohci_soft_ed_t *sed, ohci_so
  * and we have no simple way to translate this back to a kernel address.
  * To make the translation possible (and fast) we use a hash table of
  * TDs currently in the schedule.  The physical address is used as the
  * hash value.
  */
 #define HASH(a) (((a) >> 4) % OHCI_HASH_SIZE)
 /* Called at splusb() */
 void
 ohci_hash_add_td(ohci_softc_t *sc, ohci_soft_td_t *std)
+{
 	int h = HASH(std->physaddr);
-	SPLUSBCHECK;
+	//KASSERT(mutex_owned(&sc->sc_lock));
 	LIST_INSERT_HEAD(&sc->sc_hash_tds[h], std, hnext);
+}
 /* Called at splusb() */
 void
 ohci_hash_rem_td(ohci_softc_t *sc, ohci_soft_td_t *std)
+{
 	SPLUSBCHECK;
 	//KASSERT(mutex_owned(&sc->sc_lock));
 	LIST_REMOVE(std, hnext);
+}
 ohci_soft_td_t *
 ohci_hash_find_td(ohci_softc_t *sc, ohci_physaddr_t a)
+{
 	int h = HASH(a);
 	ohci_soft_td_t *std;
 	for (std = LIST_FIRST(&sc->sc_hash_tds[h]);
 	     std != NULL;
 	     std = LIST_NEXT(std, hnext))
 		if (std->physaddr == a)
 			return (std);
 	return (NULL);
+}
 /* Called at splusb() */
 void
 ohci_hash_add_itd(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
+{
 	int h = HASH(sitd->physaddr);
-	SPLUSBCHECK;
+	//KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTFN(10,("ohci_hash_add_itd: sitd=%p physaddr=0x%08lx\n",
 		    sitd, (u_long)sitd->physaddr));
 	LIST_INSERT_HEAD(&sc->sc_hash_itds[h], sitd, hnext);
+}
 /* Called at splusb() */
 void
 ohci_hash_rem_itd(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
+{
-	SPLUSBCHECK;
+	//KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTFN(10,("ohci_hash_rem_itd: sitd=%p physaddr=0x%08lx\n",
 		    sitd, (u_long)sitd->physaddr));
 	LIST_REMOVE(sitd, hnext);
+}
 ohci_soft_itd_t *
 ohci_hash_find_itd(ohci_softc_t *sc, ohci_physaddr_t a)
+{
 	int h = HASH(a);
 	ohci_soft_itd_t *sitd;
 @@ -2215,70 +2222,69 @@ ohci_open(usbd_pipe_handle pipe)
 			break;
+		}
+	}
 	return USBD_NORMAL_COMPLETION;
  bad:
 	if (std != NULL)
 		ohci_free_std(sc, std);
  bad1:
 	if (sed != NULL)
 		ohci_free_sed(sc, sed);
  bad0:
 	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;
-//	KASSERT(mutex_owned(&sc->sc_lock));
+	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);
 #endif
 #ifdef OHCI_DEBUG
 		ohci_dump_ed(sc, sed);
 		if (std)
 			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);
+	ohci_rem_ed(sc, 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;
 	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
 @@ -3349,35 +3355,35 @@ ohci_device_setintr(ohci_softc_t *sc, st
 		++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;
+	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);
+	mutex_enter(&sc->sc_lock);
 	err = usb_insert_transfer(xfer);
-	//mutex_exit(&sc->sc_lock);
+	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));
 @@ -3482,36 +3488,36 @@ 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
-	//mutex_enter(&sc->sc_lock);
+	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);
-	//mutex_exit(&sc->sc_lock);
+	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
 @@ -3539,27 +3545,27 @@ ohci_device_isoc_start(usbd_xfer_handle
 	mutex_exit(&sc->sc_lock);
 	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;
-	DPRINTFN(1,("ohci_device_isoc_abort: xfer=%p\n", xfer));
+	DPRINTFN(1,("ohci_device_isoc_abort: xfer=%p lock=%p\n", xfer, &sc->sc_lock));
 	mutex_enter(&sc->sc_lock);
 	/* Transfer is already done. */
 	if (xfer->status != USBD_NOT_STARTED &&
 	    xfer->status != USBD_IN_PROGRESS) {
 		printf("ohci_device_isoc_abort: early return\n");
 		goto done;
+	}
 	/* Give xfer the requested abort code. */
 	xfer->status = USBD_CANCELLED;
 @@ -3589,27 +3595,27 @@ ohci_device_isoc_abort(usbd_xfer_handle
 	usb_delay_ms(&sc->sc_bus, OHCI_ITD_NOFFSET);
 	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);
- done: ;
+ 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;