Sync with usb4bsd:

src/lib/libusb20/libusb20_desc.c

Make "libusb20_desc_foreach()" more readable.

src/sys/dev/usb2/controller/*.[ch]
src/sys/dev/usb2/core/*.[ch]

Implement support for USB power save for all HC's.

Implement support for Big-endian EHCI.

Move Huawei quirks back into "u3g" driver.

Improve device enumeration.

src/sys/dev/usb2/ethernet/*[ch]

Patches for supporting new AXE Gigabit chipset.

src/sys/dev/usb2/serial/*[ch]

Fix IOCTL return code.

src/sys/dev/usb2/wlan/*[ch]

Sync with old USB stack.

Submitted by: hps

11 files changed, 830 insertions, 319 deletions

diff --git a/sys/dev/usb2/controller/at91dci.c b/sys/dev/usb2/controller/at91dci.c
index a4e43df..5ed6924 100644
--- a/sys/dev/usb2/controller/at91dci.c
+++ b/sys/dev/usb2/controller/at91dci.c
@@ -261,42 +261,28 @@ at91dci_pull_down(struct at91dci_softc *sc)
 }
 
 static void
-at91dci_wakeup_peer(struct at91dci_softc *sc)
+at91dci_wakeup_peer(struct usb2_xfer *xfer)
 {
-	uint32_t temp;
+	struct at91dci_softc *sc = xfer->usb2_sc;
+	uint8_t use_polling;
 
 	if (!(sc->sc_flags.status_suspend)) {
 		return;
 	}
-	temp = AT91_UDP_READ_4(sc, AT91_UDP_GSTATE);
-
-	if (!(temp & AT91_UDP_GSTATE_ESR)) {
-		return;
-	}
-	AT91_UDP_WRITE_4(sc, AT91_UDP_GSTATE, temp);
-}
-
-static void
-at91dci_rem_wakeup_set(struct usb2_device *udev, uint8_t is_on)
-{
-	struct at91dci_softc *sc;
-	uint32_t temp;
-
-	DPRINTFN(5, "is_on=%u\n", is_on);
-
-	USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
-
-	sc = AT9100_DCI_BUS2SC(udev->bus);
+	use_polling = mtx_owned(xfer->xfer_mtx) ? 1 : 0;
 
-	temp = AT91_UDP_READ_4(sc, AT91_UDP_GSTATE);
+	AT91_UDP_WRITE_4(sc, AT91_UDP_GSTATE, AT91_UDP_GSTATE_ESR);
 
-	if (is_on) {
-		temp |= AT91_UDP_GSTATE_ESR;
+	/* wait 8 milliseconds */
+	if (use_polling) {
+		/* polling */
+		DELAY(8000);
 	} else {
-		temp &= ~AT91_UDP_GSTATE_ESR;
+		/* Wait for reset to complete. */
+		usb2_pause_mtx(&sc->sc_bus.bus_mtx, 8);
 	}
 
-	AT91_UDP_WRITE_4(sc, AT91_UDP_GSTATE, temp);
+	AT91_UDP_WRITE_4(sc, AT91_UDP_GSTATE, 0);
 }
 
 static void
@@ -2120,7 +2106,7 @@ tr_handle_clear_port_feature:
 
 	switch (value) {
 	case UHF_PORT_SUSPEND:
-		at91dci_wakeup_peer(sc);
+		at91dci_wakeup_peer(xfer);
 		break;
 
 	case UHF_PORT_ENABLE:
@@ -2492,5 +2478,4 @@ struct usb2_bus_methods at91dci_bus_methods =
 	.set_stall = &at91dci_set_stall,
 	.clear_stall = &at91dci_clear_stall,
 	.vbus_interrupt = &at91dci_vbus_interrupt,
-	.rem_wakeup_set = &at91dci_rem_wakeup_set,
 };
diff --git a/sys/dev/usb2/controller/ehci2.c b/sys/dev/usb2/controller/ehci2.c
index fdecd7c..d41fde7 100644
--- a/sys/dev/usb2/controller/ehci2.c
+++ b/sys/dev/usb2/controller/ehci2.c
@@ -84,7 +84,7 @@ SYSCTL_INT(_hw_usb2_ehci, OID_AUTO, no_hs, CTLFLAG_RW,
     &ehcinohighspeed, 0, "Disable High Speed USB");
 
 static void ehci_dump_regs(ehci_softc_t *sc);
-static void ehci_dump_sqh(ehci_qh_t *sqh);
+static void ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *sqh);
 
 #endif
 
@@ -101,7 +101,7 @@ extern struct usb2_pipe_methods ehci_root_intr_methods;
 
 static usb2_config_td_command_t ehci_root_ctrl_task;
 static void ehci_do_poll(struct usb2_bus *bus);
-static void ehci_root_ctrl_poll(struct ehci_softc *sc);
+static void ehci_root_ctrl_poll(ehci_softc_t *sc);
 static void ehci_device_done(struct usb2_xfer *xfer, usb2_error_t error);
 static uint8_t ehci_check_transfer(struct usb2_xfer *xfer);
 static void ehci_timeout(void *arg);
@@ -110,6 +110,7 @@ static usb2_sw_transfer_func_t ehci_root_intr_done;
 static usb2_sw_transfer_func_t ehci_root_ctrl_done;
 
 struct ehci_std_temp {
+	ehci_softc_t *sc;
 	struct usb2_page_cache *pc;
 	ehci_qtd_t *td;
 	ehci_qtd_t *td_next;
@@ -123,10 +124,27 @@ struct ehci_std_temp {
 	uint8_t	short_frames_ok;
 };
 
+/*
+ * Byte-order conversion functions.
+ */
+static uint32_t
+htoehci32(ehci_softc_t *sc, const uint32_t v)
+{
+	return ((sc->sc_flags & EHCI_SCFLG_BIGEDESC) ?
+	    htobe32(v) : htole32(v));
+}
+
+static uint32_t
+ehci32toh(ehci_softc_t *sc, const uint32_t v)
+{
+	return ((sc->sc_flags & EHCI_SCFLG_BIGEDESC) ?
+	    be32toh(v) : le32toh(v));
+}
+
 void
 ehci_iterate_hw_softc(struct usb2_bus *bus, usb2_bus_mem_sub_cb_t *cb)
 {
-	struct ehci_softc *sc = EHCI_BUS2SC(bus);
+	ehci_softc_t *sc = EHCI_BUS2SC(bus);
 	uint32_t i;
 
 	cb(bus, &sc->sc_hw.pframes_pc, &sc->sc_hw.pframes_pg,
@@ -280,21 +298,21 @@ ehci_init(ehci_softc_t *sc)
 		sc->sc_intr_p_last[i] = qh;
 
 		qh->qh_self =
-		    htole32(buf_res.physaddr) |
-		    htole32(EHCI_LINK_QH);
+		    htoehci32(sc, buf_res.physaddr) |
+		    htoehci32(sc, EHCI_LINK_QH);
 
 		qh->qh_endp =
-		    htole32(EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH));
+		    htoehci32(sc, EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH));
 		qh->qh_endphub =
-		    htole32(EHCI_QH_SET_MULT(1));
+		    htoehci32(sc, EHCI_QH_SET_MULT(1));
 		qh->qh_curqtd = 0;
 
 		qh->qh_qtd.qtd_next =
-		    htole32(EHCI_LINK_TERMINATE);
+		    htoehci32(sc, EHCI_LINK_TERMINATE);
 		qh->qh_qtd.qtd_altnext =
-		    htole32(EHCI_LINK_TERMINATE);
+		    htoehci32(sc, EHCI_LINK_TERMINATE);
 		qh->qh_qtd.qtd_status =
-		    htole32(EHCI_QTD_HALTED);
+		    htoehci32(sc, EHCI_QTD_HALTED);
 	}
 
 	/*
@@ -329,7 +347,7 @@ ehci_init(ehci_softc_t *sc)
 		qh = sc->sc_intr_p_last[0];
 
 		/* the last (1ms) QH terminates */
-		qh->qh_link = htole32(EHCI_LINK_TERMINATE);
+		qh->qh_link = htoehci32(sc, EHCI_LINK_TERMINATE);
 	}
 	for (i = 0; i < EHCI_VIRTUAL_FRAMELIST_COUNT; i++) {
 		ehci_sitd_t *sitd;
@@ -350,11 +368,11 @@ ehci_init(ehci_softc_t *sc)
 		/* initialize full speed isochronous */
 
 		sitd->sitd_self =
-		    htole32(buf_res.physaddr) |
-		    htole32(EHCI_LINK_SITD);
+		    htoehci32(sc, buf_res.physaddr) |
+		    htoehci32(sc, EHCI_LINK_SITD);
 
 		sitd->sitd_back =
-		    htole32(EHCI_LINK_TERMINATE);
+		    htoehci32(sc, EHCI_LINK_TERMINATE);
 
 		sitd->sitd_next =
 		    sc->sc_intr_p_last[i | (EHCI_VIRTUAL_FRAMELIST_COUNT / 2)]->qh_self;
@@ -375,8 +393,8 @@ ehci_init(ehci_softc_t *sc)
 		/* initialize high speed isochronous */
 
 		itd->itd_self =
-		    htole32(buf_res.physaddr) |
-		    htole32(EHCI_LINK_ITD);
+		    htoehci32(sc, buf_res.physaddr) |
+		    htoehci32(sc, EHCI_LINK_ITD);
 
 		itd->itd_next =
 		    sitd->sitd_self;
@@ -421,20 +439,20 @@ ehci_init(ehci_softc_t *sc)
 		/* init dummy QH that starts the async list */
 
 		qh->qh_self =
-		    htole32(buf_res.physaddr) |
-		    htole32(EHCI_LINK_QH);
+		    htoehci32(sc, buf_res.physaddr) |
+		    htoehci32(sc, EHCI_LINK_QH);
 
 		/* fill the QH */
 		qh->qh_endp =
-		    htole32(EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH) | EHCI_QH_HRECL);
-		qh->qh_endphub = htole32(EHCI_QH_SET_MULT(1));
+		    htoehci32(sc, EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH) | EHCI_QH_HRECL);
+		qh->qh_endphub = htoehci32(sc, EHCI_QH_SET_MULT(1));
 		qh->qh_link = qh->qh_self;
 		qh->qh_curqtd = 0;
 
 		/* fill the overlay qTD */
-		qh->qh_qtd.qtd_next = htole32(EHCI_LINK_TERMINATE);
-		qh->qh_qtd.qtd_altnext = htole32(EHCI_LINK_TERMINATE);
-		qh->qh_qtd.qtd_status = htole32(EHCI_QTD_HALTED);
+		qh->qh_qtd.qtd_next = htoehci32(sc, EHCI_LINK_TERMINATE);
+		qh->qh_qtd.qtd_altnext = htoehci32(sc, EHCI_LINK_TERMINATE);
+		qh->qh_qtd.qtd_status = htoehci32(sc, EHCI_QTD_HALTED);
 	}
 	/* flush all cache into memory */
 
@@ -442,7 +460,7 @@ ehci_init(ehci_softc_t *sc)
 
 #if USB_DEBUG
 	if (ehcidebug) {
-		ehci_dump_sqh(sc->sc_async_p_last);
+		ehci_dump_sqh(sc, sc->sc_async_p_last);
 	}
 #endif
 
@@ -490,7 +508,7 @@ done:
  * shut down the controller when the system is going down
  */
 void
-ehci_detach(struct ehci_softc *sc)
+ehci_detach(ehci_softc_t *sc)
 {
 	USB_BUS_LOCK(&sc->sc_bus);
 
@@ -510,7 +528,7 @@ ehci_detach(struct ehci_softc *sc)
 }
 
 void
-ehci_suspend(struct ehci_softc *sc)
+ehci_suspend(ehci_softc_t *sc)
 {
 	uint32_t cmd;
 	uint32_t hcr;
@@ -564,7 +582,7 @@ ehci_suspend(struct ehci_softc *sc)
 }
 
 void
-ehci_resume(struct ehci_softc *sc)
+ehci_resume(ehci_softc_t *sc)
 {
 	struct usb2_page_search buf_res;
 	uint32_t cmd;
@@ -723,9 +741,9 @@ ehci_dump_regs(ehci_softc_t *sc)
 }
 
 static void
