s/usb2_/usb_|usbd_/ on all function names for the USB stack.

13 files changed, 361 insertions, 361 deletions

diff --git a/sys/dev/usb/net/if_aue.c b/sys/dev/usb/net/if_aue.c
index 1e37e8c..46ec901 100644
--- a/sys/dev/usb/net/if_aue.c
+++ b/sys/dev/usb/net/if_aue.c
@@ -64,8 +64,8 @@ __FBSDID("$FreeBSD$");
  * the controller uses an external PHY chip, it's possible that board
  * designers might simply choose a 10Mbps PHY.
  *
- * Registers are accessed using usb2_ether_do_request(). Packet
- * transfers are done using usb2_transfer() and friends.
+ * Registers are accessed using uether_do_request(). Packet
+ * transfers are done using usbd_transfer() and friends.
  */
 
 #include "usbdevs.h"
@@ -297,7 +297,7 @@ aue_csr_read_1(struct aue_softc *sc, uint16_t reg)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 1);
 
-	err = usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000);
+	err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
 	if (err)
 		return (0);
 	return (val);
@@ -316,7 +316,7 @@ aue_csr_read_2(struct aue_softc *sc, uint16_t reg)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 2);
 
-	err = usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000);
+	err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
 	if (err)
 		return (0);
 	return (le16toh(val));
@@ -334,7 +334,7 @@ aue_csr_write_1(struct aue_softc *sc, uint16_t reg, uint8_t val)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 1);
 
-	if (usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000)) {
+	if (uether_do_request(&sc->sc_ue, &req, &val, 1000)) {
 		/* error ignored */
 	}
 }
@@ -352,7 +352,7 @@ aue_csr_write_2(struct aue_softc *sc, uint16_t reg, uint16_t val)
 
 	val = htole16(val);
 
-	if (usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000)) {
+	if (uether_do_request(&sc->sc_ue, &req, &val, 1000)) {
 		/* error ignored */
 	}
 }
@@ -372,7 +372,7 @@ aue_eeprom_getword(struct aue_softc *sc, int addr, uint16_t *dest)
 	for (i = 0; i != AUE_TIMEOUT; i++) {
 		if (aue_csr_read_1(sc, AUE_EE_CTL) & AUE_EECTL_DONE)
 			break;
-		if (usb2_ether_pause(&sc->sc_ue, hz / 100))
+		if (uether_pause(&sc->sc_ue, hz / 100))
 			break;
 	}
 
@@ -429,7 +429,7 @@ aue_miibus_readreg(device_t dev, int phy, int reg)
 	for (i = 0; i != AUE_TIMEOUT; i++) {
 		if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
 			break;
-		if (usb2_ether_pause(&sc->sc_ue, hz / 100))
+		if (uether_pause(&sc->sc_ue, hz / 100))
 			break;
 	}
 
@@ -465,7 +465,7 @@ aue_miibus_writereg(device_t dev, int phy, int reg, int data)
 	for (i = 0; i != AUE_TIMEOUT; i++) {
 		if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
 			break;
-		if (usb2_ether_pause(&sc->sc_ue, hz / 100))
+		if (uether_pause(&sc->sc_ue, hz / 100))
 			break;
 	}
 
@@ -520,8 +520,8 @@ aue_miibus_statchg(device_t dev)
 static void
 aue_setmulti(struct usb_ether *ue)
 {
-	struct aue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct aue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	struct ifmultiaddr *ifma;
 	uint32_t h = 0;
 	uint32_t i;
@@ -576,7 +576,7 @@ aue_reset(struct aue_softc *sc)
 	for (i = 0; i != AUE_TIMEOUT; i++) {
 		if (!(aue_csr_read_1(sc, AUE_CTL1) & AUE_CTL1_RESETMAC))
 			break;
-		if (usb2_ether_pause(&sc->sc_ue, hz / 100))
+		if (uether_pause(&sc->sc_ue, hz / 100))
 			break;
 	}
 
@@ -605,13 +605,13 @@ aue_reset(struct aue_softc *sc)
 		aue_reset_pegasus_II(sc);
 
 	/* Wait a little while for the chip to get its brains in order: */
-	usb2_ether_pause(&sc->sc_ue, hz / 100);
+	uether_pause(&sc->sc_ue, hz / 100);
 }
 
 static void
 aue_attach_post(struct usb_ether *ue)
 {
-	struct aue_softc *sc = usb2_ether_getsc(ue);
+	struct aue_softc *sc = uether_getsc(ue);
 
 	/* reset the adapter */
 	aue_reset(sc);
@@ -644,7 +644,7 @@ aue_probe(device_t dev)
 	    uaa->info.bcdDevice == 0x0413)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(aue_devs, sizeof(aue_devs), uaa));
+	return (usbd_lookup_id_by_uaa(aue_devs, sizeof(aue_devs), uaa));
 }
 
 /*
@@ -667,11 +667,11 @@ aue_attach(device_t dev)
 		sc->sc_flags |= AUE_FLAG_VER_2;
 	}
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 
 	iface_index = AUE_IFACE_IDX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, aue_config, AUE_N_TRANSFER,
 	    sc, &sc->sc_mtx);
 	if (error) {
@@ -685,7 +685,7 @@ aue_attach(device_t dev)
 	ue->ue_mtx = &sc->sc_mtx;
 	ue->ue_methods = &aue_ue_methods;
 
-	error = usb2_ether_ifattach(ue);
+	error = uether_ifattach(ue);
 	if (error) {
 		device_printf(dev, "could not attach interface\n");
 		goto detach;
@@ -703,8 +703,8 @@ aue_detach(device_t dev)
 	struct aue_softc *sc = device_get_softc(dev);
 	struct usb_ether *ue = &sc->sc_ue;
 
-	usb2_transfer_unsetup(sc->sc_xfer, AUE_N_TRANSFER);
-	usb2_ether_ifdetach(ue);
+	usbd_transfer_unsetup(sc->sc_xfer, AUE_N_TRANSFER);
+	uether_ifdetach(ue);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -714,7 +714,7 @@ static void
 aue_intr_callback(struct usb_xfer *xfer)
 {
 	struct aue_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct aue_intrpkt pkt;
 
 	switch (USB_GET_STATE(xfer)) {
@@ -723,7 +723,7 @@ aue_intr_callback(struct usb_xfer *xfer)
 		if ((ifp->if_drv_flags & IFF_DRV_RUNNING) &&
 		    xfer->actlen >= sizeof(pkt)) {
 
-			usb2_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt));
+			usbd_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt));
 
 			if (pkt.aue_txstat0)
 				ifp->if_oerrors++;
@@ -735,7 +735,7 @@ aue_intr_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -753,7 +753,7 @@ aue_bulk_read_callback(struct usb_xfer *xfer)
 {
 	struct aue_softc *sc = xfer->priv_sc;
 	struct usb_ether *ue = &sc->sc_ue;
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	struct aue_rxpkt stat;
 
 	switch (USB_GET_STATE(xfer)) {
@@ -772,7 +772,7 @@ aue_bulk_read_callback(struct usb_xfer *xfer)
 				ifp->if_ierrors++;
 				goto tr_setup;
 			}
-			usb2_copy_out(xfer->frbuffers,
+			usbd_copy_out(xfer->frbuffers,
 			    xfer->actlen - sizeof(stat), &stat, sizeof(stat));
 
 			/*
@@ -787,19 +787,19 @@ aue_bulk_read_callback(struct usb_xfer *xfer)
 			/* No errors; receive the packet. */
 			xfer->actlen -= (sizeof(stat) + ETHER_CRC_LEN);
 		}
