 @@ -1,14 +1,14 @@
-/*	$NetBSD: ehci.c,v 1.284 2020/12/22 01:07:23 riastradh Exp $ */
+/*	$NetBSD: ehci.c,v 1.285 2021/01/05 18:00:21 skrll 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.284 2020/12/22 01:07:23 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ehci.c,v 1.285 2021/01/05 18:00:21 skrll 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>
 @@ -2835,39 +2835,40 @@ ehci_alloc_sqh(ehci_softc_t *sc)
 Static void
 ehci_free_sqh(ehci_softc_t *sc, ehci_soft_qh_t *sqh)
+{
 	KASSERT(mutex_owned(&sc->sc_lock));
 	sqh->next = sc->sc_freeqhs;
 	sc->sc_freeqhs = sqh;
+}
 Static ehci_soft_qtd_t *
 ehci_alloc_sqtd(ehci_softc_t *sc)
+{
 	ehci_soft_qtd_t *sqtd = NULL;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freeqtds == NULL) {
 		DPRINTF("allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
-		err = usb_allocmem(&sc->sc_bus, EHCI_SQTD_SIZE*EHCI_SQTD_CHUNK,
+		int err = usb_allocmem(&sc->sc_bus,
-		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT, &dma);
+		    EHCI_SQTD_SIZE*EHCI_SQTD_CHUNK,
 		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT,
 		    &dma);
 #ifdef EHCI_DEBUG
 		if (err)
 			printf("ehci_alloc_sqtd: usb_allocmem()=%d\n", err);
 #endif
 		if (err)
 			goto done;
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < EHCI_SQTD_CHUNK; i++) {
 			offs = i * EHCI_SQTD_SIZE;
 			sqtd = KERNADDR(&dma, offs);
 			sqtd->physaddr = DMAADDR(&dma, offs);
 			sqtd->dma = dma;
 @@ -3092,39 +3093,37 @@ ehci_reset_sqtd_chain(ehci_softc_t *sc,
 		ehci_append_sqtd(sqtd, prev);
 		tog ^= 1;
+	}
 	*lsqtd = sqtd;
 	*toggle = tog;
+}
 Static ehci_soft_itd_t *
 ehci_alloc_itd(ehci_softc_t *sc)
+{
 	struct ehci_soft_itd *itd, *freeitd;
 	usbd_status err;
 	usb_dma_t dma;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	freeitd = LIST_FIRST(&sc->sc_freeitds);
 	if (freeitd == NULL) {
 		DPRINTF("allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
 		int err = usb_allocmem(&sc->sc_bus, EHCI_ITD_SIZE * EHCI_ITD_CHUNK,
 		err = usb_allocmem(&sc->sc_bus, EHCI_ITD_SIZE * EHCI_ITD_CHUNK,
 		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT, &dma);
 		if (err) {
 			DPRINTF("alloc returned %jd", err, 0, 0, 0);
 			return NULL;
+		}
 		mutex_enter(&sc->sc_lock);
 		for (int i = 0; i < EHCI_ITD_CHUNK; i++) {
 			int offs = i * EHCI_ITD_SIZE;
 			itd = KERNADDR(&dma, offs);
 			itd->physaddr = DMAADDR(&dma, offs);
 	 		itd->dma = dma;
 @@ -3141,39 +3140,37 @@ ehci_alloc_itd(ehci_softc_t *sc)
 	itd->frame_list.next = NULL;
 	itd->frame_list.prev = NULL;
 	itd->xfer_next = NULL;
 	itd->slot = 0;
 	return itd;
+}
 Static ehci_soft_sitd_t *
 ehci_alloc_sitd(ehci_softc_t *sc)
+{
 	struct ehci_soft_sitd *sitd, *freesitd;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	EHCIHIST_FUNC(); EHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	freesitd = LIST_FIRST(&sc->sc_freesitds);
 	if (freesitd == NULL) {
 		DPRINTF("allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
 		int err = usb_allocmem(&sc->sc_bus, EHCI_SITD_SIZE * EHCI_SITD_CHUNK,
 		err = usb_allocmem(&sc->sc_bus, EHCI_SITD_SIZE * EHCI_SITD_CHUNK,
 		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT, &dma);
 		if (err) {
 			DPRINTF("alloc returned %jd", err, 0, 0,
 );
 			return NULL;
+		}
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < EHCI_SITD_CHUNK; i++) {
 			offs = i * EHCI_SITD_SIZE;
 			sitd = KERNADDR(&dma, offs);
 			sitd->physaddr = DMAADDR(&dma, offs);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ohci.c,v 1.314 2020/12/22 01:07:23 riastradh Exp $	*/
