 @@ -1,14 +1,14 @@
-/*	$NetBSD: ahci.c,v 1.29 2022/03/03 06:04:31 riastradh Exp $	*/
+/*	$NetBSD: ahci.c,v 1.30 2022/03/03 06:12:11 riastradh Exp $	*/
 /*-
  * Copyright (c) 2007 Ruslan Ermilov and Vsevolod Lobko.
  * All rights reserved.
+ *
  * 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
 @@ -54,27 +54,27 @@
  * 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.
  */
 /*
  * !! HIGHLY EXPERIMENTAL CODE !!
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ahci.c,v 1.29 2022/03/03 06:04:31 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ahci.c,v 1.30 2022/03/03 06:12:11 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/bus.h>
 #include <machine/cpu.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 @@ -559,26 +559,28 @@ ahci_noop(struct usbd_pipe *pipe)
 static int
 ahci_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req,
     void *buf, int buflen)
+{
 	struct ahci_softc *sc = AHCI_BUS2SC(bus);
 	uint16_t len, value, index;
 	usb_port_status_t ps;
 	int totlen = 0;
 	int status;
 	DPRINTF(D_TRACE, ("SLRCstart "));
 	KASSERT(bus->ub_polling || mutex_owned(bus->ub_lock));
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	index = UGETW(req->wIndex);
 #define C(x,y) ((x) | ((y) << 8))
 	switch (C(req->bRequest, req->bmRequestType)) {
 	case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
 		switch (value) {
 #define sd ((usb_string_descriptor_t *)buf)
 		case C(2, UDESC_STRING):
 			/* Product */
 			totlen = usb_makestrdesc(sd, len, "ADM5120 root hub");
 			break;
 @@ -733,33 +735,33 @@ ahci_root_intr_transfer(struct usbd_xfer
 	DPRINTF(D_TRACE, ("SLRItransfer "));
 	/* Pipe isn't running, start first.  */
 	return ahci_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static usbd_status
 ahci_root_intr_start(struct usbd_xfer *xfer)
+{
 	struct ahci_softc *sc = AHCI_XFER2SC(xfer);
 	DPRINTF(D_TRACE, ("SLRIstart "));
-	mutex_enter(&sc->sc_lock);
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock);
 	KASSERT(sc->sc_intr_xfer == NULL);
 	sc->sc_interval = MS_TO_TICKS(xfer->ux_pipe->up_endpoint->ue_edesc->bInterval);
 	callout_schedule(&sc->sc_poll_handle, sc->sc_interval);
 	sc->sc_intr_xfer = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 ahci_root_intr_abort(struct usbd_xfer *xfer)
+{
 	struct ahci_softc *sc = AHCI_XFER2SC(xfer);
 	DPRINTF(D_TRACE, ("SLRIabort "));
 	KASSERT(mutex_owned(&sc->sc_lock));
 	KASSERT(xfer->ux_pipe->up_intrxfer == xfer);
 @@ -824,31 +826,31 @@ ahci_device_ctrl_transfer(struct usbd_xf
 static usbd_status
 ahci_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	usbd_status status =  USBD_NORMAL_COMPLETION;
 	int s, err;
 	static struct admhcd_ed ep_v __attribute__((aligned(16))), *ep;
 	static struct admhcd_td td_v[4] __attribute__((aligned(16))), *td, *td1, *td2, *td3;
 	static usb_dma_t reqdma;
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	usb_device_request_t *req = &xfer->ux_request;
 	struct ahci_softc *sc = AHCI_XFER2SC(xfer);
 	int len, isread;
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock);
 #if 0
 	struct ahci_pipe *apipe = (struct ahci_pipe *)xfer->ux_pipe;
 #endif
 	mutex_enter(&sc->sc_lock);
 /*	printf("ctrl_start>>>\n"); */
 #ifdef DIAGNOSTIC
 	if (!(xfer->ux_rqflags & URQ_REQUEST)) {
 		/* XXX panic */
 		printf("ahci_device_ctrl_transfer: not a request\n");
 		return USBD_INVAL;
+	}
 #endif
 #define KSEG1ADDR(x) (0xa0000000 | (((uint32_t)x) & 0x1fffffff))
 	DPRINTF(D_TRACE, ("st "));
 	if (!ep) {
 @@ -958,27 +960,26 @@ ahci_device_ctrl_start(struct usbd_xfer
 		};
 		status = USBD_NORMAL_COMPLETION;
 		break;
 	};
 	REG_WRITE(ADMHCD_REG_HOSTCONTROL, ADMHCD_STATE_OP);
 	xfer->ux_actlen = len;
 	xfer->ux_status = status;
 /* 	printf("ctrl_start<<<\n"); */
 	usb_transfer_complete(xfer);
 	mutex_exit(&sc->sc_lock);
 	usb_freemem(&reqdma);
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 ahci_device_ctrl_abort(struct usbd_xfer *xfer)
+{
 	DPRINTF(D_TRACE, ("Cab "));
 	usbd_xfer_abort(xfer);
+}
 @@ -996,31 +997,34 @@ ahci_device_ctrl_done(struct usbd_xfer *
 static usbd_status
 ahci_device_intr_transfer(struct usbd_xfer *xfer)
+{
 	DPRINTF(D_TRACE, ("INTRtrans "));
 	return ahci_device_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static usbd_status
 ahci_device_intr_start(struct usbd_xfer *xfer)
+{
 	struct ahci_softc *sc = AHCI_XFER2SC(xfer);
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	struct ahci_xfer *sx;
 	DPRINTF(D_TRACE, ("INTRstart "));
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock);
 	sx = kmem_intr_alloc(sizeof(*sx), KM_NOSLEEP);
 	if (sx == NULL)
 		goto reterr;
 	memset(sx, 0, sizeof(*sx));
 	sx->sx_xfer = xfer;
 	xfer->ux_hcpriv = sx;
 	/* initialize callout */
 	callout_init(&sx->sx_callout_t, 0);
 	callout_reset(&sx->sx_callout_t,
 		MS_TO_TICKS(pipe->up_endpoint->ue_edesc->bInterval),
 		ahci_poll_device, sx);
 @@ -1146,35 +1150,36 @@ ahci_device_bulk_start(struct usbd_xfer
 	static volatile int level = 0;
 	usbd_status status =  USBD_NORMAL_COMPLETION;
 	int s, err;
 	static struct admhcd_ed ep_v __attribute__((aligned(16))), *ep;
 	static struct admhcd_td td_v[NBULK_TDS] __attribute__((aligned(16))), *td[NBULK_TDS];
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	struct ahci_softc *sc = AHCI_XFER2SC(xfer);
 	int endpt, i, len, tlen, segs, offset, isread, toggle, short_ok;
 	struct ahci_pipe *apipe = (struct ahci_pipe *)xfer->ux_pipe;
 #define KSEG1ADDR(x) (0xa0000000 | (((uint32_t)x) & 0x1fffffff))
 	DPRINTF(D_TRACE, ("st "));
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock);
 #ifdef DIAGNOSTIC
 	if (xfer->ux_rqflags & URQ_REQUEST) {
 		/* XXX panic */
 		printf("ohci_device_bulk_start: a request\n");
 		return USBD_INVAL;
+	}
 #endif
 	mutex_enter(&sc->sc_lock);
 	level++;
 /* 	printf("bulk_start>>>\n"); */
 	if (!ep) {
 		ep = (struct admhcd_ed *)KSEG1ADDR(&ep_v);
 		for (i=0; i<NBULK_TDS; i++) {
 			td[i] = (struct admhcd_td *)KSEG1ADDR(&td_v[i]);
 		};
 /*		printf("ep: %p\n",ep);*/
 	};
 	if (apipe->toggle == 0) {
 		toggle = ADMHCD_TD_DATA0;
 	} else {
 @@ -1281,27 +1286,26 @@ ahci_device_bulk_start(struct usbd_xfer
 		status = USBD_NORMAL_COMPLETION;
 	};
 	xfer->ux_actlen = len;
 	xfer->ux_status = status;
 	level--;
 /*	printf("bulk_start<<<\n"); */
 	if (xfer->ux_length)
 		usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
 		    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 	usb_transfer_complete(xfer);
 	mutex_exit(&sc->sc_lock);
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 ahci_device_bulk_abort(struct usbd_xfer *xfer)
+{
 	DPRINTF(D_TRACE, ("Bab "));
 	usbd_xfer_abort(xfer);
+}
 static void
 ahci_device_bulk_close(struct usbd_pipe *pipe)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sl811hs.c,v 1.109 2022/03/03 06:04:31 riastradh Exp $	*/
+/*	$NetBSD: sl811hs.c,v 1.110 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Not (c) 2007 Matthew Orgass
  * This file is public domain, meaning anyone can make any use of part or all
  * of this file including copying into other works without credit.  Any use,
  * modified or not, is solely the responsibility of the user.  If this file is
  * part of a collection then use in the collection is governed by the terms of
  * the collection.
  */
 /*
  * Cypress/ScanLogic SL811HS/T USB Host Controller
  * Datasheet, Errata, and App Note available at www.cypress.com
 @@ -58,27 +58,27 @@
  */
 /*
  * XXX TODO:
  *   copy next output packet while transfering
  *   usb suspend
  *   could keep track of known values of all buffer space?
  *   combined print/log function for errors
+ *
  *   ub_usepolling support is untested and may not work
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sl811hs.c,v 1.109 2022/03/03 06:04:31 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sl811hs.c,v 1.110 2022/03/03 06:12:11 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_slhci.h"
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/gcq.h>
 #include <sys/intr.h>
 @@ -836,48 +836,44 @@ slhci_get_lock(struct usbd_bus *bus, kmu
+}
 usbd_status
 slhci_transfer(struct usbd_xfer *xfer)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	usbd_status error;
 	DLOG(D_TRACE, "transfer type %jd xfer %#jx spipe %#jx ",
 	    SLHCI_XFER_TYPE(xfer), (uintptr_t)xfer, (uintptr_t)xfer->ux_pipe,
 );
 	/* Pipe isn't running, so start it first.  */
 	/*
 	 * Start will take the lock.
 	 */
 	error = xfer->ux_pipe->up_methods->upm_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
 	return error;
+}
 /* It is not safe for start to return anything other than USBD_INPROG. */
 usbd_status
 slhci_start(struct usbd_xfer *xfer)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct slhci_softc *sc = SLHCI_XFER2SC(xfer);
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	struct slhci_pipe *spipe = SLHCI_PIPE2SPIPE(pipe);
 	struct slhci_transfers *t = &sc->sc_transfers;
 	usb_endpoint_descriptor_t *ed = pipe->up_endpoint->ue_edesc;
 	unsigned int max_packet;
-	mutex_enter(&sc->sc_lock);
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	max_packet = UGETW(ed->wMaxPacketSize);
 	DLOG(D_TRACE, "transfer type %jd start xfer %#jx spipe %#jx length %jd",
 	    spipe->ptype, (uintptr_t)xfer, (uintptr_t)spipe, xfer->ux_length);
 	/* root transfers use slhci_root_start */
 	KASSERT(spipe->xfer == NULL); /* not SLASSERT */
 	xfer->ux_actlen = 0;
 	xfer->ux_status = USBD_IN_PROGRESS;
 @@ -979,56 +975,54 @@ slhci_start(struct usbd_xfer *xfer)
 			xfer->ux_status = USBD_INVAL;
+	}
 	/*
 	 * The datasheet incorrectly indicates that DIRECTION is for
 	 * "transmit to host".  It is for OUT and SETUP.  The app note
 	 * describes its use correctly.
 	 */
 	if ((spipe->tregs[PID] & SL11_PID_BITS) != SL11_PID_IN)
 		spipe->control |= SL11_EPCTRL_DIRECTION;
 	slhci_start_entry(sc, spipe);
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 usbd_status
 slhci_root_start(struct usbd_xfer *xfer)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct slhci_softc *sc;
 	struct slhci_pipe *spipe __diagused;
 	spipe = SLHCI_PIPE2SPIPE(xfer->ux_pipe);
 	sc = SLHCI_XFER2SC(xfer);
 	struct slhci_transfers *t = &sc->sc_transfers;
 	LK_SLASSERT(spipe != NULL && xfer != NULL, sc, spipe, xfer, return
 	    USBD_CANCELLED);
 	DLOG(D_TRACE, "transfer type %jd start",
 	    SLHCI_XFER_TYPE(xfer), 0, 0, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	KASSERT(spipe->ptype == PT_ROOT_INTR);
 	mutex_enter(&sc->sc_intr_lock);
 	KASSERT(t->rootintr == NULL);
 	t->rootintr = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	mutex_exit(&sc->sc_intr_lock);
 	return USBD_IN_PROGRESS;
+}
 usbd_status
 slhci_open(struct usbd_pipe *pipe)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct usbd_device *dev;
 	struct slhci_softc *sc;
 	struct slhci_pipe *spipe;
 	usb_endpoint_descriptor_t *ed;
 	unsigned int max_packet, pmaxpkt;
 @@ -3191,26 +3185,28 @@ slhci_get_status(struct slhci_softc *sc,
 static int
 slhci_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req,
     void *buf, int buflen)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct slhci_softc *sc = SLHCI_BUS2SC(bus);
 	struct slhci_transfers *t = &sc->sc_transfers;
 	usbd_status error = USBD_IOERROR; /* XXX should be STALL */
 	uint16_t len, value, index;
 	uint8_t type;
 	int actlen = 0;
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	index = UGETW(req->wIndex);
 	type = req->bmRequestType;
 	SLHCI_DEXEC(D_TRACE, slhci_log_req(req));
 	/*
 	 * USB requests for hubs have two basic types, standard and class.
 	 * Each could potentially have recipients of device, interface,
 	 * endpoint, or other.  For the hub class, CLASS_OTHER means the port
 	 * and CLASS_DEVICE means the hub.  For standard requests, OTHER

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ehci.c,v 1.304 2022/03/03 06:08:50 riastradh Exp $ */
+/*	$NetBSD: ehci.c,v 1.305 2022/03/03 06:12:11 riastradh Exp $ */
 /*
  * Copyright (c) 2004-2012,2016,2020 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). Matthew R. Green (mrg@eterna.com.au), and
  * Nick Hudson .
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -44,27 +44,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.304 2022/03/03 06:08:50 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ehci.c,v 1.305 2022/03/03 06:12:11 riastradh Exp $");
 #include "ohci.h"
 #include "uhci.h"
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 @@ -2359,26 +2359,28 @@ Static int
 ehci_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req,
     void *buf, int buflen)
+{
 	ehci_softc_t *sc = EHCI_BUS2SC(bus);
 	usb_hub_descriptor_t hubd;
 	usb_port_status_t ps;
 	uint16_t len, value, index;
 	int l, totlen = 0;
 	int port, i;
 	uint32_t v;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	if (sc->sc_dying)
 		return -1;
 	DPRINTF("type=0x%02jx request=%02jx", req->bmRequestType, req->bRequest,
 , 0);
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	index = UGETW(req->wIndex);
 #define C(x,y) ((x) | ((y) << 8))
 	switch (C(req->bRequest, req->bmRequestType)) {
 	case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
 @@ -2747,38 +2749,35 @@ ehci_disown(ehci_softc_t *sc, int index,
 Static usbd_status
 ehci_root_intr_transfer(struct usbd_xfer *xfer)
+{
 	/* Pipe isn't running, start first */
 	return ehci_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 ehci_root_intr_start(struct usbd_xfer *xfer)
+{
 	ehci_softc_t *sc = EHCI_XFER2SC(xfer);
 	const bool polling = sc->sc_bus.ub_usepolling;
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intrxfer == NULL);
 	sc->sc_intrxfer = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 /* Abort a root interrupt request. */
 Static void
 ehci_root_intr_abort(struct usbd_xfer *xfer)
+{
 	ehci_softc_t *sc = EHCI_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	KASSERT(xfer->ux_pipe->up_intrxfer == xfer);
 @@ -3597,30 +3596,30 @@ ehci_device_ctrl_transfer(struct usbd_xf
 	/* Pipe isn't running, start first */
 	return ehci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 ehci_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	struct ehci_pipe *epipe = EHCI_XFER2EPIPE(xfer);
 	struct ehci_xfer *exfer = EHCI_XFER2EXFER(xfer);
 	usb_device_request_t *req = &xfer->ux_request;
 	ehci_softc_t *sc = EHCI_XFER2SC(xfer);
 	ehci_soft_qtd_t *setup, *status, *next;
 	ehci_soft_qh_t *sqh;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	KASSERT(xfer->ux_rqflags & URQ_REQUEST);
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	const int isread = req->bmRequestType & UT_READ;
 	const int len = UGETW(req->wLength);
 	DPRINTF("type=0x%02jx, request=0x%02jx, wValue=0x%04jx, wIndex=0x%04jx",
 	    req->bmRequestType, req->bRequest, UGETW(req->wValue),
 	    UGETW(req->wIndex));
 	DPRINTF("len=%jd, addr=%jd, endpt=%jd",
 	    len, epipe->pipe.up_dev->ud_addr,
 @@ -3719,36 +3718,31 @@ ehci_device_ctrl_start(struct usbd_xfer
 	 usb_syncmem(&status->dma, status->offs, sizeof(status->qtd),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	KASSERT(status->qtd.qtd_status & htole32(EHCI_QTD_TOGGLE_MASK));
 #ifdef EHCI_DEBUG
 	DPRINTFN(5, "--- dump start ---", 0, 0, 0, 0);
 	ehci_dump_sqh(sqh);
 	ehci_dump_sqtds(setup);
 	DPRINTFN(5, "--- dump end ---", 0, 0, 0, 0);
 #endif
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	/* Insert qTD in QH list - also does usb_syncmem(sqh) */
 	ehci_set_qh_qtd(sqh, setup);
 	usbd_xfer_schedule_timeout(xfer);
 	ehci_add_intr_list(sc, exfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 #if 0
 #ifdef EHCI_DEBUG
 	DPRINTFN(10, "status=%jx, dump:", EOREAD4(sc, EHCI_USBSTS), 0, 0, 0);
 //	delay(10000);
 	ehci_dump_regs(sc);
 	ehci_dump_sqh(sc->sc_async_head);
 	ehci_dump_sqh(sqh);
 	ehci_dump_sqtds(setup);
 #endif
 #endif
 	return USBD_IN_PROGRESS;
 @@ -3868,78 +3862,73 @@ ehci_device_bulk_transfer(struct usbd_xf
 	/* 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(struct usbd_xfer *xfer)
+{
 	struct ehci_pipe *epipe = EHCI_XFER2EPIPE(xfer);
 	struct ehci_xfer *exfer = EHCI_XFER2EXFER(xfer);
 	ehci_softc_t *sc = EHCI_XFER2SC(xfer);
 	ehci_soft_qh_t *sqh;
 	ehci_soft_qtd_t *end;
 	int len, isread, endpt;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	DPRINTF("xfer=%#jx len=%jd flags=%jd", (uintptr_t)xfer, xfer->ux_length,
 	    xfer->ux_flags, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	KASSERT(xfer->ux_length <= xfer->ux_bufsize);
 	len = xfer->ux_length;
 	endpt = epipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	sqh = epipe->sqh;
 	KASSERT(exfer->ex_isdone);
 #ifdef DIAGNOSTIC
 	exfer->ex_isdone = false;
 #endif
 	/* Take lock here to protect nexttoggle */
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	ehci_reset_sqtd_chain(sc, xfer, len, isread, &epipe->nexttoggle, &end);
 	exfer->ex_sqtdend = end;
 	end->qtd.qtd_status |= htole32(EHCI_QTD_IOC);
 	usb_syncmem(&end->dma, end->offs, sizeof(end->qtd),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 #ifdef EHCI_DEBUG
 	DPRINTFN(5, "--- dump start ---", 0, 0, 0, 0);
 	ehci_dump_sqh(sqh);
 	ehci_dump_sqtds(exfer->ex_sqtdstart);
 	DPRINTFN(5, "--- dump end ---", 0, 0, 0, 0);
 #endif
 	if (xfer->ux_length)
 		usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
 		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	/* also does usb_syncmem(sqh) */
 	ehci_set_qh_qtd(sqh, exfer->ex_sqtdstart);
 	usbd_xfer_schedule_timeout(xfer);
 	ehci_add_intr_list(sc, exfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 #if 0
 #ifdef EHCI_DEBUG
 	DPRINTFN(5, "data(2)", 0, 0, 0, 0);
 //	delay(10000);
 	DPRINTFN(5, "data(3)", 0, 0, 0, 0);
 	ehci_dump_regs(sc);
 #if 0
 	printf("async_head:\n");
 	ehci_dump_sqh(sc->sc_async_head);
 #endif
 	DPRINTF("sqh:", 0, 0, 0, 0);
 	ehci_dump_sqh(sqh);
 @@ -4072,78 +4061,73 @@ ehci_device_intr_transfer(struct usbd_xf
 	/* Pipe isn't running, so start it first.  */
 	return ehci_device_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 ehci_device_intr_start(struct usbd_xfer *xfer)
+{
 	struct ehci_pipe *epipe = EHCI_XFER2EPIPE(xfer);
 	struct ehci_xfer *exfer = EHCI_XFER2EXFER(xfer);
 	ehci_softc_t *sc = EHCI_XFER2SC(xfer);
 	ehci_soft_qtd_t *end;
 	ehci_soft_qh_t *sqh;
 	int len, isread, endpt;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	DPRINTF("xfer=%#jx len=%jd flags=%jd", (uintptr_t)xfer, xfer->ux_length,
 	    xfer->ux_flags, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	KASSERT(xfer->ux_length <= xfer->ux_bufsize);
 	len = xfer->ux_length;
 	endpt = epipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	sqh = epipe->sqh;
 	KASSERT(exfer->ex_isdone);
 #ifdef DIAGNOSTIC
 	exfer->ex_isdone = false;
 #endif
 	/* Take lock to protect nexttoggle */
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	ehci_reset_sqtd_chain(sc, xfer, len, isread, &epipe->nexttoggle, &end);
 	end->qtd.qtd_status |= htole32(EHCI_QTD_IOC);
 	usb_syncmem(&end->dma, end->offs, sizeof(end->qtd),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	exfer->ex_sqtdend = end;
 #ifdef EHCI_DEBUG
 	DPRINTFN(5, "--- dump start ---", 0, 0, 0, 0);
 	ehci_dump_sqh(sqh);
 	ehci_dump_sqtds(exfer->ex_sqtdstart);
 	DPRINTFN(5, "--- dump end ---", 0, 0, 0, 0);
 #endif
 	if (xfer->ux_length)
 		usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
 		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	/* also does usb_syncmem(sqh) */
 	ehci_set_qh_qtd(sqh, exfer->ex_sqtdstart);
 	usbd_xfer_schedule_timeout(xfer);
 	ehci_add_intr_list(sc, exfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 #if 0
 #ifdef EHCI_DEBUG
 	DPRINTFN(5, "data(2)", 0, 0, 0, 0);
 //	delay(10000);
 	DPRINTFN(5, "data(3)", 0, 0, 0, 0);
 	ehci_dump_regs(sc);
 	DPRINTFN(5, "sqh:", 0, 0, 0, 0);
 	ehci_dump_sqh(sqh);
 	ehci_dump_sqtds(exfer->ex_sqtdstart);
 #endif
 #endif
 @@ -4315,26 +4299,28 @@ ehci_device_fs_isoc_transfer(struct usbd
 	usb_dma_t *dma_buf;
 	int i, j, k, frames;
 	int offs;
 	int frindex;
 	u_int dir;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	sitd = NULL;
 	DPRINTF("xfer %#jx len %jd flags %jd", (uintptr_t)xfer, xfer->ux_length,
 	    xfer->ux_flags, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	/*
 	 * To avoid complication, don't allow a request right now that'll span
 	 * the entire frame table. To within 4 frames, to allow some leeway
 	 * on either side of where the hc currently is.
 	 */
 	if (epipe->pipe.up_endpoint->ue_edesc->bInterval *
 			xfer->ux_nframes >= sc->sc_flsize - 4) {
 		printf("ehci: isoc descriptor requested that spans the entire"
 		    "frametable, too many frames\n");
 		return USBD_INVAL;
 @@ -4448,28 +4434,26 @@ ehci_device_fs_isoc_transfer(struct usbd
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	if (xfer->ux_length)
 		usb_syncmem(&exfer->ex_xfer.ux_dmabuf, 0, xfer->ux_length,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	/*
 	 * Part 2: Transfer descriptors have now been set up, now they must
 	 * be scheduled into the periodic frame list. Erk. Not wanting to
 	 * complicate matters, transfer is denied if the transfer spans
 	 * more than the period frame list.
 	 */
 	mutex_enter(&sc->sc_lock);
 	/* Start inserting frames */
 	if (epipe->isoc.cur_xfers > 0) {
 		frindex = epipe->isoc.next_frame;
 	} else {
 		frindex = EOREAD4(sc, EHCI_FRINDEX);
 		frindex = frindex >> 3; /* Erase microframe index */
 		frindex += 2;
+	}
 	if (frindex >= sc->sc_flsize)
 		frindex &= (sc->sc_flsize - 1);
 	/* Whats the frame interval? */
 @@ -4512,27 +4496,26 @@ ehci_device_fs_isoc_transfer(struct usbd
 		sitd->slot = frindex;
 		sitd->frame_list.prev = NULL;
 		frindex += i;
 		if (frindex >= sc->sc_flsize)
 			frindex -= sc->sc_flsize;
+	}
 	epipe->isoc.cur_xfers++;
 	epipe->isoc.next_frame = frindex;
 	ehci_add_intr_list(sc, exfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 Static void
 ehci_device_fs_isoc_abort(struct usbd_xfer *xfer)
+{
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	DPRINTF("xfer = %#jx", (uintptr_t)xfer, 0, 0, 0);
 	ehci_abort_isoc_xfer(xfer, USBD_CANCELLED);
+}
 @@ -4680,26 +4663,28 @@ ehci_device_isoc_transfer(struct usbd_xf
 	int i, j;
 	int frames, uframes, ufrperframe;
 	int trans_count, offs;
 	int frindex;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	prev = NULL;
 	itd = NULL;
 	trans_count = 0;
 	DPRINTF("xfer %#jx flags %jd", (uintptr_t)xfer, xfer->ux_flags, 0, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	/*
 	 * To avoid complication, don't allow a request right now that'll span
 	 * the entire frame table. To within 4 frames, to allow some leeway
 	 * on either side of where the hc currently is.
 	 */
 	if ((1 << (epipe->pipe.up_endpoint->ue_edesc->bInterval)) *
 			xfer->ux_nframes >= (sc->sc_flsize - 4) * 8) {
 		DPRINTF(
 		    "isoc descriptor spans entire frametable", 0, 0, 0, 0);
 		printf("ehci: isoc descriptor requested that spans the entire frametable, too many frames\n");
 @@ -4826,28 +4811,26 @@ ehci_device_isoc_transfer(struct usbd_xf
 	} /* End of frame */
 	if (xfer->ux_length)
 		usb_syncmem(&exfer->ex_xfer.ux_dmabuf, 0, xfer->ux_length,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	/*
 	 * Part 2: Transfer descriptors have now been set up, now they must
 	 * be scheduled into the period frame list. Erk. Not wanting to
 	 * complicate matters, transfer is denied if the transfer spans
 	 * more than the period frame list.
 	 */
 	mutex_enter(&sc->sc_lock);
 	/* Start inserting frames */
 	if (epipe->isoc.cur_xfers > 0) {
 		frindex = epipe->isoc.next_frame;
 	} else {
 		frindex = EOREAD4(sc, EHCI_FRINDEX);
 		frindex = frindex >> 3; /* Erase microframe index */
 		frindex += 2;
+	}
 	if (frindex >= sc->sc_flsize)
 		frindex &= (sc->sc_flsize - 1);
 	/* What's the frame interval? */
 @@ -4895,27 +4878,26 @@ ehci_device_isoc_transfer(struct usbd_xf
 		frindex += i;
 		if (frindex >= sc->sc_flsize)
 			frindex -= sc->sc_flsize;
 		itd = itd->xfer_next;
+	}
 	epipe->isoc.cur_xfers++;
 	epipe->isoc.next_frame = frindex;
 	ehci_add_intr_list(sc, exfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 Static void
 ehci_device_isoc_abort(struct usbd_xfer *xfer)
+{
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	DPRINTF("xfer = %#jx", (uintptr_t)xfer, 0, 0, 0);
 	ehci_abort_isoc_xfer(xfer, USBD_CANCELLED);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: motg.c,v 1.39 2022/03/03 06:08:50 riastradh Exp $	*/
+/*	$NetBSD: motg.c,v 1.40 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Copyright (c) 1998, 2004, 2011, 2012, 2014 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),
  * Matthew R. Green (mrg@eterna.com.au), and Manuel Bouyer (bouyer@netbsd.org).
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -30,27 +30,27 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * This file contains the driver for the Mentor Graphics Inventra USB
  * 2.0 High Speed Dual-Role controller.
+ *
  * NOTE: The current implementation only supports Device Side Mode!
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: motg.c,v 1.39 2022/03/03 06:08:50 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: motg.c,v 1.40 2022/03/03 06:12:11 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #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/proc.h>
 @@ -796,26 +796,28 @@ motg_get_lock(struct usbd_bus *bus, kmut
 Static int
 motg_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req,
     void *buf, int buflen)
+{
 	struct motg_softc *sc = MOTG_BUS2SC(bus);
 	int status, change, totlen = 0;
 	uint16_t len, value, index;
 	usb_port_status_t ps;
 	usbd_status err;
 	uint32_t val;
 	MOTGHIST_FUNC(); MOTGHIST_CALLED();
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	if (sc->sc_dying)
 		return -1;
 	DPRINTFN(MD_ROOT, "type=0x%02jx request=%02jx", req->bmRequestType,
 	    req->bRequest, 0, 0);
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	index = UGETW(req->wIndex);
 #define C(x,y) ((x) | ((y) << 8))
 	switch (C(req->bRequest, req->bmRequestType)) {
 	case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
 @@ -1010,43 +1012,40 @@ usbd_status
 motg_root_intr_transfer(struct usbd_xfer *xfer)
+{
 	/* Pipe isn't running, start first */
 	return motg_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 /* Start a transfer on the root interrupt pipe */
 usbd_status
 motg_root_intr_start(struct usbd_xfer *xfer)
+{
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	struct motg_softc *sc = MOTG_PIPE2SC(pipe);
 	const bool polling = sc->sc_bus.ub_usepolling;
 	MOTGHIST_FUNC(); MOTGHIST_CALLED();
 	DPRINTFN(MD_ROOT, "xfer=%#jx len=%jd flags=%jd", (uintptr_t)xfer,
 	    xfer->ux_length, xfer->ux_flags, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intr_xfer == NULL);
 	sc->sc_intr_xfer = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 /* Close the root interrupt pipe. */
 void
 motg_root_intr_close(struct usbd_pipe *pipe)
+{
 	struct motg_softc *sc __diagused = MOTG_PIPE2SC(pipe);
 	MOTGHIST_FUNC(); MOTGHIST_CALLED();
 	KASSERT(mutex_owned(&sc->sc_lock));
 @@ -1266,31 +1265,30 @@ motg_setup_endpoint_rx(struct usbd_xfer
 static usbd_status
 motg_device_ctrl_transfer(struct usbd_xfer *xfer)
+{
 	/* Pipe isn't running, so start it first.  */
 	return motg_device_ctrl_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static usbd_status
 motg_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	struct motg_softc *sc = MOTG_XFER2SC(xfer);
 	usbd_status err;
-	mutex_enter(&sc->sc_lock);
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	err = motg_device_ctrl_start1(sc);
-	mutex_exit(&sc->sc_lock);
+	return motg_device_ctrl_start1(sc);
 	return err;
+}
 static usbd_status
 motg_device_ctrl_start1(struct motg_softc *sc)
+{
 	struct motg_hw_ep *ep = &sc->sc_in_ep[0];
 	struct usbd_xfer *xfer = NULL;
 	struct motg_pipe *otgpipe;
 	usbd_status err = 0;
 	MOTGHIST_FUNC(); MOTGHIST_CALLED();
 	KASSERT(mutex_owned(&sc->sc_lock));
 @@ -1707,35 +1705,34 @@ static usbd_status
 motg_device_data_transfer(struct usbd_xfer *xfer)
+{
 	MOTGHIST_FUNC(); MOTGHIST_CALLED();
 	/* Pipe isn't running, so start it first.  */
 	return motg_device_data_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static usbd_status
 motg_device_data_start(struct usbd_xfer *xfer)
+{
 	struct motg_softc *sc = MOTG_XFER2SC(xfer);
 	struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe);
 	usbd_status err;
 	MOTGHIST_FUNC(); MOTGHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	DPRINTF("xfer %#jx status %jd", (uintptr_t)xfer, xfer->ux_status, 0, 0);
 	err = motg_device_data_start1(sc, otgpipe->hw_ep);
-	mutex_exit(&sc->sc_lock);
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	return err;
 	return motg_device_data_start1(sc, otgpipe->hw_ep);
+}
 static usbd_status
 motg_device_data_start1(struct motg_softc *sc, struct motg_hw_ep *ep)
+{
 	struct usbd_xfer *xfer = NULL;
 	struct motg_pipe *otgpipe;
 	usbd_status err = 0;
 	uint32_t val __diagused;
 	MOTGHIST_FUNC(); MOTGHIST_CALLED();
 	KASSERT(mutex_owned(&sc->sc_lock));

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ohci.c,v 1.320 2022/03/03 06:08:50 riastradh Exp $	*/
+/*	$NetBSD: ohci.c,v 1.321 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Copyright (c) 1998, 2004, 2005, 2012, 2016, 2020 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),
  * Matthew R. Green (mrg@eterna.com.au), and Nick Hudson.
+ *
  * 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.320 2022/03/03 06:08:50 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.321 2022/03/03 06:12:11 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #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>
 @@ -2421,26 +2421,28 @@ dying:
 Static int
 ohci_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req,
     void *buf, int buflen)
+{
 	ohci_softc_t *sc = OHCI_BUS2SC(bus);
 	usb_port_status_t ps;
 	uint16_t len, value, index;
 	int l, totlen = 0;
 	int port, i;
 	uint32_t v;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	if (sc->sc_dying)
 		return -1;
 	DPRINTFN(4, "type=0x%02jx request=%02jx", req->bmRequestType,
 	    req->bRequest, 0, 0);
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	index = UGETW(req->wIndex);
 #define C(x,y) ((x) | ((y) << 8))
 	switch (C(req->bRequest, req->bmRequestType)) {
 	case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
 @@ -2610,38 +2612,35 @@ ohci_roothub_ctrl(struct usbd_bus *bus,
 Static usbd_status
 ohci_root_intr_transfer(struct usbd_xfer *xfer)
+{
 	/* Pipe isn't running, start first */
 	return ohci_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 ohci_root_intr_start(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	const bool polling = sc->sc_bus.ub_usepolling;
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intrxfer == NULL);
 	sc->sc_intrxfer = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 /* Abort a root interrupt request. */
 Static void
 ohci_root_intr_abort(struct usbd_xfer *xfer)
+{
 	ohci_softc_t *sc = OHCI_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	KASSERT(xfer->ux_pipe->up_intrxfer == xfer);
 @@ -2767,48 +2766,45 @@ ohci_device_ctrl_transfer(struct usbd_xf
 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;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(xfer->ux_rqflags & URQ_REQUEST);
 	isread = req->bmRequestType & UT_READ;
 	len = UGETW(req->wLength);
 	DPRINTF("xfer=%#jx len=%jd, addr=%jd, endpt=%jd", (uintptr_t)xfer, len,
 	    dev->ud_addr, opipe->pipe.up_endpoint->ue_edesc->bEndpointAddress);
 	DPRINTF("type=0x%02jx, request=0x%02jx, wValue=0x%04jx, wIndex=0x%04jx",
 	    req->bmRequestType, req->bRequest, UGETW(req->wValue),
 	    UGETW(req->wIndex));
 	/* Need to take lock here for pipe->tail.td */
 	if (!polling)
 		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;
 	setup->held = &ox->ox_setup;
 	DPRINTFN(10, "xfer=%#jx new setup=%#jx held at %#jx", (uintptr_t)ox,
 	    (uintptr_t)setup, (uintptr_t)setup->held, 0);
 	stat = ox->ox_stat;
 @@ -2923,28 +2919,26 @@ ohci_device_ctrl_start(struct usbd_xfer
 	/* 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);
 	usbd_xfer_schedule_timeout(xfer);
 	DPRINTF("done", 0, 0, 0, 0);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	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();
 @@ -3044,47 +3038,45 @@ ohci_device_bulk_transfer(struct usbd_xf
 	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;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	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=%#jx len=%jd isread=%jd flags=%jd", (uintptr_t)xfer,
 	    len, isread, xfer->ux_flags);
 	DPRINTFN(4, "endpt=%jd", endpt, 0, 0, 0);
 	if (!polling)
 		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;
 	data->held = &ox->ox_stds[0];
 	ohci_reset_std_chain(sc, xfer, len, isread, data, &last);
 	DPRINTFN(10, "xfer=%#jx new data=%#jx held at %#jx",
 	    (uintptr_t)ox, (uintptr_t)data, (uintptr_t)data->held, 0);
 	/* point at sentinel */
 @@ -3131,28 +3123,26 @@ ohci_device_bulk_start(struct usbd_xfer
 	/* 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);
 	usbd_xfer_schedule_timeout(xfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		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));
 @@ -3242,45 +3232,43 @@ ohci_device_intr_transfer(struct usbd_xf
 	/* 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;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	DPRINTFN(3, "xfer=%#jx len=%jd flags=%jd priv=%#jx", (uintptr_t)xfer,
 	    xfer->ux_length, xfer->ux_flags, (uintptr_t)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;
 	if (!polling)
 		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;
 	data->held = &ox->ox_stds[0];
 	ohci_reset_std_chain(sc, xfer, len, isread, data, &last);
 	DPRINTFN(10, "xfer=%#jx new data=%#jx held at %#jx",
 	    (uintptr_t)ox, (uintptr_t)data, (uintptr_t)data->held, 0);
 	/* point at sentinel */
 @@ -3317,28 +3305,26 @@ ohci_device_intr_start(struct usbd_xfer
+	}
 	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);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		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));
 	usbd_xfer_abort(xfer);
 @@ -3549,32 +3535,30 @@ ohci_device_isoc_enter(struct usbd_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, bp0, bp1;
 	int i, ncur, nframes;
 	size_t boff, frlen;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(5, "xfer=%#jx", (uintptr_t)xfer, 0, 0, 0);
-	mutex_enter(&sc->sc_lock);
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
-	if (sc->sc_dying) {
+	if (sc->sc_dying)
 		mutex_exit(&sc->sc_lock);
 		return;
 	struct isoc *isoc = &opipe->isoc;
 	DPRINTFN(1, "used=%jd next=%jd xfer=%#jx nframes=%jd",
 	     isoc->inuse, isoc->next, (uintptr_t)xfer, xfer->ux_nframes);
 	int isread =
 	    (UE_GET_DIR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress) == UE_DIR_IN);
 	if (xfer->ux_length)
 		usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
 		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 @@ -3713,27 +3697,26 @@ ohci_device_isoc_enter(struct usbd_xfer
 , 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=%#jx", (uintptr_t)xfer, 0, 0, 0);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uhci.c,v 1.310 2022/03/03 06:08:50 riastradh Exp $	*/
+/*	$NetBSD: uhci.c,v 1.311 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Copyright (c) 1998, 2004, 2011, 2012, 2016, 2020 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),
  * Matthew R. Green (mrg@eterna.com.au) and Nick Hudson.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -32,27 +32,27 @@
  */
 /*
  * USB Universal Host Controller driver.
  * Handles e.g. PIIX3 and PIIX4.
+ *
  * UHCI spec: http://www.intel.com/technology/usb/spec.htm
  * USB spec: http://www.usb.org/developers/docs/
  * PIIXn spec: ftp://download.intel.com/design/intarch/datashts/29055002.pdf
  *             ftp://download.intel.com/design/intarch/datashts/29056201.pdf
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uhci.c,v 1.310 2022/03/03 06:08:50 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uhci.c,v 1.311 2022/03/03 06:12:11 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #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>
 @@ -2261,50 +2261,47 @@ uhci_device_bulk_transfer(struct usbd_xf
 	/* Pipe isn't running, so start it first.  */
 	return uhci_device_bulk_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 usbd_status
 uhci_device_bulk_start(struct usbd_xfer *xfer)
+{
 	struct uhci_pipe *upipe = UHCI_PIPE2UPIPE(xfer->ux_pipe);
 	struct uhci_xfer *ux = UHCI_XFER2UXFER(xfer);
 	uhci_softc_t *sc = UHCI_XFER2SC(xfer);
 	uhci_soft_td_t *data, *dataend;
 	uhci_soft_qh_t *sqh;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	int len;
 	int endpt;
 	int isread;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	DPRINTFN(3, "xfer=%#jx len=%jd flags=%jd", (uintptr_t)xfer,
 	    xfer->ux_length, xfer->ux_flags, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	KASSERT(xfer->ux_length <= xfer->ux_bufsize);
 	len = xfer->ux_length;
 	endpt = upipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	sqh = upipe->bulk.sqh;
 	/* Take lock here to protect nexttoggle */
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	uhci_reset_std_chain(sc, xfer, len, isread, &upipe->nexttoggle,
 	    &dataend);
 	data = ux->ux_stdstart;
 	ux->ux_stdend = dataend;
 	dataend->td.td_status |= htole32(UHCI_TD_IOC);
 	usb_syncmem(&dataend->dma,
 	    dataend->offs + offsetof(uhci_td_t, td_status),
 	    sizeof(dataend->td.td_status),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 #ifdef UHCI_DEBUG
 	if (uhcidebug >= 10) {
 @@ -2318,28 +2315,26 @@ uhci_device_bulk_start(struct usbd_xfer
 	KASSERT(ux->ux_isdone);
 #ifdef DIAGNOSTIC
 	ux->ux_isdone = false;
 #endif
 	sqh->elink = data;
 	sqh->qh.qh_elink = htole32(data->physaddr | UHCI_PTR_TD);
 	/* uhci_add_bulk() will do usb_syncmem(sqh) */
 	uhci_add_bulk(sc, sqh);
 	uhci_add_intr_list(sc, ux);
 	usbd_xfer_schedule_timeout(xfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 /* Abort a device bulk request. */
 void
 uhci_device_bulk_abort(struct usbd_xfer *xfer)
+{
 	uhci_softc_t *sc __diagused = UHCI_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 @@ -2485,57 +2480,55 @@ uhci_device_ctrl_transfer(struct usbd_xf
 usbd_status
 uhci_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	uhci_softc_t *sc = UHCI_XFER2SC(xfer);
 	struct uhci_xfer *uxfer = UHCI_XFER2UXFER(xfer);
 	struct uhci_pipe *upipe = UHCI_PIPE2UPIPE(xfer->ux_pipe);
 	usb_device_request_t *req = &xfer->ux_request;
 	struct usbd_device *dev = upipe->pipe.up_dev;
 	int addr = dev->ud_addr;
 	int endpt = upipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 	uhci_soft_td_t *setup, *stat, *next, *dataend;
 	uhci_soft_qh_t *sqh;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	int len;
 	int isread;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(xfer->ux_rqflags & URQ_REQUEST);
 	DPRINTFN(3, "type=0x%02jx, request=0x%02jx, "
 	    "wValue=0x%04jx, wIndex=0x%04jx",
 	    req->bmRequestType, req->bRequest, UGETW(req->wValue),
 	    UGETW(req->wIndex));
 	DPRINTFN(3, "len=%jd, addr=%jd, endpt=%jd",
 	    UGETW(req->wLength), dev->ud_addr, endpt, 0);
 	isread = req->bmRequestType & UT_READ;
 	len = UGETW(req->wLength);
 	setup = upipe->ctrl.setup;
 	stat = upipe->ctrl.stat;
 	sqh = upipe->ctrl.sqh;
 	memcpy(KERNADDR(&upipe->ctrl.reqdma, 0), req, sizeof(*req));
 	usb_syncmem(&upipe->ctrl.reqdma, 0, sizeof(*req), BUS_DMASYNC_PREWRITE);
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	/* Set up data transaction */
 	if (len != 0) {
 		upipe->nexttoggle = 1;
 		next = uxfer->ux_data;
 		uhci_reset_std_chain(sc, xfer, len, isread,
 		    &upipe->nexttoggle, &dataend);
 		dataend->link.std = stat;
 		dataend->td.td_link = htole32(stat->physaddr | UHCI_PTR_TD);
 		usb_syncmem(&dataend->dma,
 		    dataend->offs + offsetof(uhci_td_t, td_link),
 		    sizeof(dataend->td.td_link),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	} else {
 @@ -2613,28 +2606,26 @@ uhci_device_ctrl_start(struct usbd_xfer
 		     xqh != NULL;
 		     xqh = (maxqh++ == 5 || xqh->hlink == sxqh ||
 			xqh->hlink == xqh ? NULL : xqh->hlink)) {
 			uhci_dump_qh(xqh);
+		}
 		DPRINTFN(12, "Enqueued QH:", 0, 0, 0, 0);
 		uhci_dump_qh(sqh);
 		uhci_dump_tds(sqh->elink);
 		DPRINTF("--- dump end ---", 0, 0, 0, 0);
+	}
 #endif
 	usbd_xfer_schedule_timeout(xfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 int
 uhci_device_intr_init(struct usbd_xfer *xfer)
+{
 	uhci_softc_t *sc = UHCI_XFER2SC(xfer);
 	struct uhci_xfer *ux = UHCI_XFER2UXFER(xfer);
 	usb_endpoint_descriptor_t *ed = xfer->ux_pipe->up_endpoint->ue_edesc;
 	int endpt = ed->bEndpointAddress;
 	int isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	int len = xfer->ux_bufsize;
 @@ -2675,54 +2666,53 @@ uhci_device_intr_transfer(struct usbd_xf
 	/* Pipe isn't running, so start it first.  */
 	return uhci_device_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 usbd_status
 uhci_device_intr_start(struct usbd_xfer *xfer)
+{
 	struct uhci_xfer *ux = UHCI_XFER2UXFER(xfer);
 	struct uhci_pipe *upipe = UHCI_PIPE2UPIPE(xfer->ux_pipe);
 	uhci_softc_t *sc = UHCI_XFER2SC(xfer);
 	uhci_soft_td_t *data, *dataend;
 	uhci_soft_qh_t *sqh;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	int isread, endpt;
 	int i;
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	DPRINTFN(3, "xfer=%#jx len=%jd flags=%jd", (uintptr_t)xfer,
 	    xfer->ux_length, xfer->ux_flags, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	KASSERT(xfer->ux_length <= xfer->ux_bufsize);
 	endpt = upipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	data = ux->ux_stdstart;
 	KASSERT(ux->ux_isdone);
 #ifdef DIAGNOSTIC
 	ux->ux_isdone = false;
 #endif
 	/* Take lock to protect nexttoggle */
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	uhci_reset_std_chain(sc, xfer, xfer->ux_length, isread,
 	    &upipe->nexttoggle, &dataend);
 	dataend->td.td_status |= htole32(UHCI_TD_IOC);
 	usb_syncmem(&dataend->dma,
 	    dataend->offs + offsetof(uhci_td_t, td_status),
 	    sizeof(dataend->td.td_status),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	ux->ux_stdend = dataend;
 #ifdef UHCI_DEBUG
 	if (uhcidebug >= 10) {
 		DPRINTF("--- dump start ---", 0, 0, 0, 0);
 @@ -2734,28 +2724,26 @@ uhci_device_intr_start(struct usbd_xfer
 	DPRINTFN(10, "qhs[0]=%#jx", (uintptr_t)upipe->intr.qhs[0], 0, 0, 0);
 	for (i = 0; i < upipe->intr.npoll; i++) {
 		sqh = upipe->intr.qhs[i];
 		sqh->elink = data;
 		sqh->qh.qh_elink = htole32(data->physaddr | UHCI_PTR_TD);
 		usb_syncmem(&sqh->dma,
 		    sqh->offs + offsetof(uhci_qh_t, qh_elink),
 		    sizeof(sqh->qh.qh_elink),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
+	}
 	uhci_add_intr_list(sc, ux);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 #ifdef UHCI_DEBUG
 	if (uhcidebug >= 10) {
 		DPRINTF("--- dump start ---", 0, 0, 0, 0);
 		uhci_dump_tds(data);
 		uhci_dump_qh(upipe->intr.qhs[0]);
 		DPRINTF("--- dump end ---", 0, 0, 0, 0);
+	}
 #endif
 	return USBD_IN_PROGRESS;
+}
 @@ -2844,26 +2832,28 @@ uhci_device_isoc_fini(struct usbd_xfer *
 	struct uhci_xfer *ux __diagused = UHCI_XFER2UXFER(xfer);
 	KASSERT(ux->ux_type == UX_ISOC);
+}
 usbd_status
 uhci_device_isoc_transfer(struct usbd_xfer *xfer)
+{
 	uhci_softc_t *sc = UHCI_XFER2SC(xfer);
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	DPRINTFN(5, "xfer=%#jx", (uintptr_t)xfer, 0, 0, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	/* insert into schedule, */
 	struct uhci_pipe *upipe = UHCI_PIPE2UPIPE(xfer->ux_pipe);
 	struct uhci_xfer *ux = UHCI_XFER2UXFER(xfer);
 	struct isoc *isoc = &upipe->isoc;
 	uhci_soft_td_t *std = NULL;
 	uint32_t buf, len, status, offs;
 	int i, next, nframes;
 	int rd = UE_GET_DIR(upipe->pipe.up_endpoint->ue_edesc->bEndpointAddress) == UE_DIR_IN;
 	DPRINTFN(5, "used=%jd next=%jd xfer=%#jx nframes=%jd",
 	    isoc->inuse, isoc->next, (uintptr_t)xfer, xfer->ux_nframes);
 @@ -2877,27 +2867,26 @@ uhci_device_isoc_transfer(struct usbd_xf
+	}
 #ifdef DIAGNOSTIC
 	if (isoc->inuse >= UHCI_VFRAMELIST_COUNT)
 		printf("%s: overflow!\n", __func__);
 #endif
 	KASSERT(xfer->ux_nframes != 0);
 	if (xfer->ux_length)
 		usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
 		    rd ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	mutex_enter(&sc->sc_lock);
 	next = isoc->next;
 	if (next == -1) {
 		/* Not in use yet, schedule it a few frames ahead. */
 		next = (UREAD2(sc, UHCI_FRNUM) + 3) % UHCI_VFRAMELIST_COUNT;
 		DPRINTFN(2, "start next=%jd", next, 0, 0, 0);
+	}
 	xfer->ux_status = USBD_IN_PROGRESS;
 	ux->ux_curframe = next;
 	offs = 0;
 	status = UHCI_TD_ZERO_ACTLEN(UHCI_TD_SET_ERRCNT(0) |
 				     UHCI_TD_ACTIVE |
 @@ -2939,28 +2928,26 @@ uhci_device_isoc_transfer(struct usbd_xf
 	isoc->next = next;
 	isoc->inuse += xfer->ux_nframes;
 	/* Set up interrupt info. */
 	ux->ux_stdstart = std;
 	ux->ux_stdend = std;
 	KASSERT(ux->ux_isdone);
 #ifdef DIAGNOSTIC
 	ux->ux_isdone = false;
 #endif
 	uhci_add_intr_list(sc, ux);
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 void
 uhci_device_isoc_abort(struct usbd_xfer *xfer)
+{
 	uhci_softc_t *sc = UHCI_XFER2SC(xfer);
 	struct uhci_pipe *upipe = UHCI_PIPE2UPIPE(xfer->ux_pipe);
 	struct uhci_xfer *ux = UHCI_XFER2UXFER(xfer);
 	uhci_soft_td_t **stds = upipe->isoc.stds;
 	uhci_soft_td_t *std;
 	int i, n, nframes, maxlen, len;
 @@ -3592,26 +3579,28 @@ uhci_portreset(uhci_softc_t *sc, int ind
 Static int
 uhci_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req,
     void *buf, int buflen)
+{
 	uhci_softc_t *sc = UHCI_BUS2SC(bus);
 	int port, x;
 	int status, change, totlen = 0;
 	uint16_t len, value, index;
 	usb_port_status_t ps;
 	usbd_status err;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	if (sc->sc_dying)
 		return -1;
 	DPRINTF("type=0x%02jx request=%02jx", req->bmRequestType,
 	    req->bRequest, 0, 0);
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	index = UGETW(req->wIndex);
 #define C(x,y) ((x) | ((y) << 8))
 	switch (C(req->bRequest, req->bmRequestType)) {
 	case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
 @@ -3843,50 +3832,45 @@ uhci_root_intr_transfer(struct usbd_xfer
+{
 	/* Pipe isn't running, start first */
 	return uhci_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 /* Start a transfer on the root interrupt pipe */
 usbd_status
 uhci_root_intr_start(struct usbd_xfer *xfer)
+{
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	uhci_softc_t *sc = UHCI_PIPE2SC(pipe);
 	unsigned int ival;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	DPRINTF("xfer=%#jx len=%jd flags=%jd", (uintptr_t)xfer, xfer->ux_length,
 	    xfer->ux_flags, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intr_xfer == NULL);
 	/* XXX temporary variable needed to avoid gcc3 warning */
 	ival = xfer->ux_pipe->up_endpoint->ue_edesc->bInterval;
 	sc->sc_ival = mstohz(ival);
 	callout_schedule(&sc->sc_poll_handle, sc->sc_ival);
 	sc->sc_intr_xfer = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 /* Close the root interrupt pipe. */
 void
 uhci_root_intr_close(struct usbd_pipe *pipe)
+{
 	uhci_softc_t *sc __diagused = UHCI_PIPE2SC(pipe);
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	KASSERT(mutex_owned(&sc->sc_lock));
 	/*

 @@ -1,14 +1,14 @@
-/*	$NetBSD: usbdi.c,v 1.230 2022/03/03 06:09:57 riastradh Exp $	*/
+/*	$NetBSD: usbdi.c,v 1.231 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Copyright (c) 1998, 2012, 2015 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, Matthew R. Green (mrg@eterna.com.au),
  * and Nick Hudson.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -22,27 +22,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: usbdi.c,v 1.230 2022/03/03 06:09:57 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: usbdi.c,v 1.231 2022/03/03 06:12:11 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #include "opt_compat_netbsd.h"
 #include "usb_dma.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 @@ -412,33 +412,34 @@ usbd_transfer(struct usbd_xfer *xfer)
 	/* xfer is not valid after the transfer method unless synchronous */
 	SDT_PROBE2(usb, device, pipe, transfer__start,  pipe, xfer);
 	do {
 #ifdef DIAGNOSTIC
 		xfer->ux_state = XFER_ONQU;
 #endif
 		SIMPLEQ_INSERT_TAIL(&pipe->up_queue, xfer, ux_next);
 		if (pipe->up_running && pipe->up_serialise) {
 			err = USBD_IN_PROGRESS;
 		} else {
 			pipe->up_running = 1;
 			err = USBD_NORMAL_COMPLETION;
+		}
 		usbd_unlock_pipe(pipe);
 		if (err)
 			break;
 		err = pipe->up_methods->upm_transfer(xfer);
 	} while (0);
 	SDT_PROBE3(usb, device, pipe, transfer__done,  pipe, xfer, err);
 	usbd_unlock_pipe(pipe);
 	if (err != USBD_IN_PROGRESS && err) {
 		/*
 		 * The transfer made it onto the pipe queue, but didn't get
 		 * accepted by the HCD for some reason.  It needs removing
 		 * from the pipe queue.
 		 */
 		USBHIST_LOG(usbdebug, "xfer failed: %jd, reinserting",
 		    err, 0, 0, 0);
 		usbd_lock_pipe(pipe);
 		SDT_PROBE1(usb, device, xfer, preabort,  xfer);
 #ifdef DIAGNOSTIC
 		xfer->ux_state = XFER_BUSY;
 #endif
 @@ -1180,32 +1181,28 @@ usbd_start_next(struct usbd_pipe *pipe)
 	KASSERT(pipe->up_methods->upm_start != NULL);
 	KASSERT(pipe->up_serialise == true);
 	int polling = pipe->up_dev->ud_bus->ub_usepolling;
 	KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
 	/* Get next request in queue. */
 	xfer = SIMPLEQ_FIRST(&pipe->up_queue);
 	USBHIST_CALLARGS(usbdebug, "pipe = %#jx, xfer = %#jx", (uintptr_t)pipe,
 	    (uintptr_t)xfer, 0, 0);
 	if (xfer == NULL) {
 		pipe->up_running = 0;
 	} else {
 		if (!polling)
 			mutex_exit(pipe->up_dev->ud_bus->ub_lock);
 		SDT_PROBE2(usb, device, pipe, start,  pipe, xfer);
 		err = pipe->up_methods->upm_start(xfer);
 		if (!polling)
 			mutex_enter(pipe->up_dev->ud_bus->ub_lock);
 		if (err != USBD_IN_PROGRESS) {
 			USBHIST_LOG(usbdebug, "error = %jd", err, 0, 0, 0);
 			pipe->up_running = 0;
 			/* XXX do what? */
+		}
+	}
 	KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
+}
 usbd_status
 usbd_do_request(struct usbd_device *dev, usb_device_request_t *req, void *data)

 @@ -1,14 +1,14 @@
-/* $NetBSD: usbroothub.c,v 1.12 2022/03/03 06:04:31 riastradh Exp $ */
+/* $NetBSD: usbroothub.c,v 1.13 2022/03/03 06:12:11 riastradh Exp $ */
 /*-
  * Copyright (c) 1998, 2004, 2011, 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),
  * Matthew R. Green (mrg@eterna.com.au) and Nick Hudson.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -48,27 +48,27 @@
  * 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 AUTHOR 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.
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: usbroothub.c,v 1.12 2022/03/03 06:04:31 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: usbroothub.c,v 1.13 2022/03/03 06:12:11 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>		/* for ostype */
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdivar.h>
 #include <dev/usb/usbroothub.h>
 #include <dev/usb/usbhist.h>
 /* helper functions for USB root hub emulation */
 static usbd_status	roothub_ctrl_transfer(struct usbd_xfer *);
 @@ -351,26 +351,33 @@ roothub_ctrl_transfer(struct usbd_xfer *
 static usbd_status
 roothub_ctrl_start(struct usbd_xfer *xfer)
+{
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	struct usbd_bus *bus = pipe->up_dev->ud_bus;
 	usb_device_request_t *req;
 	usbd_status err = USBD_IOERROR;		/* XXX STALL? */
 	uint16_t len, value;
 	int buflen, actlen = -1;
 	void *buf;
 	USBHIST_FUNC();
 	/*
 	 * XXX Should really assert pipe lock, in case ever have
 	 * per-pipe locking instead of using the bus lock for all
 	 * pipes.
 	 */
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	KASSERT(xfer->ux_rqflags & URQ_REQUEST);
 	req = &xfer->ux_request;
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	USBHIST_CALLARGS(usbdebug, "type=%#jx request=%#jx len=%#jx value=%#jx",
 	    req->bmRequestType, req->bRequest, len, value);
 	buf = len ? usbd_get_buffer(xfer) : NULL;
 	buflen = 0;
 #define C(x,y) ((x) | ((y) << 8))
 @@ -544,29 +551,27 @@ roothub_ctrl_start(struct usbd_xfer *xfe
 	actlen = bus->ub_methods->ubm_rhctrl(bus, req, buf, buflen);
 	if (actlen < 0)
 		goto fail;
 	xfer->ux_actlen = actlen;
 	err = USBD_NORMAL_COMPLETION;
  fail:
 	USBHIST_LOG(usbdebug, "xfer %#jx buflen %jd actlen %jd err %jd",
 	    (uintptr_t)xfer, buflen, actlen, err);
 	xfer->ux_status = err;
 	mutex_enter(bus->ub_lock);
 	usb_transfer_complete(xfer);
 	mutex_exit(bus->ub_lock);
 	return USBD_NORMAL_COMPLETION;
+}
 /* Abort a root control request. */
 Static void
 roothub_ctrl_abort(struct usbd_xfer *xfer)
+{
 	/* Nothing to do, all transfers are synchronous. */
+}
 /* Close the root pipe. */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vhci.c,v 1.24 2022/03/03 06:04:31 riastradh Exp $ */
+/*	$NetBSD: vhci.c,v 1.25 2022/03/03 06:12:11 riastradh Exp $ */
 /*
  * Copyright (c) 2019-2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Maxime Villard.
+ *
  * 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.
 @@ -20,27 +20,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vhci.c,v 1.24 2022/03/03 06:04:31 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vhci.c,v 1.25 2022/03/03 06:12:11 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 @@ -595,60 +595,55 @@ vhci_device_ctrl_transfer(struct usbd_xf
 	/* Pipe isn't running, start first */
 	return vhci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static usbd_status
 vhci_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	usb_endpoint_descriptor_t *ed = xfer->ux_pipe->up_endpoint->ue_edesc;
 	usb_device_request_t *req = &xfer->ux_request;
 	struct usbd_device *dev = xfer->ux_pipe->up_dev;
 	vhci_softc_t *sc = xfer->ux_bus->ub_hcpriv;
 	vhci_port_t *port;
 	bool polling = sc->sc_bus.ub_usepolling;
 	bool isread = (req->bmRequestType & UT_READ) != 0;
 	uint8_t addr = UE_GET_ADDR(ed->bEndpointAddress);
 	int portno, ret;
 	KASSERT(addr == 0);
 	KASSERT(xfer->ux_rqflags & URQ_REQUEST);
 	KASSERT(dev->ud_myhsport != NULL);
 	portno = dev->ud_myhsport->up_portno;
 	DPRINTF("%s: type=0x%02x, len=%d, isread=%d, portno=%d\n",
 	    __func__, req->bmRequestType, UGETW(req->wLength), isread, portno);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	port = &sc->sc_port[portno];
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	mutex_enter(&port->lock);
 	if (port->status & UPS_PORT_ENABLED) {
 		xfer->ux_status = USBD_IN_PROGRESS;
 		vhci_pkt_ctrl_create(port, xfer, isread, addr);
 		ret = USBD_IN_PROGRESS;
 	} else {
 		ret = USBD_IOERROR;
+	}
 	mutex_exit(&port->lock);
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return ret;
+}
 static void
 vhci_device_ctrl_abort(struct usbd_xfer *xfer)
+{
 	vhci_xfer_t *vxfer = (vhci_xfer_t *)xfer;
 	vhci_softc_t *sc = xfer->ux_bus->ub_hcpriv;
 	vhci_port_t *port = vxfer->port;
 	vhci_packet_t *pkt;
 	DPRINTF("%s: called\n", __func__);
 @@ -699,40 +694,37 @@ static usbd_status
 vhci_root_intr_transfer(struct usbd_xfer *xfer)
+{
 	DPRINTF("%s: called\n", __func__);
 	/* Pipe isn't running, start first */
 	return vhci_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static usbd_status
 vhci_root_intr_start(struct usbd_xfer *xfer)
+{
 	vhci_softc_t *sc = xfer->ux_bus->ub_hcpriv;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	DPRINTF("%s: called, len=%zu\n", __func__, (size_t)xfer->ux_length);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intrxfer == NULL);
 	sc->sc_intrxfer = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 vhci_root_intr_abort(struct usbd_xfer *xfer)
+{
 	vhci_softc_t *sc = xfer->ux_bus->ub_hcpriv;
 	DPRINTF("%s: called\n", __func__);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	KASSERT(xfer->ux_pipe->up_intrxfer == xfer);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: xhci.c,v 1.157 2022/03/03 06:08:50 riastradh Exp $	*/
+/*	$NetBSD: xhci.c,v 1.158 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Copyright (c) 2013 Jonathan A. Kollasch
  * All rights reserved.
+ *
  * 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.
 @@ -24,27 +24,27 @@
  * 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 rev 2.0 and rev 3.1 specification
  *  http://www.usb.org/developers/docs/
  * xHCI rev 1.1 specification
  *  http://www.intel.com/technology/usb/spec.htm
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: xhci.c,v 1.157 2022/03/03 06:08:50 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xhci.c,v 1.158 2022/03/03 06:12:11 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/device.h>
 #include <sys/select.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 @@ -2176,27 +2176,26 @@ xhci_host_dequeue(struct xhci_ring * con
  * Issue RESET_EP to recover halt condition and SET_TR_DEQUEUE to remove
  * all transfers on transfer ring.
  * These are done in thread context asynchronously.
  */
 static void
 xhci_pipe_async_task(void *cookie)
+{
 	struct xhci_pipe * const xp = cookie;
 	struct usbd_pipe * const pipe = &xp->xp_pipe;
 	struct xhci_softc * const sc = XHCI_PIPE2SC(pipe);
 	struct xhci_slot * const xs = pipe->up_dev->ud_hcpriv;
 	const u_int dci = xhci_ep_get_dci(pipe->up_endpoint->ue_edesc);
 	struct xhci_ring * const tr = xs->xs_xr[dci];
 	bool restart = false;
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("pipe %#jx slot %ju dci %ju",
 	    (uintptr_t)pipe, xs->xs_idx, dci, 0);
 	mutex_enter(&sc->sc_lock);
 	/*
 	 * - If the endpoint is halted, indicating a stall, reset it.
 	 * - If the endpoint is stopped, we're already good.
 	 * - Otherwise, someone wanted to abort the pipe, so stop the
 	 *   endpoint.
+	 *
 @@ -2217,51 +2216,38 @@ xhci_pipe_async_task(void *cookie)
 		break;
 	case XHCI_EPSTATE_ERROR:
 		device_printf(sc->sc_dev, "endpoint 0x%x error\n",
 		    pipe->up_endpoint->ue_edesc->bEndpointAddress);
 		break;
 	default:
 		device_printf(sc->sc_dev, "endpoint 0x%x failed to stop\n",
 		    pipe->up_endpoint->ue_edesc->bEndpointAddress);
+	}
 	xhci_set_dequeue(pipe);
 	/*
 	 * If we halted our own queue because it stalled, mark it no
-	 * longer halted and arrange to start it up again.
+	 * longer halted and start issuing queued transfers again.
 	 */
 	if (tr->is_halted) {
 		struct usbd_xfer *xfer = SIMPLEQ_FIRST(&pipe->up_queue);
 		tr->is_halted = false;
-		if (!SIMPLEQ_EMPTY(&pipe->up_queue))
+		if (xfer)
-			restart = true;
+			(*pipe->up_methods->upm_start)(xfer);
+	}
 	mutex_exit(&sc->sc_lock);
 	/*
 	 * If the endpoint was stalled, start issuing queued transfers
 	 * again.
 	 */
 	if (restart) {
 		/*
 		 * XXX Shouldn't touch the queue unlocked -- upm_start
 		 * should be called with the lock held instead.  The
 		 * pipe could be aborted at this point, and the xfer
 		 * freed.
 		 */
 		struct usbd_xfer *xfer = SIMPLEQ_FIRST(&pipe->up_queue);
 		(*pipe->up_methods->upm_start)(xfer);
 	DPRINTFN(4, "ends", 0, 0, 0, 0);
+}
 static void
 xhci_pipe_restart(struct usbd_pipe *pipe)
+{
 	struct xhci_pipe * const xp =
 	    container_of(pipe, struct xhci_pipe, xp_pipe);
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("pipe %#jx", (uintptr_t)pipe, 0, 0, 0);
 	usb_add_task(pipe->up_dev, &xp->xp_async_task, USB_TASKQ_HC);
 @@ -3860,26 +3846,28 @@ xhci_noop(struct usbd_pipe *pipe)
 static int
 xhci_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req,
     void *buf, int buflen)
+{
 	struct xhci_softc * const sc = XHCI_BUS2SC(bus);
 	usb_port_status_t ps;
 	int l, totlen = 0;
 	uint16_t len, value, index;
 	int port, i;
 	uint32_t v;
 	XHCIHIST_FUNC();
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	if (sc->sc_dying)
 		return -1;
 	size_t bn = bus == &sc->sc_bus ? 0 : 1;
 	len = UGETW(req->wLength);
 	value = UGETW(req->wValue);
 	index = UGETW(req->wIndex);
 	XHCIHIST_CALLARGS("rhreq: %04jx %04jx %04jx %04jx",
 	    req->bmRequestType | (req->bRequest << 8), value, index, len);
 #define C(x,y) ((x) | ((y) << 8))
 @@ -4129,40 +4117,37 @@ xhci_root_intr_transfer(struct usbd_xfer
+{
 	XHCIHIST_FUNC(); XHCIHIST_CALLED();
 	/* Pipe isn't running, start first */
 	return xhci_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 /* Wait for roothub port status/change */
 static usbd_status
 xhci_root_intr_start(struct usbd_xfer *xfer)
+{
 	struct xhci_softc * const sc = XHCI_XFER2SC(xfer);
 	const size_t bn = XHCI_XFER2BUS(xfer) == &sc->sc_bus ? 0 : 1;
 	const bool polling = xhci_polling_p(sc);
 	XHCIHIST_FUNC(); XHCIHIST_CALLED();
 	KASSERT(xhci_polling_p(sc) || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intrxfer[bn] == NULL);
 	sc->sc_intrxfer[bn] = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 xhci_root_intr_abort(struct usbd_xfer *xfer)
+{
 	struct xhci_softc * const sc = XHCI_XFER2SC(xfer);
 	const size_t bn = XHCI_XFER2BUS(xfer) == &sc->sc_bus ? 0 : 1;
 	XHCIHIST_FUNC(); XHCIHIST_CALLED();
 	KASSERT(mutex_owned(&sc->sc_lock));
 @@ -4240,34 +4225,34 @@ xhci_device_ctrl_start(struct usbd_xfer
 	const uint32_t len = UGETW(req->wLength);
 	usb_dma_t * const dma = &xfer->ux_dmabuf;
 	uint64_t parameter;
 	uint32_t status;
 	uint32_t control;
 	u_int i;
 	const bool polling = xhci_polling_p(sc);
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("req: %04jx %04jx %04jx %04jx",
 	    req->bmRequestType | (req->bRequest << 8), UGETW(req->wValue),
 	    UGETW(req->wIndex), UGETW(req->wLength));
 	KASSERT(polling || mutex_owned(&sc->sc_lock));
 	/* we rely on the bottom bits for extra info */
 	KASSERTMSG(((uintptr_t)xfer & 0x3) == 0x0, "xfer %zx",
 	    (uintptr_t) xfer);
 	KASSERT((xfer->ux_rqflags & URQ_REQUEST) != 0);
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	if (tr->is_halted)
 		goto out;
 	i = 0;
 	/* setup phase */
 	parameter = le64dec(req); /* to keep USB endian after xhci_trb_put() */
 	status = XHCI_TRB_2_IRQ_SET(0) | XHCI_TRB_2_BYTES_SET(sizeof(*req));
 	control = ((len == 0) ? XHCI_TRB_3_TRT_NONE :
 	     (isread ? XHCI_TRB_3_TRT_IN : XHCI_TRB_3_TRT_OUT)) |
 	    XHCI_TRB_3_TYPE_SET(XHCI_TRB_TYPE_SETUP_STAGE) |
 	    XHCI_TRB_3_IDT_BIT;
 	xhci_xfer_put_trb(xx, i++, parameter, status, control);
 @@ -4305,28 +4290,26 @@ xhci_device_ctrl_start(struct usbd_xfer
 	xhci_db_write_4(sc, XHCI_DOORBELL(xs->xs_idx), dci);
 out:	if (xfer->ux_status == USBD_NOT_STARTED) {
 		usbd_xfer_schedule_timeout(xfer);
 		xfer->ux_status = USBD_IN_PROGRESS;
 	} else {
 		/*
 		 * We must be coming from xhci_pipe_restart -- timeout
 		 * already set up, nothing to do.
 		 */
+	}
 	KASSERT(xfer->ux_status == USBD_IN_PROGRESS);
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 xhci_device_ctrl_done(struct usbd_xfer *xfer)
+{
 	XHCIHIST_FUNC(); XHCIHIST_CALLED();
 	usb_device_request_t *req = &xfer->ux_request;
 	int len = UGETW(req->wLength);
 	int rd = req->bmRequestType & UT_READ;
 	if (len)
 @@ -4378,26 +4361,28 @@ xhci_device_isoc_enter(struct usbd_xfer
 	uint32_t mfindex;
 	uint32_t offs;
 	int i, ival;
 	const bool polling = xhci_polling_p(sc);
 	const uint16_t MPS = UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize);
 	const uint16_t mps = UE_GET_SIZE(MPS);
 	const uint8_t maxb = xpipe->xp_maxb;
 	u_int tdpc, tbc, tlbpc;
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("%#jx slot %ju dci %ju",
 	    (uintptr_t)xfer, xs->xs_idx, dci, 0);
 	KASSERT(polling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(xfer->ux_nframes != 0 && xfer->ux_frlengths);
 	KASSERT((xfer->ux_rqflags & URQ_REQUEST) == 0);
 	const bool isread = usbd_xfer_isread(xfer);
 	if (xfer->ux_length)
 		usb_syncmem(dma, 0, xfer->ux_length,
 		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	ival = xfer->ux_pipe->up_endpoint->ue_edesc->bInterval;
 	if (ival >= 1 && ival <= 16)
 @@ -4450,33 +4435,29 @@ xhci_device_isoc_enter(struct usbd_xfer
 		xpipe->xp_isoc_next += ival;
 		offs += len;
+	}
 	xx->xx_isoc_done = 0;
 	if (!polling)
 		mutex_enter(&tr->xr_lock);
 	xhci_ring_put_xfer(sc, tr, xx, i);
 	if (!polling)
 		mutex_exit(&tr->xr_lock);
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	xhci_db_write_4(sc, XHCI_DOORBELL(xs->xs_idx), dci);
 	usbd_xfer_schedule_timeout(xfer);
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 xhci_device_isoc_abort(struct usbd_xfer *xfer)
+{
 	XHCIHIST_FUNC(); XHCIHIST_CALLED();
 	usbd_xfer_abort(xfer);
+}
 static void
 @@ -4526,33 +4507,33 @@ xhci_device_bulk_start(struct usbd_xfer
 	struct xhci_xfer * const xx = XHCI_XFER2XXFER(xfer);
 	const uint32_t len = xfer->ux_length;
 	usb_dma_t * const dma = &xfer->ux_dmabuf;
 	uint64_t parameter;
 	uint32_t status;
 	uint32_t control;
 	u_int i = 0;
 	const bool polling = xhci_polling_p(sc);
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("%#jx slot %ju dci %ju",
 	    (uintptr_t)xfer, xs->xs_idx, dci, 0);
 	KASSERT(polling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT((xfer->ux_rqflags & URQ_REQUEST) == 0);
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	if (tr->is_halted)
 		goto out;
 	parameter = DMAADDR(dma, 0);
 	const bool isread = usbd_xfer_isread(xfer);
 	if (len)
 		usb_syncmem(dma, 0, len,
 		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	/*
 	 * XXX: (dsl) The physical buffer must not cross a 64k boundary.
 	 * If the user supplied buffer crosses such a boundary then 2
 	 * (or more) TRB should be used.
 @@ -4580,28 +4561,26 @@ xhci_device_bulk_start(struct usbd_xfer
 	xhci_db_write_4(sc, XHCI_DOORBELL(xs->xs_idx), dci);
 out:	if (xfer->ux_status == USBD_NOT_STARTED) {
 		xfer->ux_status = USBD_IN_PROGRESS;
 		usbd_xfer_schedule_timeout(xfer);
 	} else {
 		/*
 		 * We must be coming from xhci_pipe_restart -- timeout
 		 * already set up, nothing to do.
 		 */
+	}
 	KASSERT(xfer->ux_status == USBD_IN_PROGRESS);
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 xhci_device_bulk_done(struct usbd_xfer *xfer)
+{
 #ifdef USB_DEBUG
 	struct xhci_slot * const xs = xfer->ux_pipe->up_dev->ud_hcpriv;
 	const u_int dci = xhci_ep_get_dci(xfer->ux_pipe->up_endpoint->ue_edesc);
 #endif
 	const bool isread = usbd_xfer_isread(xfer);
 @@ -4651,31 +4630,31 @@ xhci_device_intr_start(struct usbd_xfer
 	struct xhci_xfer * const xx = XHCI_XFER2XXFER(xfer);
 	const uint32_t len = xfer->ux_length;
 	const bool polling = xhci_polling_p(sc);
 	usb_dma_t * const dma = &xfer->ux_dmabuf;
 	uint64_t parameter;
 	uint32_t status;
 	uint32_t control;
 	u_int i = 0;
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("%#jx slot %ju dci %ju",
 	    (uintptr_t)xfer, xs->xs_idx, dci, 0);
 	KASSERT(polling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	if (tr->is_halted)
 		goto out;
 	KASSERT((xfer->ux_rqflags & URQ_REQUEST) == 0);
 	const bool isread = usbd_xfer_isread(xfer);
 	if (len)
 		usb_syncmem(dma, 0, len,
 		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	parameter = DMAADDR(dma, 0);
 	KASSERTMSG(len <= 0x10000, "len %d", len);
 	status = XHCI_TRB_2_IRQ_SET(0) |
 @@ -4693,28 +4672,26 @@ xhci_device_intr_start(struct usbd_xfer
 	xhci_db_write_4(sc, XHCI_DOORBELL(xs->xs_idx), dci);
 out:	if (xfer->ux_status == USBD_NOT_STARTED) {
 		xfer->ux_status = USBD_IN_PROGRESS;
 		usbd_xfer_schedule_timeout(xfer);
 	} else {
 		/*
 		 * We must be coming from xhci_pipe_restart -- timeout
 		 * already set up, nothing to do.
 		 */
+	}
 	KASSERT(xfer->ux_status == USBD_IN_PROGRESS);
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 xhci_device_intr_done(struct usbd_xfer *xfer)
+{
 	struct xhci_softc * const sc __diagused = XHCI_XFER2SC(xfer);
 #ifdef USB_DEBUG
 	struct xhci_slot * const xs = xfer->ux_pipe->up_dev->ud_hcpriv;
 	const u_int dci = xhci_ep_get_dci(xfer->ux_pipe->up_endpoint->ue_edesc);
 #endif
 	const bool isread = usbd_xfer_isread(xfer);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: dwc2.c,v 1.79 2022/03/03 06:08:50 riastradh Exp $	*/
+/*	$NetBSD: dwc2.c,v 1.80 2022/03/03 06:12:11 riastradh Exp $	*/
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Nick Hudson
+ *
  * 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.
 @@ -20,27 +20,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: dwc2.c,v 1.79 2022/03/03 06:08:50 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dwc2.c,v 1.80 2022/03/03 06:12:11 riastradh 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>
 @@ -610,40 +610,37 @@ Static usbd_status
 dwc2_root_intr_transfer(struct usbd_xfer *xfer)
+{
 	DPRINTF("\n");
 	/* Pipe isn't running, start first */
 	return dwc2_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 dwc2_root_intr_start(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
 	const bool polling = sc->sc_bus.ub_usepolling;
 	DPRINTF("\n");
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	if (!polling)
 		mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_intrxfer == NULL);
 	sc->sc_intrxfer = xfer;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 /* Abort a root interrupt request. */
 Static void
 dwc2_root_intr_abort(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc __diagused = DWC2_XFER2SC(xfer);
 	DPRINTF("xfer=%p\n", xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 @@ -699,37 +696,33 @@ dwc2_device_ctrl_transfer(struct usbd_xf
+{
 	DPRINTF("\n");
 	/* Pipe isn't running, start first */
 	return dwc2_device_ctrl_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 dwc2_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
 	usbd_status err;
 	const bool polling = sc->sc_bus.ub_usepolling;
 	DPRINTF("\n");
-	if (!polling)
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 		mutex_enter(&sc->sc_lock);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	err = dwc2_device_start(xfer);
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	if (err)
 		return err;
 	return USBD_IN_PROGRESS;
+}
 Static void
 dwc2_device_ctrl_abort(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc __diagused = DWC2_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 @@ -750,38 +743,32 @@ dwc2_device_ctrl_close(struct usbd_pipe
 Static void
 dwc2_device_ctrl_done(struct usbd_xfer *xfer)
+{
 	DPRINTF("xfer=%p\n", xfer);
+}
 /***********************************************************************/
 Static usbd_status
 dwc2_device_bulk_transfer(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
 	usbd_status err;
 	DPRINTF("xfer=%p\n", xfer);
 	mutex_enter(&sc->sc_lock);
 	KASSERT(xfer->ux_status == USBD_NOT_STARTED);
 	xfer->ux_status = USBD_IN_PROGRESS;
-	err = dwc2_device_start(xfer);
+	return dwc2_device_start(xfer);
 	mutex_exit(&sc->sc_lock);
 	return err;
+}
 Static void
 dwc2_device_bulk_abort(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc __diagused = DWC2_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTF("xfer=%p\n", xfer);
 	usbd_xfer_abort(xfer);
+}
 @@ -810,35 +797,31 @@ dwc2_device_intr_transfer(struct usbd_xf
 	DPRINTF("xfer=%p\n", xfer);
 	/* Pipe isn't running, start first */
 	return dwc2_device_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 Static usbd_status
 dwc2_device_intr_start(struct usbd_xfer *xfer)
+{
 	struct dwc2_pipe *dpipe = DWC2_XFER2DPIPE(xfer)
 	struct usbd_device *dev = dpipe->pipe.up_dev;
 	struct dwc2_softc *sc = dev->ud_bus->ub_hcpriv;
 	usbd_status err;
 	const bool polling = sc->sc_bus.ub_usepolling;
-	if (!polling)
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 		mutex_enter(&sc->sc_lock);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	err = dwc2_device_start(xfer);
 	if (!polling)
 		mutex_exit(&sc->sc_lock);
 	if (err)
 		return err;
 	return USBD_IN_PROGRESS;
+}
 /* Abort a device interrupt request. */
 Static void
 dwc2_device_intr_abort(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc __diagused = DWC2_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 @@ -858,38 +841,32 @@ dwc2_device_intr_close(struct usbd_pipe
 Static void
 dwc2_device_intr_done(struct usbd_xfer *xfer)
+{
 	DPRINTF("\n");
+}
 /***********************************************************************/
 usbd_status
 dwc2_device_isoc_transfer(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
 	usbd_status err;
 	DPRINTF("xfer=%p\n", xfer);
 	mutex_enter(&sc->sc_lock);
 	KASSERT(xfer->ux_status == USBD_NOT_STARTED);
 	xfer->ux_status = USBD_IN_PROGRESS;
-	err = dwc2_device_start(xfer);
+	return dwc2_device_start(xfer);
 	mutex_exit(&sc->sc_lock);
 	return err;
+}
 void
 dwc2_device_isoc_abort(struct usbd_xfer *xfer)
+{
 	struct dwc2_softc *sc __diagused = DWC2_XFER2SC(xfer);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTF("xfer=%p\n", xfer);
 	usbd_xfer_abort(xfer);
+}
 void
 @@ -923,26 +900,28 @@ dwc2_device_start(struct usbd_xfer *xfer
 	uint8_t xfertype = UE_GET_XFERTYPE(ed->bmAttributes);
 	uint8_t epnum = UE_GET_ADDR(ed->bEndpointAddress);
 	uint8_t dir = UE_GET_DIR(ed->bEndpointAddress);
 	uint16_t mps = UE_GET_SIZE(UGETW(ed->wMaxPacketSize));
 	uint32_t len;
 	uint32_t flags = 0;
 	uint32_t off = 0;
 	int retval, err;
 	int alloc_bandwidth = 0;
 	DPRINTFN(1, "xfer=%p pipe=%p\n", xfer, xfer->ux_pipe);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (xfertype == UE_ISOCHRONOUS ||
 	    xfertype == UE_INTERRUPT) {
 		mutex_spin_enter(&hsotg->lock);
 		if (!dwc2_hcd_is_bandwidth_allocated(hsotg, xfer))
 			alloc_bandwidth = 1;
 		mutex_spin_exit(&hsotg->lock);
+	}
 	/*
 	 * For Control pipe the direction is from the request, all other
 	 * transfers have been set correctly at pipe open time.
 	 */
 	if (xfertype == UE_CONTROL) {
 @@ -1111,29 +1090,27 @@ dwc2_device_start(struct usbd_xfer *xfer
 	/* might need to check cpu_intr_p */
 	mutex_spin_enter(&hsotg->lock);
 	retval = dwc2_hcd_urb_enqueue(hsotg, dwc2_urb, qh, qtd);
 	if (retval)
 		goto fail2;
 	usbd_xfer_schedule_timeout(xfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	if (alloc_bandwidth) {
 		dwc2_allocate_bus_bandwidth(hsotg,
 				dwc2_hcd_get_ep_bandwidth(hsotg, dpipe),
 				xfer);
+	}
 	mutex_spin_exit(&hsotg->lock);
 // 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
 fail2:
 	dwc2_urb->priv = NULL;
 	mutex_spin_exit(&hsotg->lock);
 	pool_cache_put(sc->sc_qtdpool, qtd);
 fail1:
 	if (qh_allocated) {
 		dpipe->priv = NULL;
 		dwc2_hcd_qh_free(hsotg, qh);
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ugenhc.c,v 1.30 2022/03/03 06:04:31 riastradh Exp $	*/
+/*	$NetBSD: ugenhc.c,v 1.31 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Copyright (c) 2009, 2010 Antti Kantee.  All Rights Reserved.
+ *
  * 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.
+ *
 @@ -51,27 +51,27 @@
  * 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.
  */
 /*
  * This rump driver attaches ugen as a kernel usb host controller.
  * It's still somewhat under the hammer ....
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ugenhc.c,v 1.30 2022/03/03 06:04:31 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ugenhc.c,v 1.31 2022/03/03 06:12:11 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/fcntl.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/kthread.h>
 #include <sys/mutex.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 @@ -217,26 +217,28 @@ ugenhc_roothub_ctrl(struct usbd_bus *bus
+}
 static usbd_status
 rumpusb_device_ctrl_start(struct usbd_xfer *xfer)
+{
 	usb_device_request_t *req = &xfer->ux_request;
 	struct ugenhc_softc *sc = UGENHC_XFER2SC(xfer);
 	uint8_t *buf = NULL;
 	int len, totlen;
 	int value;
 	int err = 0;
 	int ru_error, mightfail = 0;
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	len = totlen = UGETW(req->wLength);
 	if (len)
 		buf = xfer->ux_buf;
 	value = UGETW(req->wValue);
 #define C(x,y) ((x) | ((y) << 8))
 	switch(C(req->bRequest, req->bmRequestType)) {
 	case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
 		switch (value>>8) {
 		case UDESC_DEVICE:
+			{
 			usb_device_descriptor_t uddesc;
 			totlen = uimin(len, USB_DEVICE_DESCRIPTOR_SIZE);
 @@ -381,29 +383,27 @@ rumpusb_device_ctrl_start(struct usbd_xf
+		}
+		}
 		break;
 	default:
 		panic("unhandled request");
 		break;
+	}
 	xfer->ux_actlen = totlen;
 	err = USBD_NORMAL_COMPLETION;
  ret:
 	xfer->ux_status = err;
 	mutex_enter(&sc->sc_lock);
 	usb_transfer_complete(xfer);
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static usbd_status
 rumpusb_device_ctrl_transfer(struct usbd_xfer *xfer)
+{
 	return rumpusb_device_ctrl_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static void
 rumpusb_device_ctrl_abort(struct usbd_xfer *xfer)
 @@ -506,35 +506,35 @@ rhscintr(void *arg)
 		kpause("ugwait3", false, hz, NULL);
+	}
 	kthread_exit(0);
+}
 static usbd_status
 rumpusb_root_intr_start(struct usbd_xfer *xfer)
+{
 	struct ugenhc_softc *sc = UGENHC_XFER2SC(xfer);
 	int error;
-	mutex_enter(&sc->sc_lock);
+	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	sc->sc_intrxfer = xfer;
 	if (!sc->sc_rhintr) {
 		error = kthread_create(PRI_NONE, 0, NULL,
 		    rhscintr, sc, &sc->sc_rhintr, "ugenrhi");
 		if (error)
 			xfer->ux_status = USBD_IOERROR;
+	}
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static usbd_status
 rumpusb_root_intr_transfer(struct usbd_xfer *xfer)
+{
 	return rumpusb_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
+}
 static void
 rumpusb_root_intr_abort(struct usbd_xfer *xfer)
 @@ -571,26 +571,28 @@ static const struct usbd_pipe_methods ru
 static usbd_status
 rumpusb_device_bulk_start(struct usbd_xfer *xfer)
+{
 	struct ugenhc_softc *sc = UGENHC_XFER2SC(xfer);
 	usb_endpoint_descriptor_t *ed = xfer->ux_pipe->up_endpoint->ue_edesc;
 	size_t n, done;
 	bool isread;
 	int len, error, endpt;
 	uint8_t *buf;
 	int xfererr = USBD_NORMAL_COMPLETION;
 	int shortval, i;
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	ed = xfer->ux_pipe->up_endpoint->ue_edesc;
 	endpt = ed->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	endpt = UE_GET_ADDR(endpt);
 	KASSERT(endpt < UGEN_NEPTS);
 	buf = xfer->ux_buf;
 	done = 0;
 	if ((ed->bmAttributes & UE_XFERTYPE) == UE_ISOCHRONOUS) {
 		for (i = 0, len = 0; i < xfer->ux_nframes; i++)
 			len += xfer->ux_frlengths[i];
 	} else {
 		KASSERT(xfer->ux_length);
 @@ -657,44 +659,40 @@ rumpusb_device_bulk_start(struct usbd_xf
+	}
 	if (RUSB(xfer)->rusb_status == 0) {
 		xfer->ux_actlen = done;
 	} else {
 		xfererr = USBD_CANCELLED;
 		RUSB(xfer)->rusb_status = 2;
+	}
  out:
 	if ((ed->bmAttributes & UE_XFERTYPE) == UE_ISOCHRONOUS)
 		if (done != len)
 			panic("lazy bum");
 	xfer->ux_status = xfererr;
 	mutex_enter(&sc->sc_lock);
 	usb_transfer_complete(xfer);
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 static void
 doxfer_kth(void *arg)
+{
 	struct usbd_pipe *pipe = arg;
 	struct ugenhc_softc *sc = UGENHC_PIPE2SC(pipe);
 	mutex_enter(&sc->sc_lock);
 	do {
 		struct usbd_xfer *xfer = SIMPLEQ_FIRST(&pipe->up_queue);
 		mutex_exit(&sc->sc_lock);
 		rumpusb_device_bulk_start(xfer);
 		mutex_enter(&sc->sc_lock);
 	} while (!SIMPLEQ_EMPTY(&pipe->up_queue));
 	mutex_exit(&sc->sc_lock);
 	kthread_exit(0);
+}
 static usbd_status
 rumpusb_device_bulk_transfer(struct usbd_xfer *xfer)
+{
 	if (!rump_threads) {
 		/* XXX: lie about supporting async transfers */
 		if ((xfer->ux_flags & USBD_SYNCHRONOUS) == 0) {
 			printf("non-threaded rump does not support "

 @@ -1,14 +1,14 @@
-/*	$NetBSD: usbdivar.h,v 1.133 2022/03/03 06:09:20 riastradh Exp $	*/
+/*	$NetBSD: usbdivar.h,v 1.134 2022/03/03 06:12:11 riastradh Exp $	*/
 /*
  * Copyright (c) 1998, 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 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:
  * 1. Redistributions of source code must retain the above copyright
 @@ -41,34 +41,34 @@
  * List of hardware interface methods, and whether the lock is held
  * when each is called by this module:
+ *
  *	BUS METHOD		LOCK	NOTES
  *	----------------------- -------	-------------------------
  *	ubm_open		-	might want to take lock?
  *	ubm_softint		x	may release/reacquire lock
  *	ubm_dopoll		-	might want to take lock?
  *	ubm_allocx		-
  *	ubm_freex		-
  *	ubm_abortx		x	must not release/reacquire lock
  *	ubm_getlock 		-	Called at attach time
  *	ubm_newdev		-	Will take lock
- *	ubm_rhctrl
+ *	ubm_rhctrl              x
+ *
  *	PIPE METHOD		LOCK	NOTES
  *	----------------------- -------	-------------------------
  *	upm_init		-
  *	upm_fini		-
- *	upm_transfer		-
+ *	upm_transfer		x
- *	upm_start		-	might want to take lock?
+ *	upm_start		x
  *	upm_abort		x
  *	upm_close		x
  *	upm_cleartoggle		-
  *	upm_done		x
+ *
  * The above semantics are likely to change.  Little performance
  * evaluation has been done on this code and the locking strategy.
+ *
  * USB functions known to expect the lock taken include (this list is
  * probably not exhaustive):
  *    usb_transfer_complete()
  *    usb_start_next()
+ *