-		usb2_ether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen);
+		uether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen);
 
 		/* FALLTHROUGH */
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
-		usb2_ether_rxflush(ue);
+		usbd_transfer_submit(xfer);
+		uether_rxflush(ue);
 		return;
 
 	default:			/* Error */
 		DPRINTF("bulk read error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -814,7 +814,7 @@ static void
 aue_bulk_write_callback(struct usb_xfer *xfer)
 {
 	struct aue_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct mbuf *m;
 	uint8_t buf[2];
 
@@ -842,7 +842,7 @@ tr_setup:
 
 			xfer->frlengths[0] = m->m_pkthdr.len;
 
-			usb2_m_copy_in(xfer->frbuffers, 0,
+			usbd_m_copy_in(xfer->frbuffers, 0,
 			    m, 0, m->m_pkthdr.len);
 
 		} else {
@@ -860,9 +860,9 @@ tr_setup:
 			buf[0] = (uint8_t)(m->m_pkthdr.len);
 			buf[1] = (uint8_t)(m->m_pkthdr.len >> 8);
 
-			usb2_copy_in(xfer->frbuffers, 0, buf, 2);
+			usbd_copy_in(xfer->frbuffers, 0, buf, 2);
 
-			usb2_m_copy_in(xfer->frbuffers, 2,
+			usbd_m_copy_in(xfer->frbuffers, 2,
 			    m, 0, m->m_pkthdr.len);
 		}
 
@@ -874,12 +874,12 @@ tr_setup:
 
 		m_freem(m);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
 		DPRINTFN(11, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		ifp->if_oerrors++;
 
@@ -895,7 +895,7 @@ tr_setup:
 static void
 aue_tick(struct usb_ether *ue)
 {
-	struct aue_softc *sc = usb2_ether_getsc(ue);
+	struct aue_softc *sc = uether_getsc(ue);
 	struct mii_data *mii = GET_MII(sc);
 
 	AUE_LOCK_ASSERT(sc, MA_OWNED);
@@ -912,21 +912,21 @@ aue_tick(struct usb_ether *ue)
 static void
 aue_start(struct usb_ether *ue)
 {
-	struct aue_softc *sc = usb2_ether_getsc(ue);
+	struct aue_softc *sc = uether_getsc(ue);
 
 	/*
 	 * start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[AUE_INTR_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[AUE_BULK_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[AUE_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[AUE_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[AUE_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[AUE_BULK_DT_WR]);
 }
 
 static void
 aue_init(struct usb_ether *ue)
 {
-	struct aue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct aue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	int i;
 
 	AUE_LOCK_ASSERT(sc, MA_OWNED);
@@ -951,7 +951,7 @@ aue_init(struct usb_ether *ue)
 	AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_TX_ENB);
 	AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_EP3_CLR);
 
-	usb2_transfer_set_stall(sc->sc_xfer[AUE_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[AUE_BULK_DT_WR]);
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 	aue_start(ue);
@@ -960,8 +960,8 @@ aue_init(struct usb_ether *ue)
 static void
 aue_setpromisc(struct usb_ether *ue)
 {
-	struct aue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct aue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	AUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -1017,8 +1017,8 @@ aue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 static void
 aue_stop(struct usb_ether *ue)
 {
-	struct aue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct aue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	AUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -1028,9 +1028,9 @@ aue_stop(struct usb_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[AUE_BULK_DT_WR]);
-	usb2_transfer_stop(sc->sc_xfer[AUE_BULK_DT_RD]);
-	usb2_transfer_stop(sc->sc_xfer[AUE_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[AUE_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[AUE_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[AUE_INTR_DT_RD]);
 
 	aue_csr_write_1(sc, AUE_CTL0, 0);
 	aue_csr_write_1(sc, AUE_CTL1, 0);
diff --git a/sys/dev/usb/net/if_auereg.h b/sys/dev/usb/net/if_auereg.h
index f1f7398..4d0843e 100644
--- a/sys/dev/usb/net/if_auereg.h
+++ b/sys/dev/usb/net/if_auereg.h
@@ -55,7 +55,7 @@
 /*
  * Note that while the ADMtek technically has four endpoints, the control
  * endpoint (endpoint 0) is regarded as special by the USB code and drivers
- * don't have direct access to it (we access it using usb2_do_request()
+ * don't have direct access to it (we access it using usbd_do_request()
  * when reading/writing registers.  Consequently, our endpoint indexes
  * don't match those in the ADMtek Pegasus manual: we consider the RX data
  * endpoint to be index 0 and work up from there.
@@ -183,7 +183,7 @@ enum {
 #define	AUE_RXSTAT_DRIBBLE	0x10
 #define	AUE_RXSTAT_MASK		0x1E
 
-#define	GET_MII(sc)		usb2_ether_getmii(&(sc)->sc_ue)
+#define	GET_MII(sc)		uether_getmii(&(sc)->sc_ue)
 
 struct aue_intrpkt {
 	uint8_t	aue_txstat0;
diff --git a/sys/dev/usb/net/if_axe.c b/sys/dev/usb/net/if_axe.c
index 69f9b00..83caec0 100644
--- a/sys/dev/usb/net/if_axe.c
+++ b/sys/dev/usb/net/if_axe.c
@@ -271,7 +271,7 @@ axe_cmd(struct axe_softc *sc, int cmd, int index, int val, void *buf)
 	USETW(req.wIndex, index);
 	USETW(req.wLength, AXE_CMD_LEN(cmd));
 
-	err = usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000);
+	err = uether_do_request(&sc->sc_ue, &req, buf, 1000);
 
 	return (err);
 }
@@ -347,7 +347,7 @@ axe_miibus_statchg(device_t dev)
 	if (!locked)
 		AXE_LOCK(sc);
 
-	ifp = usb2_ether_getifp(&sc->sc_ue);
+	ifp = uether_getifp(&sc->sc_ue);
 	if (mii == NULL || ifp == NULL ||
 	    (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
 		goto done;
@@ -442,8 +442,8 @@ axe_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 static void
 axe_setmulti(struct usb_ether *ue)
 {
-	struct axe_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct axe_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	struct ifmultiaddr *ifma;
 	uint32_t h = 0;
 	uint16_t rxmode;
@@ -522,35 +522,35 @@ axe_ax88178_init(struct axe_softc *sc)
 	}
 
 	axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x008c, NULL);
-	usb2_ether_pause(&sc->sc_ue, hz / 16);
+	uether_pause(&sc->sc_ue, hz / 16);
 
 	if ((eeprom >> 8) != 0x01) {
 		axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 32);
+		uether_pause(&sc->sc_ue, hz / 32);
 
 		axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x001c, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 3);
+		uether_pause(&sc->sc_ue, hz / 3);
 
 		axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 32);
+		uether_pause(&sc->sc_ue, hz / 32);
 	} else {
 		axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x0004, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 32);
+		uether_pause(&sc->sc_ue, hz / 32);
 
 		axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x000c, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 32);
+		uether_pause(&sc->sc_ue, hz / 32);
 	}
 
 	/* soft reset */
 	axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL);
-	usb2_ether_pause(&sc->sc_ue, hz / 4);
+	uether_pause(&sc->sc_ue, hz / 4);
 
 	axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
 	    AXE_SW_RESET_PRL | AXE_178_RESET_MAGIC, NULL);
-	usb2_ether_pause(&sc->sc_ue, hz / 4);
+	uether_pause(&sc->sc_ue, hz / 4);
 	/* Enable MII/GMII/RGMII interface to work with external PHY. */
 	axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0, NULL);
-	usb2_ether_pause(&sc->sc_ue, hz / 4);
+	uether_pause(&sc->sc_ue, hz / 4);
 
 	axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
 }
@@ -559,22 +559,22 @@ static void
 axe_ax88772_init(struct axe_softc *sc)
 {
 	axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x00b0, NULL);
-	usb2_ether_pause(&sc->sc_ue, hz / 16);
+	uether_pause(&sc->sc_ue, hz / 16);
 
 	if (sc->sc_phyno == AXE_772_PHY_NO_EPHY) {
 		/* ask for the embedded PHY */
 		axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x01, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 64);
+		uether_pause(&sc->sc_ue, hz / 64);
 
 		/* power down and reset state, pin reset state */
 		axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
 		    AXE_SW_RESET_CLEAR, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 16);
+		uether_pause(&sc->sc_ue, hz / 16);
 
 		/* power down/reset state, pin operating state */
 		axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
 		    AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 4);
+		uether_pause(&sc->sc_ue, hz / 4);
 
 		/* power up, reset */
 		axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_PRL, NULL);
@@ -585,14 +585,14 @@ axe_ax88772_init(struct axe_softc *sc)
 	} else {
 		/* ask for external PHY */
 		axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x00, NULL);
-		usb2_ether_pause(&sc->sc_ue, hz / 64);
+		uether_pause(&sc->sc_ue, hz / 64);
 
 		/* power down internal PHY */
 		axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
 		    AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL);
 	}
 
-	usb2_ether_pause(&sc->sc_ue, hz / 4);
+	uether_pause(&sc->sc_ue, hz / 4);
 	axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
 }
 
@@ -602,21 +602,21 @@ axe_reset(struct axe_softc *sc)
 	struct usb_config_descriptor *cd;
 	usb_error_t err;
 
-	cd = usb2_get_config_descriptor(sc->sc_ue.ue_udev);
+	cd = usbd_get_config_descriptor(sc->sc_ue.ue_udev);
 
-	err = usb2_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx,
+	err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx,
 	    cd->bConfigurationValue);
 	if (err)
 		DPRINTF("reset failed (ignored)\n");
 
 	/* Wait a little while for the chip to get its brains in order. */
-	usb2_ether_pause(&sc->sc_ue, hz / 100);
+	uether_pause(&sc->sc_ue, hz / 100);
 }
 
 static void
 axe_attach_post(struct usb_ether *ue)
 {
-	struct axe_softc *sc = usb2_ether_getsc(ue);
+	struct axe_softc *sc = uether_getsc(ue);
 
 	/*
 	 * Load PHY indexes first. Needed by axe_xxx_init().
@@ -669,7 +669,7 @@ axe_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != AXE_IFACE_IDX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(axe_devs, sizeof(axe_devs), uaa));
+	return (usbd_lookup_id_by_uaa(axe_devs, sizeof(axe_devs), uaa));
 }
 
 /*
@@ -687,12 +687,12 @@ axe_attach(device_t dev)
 
 	sc->sc_flags = USB_GET_DRIVER_INFO(uaa);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 
 	iface_index = AXE_IFACE_IDX;
-	error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
+	error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
 	    axe_config, AXE_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "allocating USB transfers failed!\n");
@@ -705,7 +705,7 @@ axe_attach(device_t dev)
 	ue->ue_mtx = &sc->sc_mtx;
 	ue->ue_methods = &axe_ue_methods;
 
-	error = usb2_ether_ifattach(ue);
+	error = uether_ifattach(ue);
 	if (error) {
 		device_printf(dev, "could not attach interface\n");
 		goto detach;
@@ -723,8 +723,8 @@ axe_detach(device_t dev)
 	struct axe_softc *sc = device_get_softc(dev);
 	struct usb_ether *ue = &sc->sc_ue;
 
-	usb2_transfer_unsetup(sc->sc_xfer, AXE_N_TRANSFER);
-	usb2_ether_ifdetach(ue);
+	usbd_transfer_unsetup(sc->sc_xfer, AXE_N_TRANSFER);
+	uether_ifdetach(ue);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -738,7 +738,7 @@ axe_intr_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -760,7 +760,7 @@ axe_bulk_read_callback(struct usb_xfer *xfer)
 {
 	struct axe_softc *sc = xfer->priv_sc;
 	struct usb_ether *ue = &sc->sc_ue;
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	struct axe_sframe_hdr hdr;
 	int error, pos, len, adjust;
 
@@ -773,7 +773,7 @@ axe_bulk_read_callback(struct usb_xfer *xfer)
 					/* too little data */
 					break;
 				}