-ehci_dump_link(uint32_t link, int type)
+ehci_dump_link(ehci_softc_t *sc, uint32_t link, int type)
 {
-	link = le32toh(link);
+	link = ehci32toh(sc, link);
 	printf("0x%08x", link);
 	if (link & EHCI_LINK_TERMINATE)
 		printf("<T>");
@@ -752,16 +770,16 @@ ehci_dump_link(uint32_t link, int type)
 }
 
 static void
-ehci_dump_qtd(ehci_qtd_t *qtd)
+ehci_dump_qtd(ehci_softc_t *sc, ehci_qtd_t *qtd)
 {
 	uint32_t s;
 
 	printf("  next=");
-	ehci_dump_link(qtd->qtd_next, 0);
+	ehci_dump_link(sc, qtd->qtd_next, 0);
 	printf(" altnext=");
-	ehci_dump_link(qtd->qtd_altnext, 0);
+	ehci_dump_link(sc, qtd->qtd_altnext, 0);
 	printf("\n");
-	s = le32toh(qtd->qtd_status);
+	s = ehci32toh(sc, qtd->qtd_status);
 	printf("  status=0x%08x: toggle=%d bytes=0x%x ioc=%d c_page=0x%x\n",
 	    s, EHCI_QTD_GET_TOGGLE(s), EHCI_QTD_GET_BYTES(s),
 	    EHCI_QTD_GET_IOC(s), EHCI_QTD_GET_C_PAGE(s));
@@ -778,35 +796,35 @@ ehci_dump_qtd(ehci_qtd_t *qtd)
 
 	for (s = 0; s < 5; s++) {
 		printf("  buffer[%d]=0x%08x\n", s,
-		    le32toh(qtd->qtd_buffer[s]));
+		    ehci32toh(sc, qtd->qtd_buffer[s]));
 	}
 	for (s = 0; s < 5; s++) {
 		printf("  buffer_hi[%d]=0x%08x\n", s,
-		    le32toh(qtd->qtd_buffer_hi[s]));
+		    ehci32toh(sc, qtd->qtd_buffer_hi[s]));
 	}
 }
 
 static uint8_t
-ehci_dump_sqtd(ehci_qtd_t *sqtd)
+ehci_dump_sqtd(ehci_softc_t *sc, ehci_qtd_t *sqtd)
 {
 	uint8_t temp;
 
 	usb2_pc_cpu_invalidate(sqtd->page_cache);
-	printf("QTD(%p) at 0x%08x:\n", sqtd, le32toh(sqtd->qtd_self));
-	ehci_dump_qtd(sqtd);
-	temp = (sqtd->qtd_next & htole32(EHCI_LINK_TERMINATE)) ? 1 : 0;
+	printf("QTD(%p) at 0x%08x:\n", sqtd, ehci32toh(sc, sqtd->qtd_self));
+	ehci_dump_qtd(sc, sqtd);
+	temp = (sqtd->qtd_next & htoehci32(sc, EHCI_LINK_TERMINATE)) ? 1 : 0;
 	return (temp);
 }
 
 static void
-ehci_dump_sqtds(ehci_qtd_t *sqtd)
+ehci_dump_sqtds(ehci_softc_t *sc, ehci_qtd_t *sqtd)
 {
 	uint16_t i;
 	uint8_t stop;
 
 	stop = 0;
 	for (i = 0; sqtd && (i < 20) && !stop; sqtd = sqtd->obj_next, i++) {
-		stop = ehci_dump_sqtd(sqtd);
+		stop = ehci_dump_sqtd(sc, sqtd);
 	}
 	if (sqtd) {
 		printf("dump aborted, too many TDs\n");
@@ -814,16 +832,17 @@ ehci_dump_sqtds(ehci_qtd_t *sqtd)
 }
 
 static void
-ehci_dump_sqh(ehci_qh_t *qh)
+ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *qh)
 {
-	uint32_t endp, endphub;
+	uint32_t endp;
+	uint32_t endphub;
 
 	usb2_pc_cpu_invalidate(qh->page_cache);
-	printf("QH(%p) at 0x%08x:\n", qh, le32toh(qh->qh_self) & ~0x1F);
+	printf("QH(%p) at 0x%08x:\n", qh, ehci32toh(sc, qh->qh_self) & ~0x1F);
 	printf("  link=");
-	ehci_dump_link(qh->qh_link, 1);
+	ehci_dump_link(sc, qh->qh_link, 1);
 	printf("\n");
-	endp = le32toh(qh->qh_endp);
+	endp = ehci32toh(sc, qh->qh_endp);
 	printf("  endp=0x%08x\n", endp);
 	printf("    addr=0x%02x inact=%d endpt=%d eps=%d dtc=%d hrecl=%d\n",
 	    EHCI_QH_GET_ADDR(endp), EHCI_QH_GET_INACT(endp),
@@ -832,90 +851,90 @@ ehci_dump_sqh(ehci_qh_t *qh)
 	printf("    mpl=0x%x ctl=%d nrl=%d\n",
 	    EHCI_QH_GET_MPL(endp), EHCI_QH_GET_CTL(endp),
 	    EHCI_QH_GET_NRL(endp));
-	endphub = le32toh(qh->qh_endphub);
+	endphub = ehci32toh(sc, qh->qh_endphub);
 	printf("  endphub=0x%08x\n", endphub);
 	printf("    smask=0x%02x cmask=0x%02x huba=0x%02x port=%d mult=%d\n",
 	    EHCI_QH_GET_SMASK(endphub), EHCI_QH_GET_CMASK(endphub),
 	    EHCI_QH_GET_HUBA(endphub), EHCI_QH_GET_PORT(endphub),
 	    EHCI_QH_GET_MULT(endphub));
 	printf("  curqtd=");
-	ehci_dump_link(qh->qh_curqtd, 0);
+	ehci_dump_link(sc, qh->qh_curqtd, 0);
 	printf("\n");
 	printf("Overlay qTD:\n");
-	ehci_dump_qtd((void *)&qh->qh_qtd);
+	ehci_dump_qtd(sc, (void *)&qh->qh_qtd);
 }
 
 static void
-ehci_dump_sitd(ehci_sitd_t *sitd)
+ehci_dump_sitd(ehci_softc_t *sc, ehci_sitd_t *sitd)
 {
 	usb2_pc_cpu_invalidate(sitd->page_cache);
-	printf("SITD(%p) at 0x%08x\n", sitd, le32toh(sitd->sitd_self) & ~0x1F);
-	printf(" next=0x%08x\n", le32toh(sitd->sitd_next));
+	printf("SITD(%p) at 0x%08x\n", sitd, ehci32toh(sc, sitd->sitd_self) & ~0x1F);
+	printf(" next=0x%08x\n", ehci32toh(sc, sitd->sitd_next));
 	printf(" portaddr=0x%08x dir=%s addr=%d endpt=0x%x port=0x%x huba=0x%x\n",
-	    le32toh(sitd->sitd_portaddr),
-	    (sitd->sitd_portaddr & htole32(EHCI_SITD_SET_DIR_IN))
+	    ehci32toh(sc, sitd->sitd_portaddr),
+	    (sitd->sitd_portaddr & htoehci32(sc, EHCI_SITD_SET_DIR_IN))
 	    ? "in" : "out",
-	    EHCI_SITD_GET_ADDR(le32toh(sitd->sitd_portaddr)),
-	    EHCI_SITD_GET_ENDPT(le32toh(sitd->sitd_portaddr)),
-	    EHCI_SITD_GET_PORT(le32toh(sitd->sitd_portaddr)),
-	    EHCI_SITD_GET_HUBA(le32toh(sitd->sitd_portaddr)));
-	printf(" mask=0x%08x\n", le32toh(sitd->sitd_mask));
-	printf(" status=0x%08x <%s> len=0x%x\n", le32toh(sitd->sitd_status),
-	    (sitd->sitd_status & htole32(EHCI_SITD_ACTIVE)) ? "ACTIVE" : "",
-	    EHCI_SITD_GET_LEN(le32toh(sitd->sitd_status)));
+	    EHCI_SITD_GET_ADDR(ehci32toh(sc, sitd->sitd_portaddr)),
+	    EHCI_SITD_GET_ENDPT(ehci32toh(sc, sitd->sitd_portaddr)),
+	    EHCI_SITD_GET_PORT(ehci32toh(sc, sitd->sitd_portaddr)),
+	    EHCI_SITD_GET_HUBA(ehci32toh(sc, sitd->sitd_portaddr)));
+	printf(" mask=0x%08x\n", ehci32toh(sc, sitd->sitd_mask));
+	printf(" status=0x%08x <%s> len=0x%x\n", ehci32toh(sc, sitd->sitd_status),
+	    (sitd->sitd_status & htoehci32(sc, EHCI_SITD_ACTIVE)) ? "ACTIVE" : "",
+	    EHCI_SITD_GET_LEN(ehci32toh(sc, sitd->sitd_status)));
 	printf(" back=0x%08x, bp=0x%08x,0x%08x,0x%08x,0x%08x\n",
-	    le32toh(sitd->sitd_back),
-	    le32toh(sitd->sitd_bp[0]),
-	    le32toh(sitd->sitd_bp[1]),
-	    le32toh(sitd->sitd_bp_hi[0]),
-	    le32toh(sitd->sitd_bp_hi[1]));
+	    ehci32toh(sc, sitd->sitd_back),
+	    ehci32toh(sc, sitd->sitd_bp[0]),
+	    ehci32toh(sc, sitd->sitd_bp[1]),
+	    ehci32toh(sc, sitd->sitd_bp_hi[0]),
+	    ehci32toh(sc, sitd->sitd_bp_hi[1]));
 }
 
 static void
