 @@ -1,14 +1,14 @@
-/*	$NetBSD: ehci.c,v 1.234.2.38 2015/03/03 10:06:01 skrll Exp $ */
+/*	$NetBSD: ehci.c,v 1.234.2.39 2015/03/05 20:57:07 skrll Exp $ */
 /*
  * Copyright (c) 2004-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), Charles M. Hannum,
  * Jeremy Morse (jeremy.morse@gmail.com), Jared D. McNeill
  * (jmcneill@invisible.ca) and Matthew R. Green (mrg@eterna.com.au).
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -43,27 +43,27 @@
 /*
  * TODO:
  * 1) hold off explorations by companion controllers until ehci has started.
+ *
  * 2) The hub driver needs to handle and schedule the transaction translator,
  *    to assign place in frame where different devices get to go. See chapter
  *    on hubs in USB 2.0 for details.
+ *
  * 3) Command failures are not recovered correctly.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ehci.c,v 1.234.2.38 2015/03/03 10:06:01 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ehci.c,v 1.234.2.39 2015/03/05 20:57:07 skrll Exp $");
 #include "ohci.h"
 #include "uhci.h"
 #include "opt_usb.h"
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 @@ -3095,28 +3095,28 @@ ehci_close_pipe(usbd_pipe_handle pipe, e
  * 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.
  * XXX This is most probably wrong.
  * XXXMRG this doesn't make sense anymore.
  */
 Static void
 ehci_abort_xfer(usbd_xfer_handle xfer, usbd_status status)