-				usb2_copy_out(xfer->frbuffers, pos, &hdr, sizeof(hdr));
+				usbd_copy_out(xfer->frbuffers, pos, &hdr, sizeof(hdr));
 
 				if ((hdr.len ^ hdr.ilen) != 0xFFFF) {
 					/* we lost sync */
@@ -793,7 +793,7 @@ axe_bulk_read_callback(struct usb_xfer *xfer)
 				len = xfer->actlen;
 				adjust = 0;
 			}
-			error = usb2_ether_rxbuf(ue, xfer->frbuffers, pos, len);
+			error = uether_rxbuf(ue, xfer->frbuffers, pos, len);
 			if (error)
 				break;
 
@@ -815,13 +815,13 @@ axe_bulk_read_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
-		usb2_ether_rxflush(ue);
+		usbd_transfer_submit(xfer);
+		uether_rxflush(ue);
 		return;
 
 	default:			/* Error */
 		DPRINTF("bulk read error, %s\n", 
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -842,7 +842,7 @@ axe_bulk_write_callback(struct usb_xfer *xfer)
 {
 	struct axe_softc *sc = xfer->priv_sc;
 	struct axe_sframe_hdr hdr;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct mbuf *m;
 	int pos;
 
@@ -878,7 +878,7 @@ tr_setup:
 				hdr.len = htole16(m->m_pkthdr.len);
 				hdr.ilen = ~hdr.len;
 
-				usb2_copy_in(xfer->frbuffers, pos, &hdr, sizeof(hdr));
+				usbd_copy_in(xfer->frbuffers, pos, &hdr, sizeof(hdr));
 
 				pos += sizeof(hdr);
 
@@ -890,7 +890,7 @@ tr_setup:
 				 * USB_FORCE_SHORT_XFER flag instead.
 				 */
 			}
-			usb2_m_copy_in(xfer->frbuffers, pos,
+			usbd_m_copy_in(xfer->frbuffers, pos,
 			    m, 0, m->m_pkthdr.len);
 
 			pos += m->m_pkthdr.len;
@@ -915,12 +915,12 @@ tr_setup:
 		}
 
 		xfer->frlengths[0] = pos;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
 		DPRINTFN(11, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		ifp->if_oerrors++;
 
@@ -937,7 +937,7 @@ tr_setup:
 static void
 axe_tick(struct usb_ether *ue)
 {
-	struct axe_softc *sc = usb2_ether_getsc(ue);
+	struct axe_softc *sc = uether_getsc(ue);
 	struct mii_data *mii = GET_MII(sc);
 
 	AXE_LOCK_ASSERT(sc, MA_OWNED);
@@ -953,21 +953,21 @@ axe_tick(struct usb_ether *ue)
 static void
 axe_start(struct usb_ether *ue)
 {
-	struct axe_softc *sc = usb2_ether_getsc(ue);
+	struct axe_softc *sc = uether_getsc(ue);
 
 	/*
 	 * start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[AXE_INTR_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[AXE_BULK_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[AXE_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[AXE_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[AXE_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[AXE_BULK_DT_WR]);
 }
 
 static void
 axe_init(struct usb_ether *ue)
 {
-	struct axe_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct axe_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	uint16_t rxmode;
 
 	AXE_LOCK_ASSERT(sc, MA_OWNED);
@@ -1010,7 +1010,7 @@ axe_init(struct usb_ether *ue)
 	/* Load the multicast filter. */
 	axe_setmulti(ue);
 
-	usb2_transfer_set_stall(sc->sc_xfer[AXE_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[AXE_BULK_DT_WR]);
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 	axe_start(ue);
@@ -1019,8 +1019,8 @@ axe_init(struct usb_ether *ue)
 static void
 axe_setpromisc(struct usb_ether *ue)
 {
-	struct axe_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct axe_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	uint16_t rxmode;
 
 	axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, &rxmode);
@@ -1041,8 +1041,8 @@ axe_setpromisc(struct usb_ether *ue)
 static void
 axe_stop(struct usb_ether *ue)
 {
-	struct axe_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct axe_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	AXE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -1052,9 +1052,9 @@ axe_stop(struct usb_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[AXE_BULK_DT_WR]);
-	usb2_transfer_stop(sc->sc_xfer[AXE_BULK_DT_RD]);
-	usb2_transfer_stop(sc->sc_xfer[AXE_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[AXE_INTR_DT_RD]);
 
 	axe_reset(sc);
 }
diff --git a/sys/dev/usb/net/if_axereg.h b/sys/dev/usb/net/if_axereg.h
index 075dd24..ae1a1d6 100644
--- a/sys/dev/usb/net/if_axereg.h
+++ b/sys/dev/usb/net/if_axereg.h
@@ -166,7 +166,7 @@ struct axe_sframe_hdr {
 	uint16_t ilen;
 } __packed;
 
-#define	GET_MII(sc)		usb2_ether_getmii(&(sc)->sc_ue)
+#define	GET_MII(sc)		uether_getmii(&(sc)->sc_ue)
 
 /* The interrupt endpoint is currently unused by the ASIX part. */
 enum {
diff --git a/sys/dev/usb/net/if_cdce.c b/sys/dev/usb/net/if_cdce.c
index a4f2350..5083c87 100644
--- a/sys/dev/usb/net/if_cdce.c
+++ b/sys/dev/usb/net/if_cdce.c
@@ -207,7 +207,7 @@ cdce_probe(device_t dev)
 {
 	struct usb_attach_arg *uaa = device_get_ivars(dev);
 
-	return (usb2_lookup_id_by_uaa(cdce_devs, sizeof(cdce_devs), uaa));
+	return (usbd_lookup_id_by_uaa(cdce_devs, sizeof(cdce_devs), uaa));
 }
 
 static void
@@ -233,7 +233,7 @@ cdce_attach(device_t dev)
 
 	sc->sc_flags = USB_GET_DRIVER_INFO(uaa);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 
@@ -255,17 +255,17 @@ cdce_attach(device_t dev)
 
 	for (i = 0;; i++) {
 
-		iface = usb2_get_iface(uaa->device, i);
+		iface = usbd_get_iface(uaa->device, i);
 
 		if (iface) {
 
-			id = usb2_get_interface_descriptor(iface);
+			id = usbd_get_interface_descriptor(iface);
 
 			if (id && (id->bInterfaceNumber ==
 			    sc->sc_data_iface_no)) {
 				sc->sc_ifaces_index[0] = i;
 				sc->sc_ifaces_index[1] = uaa->info.bIfaceIndex;
-				usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
+				usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
 				break;
 			}
 		} else {
@@ -301,7 +301,7 @@ alloc_transfers:
 
 	for (i = 0; i != 32; i++) {
 
-		error = usb2_set_alt_interface_index
+		error = usbd_set_alt_interface_index
 		    (uaa->device, sc->sc_ifaces_index[0], i);
 
 		if (error) {
@@ -309,7 +309,7 @@ alloc_transfers:
 			    "setting found!\n");
 			goto detach;
 		}
-		error = usb2_transfer_setup
+		error = usbd_transfer_setup
 		    (uaa->device, sc->sc_ifaces_index,
 		    sc->sc_xfer, cdce_config, CDCE_N_TRANSFER,
 		    sc, &sc->sc_mtx);
@@ -326,7 +326,7 @@ alloc_transfers:
 	if ((ued == NULL) || (ued->bLength < sizeof(*ued))) {
 		error = USB_ERR_INVAL;
 	} else {
-		error = usb2_req_get_string_any(uaa->device, NULL, 
+		error = usbd_req_get_string_any(uaa->device, NULL, 
 		    eaddr_str, sizeof(eaddr_str), ued->iMacAddress);
 	}
 
@@ -375,7 +375,7 @@ alloc_transfers:
 	ue->ue_mtx = &sc->sc_mtx;
 	ue->ue_methods = &cdce_ue_methods;
 
-	error = usb2_ether_ifattach(ue);
+	error = uether_ifattach(ue);
 	if (error) {
 		device_printf(dev, "could not attach interface\n");
 		goto detach;
@@ -394,8 +394,8 @@ cdce_detach(device_t dev)
 	struct usb_ether *ue = &sc->sc_ue;
 
 	/* stop all USB transfers first */
-	usb2_transfer_unsetup(sc->sc_xfer, CDCE_N_TRANSFER);
-	usb2_ether_ifdetach(ue);
+	usbd_transfer_unsetup(sc->sc_xfer, CDCE_N_TRANSFER);
+	uether_ifdetach(ue);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -404,13 +404,13 @@ cdce_detach(device_t dev)
 static void
 cdce_start(struct usb_ether *ue)
 {
-	struct cdce_softc *sc = usb2_ether_getsc(ue);
+	struct cdce_softc *sc = uether_getsc(ue);
 
 	/*
 	 * Start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[CDCE_BULK_TX]);
-	usb2_transfer_start(sc->sc_xfer[CDCE_BULK_RX]);
+	usbd_transfer_start(sc->sc_xfer[CDCE_BULK_TX]);
+	usbd_transfer_start(sc->sc_xfer[CDCE_BULK_RX]);
 }
 
 static void
@@ -429,7 +429,7 @@ static void
 cdce_bulk_write_callback(struct usb_xfer *xfer)
 {
 	struct cdce_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct mbuf *m;
 	struct mbuf *mt;
 	uint32_t crc;
@@ -487,7 +487,7 @@ tr_setup:
 			}
 			sc->sc_tx_buf[x] = m;
 			xfer->frlengths[x] = m->m_len;
-			usb2_set_frame_data(xfer, m->m_data, x);
+			usbd_set_frame_data(xfer, m->m_data, x);
 
 			/*
 			 * If there's a BPF listener, bounce a copy of
@@ -497,13 +497,13 @@ tr_setup:
 		}
 		if (x != 0) {
 			xfer->nframes = x;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
 	default:			/* Error */
 		DPRINTFN(11, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		/* free all previous TX buffers */
 		cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX);
@@ -542,19 +542,19 @@ cdce_m_crc32(struct mbuf *m, uint32_t src_offset, uint32_t src_len)
 static void
 cdce_init(struct usb_ether *ue)
 {
-	struct cdce_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct cdce_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	CDCE_LOCK_ASSERT(sc, MA_OWNED);
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 
 	/* start interrupt transfer */
-	usb2_transfer_start(sc->sc_xfer[CDCE_INTR_RX]);
-	usb2_transfer_start(sc->sc_xfer[CDCE_INTR_TX]);
+	usbd_transfer_start(sc->sc_xfer[CDCE_INTR_RX]);
+	usbd_transfer_start(sc->sc_xfer[CDCE_INTR_TX]);
 
 	/* stall data write direction, which depends on USB mode */
-	usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]);
+	usbd_transfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]);
 
 	/* start data transfers */
 	cdce_start(ue);
@@ -563,8 +563,8 @@ cdce_init(struct usb_ether *ue)
 static void
 cdce_stop(struct usb_ether *ue)
 {
-	struct cdce_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct cdce_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	CDCE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -573,10 +573,10 @@ cdce_stop(struct usb_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_RX]);
-	usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_TX]);
-	usb2_transfer_stop(sc->sc_xfer[CDCE_INTR_RX]);
-	usb2_transfer_stop(sc->sc_xfer[CDCE_INTR_TX]);
+	usbd_transfer_stop(sc->sc_xfer[CDCE_BULK_RX]);
+	usbd_transfer_stop(sc->sc_xfer[CDCE_BULK_TX]);
+	usbd_transfer_stop(sc->sc_xfer[CDCE_INTR_RX]);
+	usbd_transfer_stop(sc->sc_xfer[CDCE_INTR_TX]);
 }
 
 static void
@@ -635,7 +635,7 @@ cdce_bulk_read_callback(struct usb_xfer *xfer)
 				continue;
 			}
 			/* queue up mbuf */
-			usb2_ether_rxmbuf(&sc->sc_ue, m, xfer->frlengths[x]);
+			uether_rxmbuf(&sc->sc_ue, m, xfer->frlengths[x]);
 		}
 
 		/* FALLTHROUGH */
@@ -646,7 +646,7 @@ cdce_bulk_read_callback(struct usb_xfer *xfer)
 		 */
 		for (x = 0; x != 1; x++) {
 			if (sc->sc_rx_buf[x] == NULL) {
-				m = usb2_ether_newbuf();
+				m = uether_newbuf();
 				if (m == NULL)
 					goto tr_stall;
 				sc->sc_rx_buf[x] = m;
@@ -654,26 +654,26 @@ cdce_bulk_read_callback(struct usb_xfer *xfer)
 				m = sc->sc_rx_buf[x];
 			}
 
-			usb2_set_frame_data(xfer, m->m_data, x);
+			usbd_set_frame_data(xfer, m->m_data, x);
 			xfer->frlengths[x] = m->m_len;
 		}
 		/* set number of frames and start hardware */
 		xfer->nframes = x;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		/* flush any received frames */
-		usb2_ether_rxflush(&sc->sc_ue);
+		uether_rxflush(&sc->sc_ue);
 		break;
 
 	default:			/* Error */
 		DPRINTF("error = %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 tr_stall:
 			/* try to clear stall first */
 			xfer->flags.stall_pipe = 1;
 			xfer->nframes = 0;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 			break;
 		}
 
@@ -699,7 +699,7 @@ cdce_intr_read_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -726,7 +726,7 @@ cdce_intr_write_callback(struct usb_xfer *xfer)
 tr_setup:
 #if 0
 		xfer->frlengths[0] = XXX;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 #endif
 		break;
 
diff --git a/sys/dev/usb/net/if_cue.c b/sys/dev/usb/net/if_cue.c
index cf37520..648722f 100644
--- a/sys/dev/usb/net/if_cue.c
+++ b/sys/dev/usb/net/if_cue.c
@@ -186,7 +186,7 @@ cue_csr_read_1(struct cue_softc *sc, uint16_t reg)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 1);
 
-	if (usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000)) {
+	if (uether_do_request(&sc->sc_ue, &req, &val, 1000)) {
 		/* ignore any errors */
 	}
 	return (val);
@@ -204,7 +204,7 @@ cue_csr_read_2(struct cue_softc *sc, uint8_t reg)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 2);
 
-	(void)usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000);
+	(void)uether_do_request(&sc->sc_ue, &req, &val, 1000);
 	return (le16toh(val));
 }
 