+/*	$NetBSD: ohci.c,v 1.315 2021/01/05 18:00:21 skrll 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.314 2020/12/22 01:07:23 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.315 2021/01/05 18:00:21 skrll 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>
 @@ -389,39 +389,38 @@ ohci_detach(struct ohci_softc *sc, int f
 	if (sc->sc_hcca != NULL)
 		usb_freemem(&sc->sc_bus, &sc->sc_hccadma);
 	pool_cache_destroy(sc->sc_xferpool);
 	cv_destroy(&sc->sc_abort_cv);
 	return rv;
+}
 ohci_soft_ed_t *
 ohci_alloc_sed(ohci_softc_t *sc)
+{
 	ohci_soft_ed_t *sed;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freeeds == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
-		err = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK,
+		int err = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK,
-		    OHCI_ED_ALIGN, USBMALLOC_COHERENT, &dma);
+		    OHCI_ED_ALIGN, 0 /*!USBMALLOC_COHERENT*/, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < OHCI_SED_CHUNK; i++) {
 			offs = i * OHCI_SED_SIZE;
 			sed = KERNADDR(&dma, offs);
 			sed->physaddr = DMAADDR(&dma, offs);
 			sed->dma = dma;
 			sed->offs = offs;
 			sed->next = sc->sc_freeeds;
 			sc->sc_freeeds = sed;
+		}
 @@ -448,39 +447,38 @@ ohci_free_sed_locked(ohci_softc_t *sc, o
 void
 ohci_free_sed(ohci_softc_t *sc, ohci_soft_ed_t *sed)
+{
 	mutex_enter(&sc->sc_lock);
 	ohci_free_sed_locked(sc, sed);
 	mutex_exit(&sc->sc_lock);
+}
 ohci_soft_td_t *
 ohci_alloc_std(ohci_softc_t *sc)
+{
 	ohci_soft_td_t *std;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freetds == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
-		err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
+		int err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
-		    OHCI_TD_ALIGN, USBMALLOC_COHERENT, &dma);
+		   OHCI_TD_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < OHCI_STD_CHUNK; i++) {
 			offs = i * OHCI_STD_SIZE;
 			std = KERNADDR(&dma, offs);
 			std->physaddr = DMAADDR(&dma, offs);
 			std->dma = dma;
 			std->offs = offs;
 			std->nexttd = sc->sc_freetds;
 			sc->sc_freetds = std;
+		}
 @@ -701,38 +699,37 @@ ohci_reset_std_chain(ohci_softc_t *sc, s
 	 	ohci_hash_add_td(sc, cur);
 		DPRINTFN(2, "add 0 xfer", 0, 0, 0, 0);
+	}
 	/* Last TD gets usb_syncmem'ed by caller */
 	*ep = cur;
+}
 ohci_soft_itd_t *
 ohci_alloc_sitd(ohci_softc_t *sc)