-ehci_dump_itd(ehci_itd_t *itd)
+ehci_dump_itd(ehci_softc_t *sc, ehci_itd_t *itd)
 {
 	usb2_pc_cpu_invalidate(itd->page_cache);
-	printf("ITD(%p) at 0x%08x\n", itd, le32toh(itd->itd_self) & ~0x1F);
-	printf(" next=0x%08x\n", le32toh(itd->itd_next));
-	printf(" status[0]=0x%08x; <%s>\n", le32toh(itd->itd_status[0]),
-	    (itd->itd_status[0] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" status[1]=0x%08x; <%s>\n", le32toh(itd->itd_status[1]),
-	    (itd->itd_status[1] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" status[2]=0x%08x; <%s>\n", le32toh(itd->itd_status[2]),
-	    (itd->itd_status[2] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" status[3]=0x%08x; <%s>\n", le32toh(itd->itd_status[3]),
-	    (itd->itd_status[3] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" status[4]=0x%08x; <%s>\n", le32toh(itd->itd_status[4]),
-	    (itd->itd_status[4] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" status[5]=0x%08x; <%s>\n", le32toh(itd->itd_status[5]),
-	    (itd->itd_status[5] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" status[6]=0x%08x; <%s>\n", le32toh(itd->itd_status[6]),
-	    (itd->itd_status[6] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" status[7]=0x%08x; <%s>\n", le32toh(itd->itd_status[7]),
-	    (itd->itd_status[7] & htole32(EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
-	printf(" bp[0]=0x%08x\n", le32toh(itd->itd_bp[0]));
+	printf("ITD(%p) at 0x%08x\n", itd, ehci32toh(sc, itd->itd_self) & ~0x1F);
+	printf(" next=0x%08x\n", ehci32toh(sc, itd->itd_next));
+	printf(" status[0]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[0]),
+	    (itd->itd_status[0] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" status[1]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[1]),
+	    (itd->itd_status[1] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" status[2]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[2]),
+	    (itd->itd_status[2] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" status[3]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[3]),
+	    (itd->itd_status[3] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" status[4]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[4]),
+	    (itd->itd_status[4] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" status[5]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[5]),
+	    (itd->itd_status[5] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" status[6]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[6]),
+	    (itd->itd_status[6] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" status[7]=0x%08x; <%s>\n", ehci32toh(sc, itd->itd_status[7]),
+	    (itd->itd_status[7] & htoehci32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : "");
+	printf(" bp[0]=0x%08x\n", ehci32toh(sc, itd->itd_bp[0]));
 	printf("  addr=0x%02x; endpt=0x%01x\n",
-	    EHCI_ITD_GET_ADDR(le32toh(itd->itd_bp[0])),
-	    EHCI_ITD_GET_ENDPT(le32toh(itd->itd_bp[0])));
-	printf(" bp[1]=0x%08x\n", le32toh(itd->itd_bp[1]));
+	    EHCI_ITD_GET_ADDR(ehci32toh(sc, itd->itd_bp[0])),
+	    EHCI_ITD_GET_ENDPT(ehci32toh(sc, itd->itd_bp[0])));
+	printf(" bp[1]=0x%08x\n", ehci32toh(sc, itd->itd_bp[1]));
 	printf(" dir=%s; mpl=0x%02x\n",
-	    (le32toh(itd->itd_bp[1]) & EHCI_ITD_SET_DIR_IN) ? "in" : "out",
-	    EHCI_ITD_GET_MPL(le32toh(itd->itd_bp[1])));
+	    (ehci32toh(sc, itd->itd_bp[1]) & EHCI_ITD_SET_DIR_IN) ? "in" : "out",
+	    EHCI_ITD_GET_MPL(ehci32toh(sc, itd->itd_bp[1])));
 	printf(" bp[2..6]=0x%08x,0x%08x,0x%08x,0x%08x,0x%08x\n",
-	    le32toh(itd->itd_bp[2]),
-	    le32toh(itd->itd_bp[3]),
-	    le32toh(itd->itd_bp[4]),
-	    le32toh(itd->itd_bp[5]),
-	    le32toh(itd->itd_bp[6]));
+	    ehci32toh(sc, itd->itd_bp[2]),
+	    ehci32toh(sc, itd->itd_bp[3]),
+	    ehci32toh(sc, itd->itd_bp[4]),
+	    ehci32toh(sc, itd->itd_bp[5]),
+	    ehci32toh(sc, itd->itd_bp[6]));
 	printf(" bp_hi=0x%08x,0x%08x,0x%08x,0x%08x,\n"
 	    "       0x%08x,0x%08x,0x%08x\n",
-	    le32toh(itd->itd_bp_hi[0]),
-	    le32toh(itd->itd_bp_hi[1]),
-	    le32toh(itd->itd_bp_hi[2]),
-	    le32toh(itd->itd_bp_hi[3]),
-	    le32toh(itd->itd_bp_hi[4]),
-	    le32toh(itd->itd_bp_hi[5]),
-	    le32toh(itd->itd_bp_hi[6]));
+	    ehci32toh(sc, itd->itd_bp_hi[0]),
+	    ehci32toh(sc, itd->itd_bp_hi[1]),
+	    ehci32toh(sc, itd->itd_bp_hi[2]),
+	    ehci32toh(sc, itd->itd_bp_hi[3]),
+	    ehci32toh(sc, itd->itd_bp_hi[4]),
+	    ehci32toh(sc, itd->itd_bp_hi[5]),
+	    ehci32toh(sc, itd->itd_bp_hi[6]));
 }
 
 static void
@@ -936,12 +955,12 @@ ehci_dump_isoc(ehci_softc_t *sc)
 	sitd = sc->sc_isoc_fs_p_last[pos];
 
 	while (itd && max && max--) {
-		ehci_dump_itd(itd);
+		ehci_dump_itd(sc, itd);
 		itd = itd->prev;
 	}
 
 	while (sitd && max && max--) {
-		ehci_dump_sitd(sitd);
+		ehci_dump_sitd(sc, sitd);
 		sitd = sitd->prev;
 	}
 }
@@ -1022,6 +1041,11 @@ _ehci_append_qh(ehci_qh_t *sqh, ehci_qh_t *last)
 {
 	DPRINTFN(11, "%p to %p\n", sqh, last);
 
+	if (sqh->prev != NULL) {
+		/* should not happen */
+		DPRINTFN(0, "QH already linked!\n");
+		return (last);
+	}
 	/* (sc->sc_bus.mtx) must be locked */
 
 	sqh->next = last->next;
@@ -1040,12 +1064,6 @@ _ehci_append_qh(ehci_qh_t *sqh, ehci_qh_t *last)
 
 	usb2_pc_cpu_flush(last->page_cache);
 
-#if USB_DEBUG
-	if (ehcidebug > 5) {
-		printf("%s:\n", __FUNCTION__);
-		ehci_dump_sqh(sqh);
-	}
-#endif
 	return (sqh);
 }
 
@@ -1109,14 +1127,6 @@ _ehci_remove_qh(ehci_qh_t *sqh, ehci_qh_t *last)
 			sqh->next->prev = sqh->prev;
 			usb2_pc_cpu_flush(sqh->next->page_cache);
 		}
-		/*
-		 * set the Terminate-bit in the e_next of the QH, in case
-		 * the transferred packet was short so that the QH still
-		 * points at the last used TD
-		 */
-
-		sqh->qh_qtd.qtd_next = htole32(EHCI_LINK_TERMINATE);
-
 		last = ((last == sqh) ? sqh->prev : last);
 
 		sqh->prev = 0;
@@ -1129,6 +1139,7 @@ _ehci_remove_qh(ehci_qh_t *sqh, ehci_qh_t *last)
 static usb2_error_t
 ehci_non_isoc_done_sub(struct usb2_xfer *xfer)
 {
+	ehci_softc_t *sc = xfer->usb2_sc;
 	ehci_qtd_t *td;
 	ehci_qtd_t *td_alt_next;
 	uint32_t status;
@@ -1140,7 +1151,7 @@ ehci_non_isoc_done_sub(struct usb2_xfer *xfer)
 	while (1) {
 
 		usb2_pc_cpu_invalidate(td->page_cache);
-		status = le32toh(td->qtd_status);
+		status = ehci32toh(sc, td->qtd_status);
 
 		len = EHCI_QTD_GET_BYTES(status);
 
@@ -1232,7 +1243,9 @@ ehci_non_isoc_done(struct usb2_xfer *xfer)
 
 #if USB_DEBUG
 	if (ehcidebug > 10) {
-		ehci_dump_sqtds(xfer->td_transfer_first);
+		ehci_softc_t *sc = xfer->usb2_sc;
+
+		ehci_dump_sqtds(sc, xfer->td_transfer_first);
 	}
 #endif
 
@@ -1282,6 +1295,7 @@ static uint8_t
 ehci_check_transfer(struct usb2_xfer *xfer)
 {
 	struct usb2_pipe_methods *methods = xfer->pipe->methods;
+	ehci_softc_t *sc = xfer->usb2_sc;
 
 	uint32_t status;
 
@@ -1294,13 +1308,13 @@ ehci_check_transfer(struct usb2_xfer *xfer)
 
 		td = xfer->td_transfer_last;
 		usb2_pc_cpu_invalidate(td->page_cache);
-		status = le32toh(td->sitd_status);
+		status = ehci32toh(sc, td->sitd_status);
 
 		/* also check if first is complete */
 
 		td = xfer->td_transfer_first;
 		usb2_pc_cpu_invalidate(td->page_cache);
-		status |= le32toh(td->sitd_status);
+		status |= ehci32toh(sc, td->sitd_status);
 
 		if (!(status & EHCI_SITD_ACTIVE)) {
 			ehci_device_done(xfer, USB_ERR_NORMAL_COMPLETION);
@@ -1329,7 +1343,7 @@ ehci_check_transfer(struct usb2_xfer *xfer)
 		    td->itd_status[6] | td->itd_status[7];
 
 		/* if no transactions are active we continue */
-		if (!(status & htole32(EHCI_ITD_ACTIVE))) {
+		if (!(status & htoehci32(sc, EHCI_ITD_ACTIVE))) {
 			ehci_device_done(xfer, USB_ERR_NORMAL_COMPLETION);
 			goto transferred;
 		}
@@ -1346,7 +1360,7 @@ ehci_check_transfer(struct usb2_xfer *xfer)
 
 		while (1) {
 			usb2_pc_cpu_invalidate(td->page_cache);
-			status = le32toh(td->qtd_status);
+			status = ehci32toh(sc, td->qtd_status);
 
 			/*
 			 * if there is an active TD the transfer isn't done
@@ -1520,7 +1534,7 @@ ehci_timeout(void *arg)
 static void
 ehci_do_poll(struct usb2_bus *bus)
 {
-	struct ehci_softc *sc = EHCI_BUS2SC(bus);
+	ehci_softc_t *sc = EHCI_BUS2SC(bus);
 
 	USB_BUS_LOCK(&sc->sc_bus);
 	ehci_interrupt_poll(sc);
@@ -1542,7 +1556,7 @@ ehci_setup_standard_chain_sub(struct ehci_std_temp *temp)
 	uint8_t shortpkt_old;
 	uint8_t precompute;
 
-	qtd_altnext = htole32(EHCI_LINK_TERMINATE);
+	qtd_altnext = htoehci32(temp->sc, EHCI_LINK_TERMINATE);
 	td_alt_next = NULL;
 	buf_offset = 0;
 	shortpkt_old = temp->shortpkt;
@@ -1599,7 +1613,8 @@ restart:
 		/* fill out current TD */
 
 		td->qtd_status =
-		    temp->qtd_status | htole32(EHCI_QTD_SET_BYTES(average));
+		    temp->qtd_status |
+		    htoehci32(temp->sc, EHCI_QTD_SET_BYTES(average));
 
 		if (average == 0) {
 
@@ -1607,7 +1622,8 @@ restart:
 
 				/* update data toggle, ZLP case */
 
-				temp->qtd_status ^= htole32(EHCI_QTD_TOGGLE_MASK);
+				temp->qtd_status ^=
+				    htoehci32(temp->sc, EHCI_QTD_TOGGLE_MASK);
 			}
 			td->len = 0;
 
@@ -1627,7 +1643,8 @@ restart:
 
 				if (((average + temp->max_frame_size - 1) /
 				    temp->max_frame_size) & 1) {
-					temp->qtd_status ^= htole32(EHCI_QTD_TOGGLE_MASK);
+					temp->qtd_status ^=
+					    htoehci32(temp->sc, EHCI_QTD_TOGGLE_MASK);
 				}
 			}
 			td->len = average;
@@ -1639,7 +1656,8 @@ restart:
 			/* fill out buffer pointers */
 
 			usb2_get_page(temp->pc, buf_offset, &buf_res);
-			td->qtd_buffer[0] = htole32(buf_res.physaddr);
+			td->qtd_buffer[0] =
+			    htoehci32(temp->sc, buf_res.physaddr);
 			td->qtd_buffer_hi[0] = 0;
 
 			x = 1;
@@ -1648,7 +1666,9 @@ restart:
 				average -= EHCI_PAGE_SIZE;
 				buf_offset += EHCI_PAGE_SIZE;
 				usb2_get_page(temp->pc, buf_offset, &buf_res);
-				td->qtd_buffer[x] = htole32(buf_res.physaddr & (~0xFFF));
+				td->qtd_buffer[x] =
+				    htoehci32(temp->sc,
+				    buf_res.physaddr & (~0xFFF));
 				td->qtd_buffer_hi[x] = 0;
 				x++;
 			}
@@ -1663,7 +1683,9 @@ restart:
 			 */
 			buf_offset += average;
 			usb2_get_page(temp->pc, buf_offset - 1, &buf_res);
-			td->qtd_buffer[x] = htole32(buf_res.physaddr & (~0xFFF));
+			td->qtd_buffer[x] =
+			    htoehci32(temp->sc,
+			    buf_res.physaddr & (~0xFFF));
 			td->qtd_buffer_hi[x] = 0;
 		}
 
@@ -1717,6 +1739,7 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 
 	temp.average = xfer->max_usb2_frame_size;
 	temp.max_frame_size = xfer->max_frame_size;
+	temp.sc = xfer->usb2_sc;
 
 	/* toggle the DMA set we are using */
 	xfer->flags_int.curr_dma_set ^= 1;
@@ -1736,7 +1759,8 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 	if (xfer->flags_int.control_xfr) {
 		if (xfer->pipe->toggle_next) {
 			/* DATA1 is next */
-			temp.qtd_status |= htole32(EHCI_QTD_SET_TOGGLE(1));
+			temp.qtd_status |=
+			    htoehci32(temp.sc, EHCI_QTD_SET_TOGGLE(1));
 		}
 		temp.auto_data_toggle = 0;
 	} else {
@@ -1745,14 +1769,16 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 
 	if (usb2_get_speed(xfer->udev) != USB_SPEED_HIGH) {
 		/* max 3 retries */
-		temp.qtd_status |= htole32(EHCI_QTD_SET_CERR(3));
+		temp.qtd_status |=
+		    htoehci32(temp.sc, EHCI_QTD_SET_CERR(3));
 	}
 	/* check if we should prepend a setup message */
 
 	if (xfer->flags_int.control_xfr) {
 		if (xfer->flags_int.control_hdr) {
 
-			temp.qtd_status &= htole32(EHCI_QTD_SET_CERR(3));
+			temp.qtd_status &=
+			    htoehci32(temp.sc, EHCI_QTD_SET_CERR(3));
 			temp.qtd_status |= htole32
 			    (EHCI_QTD_ACTIVE |
 			    EHCI_QTD_SET_PID(EHCI_QTD_PID_SETUP) |
@@ -1783,7 +1809,8 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 		}
 		/* keep previous data toggle and error count */
 
-		temp.qtd_status &= htole32(EHCI_QTD_SET_CERR(3) |
+		temp.qtd_status &=
+		    htoehci32(temp.sc, EHCI_QTD_SET_CERR(3) |
 		    EHCI_QTD_SET_TOGGLE(1));
 
 		if (temp.len == 0) {
@@ -1803,9 +1830,9 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 
 		temp.qtd_status |=
 		    (UE_GET_DIR(xfer->endpoint) == UE_DIR_IN) ?
-		    htole32(EHCI_QTD_ACTIVE |
+		    htoehci32(temp.sc, EHCI_QTD_ACTIVE |
 		    EHCI_QTD_SET_PID(EHCI_QTD_PID_IN)) :
-		    htole32(EHCI_QTD_ACTIVE |
+		    htoehci32(temp.sc, EHCI_QTD_ACTIVE |
 		    EHCI_QTD_SET_PID(EHCI_QTD_PID_OUT));
 
 		ehci_setup_standard_chain_sub(&temp);
@@ -1821,14 +1848,14 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 		 * direction.
 		 */
 
-		temp.qtd_status &= htole32(EHCI_QTD_SET_CERR(3) |
+		temp.qtd_status &= htoehci32(temp.sc, EHCI_QTD_SET_CERR(3) |
 		    EHCI_QTD_SET_TOGGLE(1));
 		temp.qtd_status |=
 		    (UE_GET_DIR(xfer->endpoint) == UE_DIR_OUT) ?
-		    htole32(EHCI_QTD_ACTIVE |
+		    htoehci32(temp.sc, EHCI_QTD_ACTIVE |
 		    EHCI_QTD_SET_PID(EHCI_QTD_PID_IN) |
 		    EHCI_QTD_SET_TOGGLE(1)) :
-		    htole32(EHCI_QTD_ACTIVE |
+		    htoehci32(temp.sc, EHCI_QTD_ACTIVE |
 		    EHCI_QTD_SET_PID(EHCI_QTD_PID_OUT) |
 		    EHCI_QTD_SET_TOGGLE(1));
 
@@ -1841,9 +1868,9 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 	td = temp.td;
 
 	/* the last TD terminates the transfer: */
-	td->qtd_next = htole32(EHCI_LINK_TERMINATE);
-	td->qtd_altnext = htole32(EHCI_LINK_TERMINATE);
-	td->qtd_status |= htole32(EHCI_QTD_IOC);
+	td->qtd_next = htoehci32(temp.sc, EHCI_LINK_TERMINATE);
+	td->qtd_altnext = htoehci32(temp.sc, EHCI_LINK_TERMINATE);
+	td->qtd_status |= htoehci32(temp.sc, EHCI_QTD_IOC);
 
 	usb2_pc_cpu_flush(td->page_cache);
 
@@ -1855,7 +1882,8 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 	if (ehcidebug > 8) {
 		DPRINTF("nexttog=%d; data before transfer:\n",
 		    xfer->pipe->toggle_next);
-		ehci_dump_sqtds(xfer->td_transfer_first);
+		ehci_dump_sqtds(temp.sc,
+		    xfer->td_transfer_first);
 	}
 #endif
 
@@ -1892,7 +1920,7 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 		}
 	}
 
-	qh->qh_endp = htole32(qh_endp);
+	qh->qh_endp = htoehci32(temp.sc, qh_endp);
 
 	qh_endphub =
 	    (EHCI_QH_SET_MULT(xfer->max_packet_count & 3) |
@@ -1901,38 +1929,42 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 	    EHCI_QH_SET_HUBA(xfer->udev->hs_hub_addr) |
 	    EHCI_QH_SET_PORT(xfer->udev->hs_port_no));
 
-	qh->qh_endphub = htole32(qh_endphub);
-	qh->qh_curqtd = htole32(0);
+	qh->qh_endphub = htoehci32(temp.sc, qh_endphub);
+	qh->qh_curqtd = htoehci32(temp.sc, 0);
 
 	/* fill the overlay qTD */
-	qh->qh_qtd.qtd_status = htole32(0);
+	qh->qh_qtd.qtd_status = htoehci32(temp.sc, 0);
 
 	if (temp.auto_data_toggle) {
 
 		/* let the hardware compute the data toggle */
 
-		qh->qh_endp &= ~htole32(EHCI_QH_DTC);
+		qh->qh_endp &= htoehci32(temp.sc, ~EHCI_QH_DTC);
 
 		if (xfer->pipe->toggle_next) {
 			/* DATA1 is next */
-			qh->qh_qtd.qtd_status |= htole32(EHCI_QTD_SET_TOGGLE(1));
+			qh->qh_qtd.qtd_status |=
+			    htoehci32(temp.sc, EHCI_QTD_SET_TOGGLE(1));
 		}
 	}
 	td = xfer->td_transfer_first;
 
 	qh->qh_qtd.qtd_next = td->qtd_self;
-	qh->qh_qtd.qtd_altnext = htole32(EHCI_LINK_TERMINATE);
+	qh->qh_qtd.qtd_altnext =
+	    htoehci32(temp.sc, EHCI_LINK_TERMINATE);
 
 	usb2_pc_cpu_flush(qh->page_cache);
 
-	EHCI_APPEND_QH(qh, *qh_last);
+	if (xfer->udev->pwr_save.suspended == 0) {
+		EHCI_APPEND_QH(qh, *qh_last);
+	}
 }
 
 static void
 ehci_root_intr_done(struct usb2_xfer *xfer,
     struct usb2_sw_transfer *std)
 {
-	struct ehci_softc *sc = xfer->usb2_sc;
+	ehci_softc_t *sc = xfer->usb2_sc;
 	uint16_t i;
 	uint16_t m;
 
@@ -1992,11 +2024,11 @@ ehci_isoc_fs_done(ehci_softc_t *sc, struct usb2_xfer *xfer)
 #if USB_DEBUG
 		if (ehcidebug > 15) {
 			DPRINTF("isoc FS-TD\n");
-			ehci_dump_sitd(td);
+			ehci_dump_sitd(sc, td);
 		}
 #endif
 		usb2_pc_cpu_invalidate(td->page_cache);
-		status = le32toh(td->sitd_status);
+		status = ehci32toh(sc, td->sitd_status);
 
 		len = EHCI_SITD_GET_LEN(status);
 
@@ -2044,12 +2076,12 @@ ehci_isoc_hs_done(ehci_softc_t *sc, struct usb2_xfer *xfer)
 #if USB_DEBUG
 		if (ehcidebug > 15) {
 			DPRINTF("isoc HS-TD\n");
-			ehci_dump_itd(td);
+			ehci_dump_itd(sc, td);
 		}
 #endif
 
 		usb2_pc_cpu_invalidate(td->page_cache);
-		status = le32toh(td->itd_status[td_no]);
+		status = ehci32toh(sc, td->itd_status[td_no]);
 
 		len = EHCI_ITD_GET_LEN(status);
 
@@ -2102,7 +2134,8 @@ ehci_device_done(struct usb2_xfer *xfer, usb2_error_t error)
 		if (ehcidebug > 8) {
 			DPRINTF("nexttog=%d; data after transfer:\n",
 			    xfer->pipe->toggle_next);
-			ehci_dump_sqtds(xfer->td_transfer_first);
+			ehci_dump_sqtds(xfer->usb2_sc,
+			    xfer->td_transfer_first);
 		}
 #endif
 
@@ -2322,6 +2355,7 @@ struct usb2_pipe_methods ehci_device_intr_methods =
 static void
 ehci_device_isoc_fs_open(struct usb2_xfer *xfer)
 {
+	ehci_softc_t *sc = xfer->usb2_sc;
 	ehci_sitd_t *td;
 	uint32_t sitd_portaddr;
 	uint8_t ds;
@@ -2335,7 +2369,7 @@ ehci_device_isoc_fs_open(struct usb2_xfer *xfer)
 	if (UE_GET_DIR(xfer->endpoint) == UE_DIR_IN) {
 		sitd_portaddr |= EHCI_SITD_SET_DIR_IN;
 	}
-	sitd_portaddr = htole32(sitd_portaddr);
+	sitd_portaddr = htoehci32(sc, sitd_portaddr);
 
 	/* initialize all TD's */
 
@@ -2352,7 +2386,7 @@ ehci_device_isoc_fs_open(struct usb2_xfer *xfer)
 			 *
 			 * micro-frame usage (8 microframes per 1ms)
 			 */
-			td->sitd_back = htole32(EHCI_LINK_TERMINATE);
+			td->sitd_back = htoehci32(sc, EHCI_LINK_TERMINATE);
 
 			usb2_pc_cpu_flush(td->page_cache);
 		}
@@ -2499,7 +2533,7 @@ ehci_device_isoc_fs_enter(struct usb2_xfer *xfer)
 			 * non-zero length
 			 */
 			usb2_get_page(xfer->frbuffers, buf_offset, &buf_res);
-			td->sitd_bp[0] = htole32(buf_res.physaddr);
+			td->sitd_bp[0] = htoehci32(sc, buf_res.physaddr);
 			buf_offset += *plen;
 			/*
 			 * NOTE: We need to subtract one from the offset so
@@ -2544,9 +2578,9 @@ ehci_device_isoc_fs_enter(struct usb2_xfer *xfer)
 		sitd_mask = (EHCI_SITD_SET_SMASK(sa) |
 		    EHCI_SITD_SET_CMASK(sb));
 
-		td->sitd_bp[1] = htole32(temp);
+		td->sitd_bp[1] = htoehci32(sc, temp);
 
-		td->sitd_mask = htole32(sitd_mask);
+		td->sitd_mask = htoehci32(sc, sitd_mask);
 
 		if (nframes == 0) {
 			td->sitd_status = htole32
@@ -2563,7 +2597,7 @@ ehci_device_isoc_fs_enter(struct usb2_xfer *xfer)
 #if USB_DEBUG
 		if (ehcidebug > 15) {
 			DPRINTF("FS-TD %d\n", nframes);
-			ehci_dump_sitd(td);
+			ehci_dump_sitd(sc, td);
 		}
 #endif
 		/* insert TD into schedule */
@@ -2606,6 +2640,7 @@ struct usb2_pipe_methods ehci_device_isoc_fs_methods =
 static void
 ehci_device_isoc_hs_open(struct usb2_xfer *xfer)
 {
+	ehci_softc_t *sc = xfer->usb2_sc;
 	ehci_itd_t *td;
 	uint32_t temp;
 	uint8_t ds;
@@ -2639,10 +2674,10 @@ ehci_device_isoc_hs_open(struct usb2_xfer *xfer)
 				temp |= EHCI_ITD_SET_DIR_IN;
 			}
 			/* set maximum packet size */
-			td->itd_bp[1] = htole32(temp);
+			td->itd_bp[1] = htoehci32(sc, temp);
 
 			/* set transfer multiplier */
-			td->itd_bp[2] = htole32(xfer->max_packet_count & 3);
+			td->itd_bp[2] = htoehci32(sc, xfer->max_packet_count & 3);
 
 			usb2_pc_cpu_flush(td->page_cache);
 		}
@@ -2764,7 +2799,7 @@ ehci_device_isoc_hs_enter(struct usb2_xfer *xfer)
 		status = (EHCI_ITD_SET_LEN(*plen) |
 		    EHCI_ITD_ACTIVE |
 		    EHCI_ITD_SET_PG(0));
-		td->itd_status[td_no] = htole32(status);
+		td->itd_status[td_no] = htoehci32(sc, status);
 		itd_offset[td_no] = buf_offset;
 		buf_offset += *plen;
 		plen++;
@@ -2787,14 +2822,14 @@ ehci_device_isoc_hs_enter(struct usb2_xfer *xfer)
 				/* get page address */
 				page_addr = buf_res.physaddr & ~0xFFF;
 				/* update page address */
-				td->itd_bp[0] &= htole32(0xFFF);
-				td->itd_bp[0] |= htole32(page_addr);
+				td->itd_bp[0] &= htoehci32(sc, 0xFFF);
+				td->itd_bp[0] |= htoehci32(sc, page_addr);
 
 				for (x = 0; x != td_no; x++) {
 					/* set page number and page offset */
 					status = (EHCI_ITD_SET_PG(page_no) |
 					    (buf_res.physaddr & 0xFFF));
-					td->itd_status[x] |= htole32(status);
+					td->itd_status[x] |= htoehci32(sc, status);
 
 					/* get next page offset */
 					if (itd_offset[x + 1] == buf_offset) {
@@ -2817,20 +2852,20 @@ ehci_device_isoc_hs_enter(struct usb2_xfer *xfer)
 						}
 						page_no++;
 						/* update page address */
-						td->itd_bp[page_no] &= htole32(0xFFF);
-						td->itd_bp[page_no] |= htole32(page_addr);
+						td->itd_bp[page_no] &= htoehci32(sc, 0xFFF);
+						td->itd_bp[page_no] |= htoehci32(sc, page_addr);
 					}
 				}
 			}
 			/* set IOC bit if we are complete */
 			if (nframes == 0) {
-				td->itd_status[7] |= htole32(EHCI_ITD_IOC);
+				td->itd_status[7] |= htoehci32(sc, EHCI_ITD_IOC);
 			}
 			usb2_pc_cpu_flush(td->page_cache);
 #if USB_DEBUG
 			if (ehcidebug > 15) {
 				DPRINTF("HS-TD %d\n", nframes);
-				ehci_dump_itd(td);
+				ehci_dump_itd(sc, td);
 			}
 #endif
 			/* insert TD into schedule */
@@ -3001,7 +3036,7 @@ ehci_root_ctrl_start(struct usb2_xfer *xfer)
 }
 
 static void
-ehci_root_ctrl_task(struct ehci_softc *sc,
+ehci_root_ctrl_task(ehci_softc_t *sc,
     struct usb2_config_td_cc *cc, uint16_t refcount)
 {
 	ehci_root_ctrl_poll(sc);
@@ -3011,7 +3046,7 @@ static void
 ehci_root_ctrl_done(struct usb2_xfer *xfer,
     struct usb2_sw_transfer *std)
 {
-	struct ehci_softc *sc = xfer->usb2_sc;
+	ehci_softc_t *sc = xfer->usb2_sc;
 	char *ptr;
 	uint32_t port;
 	uint32_t v;
@@ -3176,7 +3211,32 @@ ehci_root_ctrl_done(struct usb2_xfer *xfer,
 			EOWRITE4(sc, port, v & ~EHCI_PS_PE);
 			break;
 		case UHF_PORT_SUSPEND:
-			EOWRITE4(sc, port, v & ~EHCI_PS_SUSP);
+			if ((v & EHCI_PS_SUSP) && (!(v & EHCI_PS_FPR))) {
+
+				/*
+				 * waking up a High Speed device is rather
+				 * complicated if
+				 */
+				EOWRITE4(sc, port, v | EHCI_PS_FPR);
+			}
+			/* wait 20ms for resume sequence to complete */
+			if (use_polling) {
+				/* polling */
+				DELAY(20 * 1000);
+			} else {
+				usb2_pause_mtx(&sc->sc_bus.bus_mtx, 20);
+			}
+
+			EOWRITE4(sc, port, v & ~(EHCI_PS_SUSP |
+			    EHCI_PS_FPR | (3 << 10) /* High Speed */ ));
+
+			/* settle time */
+			if (use_polling) {
+				/* polling */
+				DELAY(4 * 1000);
+			} else {
+				usb2_pause_mtx(&sc->sc_bus.bus_mtx, 4);
+			}
 			break;
 		case UHF_PORT_POWER:
 			EOWRITE4(sc, port, v & ~EHCI_PS_PP);
@@ -3223,7 +3283,8 @@ ehci_root_ctrl_done(struct usb2_xfer *xfer,
 		    (EHCI_HCS_PPC(v) ? UHD_PWR_INDIVIDUAL : UHD_PWR_NO_SWITCH) |
 		    (EHCI_HCS_P_INDICATOR(EREAD4(sc, EHCI_HCSPARAMS)) ?
 		    UHD_PORT_IND : 0));
-		sc->sc_hub_desc.hubd.bPwrOn2PwrGood = 200;	/* XXX can't find out? */
+		/* XXX can't find out? */
+		sc->sc_hub_desc.hubd.bPwrOn2PwrGood = 200;
 		for (l = 0; l < sc->sc_noport; l++) {
 			/* XXX can't find out? */
 			sc->sc_hub_desc.hubd.DeviceRemovable[l / 8] &= ~(1 << (l % 8));
@@ -3260,7 +3321,7 @@ ehci_root_ctrl_done(struct usb2_xfer *xfer,
 			i |= UPS_CURRENT_CONNECT_STATUS;
 		if (v & EHCI_PS_PE)
 			i |= UPS_PORT_ENABLED;
-		if (v & EHCI_PS_SUSP)
+		if ((v & EHCI_PS_SUSP) && !(v & EHCI_PS_FPR))
 			i |= UPS_SUSPEND;
 		if (v & EHCI_PS_OCA)
 			i |= UPS_OVERCURRENT_INDICATOR;
@@ -3276,6 +3337,8 @@ ehci_root_ctrl_done(struct usb2_xfer *xfer,
 			i |= UPS_C_PORT_ENABLED;
 		if (v & EHCI_PS_OCC)
 			i |= UPS_C_OVERCURRENT_INDICATOR;
+		if (v & EHCI_PS_FPR)
+			i |= UPS_C_SUSPEND;
 		if (sc->sc_isreset)
 			i |= UPS_C_PORT_RESET;
 		USETW(sc->sc_hub_desc.ps.wPortChange, i);
@@ -3398,7 +3461,7 @@ done:
 }
 
 static void
-ehci_root_ctrl_poll(struct ehci_softc *sc)
+ehci_root_ctrl_poll(ehci_softc_t *sc)
 {
 	usb2_sw_transfer(&sc->sc_root_ctrl,
 	    &ehci_root_ctrl_done);
@@ -3621,7 +3684,7 @@ alloc_dma_set:
 			td = page_info.buffer;
 
 			/* init TD */
-			td->itd_self = htole32(page_info.physaddr | EHCI_LINK_ITD);
+			td->itd_self = htoehci32(sc, page_info.physaddr | EHCI_LINK_ITD);
 			td->obj_next = last_obj;
 			td->page_cache = pc + n;
 
@@ -3645,7 +3708,7 @@ alloc_dma_set:
 			td = page_info.buffer;
 
 			/* init TD */
-			td->sitd_self = htole32(page_info.physaddr | EHCI_LINK_SITD);
+			td->sitd_self = htoehci32(sc, page_info.physaddr | EHCI_LINK_SITD);
 			td->obj_next = last_obj;
 			td->page_cache = pc + n;
 
@@ -3669,7 +3732,7 @@ alloc_dma_set:
 			qtd = page_info.buffer;
 
 			/* init TD */
-			qtd->qtd_self = htole32(page_info.physaddr);
+			qtd->qtd_self = htoehci32(sc, page_info.physaddr);
 			qtd->obj_next = last_obj;
 			qtd->page_cache = pc + n;
 
@@ -3697,7 +3760,7 @@ alloc_dma_set:
 			qh = page_info.buffer;
 
 			/* init QH */
-			qh->qh_self = htole32(page_info.physaddr | EHCI_LINK_QH);
+			qh->qh_self = htoehci32(sc, page_info.physaddr | EHCI_LINK_QH);
 			qh->obj_next = last_obj;
 			qh->page_cache = pc + n;
 
@@ -3794,6 +3857,108 @@ ehci_get_dma_delay(struct usb2_bus *bus, uint32_t *pus)
 	*pus = (188);			/* microseconds */
 }
 
+static void
+ehci_device_resume(struct usb2_device *udev)
+{
+	ehci_softc_t *sc = EHCI_BUS2SC(udev->bus);
+	struct usb2_xfer *xfer;
+	struct usb2_pipe_methods *methods;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(udev->bus);
+
+	TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
+
+		if (xfer->udev == udev) {
+
+			methods = xfer->pipe->methods;
+
+			if ((methods == &ehci_device_bulk_methods) ||
+			    (methods == &ehci_device_ctrl_methods)) {
+				EHCI_APPEND_QH(xfer->qh_start[xfer->flags_int.curr_dma_set],
+				    sc->sc_async_p_last);
+			}
+			if (methods == &ehci_device_intr_methods) {
+				EHCI_APPEND_QH(xfer->qh_start[xfer->flags_int.curr_dma_set],
+				    sc->sc_intr_p_last[xfer->qh_pos]);
+			}
+		}
+	}
+
+	USB_BUS_UNLOCK(udev->bus);
+
+	return;
+}
+
+static void
+ehci_device_suspend(struct usb2_device *udev)
+{
+	ehci_softc_t *sc = EHCI_BUS2SC(udev->bus);
+	struct usb2_xfer *xfer;
+	struct usb2_pipe_methods *methods;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(udev->bus);
+
+	TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
+
+		if (xfer->udev == udev) {
+
+			methods = xfer->pipe->methods;
+
+			if ((methods == &ehci_device_bulk_methods) ||
+			    (methods == &ehci_device_ctrl_methods)) {
+				EHCI_REMOVE_QH(xfer->qh_start[xfer->flags_int.curr_dma_set],
+				    sc->sc_async_p_last);
+			}
+			if (methods == &ehci_device_intr_methods) {
+				EHCI_REMOVE_QH(xfer->qh_start[xfer->flags_int.curr_dma_set],
+				    sc->sc_intr_p_last[xfer->qh_pos]);
+			}
+		}
+	}
+
+	USB_BUS_UNLOCK(udev->bus);
+
+	return;
+}
+
+static void
+ehci_set_hw_power(struct usb2_bus *bus)
+{
+	ehci_softc_t *sc = EHCI_BUS2SC(bus);
+	uint32_t temp;
+	uint32_t flags;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(bus);
+
+	flags = bus->hw_power_state;
+
+	temp = EOREAD4(sc, EHCI_USBCMD);
+
+	temp &= ~(EHCI_CMD_ASE | EHCI_CMD_PSE);
+
+	if (flags & (USB_HW_POWER_CONTROL |
+	    USB_HW_POWER_BULK)) {
+		DPRINTF("Async is active\n");
+		temp |= EHCI_CMD_ASE;
+	}
+	if (flags & (USB_HW_POWER_INTERRUPT |
+	    USB_HW_POWER_ISOC)) {
+		DPRINTF("Periodic is active\n");
+		temp |= EHCI_CMD_PSE;
+	}
+	EOWRITE4(sc, EHCI_USBCMD, temp);
+
+	USB_BUS_UNLOCK(bus);
+
+	return;
+}
+
 struct usb2_bus_methods ehci_bus_methods =
 {
 	.pipe_init = ehci_pipe_init,
@@ -3801,4 +3966,7 @@ struct usb2_bus_methods ehci_bus_methods =
 	.xfer_unsetup = ehci_xfer_unsetup,
 	.do_poll = ehci_do_poll,
 	.get_dma_delay = ehci_get_dma_delay,
+	.device_resume = ehci_device_resume,
+	.device_suspend = ehci_device_suspend,
+	.set_hw_power = ehci_set_hw_power,
 };
diff --git a/sys/dev/usb2/controller/ehci2.h b/sys/dev/usb2/controller/ehci2.h
index 6765ace..3dee6bd 100644
--- a/sys/dev/usb2/controller/ehci2.h
+++ b/sys/dev/usb2/controller/ehci2.h
@@ -160,6 +160,15 @@
 #define	EHCI_PS_CS		0x00000001	/* RO connect status */
 #define	EHCI_PS_CLEAR		(EHCI_PS_OCC | EHCI_PS_PEC | EHCI_PS_CSC)
 
+#define	EHCI_USBMODE		0x68	/* RW USB Device mode register */
+#define	EHCI_UM_CM		0x00000003	/* R/WO Controller Mode */
+#define	EHCI_UM_CM_IDLE		0x0	/* Idle */
+#define	EHCI_UM_CM_HOST		0x3	/* Host Controller */
+#define	EHCI_UM_ES		0x00000004	/* R/WO Endian Select */
+#define	EHCI_UM_ES_LE		0x0	/* Little-endian byte alignment */
+#define	EHCI_UM_ES_BE		0x4	/* Big-endian byte alignment */
+#define	EHCI_UM_SDIS		0x00000010	/* R/WO Stream Disable Mode */
+
 #define	EHCI_PORT_RESET_COMPLETE	2	/* ms */
 
 /*
@@ -469,11 +478,12 @@ typedef struct ehci_softc {
 	uint16_t sc_intr_stat[EHCI_VIRTUAL_FRAMELIST_COUNT];
 	uint16_t sc_id_vendor;		/* vendor ID for root hub */
 	uint16_t sc_flags;		/* chip specific flags */
-#define	EHCI_SCFLG_SETMODE     0x0001	/* set bridge mode again after init
-					 * (Marvell) */
-#define	EHCI_SCFLG_FORCESPEED  0x0002	/* force speed (Marvell) */
-#define	EHCI_SCFLG_NORESTERM   0x0004	/* don't terminate reset sequence
-					 * (Marvell) */
+#define	EHCI_SCFLG_SETMODE	0x0001	/* set bridge mode again after init */
+#define	EHCI_SCFLG_FORCESPEED	0x0002	/* force speed */
+#define	EHCI_SCFLG_NORESTERM	0x0004	/* don't terminate reset sequence */
+#define	EHCI_SCFLG_BIGEDESC	0x0008	/* big-endian byte order descriptors */
+#define	EHCI_SCFLG_BIGEMMIO	0x0010	/* big-endian byte order MMIO */
+#define	EHCI_SCFLG_TT		0x0020	/* transaction translator present */
 
 	uint8_t	sc_offs;		/* offset to operational registers */
 	uint8_t	sc_doorbell_disable;	/* set on doorbell failure */
diff --git a/sys/dev/usb2/controller/musb2_otg.c b/sys/dev/usb2/controller/musb2_otg.c
index e7119bf..e2a36e3 100644
--- a/sys/dev/usb2/controller/musb2_otg.c
+++ b/sys/dev/usb2/controller/musb2_otg.c
@@ -236,12 +236,6 @@ musbotg_wakeup_peer(struct usb2_xfer *xfer)
 }
 
 static void
-musbotg_rem_wakeup_set(struct usb2_device *udev, uint8_t is_on)
-{
-	DPRINTFN(4, "is_on=%u\n", is_on);
-}
-
-static void
 musbotg_set_address(struct musbotg_softc *sc, uint8_t addr)
 {
 	DPRINTFN(4, "addr=%d\n", addr);
@@ -2891,5 +2885,4 @@ struct usb2_bus_methods musbotg_bus_methods =
 	.set_stall = &musbotg_set_stall,
 	.clear_stall = &musbotg_clear_stall,
 	.vbus_interrupt = &musbotg_vbus_interrupt,
-	.rem_wakeup_set = &musbotg_rem_wakeup_set,
 };
diff --git a/sys/dev/usb2/controller/ohci2.c b/sys/dev/usb2/controller/ohci2.c
index b3f2f0e..99076d4 100644
--- a/sys/dev/usb2/controller/ohci2.c
+++ b/sys/dev/usb2/controller/ohci2.c
@@ -681,18 +681,22 @@ ohci_transfer_intr_enqueue(struct usb2_xfer *xfer)
 	}
 }
 
-#define	OHCI_APPEND_QH(sed,td_self,last) (last) = _ohci_append_qh(sed,td_self,last)
+#define	OHCI_APPEND_QH(sed,last) (last) = _ohci_append_qh(sed,last)
 static ohci_ed_t *
-_ohci_append_qh(ohci_ed_t *sed, uint32_t td_self, ohci_ed_t *last)
+_ohci_append_qh(ohci_ed_t *sed, ohci_ed_t *last)
 {
 	DPRINTFN(11, "%p to %p\n", sed, last);
 
+	if (sed->prev != NULL) {
+		/* should not happen */
+		DPRINTFN(0, "ED already linked!\n");
+		return (last);
+	}
 	/* (sc->sc_bus.bus_mtx) must be locked */
 
 	sed->next = last->next;
 	sed->ed_next = last->ed_next;
 	sed->ed_tailp = 0;
-	sed->ed_headp = td_self;
 
 	sed->prev = last;
 
@@ -730,13 +734,6 @@ _ohci_remove_qh(ohci_ed_t *sed, ohci_ed_t *last)
 			sed->next->prev = sed->prev;
 			usb2_pc_cpu_flush(sed->next->page_cache);
 		}
-		/*
-		 * terminate transfer in case the transferred packet was
-		 * short so that the ED still points at the last used TD
-		 */
-		sed->ed_flags |= htole32(OHCI_ED_SKIP);
-		sed->ed_headp = sed->ed_tailp;
-
 		last = ((last == sed) ? sed->prev : last);
 
 		sed->prev = 0;
@@ -1565,17 +1562,23 @@ ohci_setup_standard_chain(struct usb2_xfer *xfer, ohci_ed_t **ed_last)
 
 	td = xfer->td_transfer_first;
 
-	OHCI_APPEND_QH(ed, td->td_self, *ed_last);
+	ed->ed_headp = td->td_self;
 
-	if (methods == &ohci_device_bulk_methods) {
-		ohci_softc_t *sc = xfer->usb2_sc;
+	if (xfer->udev->pwr_save.suspended == 0) {
+		OHCI_APPEND_QH(ed, *ed_last);
 
-		OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF);
-	}
-	if (methods == &ohci_device_ctrl_methods) {
-		ohci_softc_t *sc = xfer->usb2_sc;
+		if (methods == &ohci_device_bulk_methods) {
+			ohci_softc_t *sc = xfer->usb2_sc;
 
-		OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
+			OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF);
+		}
+		if (methods == &ohci_device_ctrl_methods) {
+			ohci_softc_t *sc = xfer->usb2_sc;
+
+			OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
+		}
+	} else {
+		usb2_pc_cpu_flush(ed->page_cache);
 	}
 }
 
@@ -2010,7 +2013,11 @@ ohci_device_isoc_enter(struct usb2_xfer *xfer)
 
 	td = xfer->td_transfer_first;
 
-	OHCI_APPEND_QH(ed, td->itd_self, sc->sc_isoc_p_last);
+	ed->ed_headp = td->itd_self;
+
+	/* isochronous transfers are not affected by suspend / resume */
+
+	OHCI_APPEND_QH(ed, sc->sc_isoc_p_last);
 }
 
 static void
@@ -2740,6 +2747,115 @@ ohci_get_dma_delay(struct usb2_bus *bus, uint32_t *pus)
 	*pus = (1125);			/* microseconds */
 }
 
+static void
+ohci_device_resume(struct usb2_device *udev)
+{
+	struct ohci_softc *sc = OHCI_BUS2SC(udev->bus);
+	struct usb2_xfer *xfer;
+	struct usb2_pipe_methods *methods;
+	ohci_ed_t *ed;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(udev->bus);
+
+	TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
+
+		if (xfer->udev == udev) {
+
+			methods = xfer->pipe->methods;
+			ed = xfer->qh_start[xfer->flags_int.curr_dma_set];
+
+			if (methods == &ohci_device_bulk_methods) {
+				OHCI_APPEND_QH(ed, sc->sc_bulk_p_last);
+				OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF);
+			}
+			if (methods == &ohci_device_ctrl_methods) {
+				OHCI_APPEND_QH(ed, sc->sc_ctrl_p_last);
+				OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
+			}
+			if (methods == &ohci_device_intr_methods) {
+				OHCI_APPEND_QH(ed, sc->sc_intr_p_last[xfer->qh_pos]);
+			}
+		}
+	}
+
+	USB_BUS_UNLOCK(udev->bus);
+
+	return;
+}
+
+static void
+ohci_device_suspend(struct usb2_device *udev)
+{
+	struct ohci_softc *sc = OHCI_BUS2SC(udev->bus);
+	struct usb2_xfer *xfer;
+	struct usb2_pipe_methods *methods;
+	ohci_ed_t *ed;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(udev->bus);
+
+	TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
+
+		if (xfer->udev == udev) {
+
+			methods = xfer->pipe->methods;
+			ed = xfer->qh_start[xfer->flags_int.curr_dma_set];
+
+			if (methods == &ohci_device_bulk_methods) {
+				OHCI_REMOVE_QH(ed, sc->sc_bulk_p_last);
+			}
+			if (methods == &ohci_device_ctrl_methods) {
+				OHCI_REMOVE_QH(ed, sc->sc_ctrl_p_last);
+			}
+			if (methods == &ohci_device_intr_methods) {
+				OHCI_REMOVE_QH(ed, sc->sc_intr_p_last[xfer->qh_pos]);
+			}
+		}
+	}
+
+	USB_BUS_UNLOCK(udev->bus);
+
+	return;
+}
+
+static void
+ohci_set_hw_power(struct usb2_bus *bus)
+{
+	struct ohci_softc *sc = OHCI_BUS2SC(bus);
+	uint32_t temp;
+	uint32_t flags;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(bus);
+
+	flags = bus->hw_power_state;
+
+	temp = OREAD4(sc, OHCI_CONTROL);
+	temp &= ~(OHCI_PLE | OHCI_IE | OHCI_CLE | OHCI_BLE);
+
+	if (flags & USB_HW_POWER_CONTROL)
+		temp |= OHCI_CLE;
+
+	if (flags & USB_HW_POWER_BULK)
+		temp |= OHCI_BLE;
+
+	if (flags & USB_HW_POWER_INTERRUPT)
+		temp |= OHCI_PLE;
+
+	if (flags & USB_HW_POWER_ISOC)
+		temp |= OHCI_IE | OHCI_PLE;
+
+	OWRITE4(sc, OHCI_CONTROL, temp);
+
+	USB_BUS_UNLOCK(bus);
+
+	return;
+}
+
 struct usb2_bus_methods ohci_bus_methods =
 {
 	.pipe_init = ohci_pipe_init,
@@ -2747,4 +2863,7 @@ struct usb2_bus_methods ohci_bus_methods =
 	.xfer_unsetup = ohci_xfer_unsetup,
 	.do_poll = ohci_do_poll,
 	.get_dma_delay = ohci_get_dma_delay,
+	.device_resume = ohci_device_resume,
+	.device_suspend = ohci_device_suspend,
+	.set_hw_power = ohci_set_hw_power,
 };
diff --git a/sys/dev/usb2/controller/uhci2.c b/sys/dev/usb2/controller/uhci2.c
index 478e54f..be80619 100644
--- a/sys/dev/usb2/controller/uhci2.c
+++ b/sys/dev/usb2/controller/uhci2.c
@@ -916,17 +916,19 @@ _uhci_append_td(uhci_td_t *std, uhci_td_t *last)
 	return (std);
 }
 
-#define	UHCI_APPEND_QH(sqh,td,last) (last) = _uhci_append_qh(sqh,td,last)
+#define	UHCI_APPEND_QH(sqh,last) (last) = _uhci_append_qh(sqh,last)
 static uhci_qh_t *
-_uhci_append_qh(uhci_qh_t *sqh, uhci_td_t *td, uhci_qh_t *last)
+_uhci_append_qh(uhci_qh_t *sqh, uhci_qh_t *last)
 {
 	DPRINTFN(11, "%p to %p\n", sqh, last);
 
+	if (sqh->h_prev != NULL) {
+		/* should not happen */
+		DPRINTFN(0, "QH already linked!\n");
+		return (last);
+	}
 	/* (sc->sc_bus.mtx) must be locked */
 
-	sqh->e_next = td;
-	sqh->qh_e_next = td->td_self;
-
 	sqh->h_next = last->h_next;
 	sqh->qh_h_next = last->qh_h_next;
 
@@ -990,13 +992,6 @@ _uhci_remove_qh(uhci_qh_t *sqh, uhci_qh_t *last)
 			sqh->h_next->h_prev = sqh->h_prev;
 			usb2_pc_cpu_flush(sqh->h_next->page_cache);
 		}
-		/*
-		 * set the Terminate-bit in the e_next of the QH, in case
-		 * the transferred packet was short so that the QH still
-		 * points at the last used TD
-		 */
-		sqh->qh_e_next = htole32(UHCI_PTR_T);
-
 		last = ((last == sqh) ? sqh->h_prev : last);
 
 		sqh->h_prev = 0;
@@ -1459,10 +1454,12 @@ uhci_interrupt(uhci_softc_t *sc)
 		}
 		if (status & UHCI_STS_HCH) {
 			/* no acknowledge needed */
-			printf("%s: host controller halted\n",
+			DPRINTF("%s: host controller halted\n",
 			    __FUNCTION__);
 #if USB_DEBUG
-			uhci_dump_all(sc);
+			if (uhcidebug > 0) {
+				uhci_dump_all(sc);
+			}
 #endif
 		}
 	}
@@ -1834,11 +1831,6 @@ uhci_device_done(struct usb2_xfer *xfer, usb2_error_t error)
 	qh = xfer->qh_start[xfer->flags_int.curr_dma_set];
 	if (qh) {
 		usb2_pc_cpu_invalidate(qh->page_cache);
-
-		qh->e_next = 0;
-		qh->qh_e_next = htole32(UHCI_PTR_T);
-
-		usb2_pc_cpu_flush(qh->page_cache);
 	}
 	if (xfer->flags_int.bandwidth_reclaimed) {
 		xfer->flags_int.bandwidth_reclaimed = 0;
@@ -1907,9 +1899,16 @@ uhci_device_bulk_start(struct usb2_xfer *xfer)
 	/* setup QH */
 	qh = xfer->qh_start[xfer->flags_int.curr_dma_set];
 
-	UHCI_APPEND_QH(qh, td, sc->sc_bulk_p_last);
-	uhci_add_loop(sc);
-	xfer->flags_int.bandwidth_reclaimed = 1;
+	qh->e_next = td;
+	qh->qh_e_next = td->td_self;
+
+	if (xfer->udev->pwr_save.suspended == 0) {
+		UHCI_APPEND_QH(qh, sc->sc_bulk_p_last);
+		uhci_add_loop(sc);
+		xfer->flags_int.bandwidth_reclaimed = 1;
+	} else {
+		usb2_pc_cpu_flush(qh->page_cache);
+	}
 
 	/* put transfer on interrupt queue */
 	uhci_transfer_intr_enqueue(xfer);
@@ -1959,14 +1958,21 @@ uhci_device_ctrl_start(struct usb2_xfer *xfer)
 	/* setup QH */
 	qh = xfer->qh_start[xfer->flags_int.curr_dma_set];
 
+	qh->e_next = td;
+	qh->qh_e_next = td->td_self;
+
 	/*
 	 * NOTE: some devices choke on bandwidth- reclamation for control
 	 * transfers
 	 */
-	if (xfer->udev->speed == USB_SPEED_LOW) {
-		UHCI_APPEND_QH(qh, td, sc->sc_ls_ctl_p_last);
+	if (xfer->udev->pwr_save.suspended == 0) {
+		if (xfer->udev->speed == USB_SPEED_LOW) {
+			UHCI_APPEND_QH(qh, sc->sc_ls_ctl_p_last);
+		} else {
+			UHCI_APPEND_QH(qh, sc->sc_fs_ctl_p_last);
+		}
 	} else {
-		UHCI_APPEND_QH(qh, td, sc->sc_fs_ctl_p_last);
+		usb2_pc_cpu_flush(qh->page_cache);
 	}
 	/* put transfer on interrupt queue */
 	uhci_transfer_intr_enqueue(xfer);
@@ -2047,8 +2053,17 @@ uhci_device_intr_start(struct usb2_xfer *xfer)
 	/* setup QH */
 	qh = xfer->qh_start[xfer->flags_int.curr_dma_set];
 
-	/* enter QHs into the controller data structures */
-	UHCI_APPEND_QH(qh, td, sc->sc_intr_p_last[xfer->qh_pos]);
+	qh->e_next = td;
+	qh->qh_e_next = td->td_self;
+
+	if (xfer->udev->pwr_save.suspended == 0) {
+
+		/* enter QHs into the controller data structures */
+		UHCI_APPEND_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]);
+
+	} else {
+		usb2_pc_cpu_flush(qh->page_cache);
+	}
 
 	/* put transfer on interrupt queue */
 	uhci_transfer_intr_enqueue(xfer);
@@ -2659,7 +2674,7 @@ uhci_root_ctrl_done(struct usb2_xfer *xfer,
 			break;
 		case UHF_PORT_SUSPEND:
 			x = URWMASK(UREAD2(sc, port));
-			UWRITE2(sc, port, x & ~UHCI_PORTSC_SUSP);
+			UWRITE2(sc, port, x & ~(UHCI_PORTSC_SUSP));
 			break;
 		case UHF_PORT_RESET:
 			x = URWMASK(UREAD2(sc, port));
@@ -2681,11 +2696,13 @@ uhci_root_ctrl_done(struct usb2_xfer *xfer,
 			sc->sc_isreset = 0;
 			std->err = USB_ERR_NORMAL_COMPLETION;
 			goto done;
+		case UHF_C_PORT_SUSPEND:
+			sc->sc_isresumed &= ~(1 << index);
+			break;
 		case UHF_PORT_CONNECTION:
 		case UHF_PORT_OVER_CURRENT:
 		case UHF_PORT_POWER:
 		case UHF_PORT_LOW_SPEED:
-		case UHF_C_PORT_SUSPEND:
 		default:
 			std->err = USB_ERR_IOERROR;
 			goto done;
@@ -2740,11 +2757,35 @@ uhci_root_ctrl_done(struct usb2_xfer *xfer,
 			status |= UPS_OVERCURRENT_INDICATOR;
 		if (x & UHCI_PORTSC_OCIC)
 			change |= UPS_C_OVERCURRENT_INDICATOR;
-		if (x & UHCI_PORTSC_SUSP)
-			status |= UPS_SUSPEND;
 		if (x & UHCI_PORTSC_LSDA)
 			status |= UPS_LOW_SPEED;
+		if ((x & UHCI_PORTSC_PE) && (x & UHCI_PORTSC_RD)) {
+			/* need to do a write back */
+			UWRITE2(sc, port, URWMASK(x));
+
+			/* wait 20ms for resume sequence to complete */
+			if (use_polling) {
+				/* polling */
+				DELAY(20 * 1000);
+			} else {
+				usb2_pause_mtx(&sc->sc_bus.bus_mtx, 20);
+			}
+
+			/* clear suspend and resume detect */
+			UWRITE2(sc, port, URWMASK(x) & ~(UHCI_PORTSC_RD |
+			    UHCI_PORTSC_SUSP));
+
+			/* wait a little bit */
+			usb2_pause_mtx(&sc->sc_bus.bus_mtx, 2);
+
+			sc->sc_isresumed |= (1 << index);
+
+		} else if (x & UHCI_PORTSC_SUSP) {
+			status |= UPS_SUSPEND;
+		}
 		status |= UPS_PORT_POWER;
+		if (sc->sc_isresumed & (1 << index))
+			change |= UPS_C_SUSPEND;
 		if (sc->sc_isreset)
 			change |= UPS_C_PORT_RESET;
 		USETW(sc->sc_hub_desc.ps.wPortStatus, status);
@@ -2894,13 +2935,15 @@ uhci_root_intr_check(void *arg)
 
 	sc->sc_hub_idata[0] = 0;
 
-	if (UREAD2(sc, UHCI_PORTSC1) & (UHCI_PORTSC_CSC | UHCI_PORTSC_OCIC)) {
+	if (UREAD2(sc, UHCI_PORTSC1) & (UHCI_PORTSC_CSC |
+	    UHCI_PORTSC_OCIC | UHCI_PORTSC_RD)) {
 		sc->sc_hub_idata[0] |= 1 << 1;
 	}
-	if (UREAD2(sc, UHCI_PORTSC2) & (UHCI_PORTSC_CSC | UHCI_PORTSC_OCIC)) {
+	if (UREAD2(sc, UHCI_PORTSC2) & (UHCI_PORTSC_CSC |
+	    UHCI_PORTSC_OCIC | UHCI_PORTSC_RD)) {
 		sc->sc_hub_idata[0] |= 1 << 2;
 	}
-	if ((sc->sc_hub_idata[0] == 0) || !(UREAD2(sc, UHCI_CMD) & UHCI_CMD_RS)) {
+	if (sc->sc_hub_idata[0] == 0) {
 		/*
 		 * no change or controller not running, try again in a while
 		 */
@@ -3190,6 +3233,124 @@ uhci_get_dma_delay(struct usb2_bus *bus, uint32_t *pus)
 	*pus = (1125);			/* microseconds */
 }
 
+static void
+uhci_device_resume(struct usb2_device *udev)
+{
+	struct uhci_softc *sc = UHCI_BUS2SC(udev->bus);
+	struct usb2_xfer *xfer;
+	struct usb2_pipe_methods *methods;
+	uhci_qh_t *qh;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(udev->bus);
+
+	TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
+
+		if (xfer->udev == udev) {
+
+			methods = xfer->pipe->methods;
+			qh = xfer->qh_start[xfer->flags_int.curr_dma_set];
+
+			if (methods == &uhci_device_bulk_methods) {
+				UHCI_APPEND_QH(qh, sc->sc_bulk_p_last);
+				uhci_add_loop(sc);
+				xfer->flags_int.bandwidth_reclaimed = 1;
+			}
+			if (methods == &uhci_device_ctrl_methods) {
+				if (xfer->udev->speed == USB_SPEED_LOW) {
+					UHCI_APPEND_QH(qh, sc->sc_ls_ctl_p_last);
+				} else {
+					UHCI_APPEND_QH(qh, sc->sc_fs_ctl_p_last);
+				}
+			}
+			if (methods == &uhci_device_intr_methods) {
+				UHCI_APPEND_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]);
+			}
+		}
+	}
+
+	USB_BUS_UNLOCK(udev->bus);
+
+	return;
+}
+
+static void
+uhci_device_suspend(struct usb2_device *udev)
+{
+	struct uhci_softc *sc = UHCI_BUS2SC(udev->bus);
+	struct usb2_xfer *xfer;
+	struct usb2_pipe_methods *methods;
+	uhci_qh_t *qh;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(udev->bus);
+
+	TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
+
+		if (xfer->udev == udev) {
+
+			methods = xfer->pipe->methods;
+			qh = xfer->qh_start[xfer->flags_int.curr_dma_set];
+
+			if (xfer->flags_int.bandwidth_reclaimed) {
+				xfer->flags_int.bandwidth_reclaimed = 0;
+				uhci_rem_loop(sc);
+			}
+			if (methods == &uhci_device_bulk_methods) {
+				UHCI_REMOVE_QH(qh, sc->sc_bulk_p_last);
+			}
+			if (methods == &uhci_device_ctrl_methods) {
+				if (xfer->udev->speed == USB_SPEED_LOW) {
+					UHCI_REMOVE_QH(qh, sc->sc_ls_ctl_p_last);
+				} else {
+					UHCI_REMOVE_QH(qh, sc->sc_fs_ctl_p_last);
+				}
+			}
+			if (methods == &uhci_device_intr_methods) {
+				UHCI_REMOVE_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]);
+			}
+		}
+	}
+
+	USB_BUS_UNLOCK(udev->bus);
+
+	return;
+}
+
+static void
+uhci_set_hw_power(struct usb2_bus *bus)
+{
+	struct uhci_softc *sc = UHCI_BUS2SC(bus);
+	uint32_t flags;
+
+	DPRINTF("\n");
+
+	USB_BUS_LOCK(bus);
+
+	flags = bus->hw_power_state;
+
+	if (flags & (USB_HW_POWER_CONTROL |
+	    USB_HW_POWER_BULK |
+	    USB_HW_POWER_INTERRUPT |
+	    USB_HW_POWER_ISOC)) {
+		DPRINTF("Some USB transfer is "
+		    "active on %u.\n",
+		    device_get_unit(sc->sc_bus.bdev));
+		UHCICMD(sc, (UHCI_CMD_MAXP | UHCI_CMD_RS));
+	} else {
+		DPRINTF("Power save on %u.\n",
+		    device_get_unit(sc->sc_bus.bdev));
+		UHCICMD(sc, UHCI_CMD_MAXP);
+	}
+
+	USB_BUS_UNLOCK(bus);
+
+	return;
+}
+
+
 struct usb2_bus_methods uhci_bus_methods =
 {
 	.pipe_init = uhci_pipe_init,
@@ -3197,4 +3358,7 @@ struct usb2_bus_methods uhci_bus_methods =
 	.xfer_unsetup = uhci_xfer_unsetup,
 	.do_poll = uhci_do_poll,
 	.get_dma_delay = uhci_get_dma_delay,
+	.device_resume = uhci_device_resume,
+	.device_suspend = uhci_device_suspend,
+	.set_hw_power = uhci_set_hw_power,
 };
diff --git a/sys/dev/usb2/controller/uhci2.h b/sys/dev/usb2/controller/uhci2.h
index 9be89ed..ee0b36d 100644
--- a/sys/dev/usb2/controller/uhci2.h
+++ b/sys/dev/usb2/controller/uhci2.h
@@ -300,7 +300,8 @@ typedef struct uhci_softc {
 
 	uint8_t	sc_addr;		/* device address */
 	uint8_t	sc_conf;		/* device configuration */
-	uint8_t	sc_isreset;
+	uint8_t	sc_isreset;		/* bits set if a root hub is reset */
+	uint8_t	sc_isresumed;		/* bits set if a port was resumed */
 	uint8_t	sc_saved_sof;
 	uint8_t	sc_hub_idata[1];
 
diff --git a/sys/dev/usb2/controller/usb2_bus.h b/sys/dev/usb2/controller/usb2_bus.h
index d9dc74e..f30d61f 100644
--- a/sys/dev/usb2/controller/usb2_bus.h
+++ b/sys/dev/usb2/controller/usb2_bus.h
@@ -54,10 +54,14 @@ struct usb2_bus {
 	struct usb2_process explore_proc;
 	struct usb2_bus_msg explore_msg[2];
 	struct usb2_bus_msg detach_msg[2];
-	struct mtx bus_mtx;			/* This mutex protects the USB
-					 * hardware */
+	struct usb2_bus_msg attach_msg[2];
+	/*
+	 * This mutex protects the USB hardware:
+	 */
+	struct mtx bus_mtx;
 	struct usb2_perm perm;
 	struct usb2_xfer_queue intr_q;
+	struct usb2_callout power_wdog;	/* power management */
 
 	device_t parent;
 	device_t bdev;			/* filled by HC driver */
@@ -68,6 +72,7 @@ struct usb2_bus {
 	struct usb2_bus_methods *methods;	/* filled by HC driver */
 	struct usb2_device *devices[USB_MAX_DEVICES];
 
+	uint32_t hw_power_state;	/* see USB_HW_POWER_XXX */
 	uint32_t uframe_usage[USB_HS_MICRO_FRAMES_MAX];
 	uint32_t transfer_count[4];
 	uint16_t isoc_time_last;	/* in milliseconds */
diff --git a/sys/dev/usb2/controller/usb2_controller.c b/sys/dev/usb2/controller/usb2_controller.c
index 5dd517d..ec1aff5 100644
--- a/sys/dev/usb2/controller/usb2_controller.c
+++ b/sys/dev/usb2/controller/usb2_controller.c
@@ -148,6 +148,9 @@ usb2_detach(device_t dev)
 		/* was never setup properly */
 		return (0);
 	}
+	/* Stop power watchdog */
+	usb2_callout_drain(&bus->power_wdog);
+
 	/* Let the USB explore process detach all devices. */
 
 	USB_BUS_LOCK(bus);
@@ -198,6 +201,11 @@ usb2_bus_explore(struct usb2_proc_msg *pm)
 		mtx_lock(&Giant);
 
 		/*
+		 * First update the USB power state!
+		 */
+		usb2_bus_powerd(bus);
+
+		/*
 		 * Explore the Root USB HUB. This call can sleep,
 		 * exiting Giant, which is actually Giant.
 		 */
@@ -246,24 +254,41 @@ usb2_bus_detach(struct usb2_proc_msg *pm)
 	bus->bdev = NULL;
 }
 
+static void
+usb2_power_wdog(void *arg)
+{
+	struct usb2_bus *bus = arg;
+
+	USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
+
+	usb2_callout_reset(&bus->power_wdog,
+	    4 * hz, usb2_power_wdog, arg);
+
+	USB_BUS_UNLOCK(bus);
+
+	usb2_bus_power_update(bus);
+
+	return;
+}
+
 /*------------------------------------------------------------------------*
- *	usb2_attach_sub
+ *	usb2_bus_attach
  *
- * This function is the real USB bus attach code. It is factored out,
- * hence it can be called at two different places in time. During
- * bootup this function is called from "usb2_post_init". During
- * hot-plug it is called directly from the "usb2_attach()" method.
+ * This function attaches USB in context of the explore thread.
  *------------------------------------------------------------------------*/
 static void
-usb2_attach_sub(device_t dev, struct usb2_bus *bus)
+usb2_bus_attach(struct usb2_proc_msg *pm)
 {
+	struct usb2_bus *bus;
 	struct usb2_device *child;
+	device_t dev;
 	usb2_error_t err;
 	uint8_t speed;
 
-	DPRINTF("\n");
+	bus = ((struct usb2_bus_msg *)pm)->bus;
+	dev = bus->bdev;
 
-	mtx_assert(&Giant, MA_OWNED);
+	DPRINTF("\n");
 
 	switch (bus->usbrev) {
 	case USB_REV_1_0:
@@ -291,6 +316,9 @@ usb2_attach_sub(device_t dev, struct usb2_bus *bus)
 		return;
 	}
 
+	USB_BUS_UNLOCK(bus);
+	mtx_lock(&Giant);		/* XXX not required by USB */
+
 	/* Allocate the Root USB device */
 
 	child = usb2_alloc_device(bus->bdev, bus, NULL, 0, 0, 1,
@@ -307,10 +335,36 @@ usb2_attach_sub(device_t dev, struct usb2_bus *bus)
 		err = USB_ERR_NOMEM;
 	}
 
+	mtx_unlock(&Giant);
+	USB_BUS_LOCK(bus);
+
 	if (err) {
 		device_printf(bus->bdev, "Root HUB problem, error=%s\n",
 		    usb2_errstr(err));
 	}
+
+	/* set softc - we are ready */
+	device_set_softc(dev, bus);
+
+	/* start watchdog - this function will unlock the BUS lock ! */
+	usb2_power_wdog(bus);
+
+	/* need to return locked */
+	USB_BUS_LOCK(bus);
+}
+
+/*------------------------------------------------------------------------*
+ *	usb2_attach_sub
+ *
+ * This function creates a thread which runs the USB attach code. It
+ * is factored out, hence it can be called at two different places in
+ * time. During bootup this function is called from
+ * "usb2_post_init". During hot-plug it is called directly from the
+ * "usb2_attach()" method.
+ *------------------------------------------------------------------------*/
+static void
+usb2_attach_sub(device_t dev, struct usb2_bus *bus)
+{
 	/* Initialise USB process messages */
 	bus->explore_msg[0].hdr.pm_callback = &usb2_bus_explore;
 	bus->explore_msg[0].bus = bus;
@@ -322,13 +376,24 @@ usb2_attach_sub(device_t dev, struct usb2_bus *bus)
 	bus->detach_msg[1].hdr.pm_callback = &usb2_bus_detach;
 	bus->detach_msg[1].bus = bus;
 
+	bus->attach_msg[0].hdr.pm_callback = &usb2_bus_attach;
+	bus->attach_msg[0].bus = bus;
+	bus->attach_msg[1].hdr.pm_callback = &usb2_bus_attach;
+	bus->attach_msg[1].bus = bus;
+
 	/* Create a new USB process */
 	if (usb2_proc_setup(&bus->explore_proc,
 	    &bus->bus_mtx, USB_PRI_MED)) {
 		printf("WARNING: Creation of USB explore process failed.\n");
+	} else {
+		/* Get final attach going */
+		USB_BUS_LOCK(bus);
+		if (usb2_proc_msignal(&bus->explore_proc,
+		    &bus->attach_msg[0], &bus->attach_msg[1])) {
+			/* ignore */
+		}
+		USB_BUS_UNLOCK(bus);
 	}
-	/* set softc - we are ready */
-	device_set_softc(dev, bus);
 }
 
 /*------------------------------------------------------------------------*
@@ -433,6 +498,9 @@ usb2_bus_mem_alloc_all(struct usb2_bus *bus, bus_dma_tag_t dmat,
 	mtx_init(&bus->bus_mtx, device_get_nameunit(bus->parent),
 	    NULL, MTX_DEF | MTX_RECURSE);
 
+	usb2_callout_init_mtx(&bus->power_wdog,
+	    &bus->bus_mtx, CALLOUT_RETURNUNLOCKED);
+
 	TAILQ_INIT(&bus->intr_q.head);
 
 	usb2_dma_tag_setup(bus->dma_parent_tag, bus->dma_tags,
diff --git a/sys/dev/usb2/controller/usb2_controller.h b/sys/dev/usb2/controller/usb2_controller.h
index 496e8c2..d65c3d6 100644
--- a/sys/dev/usb2/controller/usb2_controller.h
+++ b/sys/dev/usb2/controller/usb2_controller.h
@@ -61,13 +61,35 @@ struct usb2_bus_methods {
 	void    (*xfer_setup) (struct usb2_setup_params *parm);
 	void    (*xfer_unsetup) (struct usb2_xfer *xfer);
 	void    (*get_dma_delay) (struct usb2_bus *, uint32_t *pdelay);
+	void    (*device_suspend) (struct usb2_device *udev);
+	void    (*device_resume) (struct usb2_device *udev);
+	void    (*set_hw_power) (struct usb2_bus *bus);
+	/*
+	 * The following flag is set if one or more control transfers are
+	 * active:
+	 */
+#define	USB_HW_POWER_CONTROL	0x01
+	/*
+	 * The following flag is set if one or more bulk transfers are
+	 * active:
+	 */
+#define	USB_HW_POWER_BULK	0x02
+	/*
+	 * The following flag is set if one or more interrupt transfers are
+	 * active:
+	 */
+#define	USB_HW_POWER_INTERRUPT	0x04
+	/*
+	 * The following flag is set if one or more isochronous transfers
+	 * are active:
+	 */
+#define	USB_HW_POWER_ISOC	0x08
 
 	/* USB Device mode only - Mandatory */
 
 	void    (*get_hw_ep_profile) (struct usb2_device *udev, const struct usb2_hw_ep_profile **ppf, uint8_t ep_addr);
 	void    (*set_stall) (struct usb2_device *udev, struct usb2_xfer *xfer, struct usb2_pipe *pipe);
 	void    (*clear_stall) (struct usb2_device *udev, struct usb2_pipe *pipe);
-	void    (*rem_wakeup_set) (struct usb2_device *udev, uint8_t is_on);
 
 	/* USB Device mode only - Optional */
 
@@ -90,7 +112,6 @@ struct usb2_pipe_methods {
 
 	/* Optional */
 
-	uint8_t (*isdone) (struct usb2_xfer *xfer);
 	void   *info;
 
 	/* Flags */
diff --git a/sys/dev/usb2/controller/uss820dci.c b/sys/dev/usb2/controller/uss820dci.c
index d010a53..6db143a 100644
--- a/sys/dev/usb2/controller/uss820dci.c
+++ b/sys/dev/usb2/controller/uss820dci.c
@@ -223,29 +223,6 @@ uss820dci_wakeup_peer(struct uss820dci_softc *sc)
 }
 
 static void
-uss820dci_rem_wakeup_set(struct usb2_device *udev, uint8_t is_on)
-{
-	struct uss820dci_softc *sc;
-	uint8_t temp;
-
-	DPRINTFN(5, "is_on=%u\n", is_on);
-
-	USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
-
-	sc = USS820_DCI_BUS2SC(udev->bus);
-
-	temp = USS820_READ_1(sc, USS820_SCR);
-
-	if (is_on) {
-		temp |= USS820_SCR_RWUPE;
-	} else {
-		temp &= ~USS820_SCR_RWUPE;
-	}
-
-	USS820_WRITE_1(sc, USS820_SCR, temp);
-}
-
-static void
 uss820dci_set_address(struct uss820dci_softc *sc, uint8_t addr)
 {
 	DPRINTFN(5, "addr=%d\n", addr);
@@ -1375,6 +1352,7 @@ uss820dci_init(struct uss820dci_softc *sc)
 	USS820_WRITE_1(sc, USS820_SCR,
 	    USS820_SCR_T_IRQ |
 	    USS820_SCR_IE_RESET |
+	/* USS820_SCR_RWUPE | */
 	    USS820_SCR_IE_SUSP |
 	    USS820_SCR_IRQPOL);
 
@@ -2518,5 +2496,4 @@ struct usb2_bus_methods uss820dci_bus_methods =
 	.get_hw_ep_profile = &uss820dci_get_hw_ep_profile,
 	.set_stall = &uss820dci_set_stall,
 	.clear_stall = &uss820dci_clear_stall,
-	.rem_wakeup_set = &uss820dci_rem_wakeup_set,
 };