@@ -219,7 +219,7 @@ cue_csr_write_1(struct cue_softc *sc, uint16_t reg, uint16_t val)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 0);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, NULL, 1000));
 }
 
 static int
@@ -236,7 +236,7 @@ cue_mem(struct cue_softc *sc, uint8_t cmd, uint16_t addr, void *buf, int len)
 	USETW(req.wIndex, addr);
 	USETW(req.wLength, len);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 static int
@@ -250,7 +250,7 @@ cue_getmac(struct cue_softc *sc, void *buf)
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, ETHER_ADDR_LEN);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 #define	CUE_BITS 9
@@ -269,8 +269,8 @@ cue_mchash(const uint8_t *addr)
 static void
 cue_setpromisc(struct usb_ether *ue)
 {
-	struct cue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct cue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	CUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -287,8 +287,8 @@ cue_setpromisc(struct usb_ether *ue)
 static void
 cue_setmulti(struct usb_ether *ue)
 {
-	struct cue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct cue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	struct ifmultiaddr *ifma;
 	uint32_t h = 0, i;
 	uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
@@ -337,20 +337,20 @@ cue_reset(struct cue_softc *sc)
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 0);
 
-	if (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000)) {
+	if (uether_do_request(&sc->sc_ue, &req, NULL, 1000)) {
 		/* ignore any errors */
 	}
 
 	/*
 	 * wait a little while for the chip to get its brains in order:
 	 */
-	usb2_ether_pause(&sc->sc_ue, hz / 100);
+	uether_pause(&sc->sc_ue, hz / 100);
 }
 
 static void
 cue_attach_post(struct usb_ether *ue)
 {
-	struct cue_softc *sc = usb2_ether_getsc(ue);
+	struct cue_softc *sc = uether_getsc(ue);
 
 	cue_getmac(sc, ue->ue_eaddr);
 }