+{
 	ohci_soft_itd_t *sitd;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freeitds == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
-		err = usb_allocmem(&sc->sc_bus, OHCI_SITD_SIZE * OHCI_SITD_CHUNK,
+		int err = usb_allocmem(&sc->sc_bus, OHCI_SITD_SIZE * OHCI_SITD_CHUNK,
 		    OHCI_ITD_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < OHCI_SITD_CHUNK; i++) {
 			offs = i * OHCI_SITD_SIZE;
 			sitd = KERNADDR(&dma, offs);
 			sitd->physaddr = DMAADDR(&dma, offs);
 			sitd->dma = dma;
 			sitd->offs = offs;
 			sitd->nextitd = sc->sc_freeitds;
 			sc->sc_freeitds = sitd;
+		}
 @@ -819,28 +816,28 @@ ohci_init(ohci_softc_t *sc)
 	    OHCI_REV_LEGACY(rev) ? ", legacy support" : "");
 	if (OHCI_REV_HI(rev) != 1 || OHCI_REV_LO(rev) != 0) {
 		aprint_error_dev(sc->sc_dev, "unsupported OHCI revision\n");
 		sc->sc_bus.ub_revision = USBREV_UNKNOWN;
 		return -1;
+	}
 	sc->sc_bus.ub_revision = USBREV_1_0;
 	sc->sc_bus.ub_usedma = true;
 	sc->sc_bus.ub_dmaflags = USBMALLOC_MULTISEG;
 	/* XXX determine alignment by R/W */
 	/* Allocate the HCCA area. */
-	err = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE,
+	err = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE,	OHCI_HCCA_ALIGN,
-	    OHCI_HCCA_ALIGN, USBMALLOC_COHERENT, &sc->sc_hccadma);
+	    USBMALLOC_COHERENT, &sc->sc_hccadma);
 	if (err) {
 		sc->sc_hcca = NULL;
 		return err;
+	}
 	sc->sc_hcca = KERNADDR(&sc->sc_hccadma, 0);
 	memset(sc->sc_hcca, 0, OHCI_HCCA_SIZE);
 	sc->sc_eintrs = OHCI_NORMAL_INTRS;
 	/* Allocate dummy ED that starts the control list. */
 	sc->sc_ctrl_head = ohci_alloc_sed(sc);
 	if (sc->sc_ctrl_head == NULL) {
 		err = ENOMEM;
 @@ -2133,30 +2130,30 @@ ohci_open(struct usbd_pipe *pipe)
 			OHCI_ED_SET_EN(UE_GET_ADDR(ed->bEndpointAddress)) |
 			(dev->ud_speed == USB_SPEED_LOW ? OHCI_ED_SPEED : 0) |
 			fmt |
 			OHCI_ED_SET_MAXP(UGETW(ed->wMaxPacketSize)));
 		sed->ed.ed_headp = HTOO32(tdphys |
 		    (pipe->up_endpoint->ue_toggle ? OHCI_TOGGLECARRY : 0));
 		sed->ed.ed_tailp = HTOO32(tdphys);
 		usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		switch (xfertype) {
 		case UE_CONTROL:
 			pipe->up_methods = &ohci_device_ctrl_methods;
-			err = usb_allocmem(&sc->sc_bus,
+			int error = usb_allocmem(&sc->sc_bus,
 			    sizeof(usb_device_request_t), 0,
 			    USBMALLOC_COHERENT, &opipe->ctrl.reqdma);
-			if (err)
+			if (error)
 				goto bad;
 			mutex_enter(&sc->sc_lock);
 			ohci_add_ed(sc, sed, sc->sc_ctrl_head);
 			mutex_exit(&sc->sc_lock);
 			break;
 		case UE_INTERRUPT:
 			pipe->up_methods = &ohci_device_intr_methods;
 			ival = pipe->up_interval;
 			if (ival == USBD_DEFAULT_INTERVAL)
 				ival = ed->bInterval;
 			err = ohci_device_setintr(sc, opipe, ival);
 			if (err)
 				goto bad;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uhci.c,v 1.305 2020/12/22 01:07:23 riastradh Exp $	*/
+/*	$NetBSD: uhci.c,v 1.306 2021/01/05 18:00:21 skrll 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.305 2020/12/22 01:07:23 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uhci.c,v 1.306 2021/01/05 18:00:21 skrll 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>
 @@ -423,48 +423,47 @@ uhci_find_prev_qh(uhci_soft_qh_t *pqh, u
+}
 void
 uhci_globalreset(uhci_softc_t *sc)
+{
 	UHCICMD(sc, UHCI_CMD_GRESET);	/* global reset */
 	usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); /* wait a little */
 	UHCICMD(sc, 0);			/* do nothing */
+}
 int
 uhci_init(uhci_softc_t *sc)