+{
 #define exfer EXFER(xfer)
 	struct ehci_pipe *epipe = (struct ehci_pipe *)xfer->ux_pipe;
 	struct ehci_xfer *exfer = EXFER(xfer);
 	ehci_softc_t *sc = epipe->pipe.up_dev->ud_bus->ub_hcpriv;
 	ehci_soft_qh_t *sqh = epipe->sqh;
 	ehci_soft_qtd_t *sqtd;
 	ehci_physaddr_t cur;
 	uint32_t qhstatus;
 	int hit;
 	int wake;
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer=%p pipe=%p", xfer, epipe, 0, 0);
 	KASSERT(mutex_owned(&sc->sc_lock));
 @@ -3232,27 +3232,26 @@ ehci_abort_xfer(usbd_xfer_handle xfer, u
 	 * Step 4: Execute callback.
 	 */
 #ifdef DIAGNOSTIC
 	exfer->ex_isdone = true;
 #endif
 	wake = xfer->ux_hcflags & UXFER_ABORTWAIT;
 	xfer->ux_hcflags &= ~(UXFER_ABORTING | UXFER_ABORTWAIT);
 	usb_transfer_complete(xfer);
 	if (wake) {
 		cv_broadcast(&xfer->ux_hccv);
+	}
 	KASSERT(mutex_owned(&sc->sc_lock));
 #undef exfer
+}
 Static void
 ehci_abort_isoc_xfer(usbd_xfer_handle xfer, usbd_status status)
+{
 	ehci_isoc_trans_t trans_status;
 	struct ehci_pipe *epipe;
 	struct ehci_xfer *exfer;
 	ehci_softc_t *sc;
 	struct ehci_soft_itd *itd;
 	struct ehci_soft_sitd *sitd;
 	int i, wake;
 @@ -3485,28 +3484,28 @@ ehci_device_ctrl_close(usbd_pipe_handle
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	USBHIST_LOG(ehcidebug, "pipe=%p", pipe, 0, 0, 0);
 	ehci_close_pipe(pipe, sc->sc_async_head);
+}
 Static usbd_status
 ehci_device_request(usbd_xfer_handle xfer)
+{
 #define exfer EXFER(xfer)
 	struct ehci_pipe *epipe = (struct ehci_pipe *)xfer->ux_pipe;
 	struct ehci_xfer *exfer = EXFER(xfer);
 	usb_device_request_t *req = &xfer->ux_request;
 	usbd_device_handle dev = epipe->pipe.up_dev;
 	ehci_softc_t *sc = dev->ud_bus->ub_hcpriv;
 	ehci_soft_qtd_t *setup, *stat, *next;
 	ehci_soft_qh_t *sqh;
 	int isread;
 	int len;
 	usbd_status err;
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	isread = req->bmRequestType & UT_READ;
 	len = UGETW(req->wLength);
 @@ -3636,27 +3635,26 @@ ehci_device_request(usbd_xfer_handle xfe
  bad3:
 	mutex_exit(&sc->sc_lock);
 	ehci_free_sqtd(sc, stat);
  bad2:
 	ehci_free_sqtd(sc, setup);
  bad1:
 	USBHIST_LOG(ehcidebug, "no memory", 0, 0, 0, 0);
 	mutex_enter(&sc->sc_lock);
 	xfer->ux_status = err;
 	usb_transfer_complete(xfer);
 	mutex_exit(&sc->sc_lock);
 	return err;
 #undef exfer
+}
 /*
  * Some EHCI chips from VIA seem to trigger interrupts before writing back the
  * qTD status, or miss signalling occasionally under heavy load.  If the host
  * machine is too fast, we we can miss transaction completion - when we scan
  * the active list the transaction still seems to be active.  This generally
  * exhibits itself as a umass stall that never recovers.
+ *
  * We work around this behaviour by setting up this callback after any softintr
  * that completes with transactions still pending, giving us another chance to
  * check for completion after the writeback has taken place.
  */
 @@ -3682,28 +3680,28 @@ ehci_device_bulk_transfer(usbd_xfer_hand
 	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 ehci_device_bulk_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 ehci_device_bulk_start(usbd_xfer_handle xfer)
+{
 #define exfer EXFER(xfer)
 	struct ehci_pipe *epipe = (struct ehci_pipe *)xfer->ux_pipe;
 	struct ehci_xfer *exfer = EXFER(xfer);
 	usbd_device_handle dev = epipe->pipe.up_dev;
 	ehci_softc_t *sc = dev->ud_bus->ub_hcpriv;
 	ehci_soft_qtd_t *data, *dataend;
 	ehci_soft_qh_t *sqh;
 	usbd_status err;
 	int len, isread, endpt;
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer=%p len=%d flags=%d",
 	    xfer, xfer->ux_length, xfer->ux_flags, 0);
 	if (sc->sc_dying)
 @@ -3762,27 +3760,26 @@ ehci_device_bulk_start(usbd_xfer_handle
 #if 0
 	printf("async_head:\n");
 	ehci_dump_sqh(sc->sc_async_head);
 #endif
 	USBHIST_LOG(ehcidebug, "sqh:", 0, 0, 0, 0);
 	ehci_dump_sqh(sqh);
 	ehci_dump_sqtds(data);
 #endif
 	if (sc->sc_bus.ub_usepolling)
 		ehci_waitintr(sc, xfer);
 	return USBD_IN_PROGRESS;
 #undef exfer
+}
 Static void
 ehci_device_bulk_abort(usbd_xfer_handle xfer)
+{
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer %p", xfer, 0, 0, 0);
 	ehci_abort_xfer(xfer, USBD_CANCELLED);
+}
 /*
  * Close a device bulk pipe.
 @@ -3868,28 +3865,28 @@ ehci_device_intr_transfer(usbd_xfer_hand
 	if (err)
 		return err;
 	/*
 	 * Pipe isn't running (otherwise err would be USBD_INPROG),
 	 * so start it first.
 	 */
 	return ehci_device_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 ehci_device_intr_start(usbd_xfer_handle xfer)
+{
 #define exfer EXFER(xfer)
 	struct ehci_pipe *epipe = (struct ehci_pipe *)xfer->ux_pipe;
 	struct ehci_xfer *exfer = EXFER(xfer);
 	usbd_device_handle dev = xfer->ux_pipe->up_dev;
 	ehci_softc_t *sc = dev->ud_bus->ub_hcpriv;
 	ehci_soft_qtd_t *data, *dataend;
 	ehci_soft_qh_t *sqh;
 	usbd_status err;
 	int len, isread, endpt;
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer=%p len=%d flags=%d",
 	    xfer, xfer->ux_length, xfer->ux_flags, 0);
 	if (sc->sc_dying)
 @@ -3944,27 +3941,26 @@ ehci_device_intr_start(usbd_xfer_handle
 	USBHIST_LOGN(ehcidebug, 5, "data(2)", 0, 0, 0, 0);
 //	delay(10000);
 	USBHIST_LOGN(ehcidebug, 5, "data(3)", 0, 0, 0, 0);
 	ehci_dump_regs(sc);
 	USBHIST_LOGN(ehcidebug, 5, "sqh:", 0, 0, 0, 0);
 	ehci_dump_sqh(sqh);
 	ehci_dump_sqtds(data);
 #endif
 	if (sc->sc_bus.ub_usepolling)
 		ehci_waitintr(sc, xfer);
 	return USBD_IN_PROGRESS;
 #undef exfer
+}
 Static void
 ehci_device_intr_abort(usbd_xfer_handle xfer)
+{
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer=%p", xfer, 0, 0, 0);
 	KASSERT(xfer->ux_pipe->up_intrxfer == xfer);
 	/*
 	 * XXX - abort_xfer uses ehci_sync_hc, which syncs via the advance
 	 *       async doorbell. That's dependent on the async list, wheras
 @@ -3979,44 +3975,43 @@ ehci_device_intr_close(usbd_pipe_handle
 	ehci_softc_t *sc = pipe->up_dev->ud_bus->ub_hcpriv;
 	struct ehci_pipe *epipe = (struct ehci_pipe *)pipe;
 	struct ehci_soft_islot *isp;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	isp = &sc->sc_islots[epipe->sqh->islot];
 	ehci_close_pipe(pipe, isp->sqh);
+}
 Static void
 ehci_device_intr_done(usbd_xfer_handle xfer)
+{
 #define exfer EXFER(xfer)
 	struct ehci_xfer *ex = EXFER(xfer);
 	ehci_softc_t *sc = xfer->ux_pipe->up_dev->ud_bus->ub_hcpriv;
 	struct ehci_pipe *epipe = (struct ehci_pipe *)xfer->ux_pipe;
 	struct ehci_xfer *exfer = EXFER(xfer);
 	ehci_soft_qtd_t *data, *dataend;
 	ehci_soft_qh_t *sqh;
 	usbd_status err;
 	int len, isread, endpt;
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer=%p, actlen=%d",
 	    xfer, xfer->ux_actlen, 0, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (xfer->ux_pipe->up_repeat) {
-		ehci_free_sqtd_chain(sc, ex->ex_sqtdstart, NULL);
+		ehci_free_sqtd_chain(sc, exfer->ex_sqtdstart, NULL);
 		len = epipe->u.intr.length;
 		xfer->ux_length = len;
 		endpt = epipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 		isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 		usb_syncmem(&xfer->ux_dmabuf, 0, len,
 		    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 		sqh = epipe->sqh;
 		err = ehci_alloc_sqtd_chain(epipe, sc, len, isread, xfer,
 		    &data, &dataend);
 		if (err) {
 			USBHIST_LOG(ehcidebug, "no memory", 0, 0, 0, 0);
 @@ -4029,35 +4024,34 @@ ehci_device_intr_done(usbd_xfer_handle x
 		exfer->ex_sqtdend = dataend;
 		KASSERT(exfer->ex_isdone);
 #ifdef DIAGNOSTIC
 		exfer->ex_isdone = false;
 #endif
 		ehci_set_qh_qtd(sqh, data); /* also does usb_syncmem(sqh) */
 		if (xfer->ux_timeout && !sc->sc_bus.ub_usepolling) {
 			callout_reset(&xfer->ux_callout,
 			    mstohz(xfer->ux_timeout), ehci_timeout, xfer);
+		}
 		xfer->ux_status = USBD_IN_PROGRESS;
-	} else if (xfer->ux_status != USBD_NOMEM && ehci_active_intr_list(ex)) {
+	} else if (xfer->ux_status != USBD_NOMEM && ehci_active_intr_list(exfer)) {
-		ehci_del_intr_list(sc, ex); /* remove from active list */
+		ehci_del_intr_list(sc, exfer); /* remove from active list */
-		ehci_free_sqtd_chain(sc, ex->ex_sqtdstart, NULL);
+		ehci_free_sqtd_chain(sc, exfer->ex_sqtdstart, NULL);
 		endpt = epipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 		isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 		usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
 		    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
+	}
 #undef exfer
+}
 /************************/
 Static usbd_status
 ehci_device_fs_isoc_transfer(usbd_xfer_handle xfer)
+{
 	usbd_status err;
 	err = usb_insert_transfer(xfer);
 	if (err && err != USBD_IN_PROGRESS)
 		return err;