@@ -367,7 +367,7 @@ cue_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != CUE_IFACE_IDX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(cue_devs, sizeof(cue_devs), uaa));
+	return (usbd_lookup_id_by_uaa(cue_devs, sizeof(cue_devs), uaa));
 }
 
 /*
@@ -383,11 +383,11 @@ cue_attach(device_t dev)
 	uint8_t iface_index;
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 
 	iface_index = CUE_IFACE_IDX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, cue_config, CUE_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "allocating USB transfers failed!\n");
@@ -400,7 +400,7 @@ cue_attach(device_t dev)
 	ue->ue_mtx = &sc->sc_mtx;
 	ue->ue_methods = &cue_ue_methods;
 
-	error = usb2_ether_ifattach(ue);
+	error = uether_ifattach(ue);
 	if (error) {
 		device_printf(dev, "could not attach interface\n");
 		goto detach;
@@ -418,8 +418,8 @@ cue_detach(device_t dev)
 	struct cue_softc *sc = device_get_softc(dev);
 	struct usb_ether *ue = &sc->sc_ue;
 
-	usb2_transfer_unsetup(sc->sc_xfer, CUE_N_TRANSFER);
-	usb2_ether_ifdetach(ue);
+	usbd_transfer_unsetup(sc->sc_xfer, CUE_N_TRANSFER);
+	uether_ifdetach(ue);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -430,7 +430,7 @@ cue_bulk_read_callback(struct usb_xfer *xfer)
 {
 	struct cue_softc *sc = xfer->priv_sc;
 	struct usb_ether *ue = &sc->sc_ue;
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	uint8_t buf[2];
 	int len;
 
@@ -441,23 +441,23 @@ cue_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, buf, 2);
+		usbd_copy_out(xfer->frbuffers, 0, buf, 2);
 		xfer->actlen -= 2;
 		len = buf[0] | (buf[1] << 8);
 		len = min(xfer->actlen, len);
 
-		usb2_ether_rxbuf(ue, xfer->frbuffers, 2, len);
+		uether_rxbuf(ue, xfer->frbuffers, 2, len);
 		/* FALLTHROUGH */
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
-		usb2_ether_rxflush(ue);
+		usbd_transfer_submit(xfer);
+		uether_rxflush(ue);
 		return;
 
 	default:			/* Error */
 		DPRINTF("bulk read error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -473,7 +473,7 @@ static void
 cue_bulk_write_callback(struct usb_xfer *xfer)
 {
 	struct cue_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct mbuf *m;
 	uint8_t buf[2];
 
@@ -498,9 +498,9 @@ tr_setup:
 		buf[0] = (uint8_t)(m->m_pkthdr.len);
 		buf[1] = (uint8_t)(m->m_pkthdr.len >> 8);
 
-		usb2_copy_in(xfer->frbuffers, 0, buf, 2);
+		usbd_copy_in(xfer->frbuffers, 0, buf, 2);
 
-		usb2_m_copy_in(xfer->frbuffers, 2,
+		usbd_m_copy_in(xfer->frbuffers, 2,
 		    m, 0, m->m_pkthdr.len);
 
 		/*
@@ -511,13 +511,13 @@ tr_setup:
 
 		m_freem(m);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		return;
 
 	default:			/* Error */
 		DPRINTFN(11, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		ifp->if_oerrors++;
 
@@ -533,8 +533,8 @@ tr_setup:
 static void
 cue_tick(struct usb_ether *ue)
 {
-	struct cue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct cue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	CUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -549,20 +549,20 @@ cue_tick(struct usb_ether *ue)
 static void
 cue_start(struct usb_ether *ue)
 {
-	struct cue_softc *sc = usb2_ether_getsc(ue);
+	struct cue_softc *sc = uether_getsc(ue);
 
 	/*
 	 * start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[CUE_BULK_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[CUE_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[CUE_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[CUE_BULK_DT_WR]);
 }
 
 static void
 cue_init(struct usb_ether *ue)
 {
-	struct cue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct cue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	int i;
 
 	CUE_LOCK_ASSERT(sc, MA_OWNED);
@@ -598,7 +598,7 @@ cue_init(struct usb_ether *ue)
 	/* Program the LED operation. */
 	cue_csr_write_1(sc, CUE_LEDCTL, CUE_LEDCTL_FOLLOW_LINK);
 
-	usb2_transfer_set_stall(sc->sc_xfer[CUE_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[CUE_BULK_DT_WR]);
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 	cue_start(ue);
@@ -611,8 +611,8 @@ cue_init(struct usb_ether *ue)
 static void
 cue_stop(struct usb_ether *ue)
 {
-	struct cue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct cue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	CUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -621,8 +621,8 @@ cue_stop(struct usb_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[CUE_BULK_DT_WR]);
-	usb2_transfer_stop(sc->sc_xfer[CUE_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[CUE_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[CUE_BULK_DT_RD]);
 
 	cue_csr_write_1(sc, CUE_ETHCTL, 0);
 	cue_reset(sc);
diff --git a/sys/dev/usb/net/if_kue.c b/sys/dev/usb/net/if_kue.c
index a2a1c2d..555b493 100644
--- a/sys/dev/usb/net/if_kue.c
+++ b/sys/dev/usb/net/if_kue.c
@@ -223,7 +223,7 @@ kue_do_request(struct kue_softc *sc, struct usb_device_request *req,
 {
 	usb_error_t err;
 
-	err = usb2_ether_do_request(&sc->sc_ue, req, data, 60000);
+	err = uether_do_request(&sc->sc_ue, req, data, 60000);
 
 	return (err);
 }
@@ -269,7 +269,7 @@ kue_load_fw(struct kue_softc *sc)
 	uint16_t hwrev;
 	usb_error_t err;
 
-	dd = usb2_get_device_descriptor(sc->sc_ue.ue_udev);
+	dd = usbd_get_device_descriptor(sc->sc_ue.ue_udev);
 	hwrev = UGETW(dd->bcdDevice);
 
 	/*
@@ -294,7 +294,7 @@ kue_load_fw(struct kue_softc *sc)
 	    0, kue_code_seg, sizeof(kue_code_seg));
 	if (err) {
 		device_printf(sc->sc_ue.ue_dev, "failed to load code segment: %s\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		return(ENXIO);
 	}
 
@@ -303,7 +303,7 @@ kue_load_fw(struct kue_softc *sc)
 	    0, kue_fix_seg, sizeof(kue_fix_seg));
 	if (err) {
 		device_printf(sc->sc_ue.ue_dev, "failed to load fixup segment: %s\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		return(ENXIO);
 	}
 
@@ -312,7 +312,7 @@ kue_load_fw(struct kue_softc *sc)
 	    0, kue_trig_seg, sizeof(kue_trig_seg));
 	if (err) {
 		device_printf(sc->sc_ue.ue_dev, "failed to load trigger segment: %s\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		return(ENXIO);
 	}
 
@@ -322,8 +322,8 @@ kue_load_fw(struct kue_softc *sc)
 static void
 kue_setpromisc(struct usb_ether *ue)
 {
-	struct kue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct kue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	KUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -338,8 +338,8 @@ kue_setpromisc(struct usb_ether *ue)
 static void
 kue_setmulti(struct usb_ether *ue)
 {
-	struct kue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct kue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	struct ifmultiaddr *ifma;
 	int i = 0;
 
@@ -393,21 +393,21 @@ kue_reset(struct kue_softc *sc)
 	struct usb_config_descriptor *cd;
 	usb_error_t err;
 
-	cd = usb2_get_config_descriptor(sc->sc_ue.ue_udev);
+	cd = usbd_get_config_descriptor(sc->sc_ue.ue_udev);
 
-	err = usb2_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx,
+	err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx,
 	    cd->bConfigurationValue);
 	if (err)
 		DPRINTF("reset failed (ignored)\n");
 
 	/* wait a little while for the chip to get its brains in order */
-	usb2_ether_pause(&sc->sc_ue, hz / 100);
+	uether_pause(&sc->sc_ue, hz / 100);
 }
 
 static void
 kue_attach_post(struct usb_ether *ue)
 {
-	struct kue_softc *sc = usb2_ether_getsc(ue);
+	struct kue_softc *sc = uether_getsc(ue);
 	int error;
 
 	/* load the firmware into the NIC */
@@ -443,7 +443,7 @@ kue_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != KUE_IFACE_IDX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(kue_devs, sizeof(kue_devs), uaa));
+	return (usbd_lookup_id_by_uaa(kue_devs, sizeof(kue_devs), uaa));
 }
 
 /*
@@ -459,11 +459,11 @@ kue_attach(device_t dev)
 	uint8_t iface_index;
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 
 	iface_index = KUE_IFACE_IDX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, kue_config, KUE_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "allocating USB transfers failed!\n");
@@ -483,7 +483,7 @@ kue_attach(device_t dev)
 	ue->ue_mtx = &sc->sc_mtx;
 	ue->ue_methods = &kue_ue_methods;
 
-	error = usb2_ether_ifattach(ue);
+	error = uether_ifattach(ue);
 	if (error) {
 		device_printf(dev, "could not attach interface\n");
 		goto detach;
@@ -501,8 +501,8 @@ kue_detach(device_t dev)
 	struct kue_softc *sc = device_get_softc(dev);
 	struct usb_ether *ue = &sc->sc_ue;
 
-	usb2_transfer_unsetup(sc->sc_xfer, KUE_N_TRANSFER);
-	usb2_ether_ifdetach(ue);
+	usbd_transfer_unsetup(sc->sc_xfer, KUE_N_TRANSFER);
+	uether_ifdetach(ue);
 	mtx_destroy(&sc->sc_mtx);
 	free(sc->sc_mcfilters, M_USBDEV);
 
@@ -518,7 +518,7 @@ kue_bulk_read_callback(struct usb_xfer *xfer)
 {
 	struct kue_softc *sc = xfer->priv_sc;
 	struct usb_ether *ue = &sc->sc_ue;
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	uint8_t buf[2];
 	int len;
 
@@ -529,23 +529,23 @@ kue_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, buf, 2);
+		usbd_copy_out(xfer->frbuffers, 0, buf, 2);
 		xfer->actlen -= 2;
 		len = buf[0] | (buf[1] << 8);
 		len = min(xfer->actlen, len);
 
-		usb2_ether_rxbuf(ue, xfer->frbuffers, 2, len);
+		uether_rxbuf(ue, xfer->frbuffers, 2, len);
 		/* FALLTHROUGH */
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
-		usb2_ether_rxflush(ue);
+		usbd_transfer_submit(xfer);
+		uether_rxflush(ue);
 		return;
 
 	default:			/* Error */
 		DPRINTF("bulk read error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -561,7 +561,7 @@ static void
 kue_bulk_write_callback(struct usb_xfer *xfer)
 {
 	struct kue_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct mbuf *m;
 	int total_len;
 	int temp_len;
@@ -589,12 +589,12 @@ tr_setup:
 		buf[0] = (uint8_t)(m->m_pkthdr.len);
 		buf[1] = (uint8_t)(m->m_pkthdr.len >> 8);
 
-		usb2_copy_in(xfer->frbuffers, 0, buf, 2);
+		usbd_copy_in(xfer->frbuffers, 0, buf, 2);
 
-		usb2_m_copy_in(xfer->frbuffers, 2,
+		usbd_m_copy_in(xfer->frbuffers, 2,
 		    m, 0, m->m_pkthdr.len);
 
-		usb2_bzero(xfer->frbuffers, temp_len,
+		usbd_frame_zero(xfer->frbuffers, temp_len,
 		    total_len - temp_len);
 
 		xfer->frlengths[0] = total_len;
@@ -607,13 +607,13 @@ tr_setup:
 
 		m_freem(m);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		return;
 
 	default:			/* Error */
 		DPRINTFN(11, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		ifp->if_oerrors++;
 
@@ -630,20 +630,20 @@ tr_setup:
 static void
 kue_start(struct usb_ether *ue)
 {
-	struct kue_softc *sc = usb2_ether_getsc(ue);
+	struct kue_softc *sc = uether_getsc(ue);
 
 	/*
 	 * start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[KUE_BULK_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[KUE_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[KUE_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[KUE_BULK_DT_WR]);
 }
 
 static void
 kue_init(struct usb_ether *ue)
 {
-	struct kue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct kue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	KUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -664,7 +664,7 @@ kue_init(struct usb_ether *ue)
 	/* load the multicast filter */
 	kue_setpromisc(ue);
 
-	usb2_transfer_set_stall(sc->sc_xfer[KUE_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[KUE_BULK_DT_WR]);
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 	kue_start(ue);
@@ -673,8 +673,8 @@ kue_init(struct usb_ether *ue)
 static void
 kue_stop(struct usb_ether *ue)
 {
-	struct kue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct kue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	KUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -683,6 +683,6 @@ kue_stop(struct usb_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[KUE_BULK_DT_WR]);
-	usb2_transfer_stop(sc->sc_xfer[KUE_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[KUE_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[KUE_BULK_DT_RD]);
 }
diff --git a/sys/dev/usb/net/if_rue.c b/sys/dev/usb/net/if_rue.c
index 7eadb5c..36960d1 100644
--- a/sys/dev/usb/net/if_rue.c
+++ b/sys/dev/usb/net/if_rue.c
@@ -228,7 +228,7 @@ rue_read_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len)
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, len);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 static int
@@ -242,7 +242,7 @@ rue_write_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len)
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, len);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 static uint8_t
@@ -436,8 +436,8 @@ rue_miibus_statchg(device_t dev)
 static void
 rue_setpromisc(struct usb_ether *ue)
 {
-	struct rue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct rue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	RUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -454,8 +454,8 @@ rue_setpromisc(struct usb_ether *ue)
 static void
 rue_setmulti(struct usb_ether *ue)
 {
-	struct rue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct rue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	uint16_t rxcfg;
 	int h = 0;
 	uint32_t hashes[2] = { 0, 0 };
@@ -515,7 +515,7 @@ rue_reset(struct rue_softc *sc)
 	rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST);
 
 	for (i = 0; i != RUE_TIMEOUT; i++) {
-		if (usb2_ether_pause(&sc->sc_ue, hz / 1000))
+		if (uether_pause(&sc->sc_ue, hz / 1000))
 			break;
 		if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST))
 			break;
@@ -523,13 +523,13 @@ rue_reset(struct rue_softc *sc)
 	if (i == RUE_TIMEOUT)
 		device_printf(sc->sc_ue.ue_dev, "reset never completed!\n");
 
-	usb2_ether_pause(&sc->sc_ue, hz / 100);
+	uether_pause(&sc->sc_ue, hz / 100);
 }
 
 static void
 rue_attach_post(struct usb_ether *ue)
 {
-	struct rue_softc *sc = usb2_ether_getsc(ue);
+	struct rue_softc *sc = uether_getsc(ue);
 
 	/* reset the adapter */
 	rue_reset(sc);
@@ -553,7 +553,7 @@ rue_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != RUE_IFACE_IDX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa));
+	return (usbd_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa));
 }
 
 /*
@@ -569,11 +569,11 @@ rue_attach(device_t dev)
 	uint8_t iface_index;
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 
 	iface_index = RUE_IFACE_IDX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, rue_config, RUE_N_TRANSFER,
 	    sc, &sc->sc_mtx);
 	if (error) {
@@ -587,7 +587,7 @@ rue_attach(device_t dev)
 	ue->ue_mtx = &sc->sc_mtx;
 	ue->ue_methods = &rue_ue_methods;
 
-	error = usb2_ether_ifattach(ue);
+	error = uether_ifattach(ue);
 	if (error) {
 		device_printf(dev, "could not attach interface\n");
 		goto detach;
@@ -605,8 +605,8 @@ rue_detach(device_t dev)
 	struct rue_softc *sc = device_get_softc(dev);
 	struct usb_ether *ue = &sc->sc_ue;
 
-	usb2_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER);
-	usb2_ether_ifdetach(ue);
+	usbd_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER);
+	uether_ifdetach(ue);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -616,7 +616,7 @@ static void
 rue_intr_callback(struct usb_xfer *xfer)
 {
 	struct rue_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct rue_intrpkt pkt;
 
 	switch (USB_GET_STATE(xfer)) {
@@ -625,7 +625,7 @@ rue_intr_callback(struct usb_xfer *xfer)
 		if (ifp && (ifp->if_drv_flags & IFF_DRV_RUNNING) &&
 		    (xfer->actlen >= sizeof(pkt))) {
 
-			usb2_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt));
+			usbd_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt));
 
 			ifp->if_ierrors += pkt.rue_rxlost_cnt;
 			ifp->if_ierrors += pkt.rue_crcerr_cnt;
@@ -635,7 +635,7 @@ rue_intr_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -653,7 +653,7 @@ rue_bulk_read_callback(struct usb_xfer *xfer)
 {
 	struct rue_softc *sc = xfer->priv_sc;
 	struct usb_ether *ue = &sc->sc_ue;
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	uint16_t status;
 
 	switch (USB_GET_STATE(xfer)) {
@@ -663,7 +663,7 @@ rue_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, xfer->actlen - 4,
+		usbd_copy_out(xfer->frbuffers, xfer->actlen - 4,
 		    &status, sizeof(status));
 		xfer->actlen -= 4;
 
@@ -673,18 +673,18 @@ rue_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_ether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen);
+		uether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen);
 		/* FALLTHROUGH */
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
-		usb2_ether_rxflush(ue);
+		usbd_transfer_submit(xfer);
+		uether_rxflush(ue);
 		return;
 
 	default:			/* Error */
 		DPRINTF("bulk read error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -699,7 +699,7 @@ static void
 rue_bulk_write_callback(struct usb_xfer *xfer)
 {
 	struct rue_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct mbuf *m;
 	int temp_len;
 
@@ -725,7 +725,7 @@ tr_setup:
 			m->m_pkthdr.len = MCLBYTES;
 		temp_len = m->m_pkthdr.len;
 
-		usb2_m_copy_in(xfer->frbuffers, 0,
+		usbd_m_copy_in(xfer->frbuffers, 0,
 		    m, 0, m->m_pkthdr.len);
 
 		/*
@@ -734,7 +734,7 @@ tr_setup:
 		 * RUE_MIN_FRAMELEN (60) byte packet.
 		 */
 		if (temp_len < RUE_MIN_FRAMELEN) {
-			usb2_bzero(xfer->frbuffers, temp_len,
+			usbd_frame_zero(xfer->frbuffers, temp_len,
 			    RUE_MIN_FRAMELEN - temp_len);
 			temp_len = RUE_MIN_FRAMELEN;
 		}
@@ -748,13 +748,13 @@ tr_setup:
 
 		m_freem(m);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		return;
 
 	default:			/* Error */
 		DPRINTFN(11, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		ifp->if_oerrors++;
 
@@ -770,7 +770,7 @@ tr_setup:
 static void
 rue_tick(struct usb_ether *ue)
 {
-	struct rue_softc *sc = usb2_ether_getsc(ue);
+	struct rue_softc *sc = uether_getsc(ue);
 	struct mii_data *mii = GET_MII(sc);
 
 	RUE_LOCK_ASSERT(sc, MA_OWNED);
@@ -787,21 +787,21 @@ rue_tick(struct usb_ether *ue)
 static void
 rue_start(struct usb_ether *ue)
 {
-	struct rue_softc *sc = usb2_ether_getsc(ue);
+	struct rue_softc *sc = uether_getsc(ue);
 
 	/*
 	 * start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]);
 }
 
 static void
 rue_init(struct usb_ether *ue)
 {
-	struct rue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct rue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	RUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -829,7 +829,7 @@ rue_init(struct usb_ether *ue)
 	/* Enable RX and TX */
 	rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN));
 
-	usb2_transfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]);
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 	rue_start(ue);
@@ -876,8 +876,8 @@ rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 static void
 rue_stop(struct usb_ether *ue)
 {
-	struct rue_softc *sc = usb2_ether_getsc(ue);
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct rue_softc *sc = uether_getsc(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 
 	RUE_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -887,9 +887,9 @@ rue_stop(struct usb_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]);
-	usb2_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]);
-	usb2_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]);
 
 	rue_csr_write_1(sc, RUE_CR, 0x00);
 
diff --git a/sys/dev/usb/net/if_ruereg.h b/sys/dev/usb/net/if_ruereg.h
index edfa3d3..a4a4aec 100644
--- a/sys/dev/usb/net/if_ruereg.h
+++ b/sys/dev/usb/net/if_ruereg.h
@@ -144,7 +144,7 @@
 #define	RUE_RXSTAT_PMATCH	(0x04 << 12)
 #define	RUE_RXSTAT_MCAST	(0x08 << 12)
 
-#define	GET_MII(sc)		usb2_ether_getmii(&(sc)->sc_ue)
+#define	GET_MII(sc)		uether_getmii(&(sc)->sc_ue)
 
 struct rue_intrpkt {
 	uint8_t	rue_tsr;
diff --git a/sys/dev/usb/net/if_udav.c b/sys/dev/usb/net/if_udav.c
index 008f408..be9af15 100644
--- a/sys/dev/usb/net/if_udav.c
+++ b/sys/dev/usb/net/if_udav.c
@@ -197,7 +197,7 @@ static const struct usb_device_id udav_devs[] = {
 static void
 udav_attach_post(struct usb_ether *ue)
 {
-	struct udav_softc *sc = usb2_ether_getsc(ue);
+	struct udav_softc *sc = uether_getsc(ue);
 
 	/* reset the adapter */
 	udav_reset(sc);
@@ -218,7 +218,7 @@ udav_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UDAV_IFACE_INDEX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(udav_devs, sizeof(udav_devs), uaa));
+	return (usbd_lookup_id_by_uaa(udav_devs, sizeof(udav_devs), uaa));
 }
 
 static int
@@ -232,12 +232,12 @@ udav_attach(device_t dev)
 
 	sc->sc_flags = USB_GET_DRIVER_INFO(uaa);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 
 	iface_index = UDAV_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, udav_config, UDAV_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "allocating USB transfers failed!\n");
@@ -250,7 +250,7 @@ udav_attach(device_t dev)
 	ue->ue_mtx = &sc->sc_mtx;
 	ue->ue_methods = &udav_ue_methods;
 
-	error = usb2_ether_ifattach(ue);
+	error = uether_ifattach(ue);
 	if (error) {
 		device_printf(dev, "could not attach interface\n");
 		goto detach;
@@ -269,8 +269,8 @@ udav_detach(device_t dev)
 	struct udav_softc *sc = device_get_softc(dev);
 	struct usb_ether *ue = &sc->sc_ue;
 
-	usb2_transfer_unsetup(sc->sc_xfer, UDAV_N_TRANSFER);
-	usb2_ether_ifdetach(ue);
+	usbd_transfer_unsetup(sc->sc_xfer, UDAV_N_TRANSFER);
+	uether_ifdetach(ue);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -291,7 +291,7 @@ udav_mem_read(struct udav_softc *sc, uint16_t offset, void *buf,
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 static int
@@ -308,7 +308,7 @@ udav_mem_write(struct udav_softc *sc, uint16_t offset, void *buf,
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 static int
@@ -323,7 +323,7 @@ udav_mem_write1(struct udav_softc *sc, uint16_t offset,
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, 0x0000);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, NULL, 1000));
 }
 #endif
 
@@ -340,7 +340,7 @@ udav_csr_read(struct udav_softc *sc, uint16_t offset, void *buf, int len)
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 static int
@@ -357,7 +357,7 @@ udav_csr_write(struct udav_softc *sc, uint16_t offset, void *buf, int len)
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, buf, 1000));
 }
 
 static uint8_t
@@ -383,14 +383,14 @@ udav_csr_write1(struct udav_softc *sc, uint16_t offset,
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, 0x0000);
 
-	return (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000));
+	return (uether_do_request(&sc->sc_ue, &req, NULL, 1000));
 }
 
 static void
 udav_init(struct usb_ether *ue)
 {
 	struct udav_softc *sc = ue->ue_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 
 	UDAV_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -420,7 +420,7 @@ udav_init(struct usb_ether *ue)
 	UDAV_SETBIT(sc, UDAV_GPCR, UDAV_GPCR_GEP_CNTL0);
 	UDAV_CLRBIT(sc, UDAV_GPR, UDAV_GPR_GEPIO0);
 
-	usb2_transfer_set_stall(sc->sc_xfer[UDAV_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UDAV_BULK_DT_WR]);
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 	udav_start(ue);
@@ -450,11 +450,11 @@ udav_reset(struct udav_softc *sc)
 	for (i = 0; i < UDAV_TX_TIMEOUT; i++) {
 		if (!(udav_csr_read1(sc, UDAV_NCR) & UDAV_NCR_RST))
 			break;
-		if (usb2_ether_pause(&sc->sc_ue, hz / 100))
+		if (uether_pause(&sc->sc_ue, hz / 100))
 			break;
 	}
 
-	usb2_ether_pause(&sc->sc_ue, hz / 100);
+	uether_pause(&sc->sc_ue, hz / 100);
 }
 
 #define	UDAV_BITS	6
@@ -462,7 +462,7 @@ static void
 udav_setmulti(struct usb_ether *ue)
 {
 	struct udav_softc *sc = ue->ue_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct ifmultiaddr *ifma;
 	uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 	int h = 0;
@@ -502,7 +502,7 @@ static void
 udav_setpromisc(struct usb_ether *ue)
 {
 	struct udav_softc *sc = ue->ue_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	uint8_t rxmode;
 
 	rxmode = udav_csr_read1(sc, UDAV_RCR);
@@ -525,16 +525,16 @@ udav_start(struct usb_ether *ue)
 	/*
 	 * start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[UDAV_INTR_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[UDAV_BULK_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[UDAV_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UDAV_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UDAV_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UDAV_BULK_DT_WR]);
 }
 
 static void
 udav_bulk_write_callback(struct usb_xfer *xfer)
 {
 	struct udav_softc *sc = xfer->priv_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 	struct mbuf *m;
 	int extra_len;
 	int temp_len;
@@ -577,13 +577,13 @@ tr_setup:
 
 		temp_len += 2;
 
-		usb2_copy_in(xfer->frbuffers, 0, buf, 2);
+		usbd_copy_in(xfer->frbuffers, 0, buf, 2);
 
-		usb2_m_copy_in(xfer->frbuffers, 2,
+		usbd_m_copy_in(xfer->frbuffers, 2,
 		    m, 0, m->m_pkthdr.len);
 
 		if (extra_len) {
-			usb2_bzero(xfer->frbuffers, temp_len - extra_len,
+			usbd_frame_zero(xfer->frbuffers, temp_len - extra_len,
 			    extra_len);
 		}
 		/*
@@ -595,12 +595,12 @@ tr_setup:
 		m_freem(m);
 
 		xfer->frlengths[0] = temp_len;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
 		DPRINTFN(11, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		ifp->if_oerrors++;
 
@@ -618,7 +618,7 @@ udav_bulk_read_callback(struct usb_xfer *xfer)
 {
 	struct udav_softc *sc = xfer->priv_sc;
 	struct usb_ether *ue = &sc->sc_ue;
-	struct ifnet *ifp = usb2_ether_getifp(ue);
+	struct ifnet *ifp = uether_getifp(ue);
 	struct udav_rxpkt stat;
 	int len;
 
@@ -629,7 +629,7 @@ udav_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, &stat, sizeof(stat));
+		usbd_copy_out(xfer->frbuffers, 0, &stat, sizeof(stat));
 		xfer->actlen -= sizeof(stat);
 		len = min(xfer->actlen, le16toh(stat.pktlen));
 		len -= ETHER_CRC_LEN;
@@ -642,18 +642,18 @@ udav_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_ether_rxbuf(ue, xfer->frbuffers, sizeof(stat), len);
+		uether_rxbuf(ue, xfer->frbuffers, sizeof(stat), len);
 		/* FALLTHROUGH */
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
-		usb2_ether_rxflush(ue);
+		usbd_transfer_submit(xfer);
+		uether_rxflush(ue);
 		return;
 
 	default:			/* Error */
 		DPRINTF("bulk read error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -672,7 +672,7 @@ udav_intr_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -689,7 +689,7 @@ static void
 udav_stop(struct usb_ether *ue)
 {
 	struct udav_softc *sc = ue->ue_sc;
-	struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue);
+	struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 
 	UDAV_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -699,9 +699,9 @@ udav_stop(struct usb_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_WR]);
-	usb2_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_RD]);
-	usb2_transfer_stop(sc->sc_xfer[UDAV_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UDAV_INTR_DT_RD]);
 
 	udav_reset(sc);
 }
diff --git a/sys/dev/usb/net/if_udavreg.h b/sys/dev/usb/net/if_udavreg.h
index 6dba64c..82715e8 100644
--- a/sys/dev/usb/net/if_udavreg.h
+++ b/sys/dev/usb/net/if_udavreg.h
@@ -137,7 +137,7 @@
 #define	UDAV_GPR_GEPIO1		(1<<1)	/* General purpose 1 */
 #define	UDAV_GPR_GEPIO0		(1<<0)	/* General purpose 0 */
 
-#define	GET_MII(sc)		usb2_ether_getmii(&(sc)->sc_ue)
+#define	GET_MII(sc)		uether_getmii(&(sc)->sc_ue)
 
 struct udav_rxpkt {
 	uint8_t	rxstat;
diff --git a/sys/dev/usb/net/usb_ethernet.c b/sys/dev/usb/net/usb_ethernet.c
index 3d7ae51..3c42be6 100644
--- a/sys/dev/usb/net/usb_ethernet.c
+++ b/sys/dev/usb/net/usb_ethernet.c
@@ -67,13 +67,13 @@ static void	ue_watchdog(void *);
  * Else: device has been detached
  */
 uint8_t
-usb2_ether_pause(struct usb_ether *ue, unsigned int _ticks)
+uether_pause(struct usb_ether *ue, unsigned int _ticks)
 {
-	if (usb2_proc_is_gone(&ue->ue_tq)) {
+	if (usb_proc_is_gone(&ue->ue_tq)) {
 		/* nothing to do */
 		return (1);
 	}
-	usb2_pause_mtx(ue->ue_mtx, _ticks);
+	usb_pause_mtx(ue->ue_mtx, _ticks);
 	return (0);
 }
 
@@ -86,7 +86,7 @@ ue_queue_command(struct usb_ether *ue,
 
 	UE_LOCK_ASSERT(ue, MA_OWNED);
 
-	if (usb2_proc_is_gone(&ue->ue_tq)) {
+	if (usb_proc_is_gone(&ue->ue_tq)) {
 		return;         /* nothing to do */
 	}
 	/* 
@@ -95,7 +95,7 @@ ue_queue_command(struct usb_ether *ue,
 	 * structure after that the message got queued.
 	 */
 	task = (struct usb_ether_cfg_task *)
-	  usb2_proc_msignal(&ue->ue_tq, t0, t1);
+	  usb_proc_msignal(&ue->ue_tq, t0, t1);
 
 	/* Setup callback and self pointers */
 	task->hdr.pm_callback = fn;
@@ -105,23 +105,23 @@ ue_queue_command(struct usb_ether *ue,
 	 * Start and stop must be synchronous!
 	 */
 	if ((fn == ue_start_task) || (fn == ue_stop_task))
-		usb2_proc_mwait(&ue->ue_tq, t0, t1);
+		usb_proc_mwait(&ue->ue_tq, t0, t1);
 }
 
 struct ifnet *
-usb2_ether_getifp(struct usb_ether *ue)
+uether_getifp(struct usb_ether *ue)
 {
 	return (ue->ue_ifp);
 }
 
 struct mii_data *
-usb2_ether_getmii(struct usb_ether *ue)
+uether_getmii(struct usb_ether *ue)
 {
 	return (device_get_softc(ue->ue_miibus));
 }
 
 void *
-usb2_ether_getsc(struct usb_ether *ue)
+uether_getsc(struct usb_ether *ue)
 {
 	return (ue->ue_sc);
 }
@@ -137,7 +137,7 @@ ue_sysctl_parent(SYSCTL_HANDLER_ARGS)
 }
 
 int
-usb2_ether_ifattach(struct usb_ether *ue)
+uether_ifattach(struct usb_ether *ue)
 {
 	int error;
 
@@ -148,7 +148,7 @@ usb2_ether_ifattach(struct usb_ether *ue)
 	    (ue->ue_methods == NULL))
 		return (EINVAL);
 
-	error = usb2_proc_create(&ue->ue_tq, ue->ue_mtx, 
+	error = usb_proc_create(&ue->ue_tq, ue->ue_mtx, 
 	    device_get_nameunit(ue->ue_dev), USB_PRI_MED);
 	if (error) {
 		device_printf(ue->ue_dev, "could not setup taskqueue\n");
@@ -182,7 +182,7 @@ ue_attach_post_task(struct usb_proc_msg *_task)
 	UE_UNLOCK(ue);
 
 	ue->ue_unit = alloc_unr(ueunit);
-	usb2_callout_init_mtx(&ue->ue_watchdog, ue->ue_mtx, 0);
+	usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_mtx, 0);
 	sysctl_ctx_init(&ue->ue_sysctl_ctx);
 
 	ifp = if_alloc(IFT_ETHER);
@@ -198,7 +198,7 @@ ue_attach_post_task(struct usb_proc_msg *_task)
 	if (ue->ue_methods->ue_ioctl != NULL)
 		ifp->if_ioctl = ue->ue_methods->ue_ioctl;
 	else
-		ifp->if_ioctl = usb2_ether_ioctl;
+		ifp->if_ioctl = uether_ioctl;
 	ifp->if_start = ue_start;
 	ifp->if_init = ue_init;
 	IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
@@ -244,12 +244,12 @@ error:
 }
 
 void
-usb2_ether_ifdetach(struct usb_ether *ue)
+uether_ifdetach(struct usb_ether *ue)
 {
 	struct ifnet *ifp;
 
 	/* wait for any post attach or other command to complete */
-	usb2_proc_drain(&ue->ue_tq);
+	usb_proc_drain(&ue->ue_tq);
 
 	/* read "ifnet" pointer after taskqueue drain */
 	ifp = ue->ue_ifp;
@@ -262,7 +262,7 @@ usb2_ether_ifdetach(struct usb_ether *ue)
 		UE_UNLOCK(ue);
 
 		/* drain any callouts */
-		usb2_callout_drain(&ue->ue_watchdog);
+		usb_callout_drain(&ue->ue_watchdog);
 
 		/* detach miibus */
 		if (ue->ue_miibus != NULL) {
@@ -285,13 +285,13 @@ usb2_ether_ifdetach(struct usb_ether *ue)
 	}
 
 	/* free taskqueue, if any */
-	usb2_proc_free(&ue->ue_tq);
+	usb_proc_free(&ue->ue_tq);
 }
 
 uint8_t
-usb2_ether_is_gone(struct usb_ether *ue)
+uether_is_gone(struct usb_ether *ue)
 {
-	return (usb2_proc_is_gone(&ue->ue_tq));
+	return (usb_proc_is_gone(&ue->ue_tq));
 }
 
 static void
@@ -322,7 +322,7 @@ ue_start_task(struct usb_proc_msg *_task)
 		return;
 
 	if (ue->ue_methods->ue_tick != NULL)
-		usb2_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue);
+		usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue);
 }
 
 static void
@@ -334,7 +334,7 @@ ue_stop_task(struct usb_proc_msg *_task)
 
 	UE_LOCK_ASSERT(ue, MA_OWNED);
 
-	usb2_callout_stop(&ue->ue_watchdog);
+	usb_callout_stop(&ue->ue_watchdog);
 
 	ue->ue_methods->ue_stop(ue);
 }
@@ -411,7 +411,7 @@ ue_watchdog(void *arg)
 	    &ue->ue_tick_task[0].hdr, 
 	    &ue->ue_tick_task[1].hdr);
 
-	usb2_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue);
+	usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue);
 }
 
 static void