+{
 	usbd_status err;
 	int i, j;
 	uhci_soft_qh_t *clsqh, *chsqh, *bsqh, *sqh, *lsqh;
 	uhci_soft_td_t *std;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 #ifdef UHCI_DEBUG
 	thesc = sc;
 	if (uhcidebug >= 2)
 		uhci_dumpregs(sc);
 #endif
 	sc->sc_suspend = PWR_RESUME;
 	UWRITE2(sc, UHCI_INTR, 0);		/* disable interrupts */
 	uhci_globalreset(sc);			/* reset the controller */
 	uhci_reset(sc);
 	/* Allocate and initialize real frame array. */
-	err = usb_allocmem(&sc->sc_bus,
+	int err = usb_allocmem(&sc->sc_bus,
 	    UHCI_FRAMELIST_COUNT * sizeof(uhci_physaddr_t),
 	    UHCI_FRAMELIST_ALIGN, USBMALLOC_COHERENT, &sc->sc_dma);
 	if (err)
 		return err;
 	sc->sc_pframes = KERNADDR(&sc->sc_dma, 0);
 	/* set frame number to 0 */
 	UWRITE2(sc, UHCI_FRNUM, 0);
 	/* set frame list */
 	UWRITE4(sc, UHCI_FLBASEADDR, DMAADDR(&sc->sc_dma, 0));
 	/* Initialise mutex early for uhci_alloc_* */
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_USB);
 @@ -1825,38 +1824,37 @@ uhci_run(uhci_softc_t *sc, int run, int
  * Memory management routines.
  *  uhci_alloc_std allocates TDs
  *  uhci_alloc_sqh allocates QHs
  * These two routines do their own free list management,
  * partly for speed, partly because allocating DMAable memory
  * has page size granularity so much memory would be wasted if
  * only one TD/QH (32 bytes) was placed in each allocated chunk.
  */
 uhci_soft_td_t *
 uhci_alloc_std(uhci_softc_t *sc)
+{
 	uhci_soft_td_t *std;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freetds == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
-		err = usb_allocmem(&sc->sc_bus, UHCI_STD_SIZE * UHCI_STD_CHUNK,
+		int err = usb_allocmem(&sc->sc_bus, UHCI_STD_SIZE * UHCI_STD_CHUNK,
 		    UHCI_TD_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < UHCI_STD_CHUNK; i++) {
 			offs = i * UHCI_STD_SIZE;
 			std = KERNADDR(&dma, offs);
 			std->physaddr = DMAADDR(&dma, offs);
 			std->dma = dma;
 			std->offs = offs;
 			std->link.std = sc->sc_freetds;
 			sc->sc_freetds = std;
 @@ -1892,38 +1890,37 @@ uhci_free_std_locked(uhci_softc_t *sc, u
 void
 uhci_free_std(uhci_softc_t *sc, uhci_soft_td_t *std)
+{
 	mutex_enter(&sc->sc_lock);
 	uhci_free_std_locked(sc, std);
 	mutex_exit(&sc->sc_lock);
+}
 uhci_soft_qh_t *
 uhci_alloc_sqh(uhci_softc_t *sc)
+{
 	uhci_soft_qh_t *sqh;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_freeqhs == NULL) {
 		DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
-		err = usb_allocmem(&sc->sc_bus, UHCI_SQH_SIZE * UHCI_SQH_CHUNK,
+		int err = usb_allocmem(&sc->sc_bus, UHCI_SQH_SIZE * UHCI_SQH_CHUNK,
 		    UHCI_QH_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
 		for (i = 0; i < UHCI_SQH_CHUNK; i++) {
 			offs = i * UHCI_SQH_SIZE;
 			sqh = KERNADDR(&dma, offs);
 			sqh->physaddr = DMAADDR(&dma, offs);
 			sqh->dma = dma;
 			sqh->offs = offs;
 			sqh->hlink = sc->sc_freeqhs;
 			sc->sc_freeqhs = sqh;
 @@ -3455,27 +3452,26 @@ uhci_device_setintr(uhci_softc_t *sc, st
 	DPRINTFN(5, "returns %#jx", (uintptr_t)upipe, 0, 0, 0);
 	return USBD_NORMAL_COMPLETION;
+}
 /* Open a new pipe. */
 usbd_status
 uhci_open(struct usbd_pipe *pipe)
+{
 	uhci_softc_t *sc = UHCI_PIPE2SC(pipe);
 	struct usbd_bus *bus = pipe->up_dev->ud_bus;
 	struct uhci_pipe *upipe = UHCI_PIPE2UPIPE(pipe);
 	usb_endpoint_descriptor_t *ed = pipe->up_endpoint->ue_edesc;
 	usbd_status err = USBD_NOMEM;
 	int ival;
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	DPRINTF("pipe=%#jx, addr=%jd, endpt=%jd (%jd)",
 	    (uintptr_t)pipe, pipe->up_dev->ud_addr, ed->bEndpointAddress,
 	    bus->ub_rhaddr);
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	upipe->aborting = 0;
 	/* toggle state needed for bulk endpoints */
 	upipe->nexttoggle = pipe->up_endpoint->ue_toggle;
 @@ -3499,27 +3495,27 @@ uhci_open(struct usbd_pipe *pipe)
 			if (upipe->ctrl.sqh == NULL)
 				goto bad;
 			upipe->ctrl.setup = uhci_alloc_std(sc);
 			if (upipe->ctrl.setup == NULL) {
 				uhci_free_sqh(sc, upipe->ctrl.sqh);
 				goto bad;
+			}
 			upipe->ctrl.stat = uhci_alloc_std(sc);
 			if (upipe->ctrl.stat == NULL) {
 				uhci_free_sqh(sc, upipe->ctrl.sqh);
 				uhci_free_std(sc, upipe->ctrl.setup);
 				goto bad;
+			}
-			err = usb_allocmem(&sc->sc_bus,
+			int err = usb_allocmem(&sc->sc_bus,
 			    sizeof(usb_device_request_t), 0,
 			    USBMALLOC_COHERENT, &upipe->ctrl.reqdma);
 			if (err) {
 				uhci_free_sqh(sc, upipe->ctrl.sqh);
 				uhci_free_std(sc, upipe->ctrl.setup);
 				uhci_free_std(sc, upipe->ctrl.stat);
 				goto bad;
+			}
 			break;
 		case UE_INTERRUPT:
 			pipe->up_methods = &uhci_device_intr_methods;
 			ival = pipe->up_interval;
 			if (ival == USBD_DEFAULT_INTERVAL)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: usb_mem.c,v 1.79 2021/01/05 16:15:09 skrll Exp $	*/
+/*	$NetBSD: usb_mem.c,v 1.80 2021/01/05 18:00:21 skrll Exp $	*/
 /*
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (lennart@augustsson.net) at
  * Carlstedt Research & Technology.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -28,27 +28,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 DMA memory allocation.
  * We need to allocate a lot of small (many 8 byte, some larger)
  * memory blocks that can be used for DMA.  Using the bus_dma
  * routines directly would incur large overheads in space and time.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: usb_mem.c,v 1.79 2021/01/05 16:15:09 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: usb_mem.c,v 1.80 2021/01/05 18:00:21 skrll 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>		/* for usbdivar.h */
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/once.h>
 #include <sys/queue.h>
 @@ -64,29 +64,29 @@ __KERNEL_RCSID(0, "$NetBSD: usb_mem.c,v
 #define	DPRINTFN(N,FMT,A,B,C,D)	USBHIST_LOGN(usbdebug,N,FMT,A,B,C,D)
 #define USB_MEM_SMALL roundup(64, CACHE_LINE_SIZE)
 #define USB_MEM_CHUNKS 64
 #define USB_MEM_BLOCK (USB_MEM_SMALL * USB_MEM_CHUNKS)
 /* This struct is overlayed on free fragments. */
 struct usb_frag_dma {
 	usb_dma_block_t		*ufd_block;
 	u_int			ufd_offs;
 	LIST_ENTRY(usb_frag_dma) ufd_next;
 };
-Static usbd_status	usb_block_allocmem(bus_dma_tag_t, size_t, size_t,
+Static int	usb_block_allocmem(bus_dma_tag_t, size_t, size_t,
-			    u_int, usb_dma_block_t **);
+		    u_int, usb_dma_block_t **);
-Static void		usb_block_freemem(usb_dma_block_t *);
+Static void	usb_block_freemem(usb_dma_block_t *);
 LIST_HEAD(usb_dma_block_qh, usb_dma_block);
 Static struct usb_dma_block_qh usb_blk_freelist =
 	LIST_HEAD_INITIALIZER(usb_blk_freelist);
 kmutex_t usb_blk_lock;
 #ifdef DEBUG
 Static struct usb_dma_block_qh usb_blk_fraglist =
 	LIST_HEAD_INITIALIZER(usb_blk_fraglist);
 Static struct usb_dma_block_qh usb_blk_fulllist =
 	LIST_HEAD_INITIALIZER(usb_blk_fulllist);
 #endif
 Static u_int usb_blk_nfree = 0;
 @@ -94,27 +94,27 @@ Static u_int usb_blk_nfree = 0;
 Static LIST_HEAD(, usb_frag_dma) usb_frag_freelist =
 	LIST_HEAD_INITIALIZER(usb_frag_freelist);
 Static int usb_mem_init(void);
 Static int
 usb_mem_init(void)
+{
 	mutex_init(&usb_blk_lock, MUTEX_DEFAULT, IPL_NONE);
 	return 0;
+}
-Static usbd_status
+Static int
 usb_block_allocmem(bus_dma_tag_t tag, size_t size, size_t align,
     u_int flags, usb_dma_block_t **dmap)
+{
 	usb_dma_block_t *b;
 	int error;
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "size=%ju align=%ju flags=%#jx", size, align, flags, 0);
 	ASSERT_SLEEPABLE();
 	KASSERT(size != 0);
 	KASSERT(mutex_owned(&usb_blk_lock));
 @@ -125,27 +125,27 @@ usb_block_allocmem(bus_dma_tag_t tag, si
 	/* First check the free list. */
 	LIST_FOREACH(b, &usb_blk_freelist, next) {
 		/* Don't allocate multiple segments to unwilling callers */
 		if (b->nsegs != 1 && !multiseg)
 			continue;
 		if (b->tag == tag &&
 		    b->size >= size &&
 		    b->align >= align &&
 		    (b->flags & USB_DMA_COHERENT) == dmaflags) {
 			LIST_REMOVE(b, next);
 			usb_blk_nfree--;
 			*dmap = b;
 			DPRINTFN(6, "free list size=%ju", b->size, 0, 0, 0);
-			return USBD_NORMAL_COMPLETION;
+			return 0;
+		}
+	}
 	DPRINTFN(6, "no freelist entry", 0, 0, 0, 0);
 	mutex_exit(&usb_blk_lock);
 	b = kmem_zalloc(sizeof(*b), KM_SLEEP);
 	b->tag = tag;
 	b->size = size;
 	b->align = align;
 	b->flags = dmaflags;
 	if (!multiseg)
 @@ -181,27 +181,27 @@ usb_block_allocmem(bus_dma_tag_t tag, si
 	*dmap = b;
 #ifdef USB_FRAG_DMA_WORKAROUND
 	flags |= USBMALLOC_ZERO;
 #endif
 	if ((flags & USBMALLOC_ZERO) != 0) {
 		memset(b->kaddr, 0, b->size);
 		bus_dmamap_sync(b->tag, b->map, 0, b->size,
 		    BUS_DMASYNC_PREWRITE);
+	}
 	mutex_enter(&usb_blk_lock);
-	return USBD_NORMAL_COMPLETION;
+	return 0;
  destroy:
 	bus_dmamap_destroy(tag, b->map);
  unmap:
 	bus_dmamem_unmap(tag, b->kaddr, b->size);
  free1:
 	bus_dmamem_free(tag, b->segs, b->nsegs);
  free0:
 	kmem_free(b->segs, b->nsegs_alloc * sizeof(*b->segs));
 	kmem_free(b, sizeof(*b));
 	mutex_enter(&usb_blk_lock);
 	return USBD_NOMEM;
 @@ -245,27 +245,27 @@ usb_block_freemem(usb_dma_block_t *b)
+{
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "size=%ju", b->size, 0, 0, 0);
 	KASSERT(mutex_owned(&usb_blk_lock));
 #ifdef DEBUG
 	LIST_REMOVE(b, next);
 #endif
 	LIST_INSERT_HEAD(&usb_blk_freelist, b, next);
 	usb_blk_nfree++;
+}
-usbd_status
+int
 usb_allocmem(struct usbd_bus *bus, size_t size, size_t align, u_int flags,
     usb_dma_t *p)
+{
 	bus_dma_tag_t tag = bus->ub_dmatag;
 	usbd_status err;
 	struct usb_frag_dma *f;
 	usb_dma_block_t *b;
 	int i;
 	static ONCE_DECL(init_control);
 	USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
 	ASSERT_SLEEPABLE();
 @@ -325,27 +325,27 @@ usb_allocmem(struct usbd_bus *bus, size_
 #endif
+		}
 		f = LIST_FIRST(&usb_frag_freelist);
+	}
 	p->udma_block = f->ufd_block;
 	p->udma_offs = f->ufd_offs;
 #ifdef USB_FRAG_DMA_WORKAROUND
 	p->udma_offs += USB_MEM_SMALL;
 #endif
 	LIST_REMOVE(f, ufd_next);
 	mutex_exit(&usb_blk_lock);
 	DPRINTFN(5, "use frag=%#jx size=%jd", (uintptr_t)f, size, 0, 0);
-	return USBD_NORMAL_COMPLETION;
+	return 0;
+}
 void
 usb_freemem(struct usbd_bus *bus, usb_dma_t *p)
+{
 	struct usb_frag_dma *f;
 	USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
 	mutex_enter(&usb_blk_lock);
 	if (p->udma_block->flags & USB_DMA_FULLBLOCK) {
 		KDASSERTMSG(usb_valid_block_p(p->udma_block, &usb_blk_fulllist),
 		    "%s: dma %p: invalid block pointer %p",

 @@ -1,14 +1,14 @@
-/*	$NetBSD: xhci.c,v 1.137 2021/01/02 12:39:33 jmcneill Exp $	*/
+/*	$NetBSD: xhci.c,v 1.138 2021/01/05 18:00:21 skrll 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.137 2021/01/02 12:39:33 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xhci.c,v 1.138 2021/01/05 18:00:21 skrll 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>
 @@ -1070,28 +1070,27 @@ xhci_init(struct xhci_softc *sc)
 	pagesize = xhci_op_read_4(sc, XHCI_PAGESIZE);
 	aprint_debug_dev(sc->sc_dev, "PAGESIZE 0x%08x\n", pagesize);
 	pagesize = ffs(pagesize);
 	if (pagesize == 0) {
 		aprint_error_dev(sc->sc_dev, "pagesize is 0\n");
 		return EIO;
+	}
 	sc->sc_pgsz = 1 << (12 + (pagesize - 1));
 	aprint_debug_dev(sc->sc_dev, "sc_pgsz 0x%08x\n", (uint32_t)sc->sc_pgsz);
 	aprint_debug_dev(sc->sc_dev, "sc_maxslots 0x%08x\n",
 	    (uint32_t)sc->sc_maxslots);
 	aprint_debug_dev(sc->sc_dev, "sc_maxports %d\n", sc->sc_maxports);
-	usbd_status err;
+	int err;
 	sc->sc_maxspbuf = XHCI_HCS2_MAXSPBUF(hcs2);
 	aprint_debug_dev(sc->sc_dev, "sc_maxspbuf %d\n", sc->sc_maxspbuf);
 	if (sc->sc_maxspbuf != 0) {
 		err = usb_allocmem(&sc->sc_bus,
 		    sizeof(uint64_t) * sc->sc_maxspbuf, sizeof(uint64_t),
 		    USBMALLOC_COHERENT | USBMALLOC_ZERO,
 		    &sc->sc_spbufarray_dma);
 		if (err) {
 			aprint_error_dev(sc->sc_dev,
 			    "spbufarray init fail, err %d\n", err);
 			return ENOMEM;
+		}
 @@ -2560,38 +2559,37 @@ xhci_new_device(device_t parent, struct
 	err = usbd_probe_and_attach(parent, dev, port, dev->ud_addr);
  bad:
 	if (err != USBD_NORMAL_COMPLETION) {
 		usbd_remove_device(dev, up);
+	}
 	return err;
+}
 static usbd_status
 xhci_ring_init(struct xhci_softc * const sc, struct xhci_ring **xrp,
     size_t ntrb, size_t align)
+{
 	usbd_status err;
 	size_t size = ntrb * XHCI_TRB_SIZE;
 	struct xhci_ring *xr;
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("xr %#jx ntrb %#jx align %#jx",
 	    (uintptr_t)*xrp, ntrb, align, 0);
 	xr = kmem_zalloc(sizeof(struct xhci_ring), KM_SLEEP);
 	DPRINTFN(1, "ring %#jx", (uintptr_t)xr, 0, 0, 0);
-	err = usb_allocmem(&sc->sc_bus, size, align,
+	int err = usb_allocmem(&sc->sc_bus, size, align,
 	    USBMALLOC_COHERENT | USBMALLOC_ZERO, &xr->xr_dma);
 	if (err) {
 		kmem_free(xr, sizeof(struct xhci_ring));
 		DPRINTFN(1, "alloc xr_dma failed %jd", err, 0, 0, 0);
 		return err;
+	}
 	mutex_init(&xr->xr_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	xr->xr_cookies = kmem_zalloc(sizeof(*xr->xr_cookies) * ntrb, KM_SLEEP);
 	xr->xr_trb = xhci_ring_trbv(xr, 0);
 	xr->xr_ntrb = ntrb;
 	xr->is_halted = false;
 	xhci_host_dequeue(xr);
 	*xrp = xr;
 @@ -3002,59 +3000,57 @@ xhci_set_dcba(struct xhci_softc * const
 	usb_syncmem(&sc->sc_dcbaa_dma, si * sizeof(uint64_t), sizeof(uint64_t),
 	    BUS_DMASYNC_PREWRITE);
+}
 /*
  * Allocate device and input context DMA buffer, and
  * TRB DMA buffer for each endpoint.
  */
 static usbd_status
 xhci_init_slot(struct usbd_device *dev, uint32_t slot)
+{
 	struct xhci_softc * const sc = XHCI_BUS2SC(dev->ud_bus);
 	struct xhci_slot *xs;
 	usbd_status err;
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("slot %ju", slot, 0, 0, 0);
 	xs = &sc->sc_slots[slot];
 	/* allocate contexts */
-	err = usb_allocmem(&sc->sc_bus, sc->sc_pgsz, sc->sc_pgsz,
+	int err = usb_allocmem(&sc->sc_bus, sc->sc_pgsz, sc->sc_pgsz,
 	    USBMALLOC_COHERENT | USBMALLOC_ZERO, &xs->xs_dc_dma);
 	if (err) {
 		DPRINTFN(1, "failed to allocmem output device context %jd",
 		    err, 0, 0, 0);
-		return err;
+		return USBD_NOMEM;
+	}
 	err = usb_allocmem(&sc->sc_bus, sc->sc_pgsz, sc->sc_pgsz,
 	    USBMALLOC_COHERENT | USBMALLOC_ZERO, &xs->xs_ic_dma);
 	if (err) {
 		DPRINTFN(1, "failed to allocmem input device context %jd",
 		    err, 0, 0, 0);
-		goto bad1;
+		return USBD_NOMEM;
+	}
 	memset(&xs->xs_xr[0], 0, sizeof(xs->xs_xr));
 	xs->xs_idx = slot;
 	return USBD_NORMAL_COMPLETION;
  bad1:
 	usb_freemem(&sc->sc_bus, &xs->xs_dc_dma);
 	xs->xs_idx = 0;
-	return err;
+	return USBD_NOMEM;
+}
 static void
 xhci_free_slot(struct xhci_softc *sc, struct xhci_slot *xs)
+{
 	u_int dci;
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("slot %ju", xs->xs_idx, 0, 0, 0);
 	/* deallocate all allocated rings in the slot */
 	for (dci = XHCI_DCI_SLOT; dci <= XHCI_MAX_DCI; dci++) {
 		if (xs->xs_xr[dci] != NULL)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: usb_mem.h,v 1.33 2021/01/02 12:39:03 jmcneill Exp $	*/
+/*	$NetBSD: usb_mem.h,v 1.34 2021/01/05 18:00:21 skrll Exp $	*/
 /*	$FreeBSD: src/sys/dev/usb/usb_mem.h,v 1.9 1999/11/17 22:33:47 n_hibma Exp $	*/
 /*
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (lennart@augustsson.net) at
  * Carlstedt Research & Technology.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -41,22 +41,22 @@ typedef struct usb_dma_block {
 	size_t size;
 	size_t align;
 	int flags;
 #define USB_DMA_FULLBLOCK	__BIT(0)
 #define USB_DMA_COHERENT	__BIT(1)
 	LIST_ENTRY(usb_dma_block) next;
 } usb_dma_block_t;
 #define USBMALLOC_MULTISEG	__BIT(0)
 #define USBMALLOC_COHERENT	__BIT(1)
 #define USBMALLOC_ZERO		__BIT(2)
-usbd_status	usb_allocmem(struct usbd_bus *, size_t, size_t, u_int, usb_dma_t *);
+int		usb_allocmem(struct usbd_bus *, size_t, size_t, u_int, usb_dma_t *);
 void		usb_freemem(struct usbd_bus *, usb_dma_t *);
 void		usb_syncmem(usb_dma_t *, bus_addr_t, bus_size_t, int);
 bus_addr_t	usb_dmaaddr(usb_dma_t *, unsigned int);
 #define DMAADDR(dma, o) usb_dmaaddr((dma), (o))
 #define KERNADDR(dma, o) \
 	((void *)((char *)(dma)->udma_block->kaddr + (dma)->udma_offs + (o)))