@@ -429,7 +429,7 @@ ue_tick_task(struct usb_proc_msg *_task)
 }
 
 int
-usb2_ether_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
+uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 {
 	struct usb_ether *ue = ifp->if_softc;
 	struct ifreq *ifr = (struct ifreq *)data;
@@ -479,7 +479,7 @@ usb2_ether_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 }
 
 static int
-usb2_ether_modevent(module_t mod, int type, void *data)
+uether_modevent(module_t mod, int type, void *data)
 {
 
 	switch (type) {
@@ -493,14 +493,14 @@ usb2_ether_modevent(module_t mod, int type, void *data)
 	}
 	return (0);
 }
-static moduledata_t usb2_ether_mod = {
+static moduledata_t uether_mod = {
 	"uether",
-	usb2_ether_modevent,
+	uether_modevent,
 	0
 };
 
 struct mbuf *
-usb2_ether_newbuf(void)
+uether_newbuf(void)
 {
 	struct mbuf *m_new;
 
@@ -514,7 +514,7 @@ usb2_ether_newbuf(void)
 }
 
 int
-usb2_ether_rxmbuf(struct usb_ether *ue, struct mbuf *m, 
+uether_rxmbuf(struct usb_ether *ue, struct mbuf *m, 
     unsigned int len)
 {
 	struct ifnet *ifp = ue->ue_ifp;
@@ -532,7 +532,7 @@ usb2_ether_rxmbuf(struct usb_ether *ue, struct mbuf *m,
 }
 
 int
-usb2_ether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, 
+uether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, 
     unsigned int offset, unsigned int len)
 {
 	struct ifnet *ifp = ue->ue_ifp;
@@ -543,13 +543,13 @@ usb2_ether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc,
 	if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN)
 		return (1);
 
-	m = usb2_ether_newbuf();
+	m = uether_newbuf();
 	if (m == NULL) {
 		ifp->if_ierrors++;
 		return (ENOMEM);
 	}
 
-	usb2_copy_out(pc, offset, mtod(m, uint8_t *), len);
+	usbd_copy_out(pc, offset, mtod(m, uint8_t *), len);
 
 	/* finalize mbuf */
 	ifp->if_ipackets++;
@@ -562,7 +562,7 @@ usb2_ether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc,
 }
 
 void
-usb2_ether_rxflush(struct usb_ether *ue)
+uether_rxflush(struct usb_ether *ue)
 {
 	struct ifnet *ifp = ue->ue_ifp;
 	struct mbuf *m;
@@ -583,5 +583,5 @@ usb2_ether_rxflush(struct usb_ether *ue)
 	}
 }
 
-DECLARE_MODULE(uether, usb2_ether_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
+DECLARE_MODULE(uether, uether_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
 MODULE_VERSION(uether, 1);
diff --git a/sys/dev/usb/net/usb_ethernet.h b/sys/dev/usb/net/usb_ethernet.h
index 10908cc..ad57a85 100644
--- a/sys/dev/usb/net/usb_ethernet.h
+++ b/sys/dev/usb/net/usb_ethernet.h
@@ -81,7 +81,7 @@ struct usb_ether {
 	const struct usb_ether_methods *ue_methods;
 	struct sysctl_oid	*ue_sysctl_oid;
 	void			*ue_sc;
-	struct usb_device	*ue_udev; /* used by usb2_ether_do_request() */
+	struct usb_device	*ue_udev; /* used by uether_do_request() */
 	device_t		ue_dev;
 	device_t		ue_miibus;
 
@@ -101,22 +101,22 @@ struct usb_ether {
 	uint8_t			ue_eaddr[ETHER_ADDR_LEN];
 };
 
-#define	usb2_ether_do_request(ue,req,data,timo) \
-    usb2_do_request_proc((ue)->ue_udev,&(ue)->ue_tq,req,data,0,NULL,timo)
-
-uint8_t		usb2_ether_pause(struct usb_ether *, unsigned int);
-struct ifnet	*usb2_ether_getifp(struct usb_ether *);
-struct mii_data *usb2_ether_getmii(struct usb_ether *);
-void		*usb2_ether_getsc(struct usb_ether *);
-int		usb2_ether_ifattach(struct usb_ether *);
-void		usb2_ether_ifdetach(struct usb_ether *);
-int		usb2_ether_ioctl(struct ifnet *, u_long, caddr_t);
-struct mbuf	*usb2_ether_newbuf(void);
-int		usb2_ether_rxmbuf(struct usb_ether *, struct mbuf *, 
+#define	uether_do_request(ue,req,data,timo) \
+    usbd_do_request_proc((ue)->ue_udev,&(ue)->ue_tq,req,data,0,NULL,timo)
+
+uint8_t		uether_pause(struct usb_ether *, unsigned int);
+struct ifnet	*uether_getifp(struct usb_ether *);
+struct mii_data *uether_getmii(struct usb_ether *);
+void		*uether_getsc(struct usb_ether *);
+int		uether_ifattach(struct usb_ether *);
+void		uether_ifdetach(struct usb_ether *);
+int		uether_ioctl(struct ifnet *, u_long, caddr_t);
+struct mbuf	*uether_newbuf(void);
+int		uether_rxmbuf(struct usb_ether *, struct mbuf *, 
 		    unsigned int);
-int		usb2_ether_rxbuf(struct usb_ether *,
+int		uether_rxbuf(struct usb_ether *,
 		    struct usb_page_cache *, 
 		    unsigned int, unsigned int);
-void		usb2_ether_rxflush(struct usb_ether *);
-uint8_t		usb2_ether_is_gone(struct usb_ether *);
+void		uether_rxflush(struct usb_ether *);
+uint8_t		uether_is_gone(struct usb_ether *);
 #endif					/* _USB2_ETHERNET_H_ */