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

116 files changed, 3941 insertions, 3941 deletions

diff --git a/sys/compat/ndis/subr_usbd.c b/sys/compat/ndis/subr_usbd.c
index a9d4376..de40cd3 100644
--- a/sys/compat/ndis/subr_usbd.c
+++ b/sys/compat/ndis/subr_usbd.c
@@ -472,7 +472,7 @@ usbd_func_getdesc(ip)
 		 * The NDIS driver is not allowed to change the
 		 * config! There is only one choice!
 		 */
-		cdp = usb2_get_config_descriptor(sc->ndisusb_dev);
+		cdp = usbd_get_config_descriptor(sc->ndisusb_dev);
 		if (cdp == NULL) {
 			status = USB_ERR_INVAL;
 			goto exit;
@@ -492,7 +492,7 @@ usbd_func_getdesc(ip)
 		status = USB_ERR_NORMAL_COMPLETION;
 	} else {
 		NDISUSB_LOCK(sc);
-		status = usb2_req_get_desc(sc->ndisusb_dev, &sc->ndisusb_mtx,
+		status = usbd_req_get_desc(sc->ndisusb_dev, &sc->ndisusb_mtx,
 		    &actlen, ctldesc->ucd_trans_buf, 2,
 		    ctldesc->ucd_trans_buflen, ctldesc->ucd_langid,
 		    ctldesc->ucd_desctype, ctldesc->ucd_idx,
@@ -540,16 +540,16 @@ usbd_func_selconf(ip)
 
 	intf = &selconf->usc_intf;
 	for (i = 0; i < conf->bNumInterface && intf->uii_len > 0; i++) {
-		ret = usb2_set_alt_interface_index(udev,
+		ret = usbd_set_alt_interface_index(udev,
 		    intf->uii_intfnum, intf->uii_altset);
 		if (ret != USB_ERR_NORMAL_COMPLETION && ret != USB_ERR_IN_USE) {
 			device_printf(dev,
 			    "setting alternate interface failed: %s\n",
-			    usb2_errstr(ret));
+			    usbd_errstr(ret));
 			return usbd_usb2urb(ret);
 		}
 
-		for (j = 0; (ep = usb2_endpoint_foreach(udev, ep)); j++) {
+		for (j = 0; (ep = usb_endpoint_foreach(udev, ep)); j++) {
 			if (j >= intf->uii_numeps) {
 				device_printf(dev,
 				    "endpoint %d and above are ignored",
@@ -608,11 +608,11 @@ usbd_setup_endpoint_one(ip, ifidx, ne, epconf)
 	InitializeListHead(&ne->ne_pending);
 	KeInitializeSpinLock(&ne->ne_lock);
 
-	status = usb2_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer,
+	status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer,
 	    epconf, 1, sc, &sc->ndisusb_mtx);
 	if (status != USB_ERR_NORMAL_COMPLETION) {
 		device_printf(dev, "couldn't setup xfer: %s\n",
-		    usb2_errstr(status));
+		    usbd_errstr(status));
 		return (status);
 	}
 	xfer = ne->ne_xfer[0];
@@ -680,11 +680,11 @@ usbd_setup_endpoint(ip, ifidx, ep)
 	if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_IN)
 		cfg.flags.short_xfer_ok = 1;
 
-	status = usb2_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer,
+	status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer,
 	    &cfg, 1, sc, &sc->ndisusb_mtx);
 	if (status != USB_ERR_NORMAL_COMPLETION) {
 		device_printf(dev, "couldn't setup xfer: %s\n",
-		    usb2_errstr(status));
+		    usbd_errstr(status));
 		return (status);
 	}
 	xfer = ne->ne_xfer[0];
@@ -718,8 +718,8 @@ usbd_func_abort_pipe(ip)
 	}
 
 	NDISUSB_LOCK(sc);
-	usb2_transfer_stop(ne->ne_xfer[0]);
-	usb2_transfer_start(ne->ne_xfer[0]);
+	usbd_transfer_stop(ne->ne_xfer[0]);
+	usbd_transfer_start(ne->ne_xfer[0]);
 	NDISUSB_UNLOCK(sc);
 
 	return (USBD_STATUS_SUCCESS);
@@ -800,8 +800,8 @@ usbd_irpcancel(dobj, ip)
 	 * cancelled and then restarted.
 	 */
 	NDISUSB_LOCK(sc);
-	usb2_transfer_stop(ne->ne_xfer[0]);
-	usb2_transfer_start(ne->ne_xfer[0]);
+	usbd_transfer_stop(ne->ne_xfer[0]);
+	usbd_transfer_start(ne->ne_xfer[0]);
 	NDISUSB_UNLOCK(sc);
 
 	ip->irp_cancel = TRUE;
@@ -873,7 +873,7 @@ usbd_non_isoc_callback(struct usb_xfer *xfer)
 
 		/* copy in data with regard to the URB */
 		if (ne->ne_dirin != 0)
-			usb2_copy_out(xfer->frbuffers, 0, nx->nx_urbbuf,
+			usbd_copy_out(xfer->frbuffers, 0, nx->nx_urbbuf,
 			    xfer->frlengths[0]);
 		nx->nx_urbbuf += xfer->frlengths[0];
 		nx->nx_urbactlen += xfer->frlengths[0];
@@ -929,10 +929,10 @@ next:
 extra:
 		len = MIN(xfer->max_data_length, nx->nx_urblen);
 		if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_OUT)
-			usb2_copy_in(xfer->frbuffers, 0, nx->nx_urbbuf, len);
+			usbd_copy_in(xfer->frbuffers, 0, nx->nx_urbbuf, len);
 		xfer->frlengths[0] = len;
 		xfer->nframes = 1;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 	default:
 		nx = usbd_aq_getfirst(sc, ne);
@@ -941,7 +941,7 @@ extra:
 		if (xfer->error != USB_ERR_CANCELLED) {
 			xfer->flags.stall_pipe = 1;
 			device_printf(sc->ndis_dev, "usb xfer warning (%s)\n",
-			    usb2_errstr(xfer->error));
+			    usbd_errstr(xfer->error));
 		}
 		usbd_xfer_complete(sc, ne, nx, xfer->error);
 		if (xfer->error != USB_ERR_CANCELLED)
@@ -974,7 +974,7 @@ usbd_ctrl_callback(struct usb_xfer *xfer)
 		vcreq = &urb->uu_vcreq;
 
 		if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) {
-			usb2_copy_out(xfer->frbuffers + 1, 0,
+			usbd_copy_out(xfer->frbuffers + 1, 0,
 			    vcreq->uvc_trans_buf, xfer->frlengths[1]);
 			nx->nx_urbactlen += xfer->frlengths[1];
 		}
@@ -1044,7 +1044,7 @@ next:
 		nx->nx_urblen		= vcreq->uvc_trans_buflen;
 		nx->nx_urbactlen	= 0;
 
-		usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+		usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 		xfer->frlengths[0] = sizeof(req);
 		xfer->nframes = 1;
 		if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) {
@@ -1066,13 +1066,13 @@ next:
 			 * the future if it needs to be.
 			 */
 			if (nx->nx_urblen > 0) {
-				usb2_copy_in(xfer->frbuffers + 1 , 0,
+				usbd_copy_in(xfer->frbuffers + 1 , 0,
 				    nx->nx_urbbuf, nx->nx_urblen);
 				xfer->frlengths[1] = nx->nx_urblen;
 				xfer->nframes = 2;
 			}
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 	default:
 		nx = usbd_aq_getfirst(sc, ne);
@@ -1081,7 +1081,7 @@ next:
 		if (xfer->error != USB_ERR_CANCELLED) {
 			xfer->flags.stall_pipe = 1;
 			device_printf(sc->ndis_dev, "usb xfer warning (%s)\n",
-			    usb2_errstr(xfer->error));
+			    usbd_errstr(xfer->error));
 		}
 		usbd_xfer_complete(sc, ne, nx, xfer->error);
 		if (xfer->error != USB_ERR_CANCELLED)
@@ -1244,7 +1244,7 @@ usbd_task(dobj, arg)
 			ne = usbd_get_ndisep(ip, urb->uu_bulkintr.ubi_epdesc);
 			if (ne == NULL)
 				goto exit;
-			usb2_transfer_start(ne->ne_xfer[0]);
+			usbd_transfer_start(ne->ne_xfer[0]);
 			break;
 		case NDISUSB_TASK_IRPCANCEL:
 			ne = usbd_get_ndisep(ip,
@@ -1254,14 +1254,14 @@ usbd_task(dobj, arg)
 			if (ne == NULL)
 				goto exit;
 			
-			usb2_transfer_stop(ne->ne_xfer[0]);
-			usb2_transfer_start(ne->ne_xfer[0]);
+			usbd_transfer_stop(ne->ne_xfer[0]);
+			usbd_transfer_start(ne->ne_xfer[0]);
 			break;
 		case NDISUSB_TASK_VENDOR:
 			ne = (urb->uu_vcreq.uvc_trans_flags &
 			    USBD_TRANSFER_DIRECTION_IN) ?
 			    &sc->ndisusb_dread_ep : &sc->ndisusb_dwrite_ep;
-			usb2_transfer_start(ne->ne_xfer[0]);
+			usbd_transfer_start(ne->ne_xfer[0]);
 			break;
 		default:
 			break;
@@ -1437,7 +1437,7 @@ USBD_ParseConfigurationDescriptorEx(conf, start, intfnum,
 	struct usb_descriptor *next = NULL;
 	usb_interface_descriptor_t *desc;
 
-	while ((next = usb2_desc_foreach(conf, next)) != NULL) {
+	while ((next = usb_desc_foreach(conf, next)) != NULL) {
 		desc = (usb_interface_descriptor_t *)next;
 		if (desc->bDescriptorType != UDESC_INTERFACE)
 			continue;
diff --git a/sys/dev/ata/ata-usb.c b/sys/dev/ata/ata-usb.c
index a0db29e..aeef67d 100644
--- a/sys/dev/ata/ata-usb.c
+++ b/sys/dev/ata/ata-usb.c
@@ -288,7 +288,7 @@ atausb2_probe(device_t dev)
 		/* give other drivers a try first */
 		return (ENXIO);
 	}
-	id = usb2_get_interface_descriptor(uaa->iface);
+	id = usbd_get_interface_descriptor(uaa->iface);
 	if ((!id) || (id->bInterfaceClass != UICLASS_MASS)) {
 		return (ENXIO);
 	}
@@ -328,16 +328,16 @@ atausb2_attach(device_t dev)
 	uint8_t has_intr;
 	int err;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	sc->dev = dev;
 	sc->maxlun = 0;
 	sc->locked_ch = NULL;
 	sc->restart_ch = NULL;
-	sc->usb2_speed = usb2_get_speed(uaa->device);
+	sc->usb2_speed = usbd_get_speed(uaa->device);
 	mtx_init(&sc->locked_mtx, "ATAUSB lock", NULL, (MTX_DEF | MTX_RECURSE));
 
-	id = usb2_get_interface_descriptor(uaa->iface);
+	id = usbd_get_interface_descriptor(uaa->iface);
 	switch (id->bInterfaceProtocol) {
 	case UIPROTO_MASS_BBB:
 	case UIPROTO_MASS_BBB_OLD:
@@ -380,7 +380,7 @@ atausb2_attach(device_t dev)
 	    (strcmp(subclass, "ATAPI") && strcmp(subclass, "SCSI"))) {
 		goto detach;
 	}
-	err = usb2_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
+	err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
 	    sc->xfer, atausb2_config, ATAUSB_T_BBB_MAX, sc,
 	    &sc->locked_mtx);
 
@@ -389,7 +389,7 @@ atausb2_attach(device_t dev)
 
 	if (err) {
 		device_printf(sc->dev, "could not setup required "
-		    "transfers, %s\n", usb2_errstr(err));
+		    "transfers, %s\n", usbd_errstr(err));
 		goto detach;
 	}
 	/* get number of devices so we can add matching channels */
@@ -398,12 +398,12 @@ atausb2_attach(device_t dev)
 	USETW(request.wValue, 0);
 	USETW(request.wIndex, sc->iface_no);
 	USETW(request.wLength, sizeof(maxlun));
-	err = usb2_do_request(uaa->device, &Giant, &request, &maxlun);
+	err = usbd_do_request(uaa->device, &Giant, &request, &maxlun);
 
 	if (err) {
 		if (bootverbose) {
 			device_printf(sc->dev, "get maxlun not supported %s\n",
-			    usb2_errstr(err));
+			    usbd_errstr(err));
 		}
 	} else {
 		sc->maxlun = maxlun;
@@ -438,7 +438,7 @@ atausb2_detach(device_t dev)
 
 	/* teardown our statemachine */
 
-	usb2_transfer_unsetup(sc->xfer, ATAUSB_T_MAX);
+	usbd_transfer_unsetup(sc->xfer, ATAUSB_T_MAX);
 
 	/* detach & delete all children, if any */
 
@@ -460,7 +460,7 @@ atausb2_transfer_start(struct atausb2_softc *sc, uint8_t xfer_no)
 	}
 	if (sc->xfer[xfer_no]) {
 		sc->last_xfer_no = xfer_no;
-		usb2_transfer_start(sc->xfer[xfer_no]);
+		usbd_transfer_start(sc->xfer[xfer_no]);
 	} else {
 		atausb2_cancel_request(sc);
 	}
@@ -485,11 +485,11 @@ atausb2_t_bbb_reset1_callback(struct usb_xfer *xfer)
 		req.wIndex[1] = 0;
 		USETW(req.wLength, 0);
 
-		usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+		usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 		xfer->frlengths[0] = sizeof(req);
 		xfer->nframes = 1;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -527,7 +527,7 @@ tr_transferred:
 		return;
 
 	case USB_ST_SETUP:
-		if (usb2_clear_stall_callback(xfer, sc->xfer[stall_xfer])) {
+		if (usbd_clear_stall_callback(xfer, sc->xfer[stall_xfer])) {
 			goto tr_transferred;
 		}
 		return;
@@ -575,10 +575,10 @@ atausb2_t_bbb_command_callback(struct usb_xfer *xfer)
 			bzero(sc->cbw.cdb, 16);
 			bcopy(request->u.atapi.ccb, sc->cbw.cdb, 12);	/* XXX SOS */
 
-			usb2_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw));
+			usbd_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw));
 
 			xfer->frlengths[0] = sizeof(sc->cbw);
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -598,7 +598,7 @@ atausb2_t_bbb_data_read_callback(struct usb_xfer *xfer)
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
 
-		usb2_copy_out(xfer->frbuffers, 0,
+		usbd_copy_out(xfer->frbuffers, 0,
 		    sc->ata_data, xfer->actlen);
 
 		sc->ata_bytecount -= xfer->actlen;
@@ -625,7 +625,7 @@ atausb2_t_bbb_data_read_callback(struct usb_xfer *xfer)
 		xfer->timeout = sc->timeout;
 		xfer->frlengths[0] = max_bulk;
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -675,10 +675,10 @@ atausb2_t_bbb_data_write_callback(struct usb_xfer *xfer)
 		xfer->timeout = sc->timeout;
 		xfer->frlengths[0] = max_bulk;
 
-		usb2_copy_in(xfer->frbuffers, 0,
+		usbd_copy_in(xfer->frbuffers, 0,
 		    sc->ata_data, max_bulk);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -712,7 +712,7 @@ atausb2_t_bbb_status_callback(struct usb_xfer *xfer)
 		if (xfer->actlen < sizeof(sc->csw)) {
 			bzero(&sc->csw, sizeof(sc->csw));
 		}
-		usb2_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen);
+		usbd_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen);
 
 		if (request->flags & (ATA_R_READ | ATA_R_WRITE)) {
 			request->donecount = sc->ata_donecount;
@@ -780,7 +780,7 @@ atausb2_t_bbb_status_callback(struct usb_xfer *xfer)
 
 	case USB_ST_SETUP:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:
@@ -828,7 +828,7 @@ atausb2_tr_error(struct usb_xfer *xfer)
 
 		if (atausbdebug) {
 			device_printf(sc->dev, "transfer failed, %s, in state %d "
-			    "-> BULK reset\n", usb2_errstr(xfer->error),
+			    "-> BULK reset\n", usbd_errstr(xfer->error),
 			    sc->last_xfer_no);
 		}
 	}
@@ -903,7 +903,7 @@ ata_usbchannel_begin_transaction(struct ata_request *request)
 		sc->ata_data = request->data;
 		sc->ata_donecount = 0;
 
-		usb2_transfer_start(sc->xfer[sc->last_xfer_no]);
+		usbd_transfer_start(sc->xfer[sc->last_xfer_no]);
 		error = ATA_OP_CONTINUES;
 	} else {
 		request->result = EIO;
diff --git a/sys/dev/if_ndis/if_ndis_usb.c b/sys/dev/if_ndis/if_ndis_usb.c
index 2098493..69fd1af 100644
--- a/sys/dev/if_ndis/if_ndis_usb.c
+++ b/sys/dev/if_ndis/if_ndis_usb.c
@@ -211,12 +211,12 @@ ndisusb_detach(device_t self)
 	ndis_pnpevent_nic(self, NDIS_PNP_EVENT_SURPRISE_REMOVED);
 
 	if (sc->ndisusb_status & NDISUSB_STATUS_SETUP_EP) {
-		usb2_transfer_unsetup(sc->ndisusb_dread_ep.ne_xfer, 1);
-		usb2_transfer_unsetup(sc->ndisusb_dwrite_ep.ne_xfer, 1);
+		usbd_transfer_unsetup(sc->ndisusb_dread_ep.ne_xfer, 1);
+		usbd_transfer_unsetup(sc->ndisusb_dwrite_ep.ne_xfer, 1);
 	}
 	for (i = 0; i < NDISUSB_ENDPT_MAX; i++) {
 		ne = &sc->ndisusb_ep[i];
-		usb2_transfer_unsetup(ne->ne_xfer, 1);
+		usbd_transfer_unsetup(ne->ne_xfer, 1);
 	}
 
 	(void)ndis_detach(self);
diff --git a/sys/dev/sound/usb/uaudio.c b/sys/dev/sound/usb/uaudio.c
index 1912008..48f8ce8 100644
--- a/sys/dev/sound/usb/uaudio.c
+++ b/sys/dev/sound/usb/uaudio.c
@@ -547,7 +547,7 @@ uaudio_probe(device_t dev)
 
 	if ((uaa->info.bInterfaceClass == UICLASS_AUDIO) &&
 	    (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL)) {
-		if (usb2_test_quirk(uaa, UQ_BAD_AUDIO))
+		if (usb_test_quirk(uaa, UQ_BAD_AUDIO))
 			return (ENXIO);
 		else
 			return (0);
@@ -567,23 +567,23 @@ uaudio_attach(device_t dev)
 	sc->sc_rec_chan.priv_sc = sc;
 	sc->sc_udev = uaa->device;
 
-	if (usb2_test_quirk(uaa, UQ_AUDIO_SWAP_LR))
+	if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR))
 		sc->sc_uq_audio_swap_lr = 1;
 
-	if (usb2_test_quirk(uaa, UQ_AU_INP_ASYNC))
+	if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC))
 		sc->sc_uq_au_inp_async = 1;
 
-	if (usb2_test_quirk(uaa, UQ_AU_NO_XU))
+	if (usb_test_quirk(uaa, UQ_AU_NO_XU))
 		sc->sc_uq_au_no_xu = 1;
 
-	if (usb2_test_quirk(uaa, UQ_BAD_ADC))
+	if (usb_test_quirk(uaa, UQ_BAD_ADC))
 		sc->sc_uq_bad_adc = 1;
 
 	umidi_init(dev);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
-	id = usb2_get_interface_descriptor(uaa->iface);
+	id = usbd_get_interface_descriptor(uaa->iface);
 
 	uaudio_chan_fill_info(sc, uaa->device);
 
@@ -728,7 +728,7 @@ repeat:
 
 	if (error) {
 		device_printf(dev, "Waiting for sound application to exit!\n");
-		usb2_pause_mtx(NULL, 2 * hz);
+		usb_pause_mtx(NULL, 2 * hz);
 		goto repeat;		/* try again */
 	}
 	return (0);			/* success */
@@ -783,7 +783,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
 	const struct usb2_audio_streaming_endpoint_descriptor *sed = NULL;
 	const usb2_endpoint_descriptor_audio_t *ed1 = NULL;
 	const usb2_endpoint_descriptor_audio_t *ed2 = NULL;
-	struct usb_config_descriptor *cd = usb2_get_config_descriptor(udev);
+	struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
 	struct usb_interface_descriptor *id;
 	const struct uaudio_format *p_fmt;
 	struct uaudio_chan *chan;
@@ -800,7 +800,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
 	uint8_t audio_if = 0;
 	uint8_t sample_size;
 
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 
 		if ((desc->bDescriptorType == UDESC_INTERFACE) &&
 		    (desc->bLength >= sizeof(*id))) {
@@ -832,7 +832,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
 				 */
 
 				if ((sc->sc_midi_chan.valid == 0) &&
-				    usb2_get_iface(udev, curidx)) {
+				    usbd_get_iface(udev, curidx)) {
 					sc->sc_midi_chan.iface_index = curidx;
 					sc->sc_midi_chan.iface_alt_index = alt_index;
 					sc->sc_midi_chan.valid = 1;
@@ -994,7 +994,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
 				    &sc->sc_rec_chan :
 				    &sc->sc_play_chan;
 
-				if ((chan->valid == 0) && usb2_get_iface(udev, curidx)) {
+				if ((chan->valid == 0) && usbd_get_iface(udev, curidx)) {
 
 					chan->valid = 1;
 #if USB_DEBUG
@@ -1061,7 +1061,7 @@ uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev)
 {
 	uint32_t rate = uaudio_default_rate;
 	uint32_t z;
-	uint16_t fps = usb2_get_isoc_fps(udev);
+	uint16_t fps = usbd_get_isoc_fps(udev);
 	uint8_t bits = uaudio_default_bits;
 	uint8_t y;
 	uint8_t channels = uaudio_default_channels;
@@ -1172,7 +1172,7 @@ tr_transferred:
 			if (n > total) {
 				n = total;
 			}
-			usb2_copy_in(xfer->frbuffers, offset, ch->cur, n);
+			usbd_copy_in(xfer->frbuffers, offset, ch->cur, n);
 
 			total -= n;
 			ch->cur += n;
@@ -1183,7 +1183,7 @@ tr_transferred:
 			}
 		}
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -1249,7 +1249,7 @@ tr_transferred:
 				if (m > p_len[n]) {
 					m = p_len[n];
 				}
-				usb2_copy_out(xfer->frbuffers, offset1, ch->cur, m);
+				usbd_copy_out(xfer->frbuffers, offset1, ch->cur, m);
 
 				p_len[n] -= m;
 				offset1 += m;
@@ -1282,7 +1282,7 @@ tr_transferred:
 			DPRINTF("no buffer!\n");
 			return;
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -1361,13 +1361,13 @@ uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b,
 	DPRINTF("endpoint=0x%02x, speed=%d, iface=%d alt=%d\n",
 	    endpoint, ch->sample_rate, iface_index, alt_index);
 
-	err = usb2_set_alt_interface_index(sc->sc_udev, iface_index, alt_index);
+	err = usbd_set_alt_interface_index(sc->sc_udev, iface_index, alt_index);
 	if (err) {
 		DPRINTF("setting of alternate index failed: %s!\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		goto error;
 	}
-	usb2_set_parent_iface(sc->sc_udev, iface_index, sc->sc_mixer_iface_index);
+	usbd_set_parent_iface(sc->sc_udev, iface_index, sc->sc_mixer_iface_index);
 
 	/*
 	 * If just one sampling rate is supported,
@@ -1383,7 +1383,7 @@ uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b,
 			DPRINTF("setting of sample rate failed! (continuing anyway)\n");
 		}
 	}
-	if (usb2_transfer_setup(sc->sc_udev, &iface_index, ch->xfer,
+	if (usbd_transfer_setup(sc->sc_udev, &iface_index, ch->xfer,
 	    ch->usb2_cfg, UAUDIO_NCHANBUFS, ch, ch->pcm_mtx)) {
 		DPRINTF("could not allocate USB transfers!\n");
 		goto error;
@@ -1402,7 +1402,7 @@ uaudio_chan_free(struct uaudio_chan *ch)
 		free(ch->buf, M_DEVBUF);
 		ch->buf = NULL;
 	}
-	usb2_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS);
+	usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS);
 
 	ch->valid = 0;
 
@@ -1521,10 +1521,10 @@ uaudio_chan_start(struct uaudio_chan *ch)
 #error "please update code"
 #endif
 	if (ch->xfer[0]) {
-		usb2_transfer_start(ch->xfer[0]);
+		usbd_transfer_start(ch->xfer[0]);
 	}
 	if (ch->xfer[1]) {
-		usb2_transfer_start(ch->xfer[1]);
+		usbd_transfer_start(ch->xfer[1]);
 	}
 	return (0);
 }
@@ -1535,8 +1535,8 @@ uaudio_chan_stop(struct uaudio_chan *ch)
 #if (UAUDIO_NCHANBUFS != 2)
 #error "please update code"
 #endif
-	usb2_transfer_stop(ch->xfer[0]);
-	usb2_transfer_stop(ch->xfer[1]);
+	usbd_transfer_stop(ch->xfer[0]);
+	usbd_transfer_stop(ch->xfer[1]);
 	return (0);
 }
 
@@ -2677,7 +2677,7 @@ uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev,
     void *desc)
 {
 	const struct usb2_audio_control_descriptor *acdp;
-	struct usb_config_descriptor *cd = usb2_get_config_descriptor(udev);
+	struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
 	const struct usb_descriptor *dp;
 	const struct usb2_audio_unit *au;
 	struct uaudio_terminal_node *iot = NULL;
@@ -2685,7 +2685,7 @@ uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev,
 	uint8_t ID_max = 0;		/* inclusive */
 	uint8_t i;
 
-	desc = usb2_desc_foreach(cd, desc);
+	desc = usb_desc_foreach(cd, desc);
 
 	if (desc == NULL) {
 		DPRINTF("no Audio Control header\n");
@@ -2724,7 +2724,7 @@ uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev,
 		DPRINTF("no memory!\n");
 		goto done;
 	}
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 
 		dp = desc;
 
@@ -2939,9 +2939,9 @@ uaudio_mixer_get(struct usb_device *udev, uint8_t what,
 	USETW(req.wIndex, mc->wIndex);
 	USETW(req.wLength, len);
 
-	err = usb2_do_request(udev, &Giant, &req, data);
+	err = usbd_do_request(udev, &Giant, &req, data);
 	if (err) {
-		DPRINTF("err=%s\n", usb2_errstr(err));
+		DPRINTF("err=%s\n", usbd_errstr(err));
 		return (0);
 	}
 	if (len < 1) {
@@ -3011,13 +3011,13 @@ tr_setup:
 					if (len > 1) {
 						buf[1] = (mc->wData[chan] >> 8) & 0xFF;
 					}
-					usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
-					usb2_copy_in(xfer->frbuffers + 1, 0, buf, len);
+					usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+					usbd_copy_in(xfer->frbuffers + 1, 0, buf, len);
 
 					xfer->frlengths[0] = sizeof(req);
 					xfer->frlengths[1] = len;
 					xfer->nframes = xfer->frlengths[1] ? 2 : 1;
-					usb2_start_hardware(xfer);
+					usbd_transfer_submit(xfer);
 					return;
 				}
 			}
@@ -3033,7 +3033,7 @@ tr_setup:
 		break;
 
 	default:			/* Error */
-		DPRINTF("error=%s\n", usb2_errstr(xfer->error));
+		DPRINTF("error=%s\n", usbd_errstr(xfer->error));
 		if (xfer->error == USB_ERR_CANCELLED) {
 			/* do nothing - we are detaching */
 			break;
@@ -3059,7 +3059,7 @@ uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
 	data[1] = speed >> 8;
 	data[2] = speed >> 16;
 
-	return (usb2_do_request(udev, &Giant, &req, data));
+	return (usbd_do_request(udev, &Giant, &req, data));
 }
 
 static int
@@ -3105,7 +3105,7 @@ uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc,
 
 	/* start the transfer, if not already started */
 
-	usb2_transfer_start(sc->sc_mixer_xfer[0]);
+	usbd_transfer_start(sc->sc_mixer_xfer[0]);
 }
 
 static void
@@ -3142,7 +3142,7 @@ uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
 {
 	DPRINTF("\n");
 
-	if (usb2_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
+	if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
 	    sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
 	    mixer_get_lock(m))) {
 		DPRINTFN(0, "could not allocate USB "
@@ -3163,7 +3163,7 @@ uaudio_mixer_uninit_sub(struct uaudio_softc *sc)
 {
 	DPRINTF("\n");
 
-	usb2_transfer_unsetup(sc->sc_mixer_xfer, 1);
+	usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
 
 	return (0);
 }
@@ -3242,10 +3242,10 @@ umidi_read_clear_stall_callback(struct usb_xfer *xfer)
 	struct umidi_chan *chan = xfer->priv_sc;
 	struct usb_xfer *xfer_other = chan->xfer[1];
 
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTF("stall cleared\n");
 		chan->flags &= ~UMIDI_FLAG_READ_STALL;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -3272,14 +3272,14 @@ umidi_bulk_read_callback(struct usb_xfer *xfer)
 
 		while (xfer->actlen >= 4) {
 
-			usb2_copy_out(xfer->frbuffers, pos, buf, 1);
+			usbd_copy_out(xfer->frbuffers, pos, buf, 1);
 
 			cmd_len = umidi_cmd_to_len[buf[0] & 0xF];	/* command length */
 			cn = buf[0] >> 4;	/* cable number */
 			sub = &chan->sub[cn];
 
 			if (cmd_len && (cn < chan->max_cable) && sub->read_open) {
-				usb2_fifo_put_data(sub->fifo.fp[USB_FIFO_RX], xfer->frbuffers,
+				usb_fifo_put_data(sub->fifo.fp[USB_FIFO_RX], xfer->frbuffers,
 				    pos + 1, cmd_len, 1);
 			} else {
 				/* ignore the command */
@@ -3293,22 +3293,22 @@ umidi_bulk_read_callback(struct usb_xfer *xfer)
 		DPRINTF("start\n");
 
 		if (chan->flags & UMIDI_FLAG_READ_STALL) {
-			usb2_transfer_start(chan->xfer[3]);
+			usbd_transfer_start(chan->xfer[3]);
 			return;
 		}
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:
 tr_error:
 
-		DPRINTF("error=%s\n", usb2_errstr(xfer->error));
+		DPRINTF("error=%s\n", usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
 			chan->flags |= UMIDI_FLAG_READ_STALL;
-			usb2_transfer_start(chan->xfer[3]);
+			usbd_transfer_start(chan->xfer[3]);
 		}
 		return;
 
@@ -3321,10 +3321,10 @@ umidi_write_clear_stall_callback(struct usb_xfer *xfer)
 	struct umidi_chan *chan = xfer->priv_sc;
 	struct usb_xfer *xfer_other = chan->xfer[0];
 
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTF("stall cleared\n");
 		chan->flags &= ~UMIDI_FLAG_WRITE_STALL;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -3481,7 +3481,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer)
 		DPRINTF("start\n");
 
 		if (chan->flags & UMIDI_FLAG_WRITE_STALL) {
-			usb2_transfer_start(chan->xfer[2]);
+			usbd_transfer_start(chan->xfer[2]);
 			return;
 		}
 		total_length = 0;	/* reset */
@@ -3497,7 +3497,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer)
 			sub = &chan->sub[chan->curr_cable];
 
 			if (sub->write_open) {
-				usb2_fifo_get_data(sub->fifo.fp[USB_FIFO_TX],
+				usb_fifo_get_data(sub->fifo.fp[USB_FIFO_TX],
 				    xfer->frbuffers, total_length,
 				    1, &actlen, 0);
 			} else {
@@ -3505,7 +3505,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer)
 			}
 
 			if (actlen) {
-				usb2_copy_out(xfer->frbuffers, total_length, &buf, 1);
+				usbd_copy_out(xfer->frbuffers, total_length, &buf, 1);
 
 				tr_any = 1;
 
@@ -3517,7 +3517,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer)
 					    sub->temp_cmd[0], sub->temp_cmd[1],
 					    sub->temp_cmd[2], sub->temp_cmd[3]);
 
-					usb2_copy_in(xfer->frbuffers, total_length,
+					usbd_copy_in(xfer->frbuffers, total_length,
 					    sub->temp_cmd, 4);
 
 					total_length += 4;
@@ -3543,18 +3543,18 @@ umidi_bulk_write_callback(struct usb_xfer *xfer)
 
 		if (total_length) {
 			xfer->frlengths[0] = total_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
 	default:			/* Error */
 
-		DPRINTF("error=%s\n", usb2_errstr(xfer->error));
+		DPRINTF("error=%s\n", usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
 			chan->flags |= UMIDI_FLAG_WRITE_STALL;
-			usb2_transfer_start(chan->xfer[2]);
+			usbd_transfer_start(chan->xfer[2]);
 		}
 		return;
 
@@ -3587,7 +3587,7 @@ umidi_start_read(struct usb_fifo *fifo)
 {
 	struct umidi_chan *chan = fifo->priv_sc0;
 
-	usb2_transfer_start(chan->xfer[1]);
+	usbd_transfer_start(chan->xfer[1]);
 }
 
 static void
@@ -3614,7 +3614,7 @@ umidi_start_write(struct usb_fifo *fifo)
 {
 	struct umidi_chan *chan = fifo->priv_sc0;
 
-	usb2_transfer_start(chan->xfer[0]);
+	usbd_transfer_start(chan->xfer[0]);
 }
 
 static void
@@ -3629,8 +3629,8 @@ umidi_stop_write(struct usb_fifo *fifo)
 
 	if (--(chan->write_open_refcount) == 0) {
 		DPRINTF("(stopping write transfer)\n");
-		usb2_transfer_stop(chan->xfer[2]);
-		usb2_transfer_stop(chan->xfer[0]);
+		usbd_transfer_stop(chan->xfer[2]);
+		usbd_transfer_stop(chan->xfer[0]);
 	}
 }
 
@@ -3641,7 +3641,7 @@ umidi_open(struct usb_fifo *fifo, int fflags)
 	struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
 
 	if (fflags & FREAD) {
-		if (usb2_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
+		if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
 			return (ENOMEM);
 		}
 		mtx_lock(fifo->priv_mtx);
@@ -3650,7 +3650,7 @@ umidi_open(struct usb_fifo *fifo, int fflags)
 		mtx_unlock(fifo->priv_mtx);
 	}
 	if (fflags & FWRITE) {
-		if (usb2_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
+		if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
 			return (ENOMEM);
 		}
 		/* clear stall first */
@@ -3670,10 +3670,10 @@ static void
 umidi_close(struct usb_fifo *fifo, int fflags)
 {
 	if (fflags & FREAD) {
-		usb2_fifo_free_buffer(fifo);
+		usb_fifo_free_buffer(fifo);
 	}
 	if (fflags & FWRITE) {
-		usb2_fifo_free_buffer(fifo);
+		usb_fifo_free_buffer(fifo);
 	}
 }
 
@@ -3716,18 +3716,18 @@ umidi_probe(device_t dev)
 	int error;
 	uint32_t n;
 
-	if (usb2_set_alt_interface_index(sc->sc_udev, chan->iface_index,
+	if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index,
 	    chan->iface_alt_index)) {
 		DPRINTF("setting of alternate index failed!\n");
 		goto detach;
 	}
-	usb2_set_parent_iface(sc->sc_udev, chan->iface_index, sc->sc_mixer_iface_index);
+	usbd_set_parent_iface(sc->sc_udev, chan->iface_index, sc->sc_mixer_iface_index);
 
-	error = usb2_transfer_setup(uaa->device, &chan->iface_index,
+	error = usbd_transfer_setup(uaa->device, &chan->iface_index,
 	    chan->xfer, umidi_config, UMIDI_N_TRANSFER,
 	    chan, &chan->mtx);
 	if (error) {
-		DPRINTF("error=%s\n", usb2_errstr(error));
+		DPRINTF("error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 	if ((chan->max_cable > UMIDI_CABLES_MAX) ||
@@ -3739,7 +3739,7 @@ umidi_probe(device_t dev)
 
 		sub = &chan->sub[n];
 
-		error = usb2_fifo_attach(sc->sc_udev, chan, &chan->mtx,
+		error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
 		    &umidi_fifo_methods, &sub->fifo, unit, n,
 		    chan->iface_index,
 		    UID_ROOT, GID_OPERATOR, 0644);
@@ -3757,7 +3757,7 @@ umidi_probe(device_t dev)
 	 * NOTE: at least one device will not work properly unless
 	 * the BULK pipe is open all the time.
 	 */
-	usb2_transfer_start(chan->xfer[1]);
+	usbd_transfer_start(chan->xfer[1]);
 
 	mtx_unlock(&chan->mtx);
 
@@ -3775,17 +3775,17 @@ umidi_detach(device_t dev)
 	uint32_t n;
 
 	for (n = 0; n < UMIDI_CABLES_MAX; n++) {
-		usb2_fifo_detach(&chan->sub[n].fifo);
+		usb_fifo_detach(&chan->sub[n].fifo);
 	}
 
 	mtx_lock(&chan->mtx);
 
-	usb2_transfer_stop(chan->xfer[3]);
-	usb2_transfer_stop(chan->xfer[1]);
+	usbd_transfer_stop(chan->xfer[3]);
+	usbd_transfer_stop(chan->xfer[1]);
 
 	mtx_unlock(&chan->mtx);
 
-	usb2_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
+	usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
 
 	mtx_destroy(&chan->mtx);
 
diff --git a/sys/dev/usb/controller/at91dci.c b/sys/dev/usb/controller/at91dci.c
index 5831a7e..fd1b684 100644
--- a/sys/dev/usb/controller/at91dci.c
+++ b/sys/dev/usb/controller/at91dci.c
@@ -260,7 +260,7 @@ at91dci_wakeup_peer(struct at91dci_softc *sc)
 
 	/* wait 8 milliseconds */
 	/* Wait for reset to complete. */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
 
 	AT91_UDP_WRITE_4(sc, AT91_UDP_GSTATE, 0);
 }
@@ -321,7 +321,7 @@ at91dci_setup_rx(struct at91dci_td *td)
 	    td->fifo_reg, (void *)&req, sizeof(req));
 
 	/* copy data into real buffer */
-	usb2_copy_in(td->pc, 0, &req, sizeof(req));
+	usbd_copy_in(td->pc, 0, &req, sizeof(req));
 
 	td->offset = sizeof(req);
 	td->remainder = 0;
@@ -442,7 +442,7 @@ repeat:
 		return (0);		/* we are complete */
 	}
 	while (count > 0) {
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -549,7 +549,7 @@ repeat:
 	}
 	while (count > 0) {
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -865,7 +865,7 @@ at91dci_setup_standard_chain(struct usb_xfer *xfer)
 
 	DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpointno),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.max_frame_size = xfer->max_frame_size;
 
@@ -1046,11 +1046,11 @@ at91dci_start_standard_chain(struct usb_xfer *xfer)
 		DPRINTFN(15, "enable interrupts on endpoint %d\n", ep_no);
 
 		/* put transfer on interrupt queue */
-		usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+		usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 		/* start timeout, if any */
 		if (xfer->timeout != 0) {
-			usb2_transfer_timeout_ms(xfer,
+			usbd_transfer_timeout_ms(xfer,
 			    &at91dci_timeout, xfer->timeout);
 		}
 	}
@@ -1203,7 +1203,7 @@ at91dci_device_done(struct usb_xfer *xfer, usb_error_t error)
 		DPRINTFN(15, "disable interrupts on endpoint %d\n", ep_no);
 	}
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 static void
@@ -1375,7 +1375,7 @@ at91dci_init(struct at91dci_softc *sc)
 		(sc->sc_clocks_on) (sc->sc_clocks_arg);
 	}
 	/* wait a little for things to stabilise */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
 
 	/* disable and clear all interrupts */
 
@@ -1632,7 +1632,7 @@ at91dci_device_isoc_fs_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp +
+	    usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
 	    xfer->nframes;
 
 	/* compute frame number for next insertion */
@@ -2165,7 +2165,7 @@ at91dci_xfer_setup(struct usb_setup_params *parm)
 	parm->hc_max_packet_count = 1;
 	parm->hc_max_frame_size = 0x500;
 
-	usb2_transfer_setup_sub(parm);
+	usbd_transfer_setup_sub(parm);
 
 	/*
 	 * compute maximum number of TDs
@@ -2193,7 +2193,7 @@ at91dci_xfer_setup(struct usb_setup_params *parm)
 	}
 
 	/*
-	 * check if "usb2_transfer_setup_sub" set an error
+	 * check if "usbd_transfer_setup_sub" set an error
 	 */
 	if (parm->err) {
 		return;
diff --git a/sys/dev/usb/controller/at91dci_atmelarm.c b/sys/dev/usb/controller/at91dci_atmelarm.c
index aedd30f..37d79e5 100644
--- a/sys/dev/usb/controller/at91dci_atmelarm.c
+++ b/sys/dev/usb/controller/at91dci_atmelarm.c
@@ -144,7 +144,7 @@ at91_udp_attach(device_t dev)
 	sc->sc_dci.sc_bus.devices_max = AT91_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_dci.sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_dci.sc_bus,
 	    USB_GET_DMA_TAG(dev), NULL)) {
 		return (ENOMEM);
 	}
@@ -166,7 +166,7 @@ at91_udp_attach(device_t dev)
 	at91_udp_pull_down(sc);
 
 	/* wait 10ms for pulldown to stabilise */
-	usb2_pause_mtx(NULL, hz / 100);
+	usb_pause_mtx(NULL, hz / 100);
 
 	sc->sc_iclk = at91_pmc_clock_ref("udc_clk");
 	sc->sc_fclk = at91_pmc_clock_ref("udpck");
@@ -295,7 +295,7 @@ at91_udp_detach(device_t dev)
 		    sc->sc_dci.sc_io_res);
 		sc->sc_dci.sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_dci.sc_bus, NULL);
+	usb_bus_mem_free_all(&sc->sc_dci.sc_bus, NULL);
 
 	/* disable clocks */
 	at91_pmc_clock_disable(sc->sc_iclk);
diff --git a/sys/dev/usb/controller/atmegadci.c b/sys/dev/usb/controller/atmegadci.c
index 0f4ef24..79d9fcb 100644
--- a/sys/dev/usb/controller/atmegadci.c
+++ b/sys/dev/usb/controller/atmegadci.c
@@ -204,7 +204,7 @@ atmegadci_wakeup_peer(struct atmegadci_softc *sc)
 
 	/* wait 8 milliseconds */
 	/* Wait for reset to complete. */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
 
 	/* hardware should have cleared RMWKUP bit */
 }
@@ -267,7 +267,7 @@ atmegadci_setup_rx(struct atmegadci_td *td)
 	    (void *)&req, sizeof(req));
 
 	/* copy data into real buffer */
-	usb2_copy_in(td->pc, 0, &req, sizeof(req));
+	usbd_copy_in(td->pc, 0, &req, sizeof(req));
 
 	td->offset = sizeof(req);
 	td->remainder = 0;
@@ -378,7 +378,7 @@ repeat:
 		return (0);		/* we are complete */
 	}
 	while (count > 0) {
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -465,7 +465,7 @@ repeat:
 	}
 	while (count > 0) {
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -768,7 +768,7 @@ atmegadci_setup_standard_chain(struct usb_xfer *xfer)
 
 	DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpointno),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.max_frame_size = xfer->max_frame_size;
 
@@ -929,11 +929,11 @@ atmegadci_start_standard_chain(struct usb_xfer *xfer)
 	if (atmegadci_xfer_do_fifo(xfer)) {
 
 		/* put transfer on interrupt queue */
-		usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+		usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 		/* start timeout, if any */
 		if (xfer->timeout != 0) {
-			usb2_transfer_timeout_ms(xfer,
+			usbd_transfer_timeout_ms(xfer,
 			    &atmegadci_timeout, xfer->timeout);
 		}
 	}
@@ -1089,7 +1089,7 @@ atmegadci_device_done(struct usb_xfer *xfer, usb_error_t error)
 		DPRINTFN(15, "disabled interrupts!\n");
 	}
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 static void
@@ -1236,7 +1236,7 @@ atmegadci_init(struct atmegadci_softc *sc)
 		if (ATMEGA_READ_1(sc, 0x49) & 0x01)
 			break;
 		/* wait a little bit for PLL to start */
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
+		usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
 	}
 
 	/* make sure USB is enabled */
@@ -1252,7 +1252,7 @@ atmegadci_init(struct atmegadci_softc *sc)
 	ATMEGA_WRITE_1(sc, ATMEGA_UDCON, ATMEGA_UDCON_DETACH);
 
 	/* wait a little for things to stabilise */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20);
 
 	/* enable interrupts */
 	ATMEGA_WRITE_1(sc, ATMEGA_UDIEN,
@@ -1453,7 +1453,7 @@ atmegadci_device_isoc_fs_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp +
+	    usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
 	    xfer->nframes;
 
 	/* compute frame number for next insertion */
@@ -2017,7 +2017,7 @@ atmegadci_xfer_setup(struct usb_setup_params *parm)
 	parm->hc_max_packet_count = 1;
 	parm->hc_max_frame_size = 0x500;
 
-	usb2_transfer_setup_sub(parm);
+	usbd_transfer_setup_sub(parm);
 
 	/*
 	 * compute maximum number of TDs
@@ -2032,7 +2032,7 @@ atmegadci_xfer_setup(struct usb_setup_params *parm)
 	}
 
 	/*
-	 * check if "usb2_transfer_setup_sub" set an error
+	 * check if "usbd_transfer_setup_sub" set an error
 	 */
 	if (parm->err)
 		return;
diff --git a/sys/dev/usb/controller/atmegadci_atmelarm.c b/sys/dev/usb/controller/atmegadci_atmelarm.c
index 6412851..3a85b50 100644
--- a/sys/dev/usb/controller/atmegadci_atmelarm.c
+++ b/sys/dev/usb/controller/atmegadci_atmelarm.c
@@ -84,7 +84,7 @@ atmegadci_attach(device_t dev)
 	sc->sc_otg.sc_bus.devices_max = ATMEGA_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_otg.sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_otg.sc_bus,
 	    USB_GET_DMA_TAG(dev), NULL)) {
 		return (ENOMEM);
 	}
@@ -168,7 +168,7 @@ atmegadci_detach(device_t dev)
 		    sc->sc_otg.sc_io_res);
 		sc->sc_otg.sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL);
+	usb_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL);
 
 	return (0);
 }
diff --git a/sys/dev/usb/controller/avr32dci.c b/sys/dev/usb/controller/avr32dci.c
index 5463b7f..edf7879 100644
--- a/sys/dev/usb/controller/avr32dci.c
+++ b/sys/dev/usb/controller/avr32dci.c
@@ -237,7 +237,7 @@ avr32dci_wakeup_peer(struct avr32dci_softc *sc)
 
 	/* wait 8 milliseconds */
 	/* Wait for reset to complete. */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
 
 	/* hardware should have cleared RMWKUP bit */
 }
@@ -289,7 +289,7 @@ avr32dci_setup_rx(struct avr32dci_td *td)
 	memcpy(&req, sc->physdata, sizeof(req));
 
 	/* copy data into real buffer */
-	usb2_copy_in(td->pc, 0, &req, sizeof(req));
+	usbd_copy_in(td->pc, 0, &req, sizeof(req));
 
 	td->offset = sizeof(req);
 	td->remainder = 0;
@@ -390,7 +390,7 @@ repeat:
 		return (0);		/* we are complete */
 	}
 	while (count > 0) {
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -466,7 +466,7 @@ repeat:
 	}
 	while (count > 0) {
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -738,7 +738,7 @@ avr32dci_setup_standard_chain(struct usb_xfer *xfer)
 
 	DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpoint),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.max_frame_size = xfer->max_frame_size;
 
@@ -900,11 +900,11 @@ avr32dci_start_standard_chain(struct usb_xfer *xfer)
 		avr32dci_mod_ien(sc, AVR32_INT_EPT_INT(ep_no), 0);
 
 		/* put transfer on interrupt queue */
-		usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+		usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 		/* start timeout, if any */
 		if (xfer->timeout != 0) {
-			usb2_transfer_timeout_ms(xfer,
+			usbd_transfer_timeout_ms(xfer,
 			    &avr32dci_timeout, xfer->timeout);
 		}
 	}
@@ -1057,7 +1057,7 @@ avr32dci_device_done(struct usb_xfer *xfer, usb_error_t error)
 		DPRINTFN(15, "disabled interrupts!\n");
 	}
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 static void
@@ -1198,7 +1198,7 @@ avr32dci_init(struct avr32dci_softc *sc)
 	avr32dci_mod_ctrl(sc, AVR32_CTRL_DEV_DETACH, 0);
 
 	/* wait a little for things to stabilise */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20);
 
 	/* disable interrupts */
 	avr32dci_mod_ien(sc, 0, 0xFFFFFFFF);
@@ -1387,7 +1387,7 @@ avr32dci_device_isoc_fs_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp +
+	    usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
 	    xfer->nframes;
 
 	/* compute frame number for next insertion */
@@ -1950,7 +1950,7 @@ avr32dci_xfer_setup(struct usb_setup_params *parm)
 	parm->hc_max_packet_count = 1;
 	parm->hc_max_frame_size = 0x400;
 
-	usb2_transfer_setup_sub(parm);
+	usbd_transfer_setup_sub(parm);
 
 	/*
 	 * compute maximum number of TDs
@@ -1965,7 +1965,7 @@ avr32dci_xfer_setup(struct usb_setup_params *parm)
 	}
 
 	/*
-	 * check if "usb2_transfer_setup_sub" set an error
+	 * check if "usbd_transfer_setup_sub" set an error
 	 */
 	if (parm->err)
 		return;
diff --git a/sys/dev/usb/controller/ehci.c b/sys/dev/usb/controller/ehci.c
index 6b51600..9bbb7c4 100644
--- a/sys/dev/usb/controller/ehci.c
+++ b/sys/dev/usb/controller/ehci.c
@@ -153,7 +153,7 @@ ehci_reset(ehci_softc_t *sc)
 
 	EOWRITE4(sc, EHCI_USBCMD, EHCI_CMD_HCRESET);
 	for (i = 0; i < 100; i++) {
-		usb2_pause_mtx(NULL, hz / 1000);
+		usb_pause_mtx(NULL, hz / 1000);
 		hcr = EOREAD4(sc, EHCI_USBCMD) & EHCI_CMD_HCRESET;
 		if (!hcr) {
 			if (sc->sc_flags & (EHCI_SCFLG_SETMODE | EHCI_SCFLG_BIGEMMIO)) {
@@ -189,7 +189,7 @@ ehci_hcreset(ehci_softc_t *sc)
 
 	EOWRITE4(sc, EHCI_USBCMD, 0);	/* Halt controller */
 	for (i = 0; i < 100; i++) {
-		usb2_pause_mtx(NULL, hz / 1000);
+		usb_pause_mtx(NULL, hz / 1000);
 		hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH;
 		if (hcr)
 			break;
@@ -221,7 +221,7 @@ ehci_init(ehci_softc_t *sc)
 
 	DPRINTF("start\n");
 
-	usb2_callout_init_mtx(&sc->sc_tmo_pcd, &sc->sc_bus.bus_mtx, 0);
+	usb_callout_init_mtx(&sc->sc_tmo_pcd, &sc->sc_bus.bus_mtx, 0);
 
 #if USB_DEBUG
 	if (ehcidebug > 2) {
@@ -274,7 +274,7 @@ ehci_init(ehci_softc_t *sc)
 	for (i = 0; i < EHCI_VIRTUAL_FRAMELIST_COUNT; i++) {
 		ehci_qh_t *qh;
 
-		usb2_get_page(sc->sc_hw.intr_start_pc + i, 0, &buf_res);
+		usbd_get_page(sc->sc_hw.intr_start_pc + i, 0, &buf_res);
 
 		qh = buf_res.buffer;
 
@@ -342,7 +342,7 @@ ehci_init(ehci_softc_t *sc)
 		ehci_sitd_t *sitd;
 		ehci_itd_t *itd;
 
-		usb2_get_page(sc->sc_hw.isoc_fs_start_pc + i, 0, &buf_res);
+		usbd_get_page(sc->sc_hw.isoc_fs_start_pc + i, 0, &buf_res);
 
 		sitd = buf_res.buffer;
 
@@ -367,7 +367,7 @@ ehci_init(ehci_softc_t *sc)
 		    sc->sc_intr_p_last[i | (EHCI_VIRTUAL_FRAMELIST_COUNT / 2)]->qh_self;
 
 
-		usb2_get_page(sc->sc_hw.isoc_hs_start_pc + i, 0, &buf_res);
+		usbd_get_page(sc->sc_hw.isoc_hs_start_pc + i, 0, &buf_res);
 
 		itd = buf_res.buffer;
 
@@ -389,7 +389,7 @@ ehci_init(ehci_softc_t *sc)
 		    sitd->sitd_self;
 	}
 
-	usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
 
 	if (1) {
 		uint32_t *pframes;
@@ -409,7 +409,7 @@ ehci_init(ehci_softc_t *sc)
 	/* setup sync list pointer */
 	EOWRITE4(sc, EHCI_PERIODICLISTBASE, buf_res.physaddr);
 
-	usb2_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res);
 
 	if (1) {
 
@@ -445,7 +445,7 @@ ehci_init(ehci_softc_t *sc)
 	}
 	/* flush all cache into memory */
 
-	usb2_bus_mem_flush_all(&sc->sc_bus, &ehci_iterate_hw_softc);
+	usb_bus_mem_flush_all(&sc->sc_bus, &ehci_iterate_hw_softc);
 
 #if USB_DEBUG
 	if (ehcidebug) {
@@ -472,7 +472,7 @@ ehci_init(ehci_softc_t *sc)
 	EOWRITE4(sc, EHCI_CONFIGFLAG, EHCI_CONF_CF);
 
 	for (i = 0; i < 100; i++) {
-		usb2_pause_mtx(NULL, hz / 1000);
+		usb_pause_mtx(NULL, hz / 1000);
 		hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH;
 		if (!hcr) {
 			break;
@@ -498,7 +498,7 @@ ehci_detach(ehci_softc_t *sc)
 {
 	USB_BUS_LOCK(&sc->sc_bus);
 
-	usb2_callout_stop(&sc->sc_tmo_pcd);
+	usb_callout_stop(&sc->sc_tmo_pcd);
 
 	EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs);
 	USB_BUS_UNLOCK(&sc->sc_bus);
@@ -508,9 +508,9 @@ ehci_detach(ehci_softc_t *sc)
 	}
 
 	/* XXX let stray task complete */
-	usb2_pause_mtx(NULL, hz / 20);
+	usb_pause_mtx(NULL, hz / 20);
 
-	usb2_callout_drain(&sc->sc_tmo_pcd);
+	usb_callout_drain(&sc->sc_tmo_pcd);
 }
 
 void
@@ -543,7 +543,7 @@ ehci_suspend(ehci_softc_t *sc)
 		if (hcr == 0) {
 			break;
 		}
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
+		usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
 	}
 
 	if (hcr != 0) {
@@ -557,7 +557,7 @@ ehci_suspend(ehci_softc_t *sc)
 		if (hcr == EHCI_STS_HCH) {
 			break;
 		}
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
+		usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
 	}
 
 	if (hcr != EHCI_STS_HCH) {
@@ -580,10 +580,10 @@ ehci_resume(ehci_softc_t *sc)
 	/* restore things in case the bios doesn't */
 	EOWRITE4(sc, EHCI_CTRLDSSEGMENT, 0);
 
-	usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
 	EOWRITE4(sc, EHCI_PERIODICLISTBASE, buf_res.physaddr);
 
-	usb2_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res);
 	EOWRITE4(sc, EHCI_ASYNCLISTADDR, buf_res.physaddr | EHCI_LINK_QH);
 
 	EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs);
@@ -600,7 +600,7 @@ ehci_resume(ehci_softc_t *sc)
 	}
 
 	if (hcr) {
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+		usb_pause_mtx(&sc->sc_bus.bus_mtx,
 		    USB_MS_TO_TICKS(USB_RESUME_WAIT));
 
 		for (i = 1; i <= sc->sc_noport; i++) {
@@ -619,7 +619,7 @@ ehci_resume(ehci_softc_t *sc)
 		if (hcr != EHCI_STS_HCH) {
 			break;
 		}
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
+		usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
 	}
 	if (hcr == EHCI_STS_HCH) {
 		device_printf(sc->sc_bus.bdev, "config timeout\n");
@@ -627,7 +627,7 @@ ehci_resume(ehci_softc_t *sc)
 
 	USB_BUS_UNLOCK(&sc->sc_bus);
 
-	usb2_pause_mtx(NULL,
+	usb_pause_mtx(NULL,
 	    USB_MS_TO_TICKS(USB_RESUME_WAIT));
 
 	/* catch any lost interrupts */
@@ -793,7 +793,7 @@ ehci_dump_sqtd(ehci_softc_t *sc, ehci_qtd_t *sqtd)
 {
 	uint8_t temp;
 
-	usb2_pc_cpu_invalidate(sqtd->page_cache);
+	usb_pc_cpu_invalidate(sqtd->page_cache);
 	printf("QTD(%p) at 0x%08x:\n", sqtd, hc32toh(sc, sqtd->qtd_self));
 	ehci_dump_qtd(sc, sqtd);
 	temp = (sqtd->qtd_next & htohc32(sc, EHCI_LINK_TERMINATE)) ? 1 : 0;
@@ -821,7 +821,7 @@ ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *qh)
 	uint32_t endp;
 	uint32_t endphub;
 
-	usb2_pc_cpu_invalidate(qh->page_cache);
+	usb_pc_cpu_invalidate(qh->page_cache);
 	printf("QH(%p) at 0x%08x:\n", qh, hc32toh(sc, qh->qh_self) & ~0x1F);
 	printf("  link=");
 	ehci_dump_link(sc, qh->qh_link, 1);
@@ -851,7 +851,7 @@ ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *qh)
 static void
 ehci_dump_sitd(ehci_softc_t *sc, ehci_sitd_t *sitd)
 {
-	usb2_pc_cpu_invalidate(sitd->page_cache);
+	usb_pc_cpu_invalidate(sitd->page_cache);
 	printf("SITD(%p) at 0x%08x\n", sitd, hc32toh(sc, sitd->sitd_self) & ~0x1F);
 	printf(" next=0x%08x\n", hc32toh(sc, sitd->sitd_next));
 	printf(" portaddr=0x%08x dir=%s addr=%d endpt=0x%x port=0x%x huba=0x%x\n",
@@ -877,7 +877,7 @@ ehci_dump_sitd(ehci_softc_t *sc, ehci_sitd_t *sitd)
 static void
 ehci_dump_itd(ehci_softc_t *sc, ehci_itd_t *itd)
 {
-	usb2_pc_cpu_invalidate(itd->page_cache);
+	usb_pc_cpu_invalidate(itd->page_cache);
 	printf("ITD(%p) at 0x%08x\n", itd, hc32toh(sc, itd->itd_self) & ~0x1F);
 	printf(" next=0x%08x\n", hc32toh(sc, itd->itd_next));
 	printf(" status[0]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[0]),
@@ -959,11 +959,11 @@ ehci_transfer_intr_enqueue(struct usb_xfer *xfer)
 		return;
 	}
 	/* put transfer on interrupt queue */
-	usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+	usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 	/* start timeout, if any */
 	if (xfer->timeout != 0) {
-		usb2_transfer_timeout_ms(xfer, &ehci_timeout, xfer->timeout);
+		usbd_transfer_timeout_ms(xfer, &ehci_timeout, xfer->timeout);
 	}
 }
 
@@ -980,7 +980,7 @@ _ehci_append_fs_td(ehci_sitd_t *std, ehci_sitd_t *last)
 
 	std->prev = last;
 
-	usb2_pc_cpu_flush(std->page_cache);
+	usb_pc_cpu_flush(std->page_cache);
 
 	/*
 	 * the last->next->prev is never followed: std->next->prev = std;
@@ -988,7 +988,7 @@ _ehci_append_fs_td(ehci_sitd_t *std, ehci_sitd_t *last)
 	last->next = std;
 	last->sitd_next = std->sitd_self;
 
-	usb2_pc_cpu_flush(last->page_cache);
+	usb_pc_cpu_flush(last->page_cache);
 
 	return (std);
 }
@@ -1006,7 +1006,7 @@ _ehci_append_hs_td(ehci_itd_t *std, ehci_itd_t *last)
 
 	std->prev = last;
 
-	usb2_pc_cpu_flush(std->page_cache);
+	usb_pc_cpu_flush(std->page_cache);
 
 	/*
 	 * the last->next->prev is never followed: std->next->prev = std;
@@ -1014,7 +1014,7 @@ _ehci_append_hs_td(ehci_itd_t *std, ehci_itd_t *last)
 	last->next = std;
 	last->itd_next = std->itd_self;
 
-	usb2_pc_cpu_flush(last->page_cache);
+	usb_pc_cpu_flush(last->page_cache);
 
 	return (std);
 }
@@ -1037,7 +1037,7 @@ _ehci_append_qh(ehci_qh_t *sqh, ehci_qh_t *last)
 
 	sqh->prev = last;
 
-	usb2_pc_cpu_flush(sqh->page_cache);
+	usb_pc_cpu_flush(sqh->page_cache);
 
 	/*
 	 * the last->next->prev is never followed: sqh->next->prev = sqh;
@@ -1046,7 +1046,7 @@ _ehci_append_qh(ehci_qh_t *sqh, ehci_qh_t *last)
 	last->next = sqh;
 	last->qh_link = sqh->qh_self;
 
-	usb2_pc_cpu_flush(last->page_cache);
+	usb_pc_cpu_flush(last->page_cache);
 
 	return (sqh);
 }
@@ -1062,11 +1062,11 @@ _ehci_remove_fs_td(ehci_sitd_t *std, ehci_sitd_t *last)
 	std->prev->next = std->next;
 	std->prev->sitd_next = std->sitd_next;
 
-	usb2_pc_cpu_flush(std->prev->page_cache);
+	usb_pc_cpu_flush(std->prev->page_cache);
 
 	if (std->next) {
 		std->next->prev = std->prev;
-		usb2_pc_cpu_flush(std->next->page_cache);
+		usb_pc_cpu_flush(std->next->page_cache);
 	}
 	return ((last == std) ? std->prev : last);
 }
@@ -1082,11 +1082,11 @@ _ehci_remove_hs_td(ehci_itd_t *std, ehci_itd_t *last)
 	std->prev->next = std->next;
 	std->prev->itd_next = std->itd_next;
 
-	usb2_pc_cpu_flush(std->prev->page_cache);
+	usb_pc_cpu_flush(std->prev->page_cache);
 
 	if (std->next) {
 		std->next->prev = std->prev;
-		usb2_pc_cpu_flush(std->next->page_cache);
+		usb_pc_cpu_flush(std->next->page_cache);
 	}
 	return ((last == std) ? std->prev : last);
 }
@@ -1105,17 +1105,17 @@ _ehci_remove_qh(ehci_qh_t *sqh, ehci_qh_t *last)
 		sqh->prev->next = sqh->next;
 		sqh->prev->qh_link = sqh->qh_link;
 
-		usb2_pc_cpu_flush(sqh->prev->page_cache);
+		usb_pc_cpu_flush(sqh->prev->page_cache);
 
 		if (sqh->next) {
 			sqh->next->prev = sqh->prev;
-			usb2_pc_cpu_flush(sqh->next->page_cache);
+			usb_pc_cpu_flush(sqh->next->page_cache);
 		}
 		last = ((last == sqh) ? sqh->prev : last);
 
 		sqh->prev = 0;
 
-		usb2_pc_cpu_flush(sqh->page_cache);
+		usb_pc_cpu_flush(sqh->page_cache);
 	}
 	return (last);
 }
@@ -1137,7 +1137,7 @@ ehci_non_isoc_done_sub(struct usb_xfer *xfer)
 	}
 	while (1) {
 
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status = hc32toh(sc, td->qtd_status);
 
 		len = EHCI_QTD_GET_BYTES(status);
@@ -1287,13 +1287,13 @@ ehci_check_transfer(struct usb_xfer *xfer)
 		/* isochronous full speed transfer */
 
 		td = xfer->td_transfer_last;
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status = hc32toh(sc, td->sitd_status);
 
 		/* also check if first is complete */
 
 		td = xfer->td_transfer_first;
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status |= hc32toh(sc, td->sitd_status);
 
 		if (!(status & EHCI_SITD_ACTIVE)) {
@@ -1306,7 +1306,7 @@ ehci_check_transfer(struct usb_xfer *xfer)
 		/* isochronous high speed transfer */
 
 		td = xfer->td_transfer_last;
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status =
 		    td->itd_status[0] | td->itd_status[1] |
 		    td->itd_status[2] | td->itd_status[3] |
@@ -1315,7 +1315,7 @@ ehci_check_transfer(struct usb_xfer *xfer)
 
 		/* also check first transfer */
 		td = xfer->td_transfer_first;
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status |=
 		    td->itd_status[0] | td->itd_status[1] |
 		    td->itd_status[2] | td->itd_status[3] |
@@ -1339,7 +1339,7 @@ ehci_check_transfer(struct usb_xfer *xfer)
 		td = xfer->td_transfer_cache;
 
 		while (1) {
-			usb2_pc_cpu_invalidate(td->page_cache);
+			usb_pc_cpu_invalidate(td->page_cache);
 			status = hc32toh(sc, td->qtd_status);
 
 			/*
@@ -1475,7 +1475,7 @@ ehci_interrupt(ehci_softc_t *sc)
 		ehci_root_intr(sc);
 
 		/* do not allow RHSC interrupts > 1 per second */
-		usb2_callout_reset(&sc->sc_tmo_pcd, hz,
+		usb_callout_reset(&sc->sc_tmo_pcd, hz,
 		    (void *)&ehci_pcd_enable, sc);
 	}
 	status &= ~(EHCI_STS_INT | EHCI_STS_ERRINT | EHCI_STS_PCD | EHCI_STS_IAA);
@@ -1634,7 +1634,7 @@ restart:
 
 			/* fill out buffer pointers */
 
-			usb2_get_page(temp->pc, buf_offset, &buf_res);
+			usbd_get_page(temp->pc, buf_offset, &buf_res);
 			td->qtd_buffer[0] =
 			    htohc32(temp->sc, buf_res.physaddr);
 			td->qtd_buffer_hi[0] = 0;
@@ -1644,7 +1644,7 @@ restart:
 			while (average > EHCI_PAGE_SIZE) {
 				average -= EHCI_PAGE_SIZE;
 				buf_offset += EHCI_PAGE_SIZE;
-				usb2_get_page(temp->pc, buf_offset, &buf_res);
+				usbd_get_page(temp->pc, buf_offset, &buf_res);
 				td->qtd_buffer[x] =
 				    htohc32(temp->sc,
 				    buf_res.physaddr & (~0xFFF));
@@ -1661,7 +1661,7 @@ restart:
 			 * of a valid page !
 			 */
 			buf_offset += average;
-			usb2_get_page(temp->pc, buf_offset - 1, &buf_res);
+			usbd_get_page(temp->pc, buf_offset - 1, &buf_res);
 			td->qtd_buffer[x] =
 			    htohc32(temp->sc,
 			    buf_res.physaddr & (~0xFFF));
@@ -1675,7 +1675,7 @@ restart:
 		td->qtd_altnext = qtd_altnext;
 		td->alt_next = td_alt_next;
 
-		usb2_pc_cpu_flush(td->page_cache);
+		usb_pc_cpu_flush(td->page_cache);
 	}
 
 	if (precompute) {
@@ -1717,7 +1717,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last)
 
 	DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpointno),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.average = xfer->max_hc_frame_size;
 	temp.max_frame_size = xfer->max_frame_size;
@@ -1749,7 +1749,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last)
 		temp.auto_data_toggle = 1;
 	}
 
-	if (usb2_get_speed(xfer->xroot->udev) != USB_SPEED_HIGH) {
+	if (usbd_get_speed(xfer->xroot->udev) != USB_SPEED_HIGH) {
 		/* max 3 retries */
 		temp.qtd_status |=
 		    htohc32(temp.sc, EHCI_QTD_SET_CERR(3));
@@ -1872,7 +1872,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last)
 	td->qtd_altnext = htohc32(temp.sc, EHCI_LINK_TERMINATE);
 	td->qtd_status |= htohc32(temp.sc, EHCI_QTD_IOC);
 
-	usb2_pc_cpu_flush(td->page_cache);
+	usb_pc_cpu_flush(td->page_cache);
 
 	/* must have at least one frame! */
 
@@ -1898,14 +1898,14 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last)
 	    EHCI_QH_SET_ENDPT(UE_GET_ADDR(xfer->endpointno)) |
 	    EHCI_QH_SET_MPL(xfer->max_packet_size));
 
-	if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) {
+	if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) {
 		qh_endp |= (EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH) |
 		    EHCI_QH_DTC);
 		if (methods != &ehci_device_intr_methods)
 			qh_endp |= EHCI_QH_SET_NRL(8);
 	} else {
 
-		if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_FULL) {
+		if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_FULL) {
 			qh_endp |= (EHCI_QH_SET_EPS(EHCI_QH_SPEED_FULL) |
 			    EHCI_QH_DTC);
 		} else {
@@ -1926,8 +1926,8 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last)
 
 	qh_endphub =
 	    (EHCI_QH_SET_MULT(xfer->max_packet_count & 3) |
-	    EHCI_QH_SET_CMASK(xfer->usb2_cmask) |
-	    EHCI_QH_SET_SMASK(xfer->usb2_smask) |
+	    EHCI_QH_SET_CMASK(xfer->usb_cmask) |
+	    EHCI_QH_SET_SMASK(xfer->usb_smask) |
 	    EHCI_QH_SET_HUBA(xfer->xroot->udev->hs_hub_addr) |
 	    EHCI_QH_SET_PORT(xfer->xroot->udev->hs_port_no));
 
@@ -1955,7 +1955,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last)
 	qh->qh_qtd.qtd_altnext =
 	    htohc32(temp.sc, EHCI_LINK_TERMINATE);
 
-	usb2_pc_cpu_flush(qh->page_cache);
+	usb_pc_cpu_flush(qh->page_cache);
 
 	if (xfer->xroot->udev->flags.self_suspended == 0) {
 		EHCI_APPEND_QH(qh, *qh_last);
@@ -2016,7 +2016,7 @@ ehci_isoc_fs_done(ehci_softc_t *sc, struct usb_xfer *xfer)
 			ehci_dump_sitd(sc, td);
 		}
 #endif
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status = hc32toh(sc, td->sitd_status);
 
 		len = EHCI_SITD_GET_LEN(status);
@@ -2071,7 +2071,7 @@ ehci_isoc_hs_done(ehci_softc_t *sc, struct usb_xfer *xfer)
 		}
 #endif
 
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status = hc32toh(sc, td->itd_status[td_no]);
 
 		len = EHCI_ITD_GET_LEN(status);
@@ -2155,7 +2155,7 @@ ehci_device_done(struct usb_xfer *xfer, usb_error_t error)
 		xfer->td_transfer_last = NULL;
 	}
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 /*------------------------------------------------------------------------*
@@ -2263,17 +2263,17 @@ ehci_device_intr_open(struct usb_xfer *xfer)
 
 	/* Allocate a microframe slot first: */
 
-	slot = usb2_intr_schedule_adjust
+	slot = usb_intr_schedule_adjust
 	    (xfer->xroot->udev, xfer->max_frame_size, USB_HS_MICRO_FRAMES_MAX);
 
-	if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) {
-		xfer->usb2_uframe = slot;
-		xfer->usb2_smask = (1 << slot) & 0xFF;
-		xfer->usb2_cmask = 0;
+	if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) {
+		xfer->usb_uframe = slot;
+		xfer->usb_smask = (1 << slot) & 0xFF;
+		xfer->usb_cmask = 0;
 	} else {
-		xfer->usb2_uframe = slot;
-		xfer->usb2_smask = (1 << slot) & 0x3F;
-		xfer->usb2_cmask = (-(4 << slot)) & 0xFE;
+		xfer->usb_uframe = slot;
+		xfer->usb_smask = (1 << slot) & 0x3F;
+		xfer->usb_cmask = (-(4 << slot)) & 0xFE;
 	}
 
 	/*
@@ -2311,8 +2311,8 @@ ehci_device_intr_close(struct usb_xfer *xfer)
 	ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus);
 	uint8_t slot;
 
-	slot = usb2_intr_schedule_adjust
-	    (xfer->xroot->udev, -(xfer->max_frame_size), xfer->usb2_uframe);
+	slot = usb_intr_schedule_adjust
+	    (xfer->xroot->udev, -(xfer->max_frame_size), xfer->usb_uframe);
 
 	sc->sc_intr_stat[xfer->qh_pos]--;
 
@@ -2384,7 +2384,7 @@ ehci_device_isoc_fs_open(struct usb_xfer *xfer)
 			 */
 			td->sitd_back = htohc32(sc, EHCI_LINK_TERMINATE);
 
-			usb2_pc_cpu_flush(td->page_cache);
+			usb_pc_cpu_flush(td->page_cache);
 		}
 	}
 }
@@ -2459,7 +2459,7 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_fs_isoc_schedule_isoc_time_expand
+	    usbd_fs_isoc_schedule_isoc_time_expand
 	    (xfer->xroot->udev, &fss_start, &fss_end, nframes) + buf_offset +
 	    xfer->nframes;
 
@@ -2515,7 +2515,7 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer)
 		 * We currently don't care if the ISOCHRONOUS schedule is
 		 * full!
 		 */
-		error = usb2_fs_isoc_schedule_alloc(fss, &sa, *plen);
+		error = usbd_fs_isoc_schedule_alloc(fss, &sa, *plen);
 		if (error) {
 			/*
 			 * The FULL speed schedule is FULL! Set length
@@ -2525,17 +2525,17 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer)
 		}
 		if (*plen) {
 			/*
-			 * only call "usb2_get_page()" when we have a
+			 * only call "usbd_get_page()" when we have a
 			 * non-zero length
 			 */
-			usb2_get_page(xfer->frbuffers, buf_offset, &buf_res);
+			usbd_get_page(xfer->frbuffers, buf_offset, &buf_res);
 			td->sitd_bp[0] = htohc32(sc, buf_res.physaddr);
 			buf_offset += *plen;
 			/*
 			 * NOTE: We need to subtract one from the offset so
 			 * that we are on a valid page!
 			 */
-			usb2_get_page(xfer->frbuffers, buf_offset - 1,
+			usbd_get_page(xfer->frbuffers, buf_offset - 1,
 			    &buf_res);
 			temp = buf_res.physaddr & ~0xFFF;
 		} else {
@@ -2588,7 +2588,7 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer)
 			    EHCI_SITD_ACTIVE |
 			    EHCI_SITD_SET_LEN(*plen));
 		}
-		usb2_pc_cpu_flush(td->page_cache);
+		usb_pc_cpu_flush(td->page_cache);
 
 #if USB_DEBUG
 		if (ehcidebug > 15) {
@@ -2673,7 +2673,7 @@ ehci_device_isoc_hs_open(struct usb_xfer *xfer)
 			/* set transfer multiplier */
 			td->itd_bp[2] = htohc32(sc, xfer->max_packet_count & 3);
 
-			usb2_pc_cpu_flush(td->page_cache);
+			usb_pc_cpu_flush(td->page_cache);
 		}
 	}
 }
@@ -2745,7 +2745,7 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset +
+	    usb_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset +
 	    ((xfer->nframes + 7) / 8);
 
 	/* get the real number of frames */
@@ -2812,7 +2812,7 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer)
 				itd_offset[td_no] = buf_offset;
 
 				/* get first page offset */
-				usb2_get_page(xfer->frbuffers, itd_offset[0], &buf_res);
+				usbd_get_page(xfer->frbuffers, itd_offset[0], &buf_res);
 				/* get page address */
 				page_addr = buf_res.physaddr & ~0xFFF;
 				/* update page address */
@@ -2832,9 +2832,9 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer)
 						 * we don't go off the last
 						 * page!
 						 */
-						usb2_get_page(xfer->frbuffers, buf_offset - 1, &buf_res);
+						usbd_get_page(xfer->frbuffers, buf_offset - 1, &buf_res);
 					} else {
-						usb2_get_page(xfer->frbuffers, itd_offset[x + 1], &buf_res);
+						usbd_get_page(xfer->frbuffers, itd_offset[x + 1], &buf_res);
 					}
 
 					/* check if we need a new page */
@@ -2855,7 +2855,7 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer)
 			if (nframes == 0) {
 				td->itd_status[7] |= htohc32(sc, EHCI_ITD_IOC);
 			}
-			usb2_pc_cpu_flush(td->page_cache);
+			usb_pc_cpu_flush(td->page_cache);
 #if USB_DEBUG
 			if (ehcidebug > 15) {
 				DPRINTF("HS-TD %d\n", nframes);
@@ -3081,7 +3081,7 @@ ehci_roothub_exec(struct usb_device *udev,
 				break;
 			}
 
-			len = usb2_make_str_desc(
+			len = usb_make_str_desc(
 			    sc->sc_hub_desc.temp,
 			    sizeof(sc->sc_hub_desc.temp),
 			    str_ptr);
@@ -3156,13 +3156,13 @@ ehci_roothub_exec(struct usb_device *udev,
 				EOWRITE4(sc, port, v | EHCI_PS_FPR);
 			}
 			/* wait 20ms for resume sequence to complete */
-			usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50);
+			usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50);
 
 			EOWRITE4(sc, port, v & ~(EHCI_PS_SUSP |
 			    EHCI_PS_FPR | (3 << 10) /* High Speed */ ));
 
 			/* 4ms settle time */
-			usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 250);
+			usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 250);
 			break;
 		case UHF_PORT_POWER:
 			EOWRITE4(sc, port, v & ~EHCI_PS_PP);
@@ -3313,7 +3313,7 @@ ehci_roothub_exec(struct usb_device *udev,
 			EOWRITE4(sc, port, v | EHCI_PS_PR);
 
 			/* Wait for reset to complete. */
-			usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+			usb_pause_mtx(&sc->sc_bus.bus_mtx,
 			    USB_MS_TO_TICKS(USB_PORT_ROOT_RESET_DELAY));
 
 			/* Terminate reset sequence. */
@@ -3321,7 +3321,7 @@ ehci_roothub_exec(struct usb_device *udev,
 				EOWRITE4(sc, port, v);
 
 			/* Wait for HC to complete reset. */
-			usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+			usb_pause_mtx(&sc->sc_bus.bus_mtx,
 			    USB_MS_TO_TICKS(EHCI_PORT_RESET_COMPLETE));
 
 			v = EOREAD4(sc, port);
@@ -3438,7 +3438,7 @@ ehci_xfer_setup(struct usb_setup_params *parm)
 		parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX;
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nqh = 1;
 		nqtd = ((2 * xfer->nframes) + 1	/* STATUS */
@@ -3451,7 +3451,7 @@ ehci_xfer_setup(struct usb_setup_params *parm)
 		parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX;
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nqh = 1;
 		nqtd = ((2 * xfer->nframes)
@@ -3473,7 +3473,7 @@ ehci_xfer_setup(struct usb_setup_params *parm)
 		parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX;
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nqh = 1;
 		nqtd = ((2 * xfer->nframes)
@@ -3486,7 +3486,7 @@ ehci_xfer_setup(struct usb_setup_params *parm)
 		parm->hc_max_frame_size = 0x3FF;
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nsitd = xfer->nframes;
 
@@ -3497,7 +3497,7 @@ ehci_xfer_setup(struct usb_setup_params *parm)
 		parm->hc_max_frame_size = 0xC00;
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nitd = (xfer->nframes + 7) / 8;
 
@@ -3507,7 +3507,7 @@ ehci_xfer_setup(struct usb_setup_params *parm)
 		parm->hc_max_packet_count = 1;
 		parm->hc_max_frame_size = 0x400;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 	}
 
 alloc_dma_set:
@@ -3520,7 +3520,7 @@ alloc_dma_set:
 	 */
 	last_obj = NULL;
 
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(ehci_itd_t),
 	    EHCI_ITD_ALIGN, nitd)) {
 		parm->err = USB_ERR_NOMEM;
@@ -3530,7 +3530,7 @@ alloc_dma_set:
 		for (n = 0; n != nitd; n++) {
 			ehci_itd_t *td;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			td = page_info.buffer;
 
@@ -3541,10 +3541,10 @@ alloc_dma_set:
 
 			last_obj = td;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(ehci_sitd_t),
 	    EHCI_SITD_ALIGN, nsitd)) {
 		parm->err = USB_ERR_NOMEM;
@@ -3554,7 +3554,7 @@ alloc_dma_set:
 		for (n = 0; n != nsitd; n++) {
 			ehci_sitd_t *td;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			td = page_info.buffer;
 
@@ -3565,10 +3565,10 @@ alloc_dma_set:
 
 			last_obj = td;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(ehci_qtd_t),
 	    EHCI_QTD_ALIGN, nqtd)) {
 		parm->err = USB_ERR_NOMEM;
@@ -3578,7 +3578,7 @@ alloc_dma_set:
 		for (n = 0; n != nqtd; n++) {
 			ehci_qtd_t *qtd;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			qtd = page_info.buffer;
 
@@ -3589,14 +3589,14 @@ alloc_dma_set:
 
 			last_obj = qtd;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
 	xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj;
 
 	last_obj = NULL;
 
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(ehci_qh_t),
 	    EHCI_QH_ALIGN, nqh)) {
 		parm->err = USB_ERR_NOMEM;
@@ -3606,7 +3606,7 @@ alloc_dma_set:
 		for (n = 0; n != nqh; n++) {
 			ehci_qh_t *qh;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			qh = page_info.buffer;
 
@@ -3617,7 +3617,7 @@ alloc_dma_set:
 
 			last_obj = qh;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
 	xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj;
diff --git a/sys/dev/usb/controller/ehci_ixp4xx.c b/sys/dev/usb/controller/ehci_ixp4xx.c
index 672a6ee..a29375f 100644
--- a/sys/dev/usb/controller/ehci_ixp4xx.c
+++ b/sys/dev/usb/controller/ehci_ixp4xx.c
@@ -131,7 +131,7 @@ ehci_ixp_attach(device_t self)
 	sc->sc_bus.devices_max = EHCI_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_bus,
 	    USB_GET_DMA_TAG(self), &ehci_iterate_hw_softc)) {
 		return (ENOMEM);
 	}
@@ -273,7 +273,7 @@ ehci_ixp_detach(device_t self)
 		    sc->sc_io_res);
 		sc->sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc);
+	usb_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc);
 
 	return (0);
 }
diff --git a/sys/dev/usb/controller/ehci_mbus.c b/sys/dev/usb/controller/ehci_mbus.c
index eb9c101..73a8faf 100644
--- a/sys/dev/usb/controller/ehci_mbus.c
+++ b/sys/dev/usb/controller/ehci_mbus.c
@@ -140,7 +140,7 @@ ehci_mbus_attach(device_t self)
 	sc->sc_bus.devices_max = EHCI_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_bus,
 	    USB_GET_DMA_TAG(self), &ehci_iterate_hw_softc)) {
 		return (ENOMEM);
 	}
@@ -307,7 +307,7 @@ ehci_mbus_detach(device_t self)
 		    sc->sc_io_res);
 		sc->sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc);
+	usb_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc);
 
 	return (0);
 }
diff --git a/sys/dev/usb/controller/ehci_pci.c b/sys/dev/usb/controller/ehci_pci.c
index 744f5f5..77efeb3 100644
--- a/sys/dev/usb/controller/ehci_pci.c
+++ b/sys/dev/usb/controller/ehci_pci.c
@@ -231,7 +231,7 @@ ehci_pci_attach(device_t self)
 	sc->sc_bus.devices_max = EHCI_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_bus,
 	    USB_GET_DMA_TAG(self), &ehci_iterate_hw_softc)) {
 		return (ENOMEM);
 	}
@@ -408,7 +408,7 @@ ehci_pci_detach(device_t self)
 		    sc->sc_io_res);
 		sc->sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc);
+	usb_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc);
 
 	return (0);
 }
@@ -453,7 +453,7 @@ ehci_pci_takecontroller(device_t self)
 				    "timed out waiting for BIOS\n");
 				break;
 			}
-			usb2_pause_mtx(NULL, hz / 100);	/* wait 10ms */
+			usb_pause_mtx(NULL, hz / 100);	/* wait 10ms */
 		}
 	}
 }
diff --git a/sys/dev/usb/controller/musb_otg.c b/sys/dev/usb/controller/musb_otg.c
index d242574..22ce005 100644
--- a/sys/dev/usb/controller/musb_otg.c
+++ b/sys/dev/usb/controller/musb_otg.c
@@ -209,7 +209,7 @@ musbotg_wakeup_peer(struct musbotg_softc *sc)
 
 	/* wait 8 milliseconds */
 	/* Wait for reset to complete. */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
 
 	temp = MUSB2_READ_1(sc, MUSB2_REG_POWER);
 	temp &= ~MUSB2_MASK_RESUME;
@@ -301,7 +301,7 @@ musbotg_setup_rx(struct musbotg_td *td)
 	    MUSB2_REG_EPFIFO(0), (void *)&req, sizeof(req));
 
 	/* copy data into real buffer */
-	usb2_copy_in(td->pc, 0, &req, sizeof(req));
+	usbd_copy_in(td->pc, 0, &req, sizeof(req));
 
 	td->offset = sizeof(req);
 	td->remainder = 0;
@@ -404,7 +404,7 @@ musbotg_setup_data_rx(struct musbotg_td *td)
 	while (count > 0) {
 		uint32_t temp;
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -428,7 +428,7 @@ musbotg_setup_data_rx(struct musbotg_td *td)
 				    MUSB2_REG_EPFIFO(0),
 				    (void *)(&sc->sc_bounce_buf[count / 4]), temp);
 			}
-			usb2_copy_in(td->pc, td->offset,
+			usbd_copy_in(td->pc, td->offset,
 			    sc->sc_bounce_buf, count);
 
 			/* update offset and remainder */
@@ -522,7 +522,7 @@ musbotg_setup_data_tx(struct musbotg_td *td)
 	while (count > 0) {
 		uint32_t temp;
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -531,7 +531,7 @@ musbotg_setup_data_tx(struct musbotg_td *td)
 		/* check for unaligned memory address */
 		if (USB_P2U(buf_res.buffer) & 3) {
 
-			usb2_copy_out(td->pc, td->offset,
+			usbd_copy_out(td->pc, td->offset,
 			    sc->sc_bounce_buf, count);
 
 			temp = count & ~3;
@@ -692,7 +692,7 @@ repeat:
 	while (count > 0) {
 		uint32_t temp;
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -716,7 +716,7 @@ repeat:
 				    sc->sc_io_hdl, MUSB2_REG_EPFIFO(td->ep_no),
 				    ((void *)&sc->sc_bounce_buf[count / 4]), temp);
 			}
-			usb2_copy_in(td->pc, td->offset,
+			usbd_copy_in(td->pc, td->offset,
 			    sc->sc_bounce_buf, count);
 
 			/* update offset and remainder */
@@ -810,7 +810,7 @@ repeat:
 	while (count > 0) {
 		uint32_t temp;
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -819,7 +819,7 @@ repeat:
 		/* check for unaligned memory address */
 		if (USB_P2U(buf_res.buffer) & 3) {
 
-			usb2_copy_out(td->pc, td->offset,
+			usbd_copy_out(td->pc, td->offset,
 			    sc->sc_bounce_buf, count);
 
 			temp = count & ~3;
@@ -1115,7 +1115,7 @@ musbotg_setup_standard_chain(struct usb_xfer *xfer)
 
 	DPRINTFN(8, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpointno),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.max_frame_size = xfer->max_frame_size;
 
@@ -1297,11 +1297,11 @@ musbotg_start_standard_chain(struct usb_xfer *xfer)
 		DPRINTFN(14, "enabled interrupts on endpoint\n");
 
 		/* put transfer on interrupt queue */
-		usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+		usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 		/* start timeout, if any */
 		if (xfer->timeout != 0) {
-			usb2_transfer_timeout_ms(xfer,
+			usbd_transfer_timeout_ms(xfer,
 			    &musbotg_timeout, xfer->timeout);
 		}
 	}
@@ -1449,7 +1449,7 @@ musbotg_device_done(struct usb_xfer *xfer, usb_error_t error)
 		DPRINTFN(14, "disabled interrupts on endpoint\n");
 	}
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 static void
@@ -1689,7 +1689,7 @@ musbotg_init(struct musbotg_softc *sc)
 		(sc->sc_clocks_on) (sc->sc_clocks_arg);
 	}
 	/* wait a little for things to stabilise */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
 
 	/* disable all interrupts */
 
@@ -1702,7 +1702,7 @@ musbotg_init(struct musbotg_softc *sc)
 	musbotg_pull_common(sc, 0);
 
 	/* wait a little bit (10ms) */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
 
 	/* disable double packet buffering */
 	MUSB2_WRITE_2(sc, MUSB2_REG_RXDBDIS, 0xFFFF);
@@ -2011,7 +2011,7 @@ musbotg_device_isoc_enter(struct usb_xfer *xfer)
 	 */
 	temp = (nframes - xfer->endpoint->isoc_next) & MUSB2_MASK_FRAME;
 
-	if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) {
+	if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) {
 		fs_frames = (xfer->nframes + 7) / 8;
 	} else {
 		fs_frames = xfer->nframes;
@@ -2039,7 +2039,7 @@ musbotg_device_isoc_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp +
+	    usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
 	    fs_frames;
 
 	/* compute frame number for next insertion */
@@ -2581,7 +2581,7 @@ musbotg_xfer_setup(struct usb_setup_params *parm)
 	else
 		parm->hc_max_packet_count = 1;
 
-	usb2_transfer_setup_sub(parm);
+	usbd_transfer_setup_sub(parm);
 
 	/*
 	 * compute maximum number of TDs
@@ -2608,7 +2608,7 @@ musbotg_xfer_setup(struct usb_setup_params *parm)
 	}
 
 	/*
-	 * check if "usb2_transfer_setup_sub" set an error
+	 * check if "usbd_transfer_setup_sub" set an error
 	 */
 	if (parm->err) {
 		return;
diff --git a/sys/dev/usb/controller/musb_otg_atmelarm.c b/sys/dev/usb/controller/musb_otg_atmelarm.c
index 2589287..fa5f7ed 100644
--- a/sys/dev/usb/controller/musb_otg_atmelarm.c
+++ b/sys/dev/usb/controller/musb_otg_atmelarm.c
@@ -99,7 +99,7 @@ musbotg_attach(device_t dev)
 	sc->sc_otg.sc_bus.devices_max = MUSB2_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_otg.sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_otg.sc_bus,
 	    USB_GET_DMA_TAG(dev), NULL)) {
 		return (ENOMEM);
 	}
@@ -192,7 +192,7 @@ musbotg_detach(device_t dev)
 		    sc->sc_otg.sc_io_res);
 		sc->sc_otg.sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL);
+	usb_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL);
 
 	return (0);
 }
diff --git a/sys/dev/usb/controller/ohci.c b/sys/dev/usb/controller/ohci.c
index 2e6e6bc..5bce062 100644
--- a/sys/dev/usb/controller/ohci.c
+++ b/sys/dev/usb/controller/ohci.c
@@ -115,7 +115,7 @@ struct ohci_std_temp {
 static struct ohci_hcca *
 ohci_get_hcca(ohci_softc_t *sc)
 {
-	usb2_pc_cpu_invalidate(&sc->sc_hw.hcca_pc);
+	usb_pc_cpu_invalidate(&sc->sc_hw.hcca_pc);
 	return (sc->sc_hcca_p);
 }
 
@@ -162,7 +162,7 @@ ohci_controller_init(ohci_softc_t *sc)
 		DPRINTF("SMM active, request owner change\n");
 		OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_OCR);
 		for (i = 0; (i < 100) && (ctl & OHCI_IR); i++) {
-			usb2_pause_mtx(NULL, hz / 1000);
+			usb_pause_mtx(NULL, hz / 1000);
 			ctl = OREAD4(sc, OHCI_CONTROL);
 		}
 		if (ctl & OHCI_IR) {
@@ -175,7 +175,7 @@ ohci_controller_init(ohci_softc_t *sc)
 		DPRINTF("cold started\n");
 reset:
 		/* controller was cold started */
-		usb2_pause_mtx(NULL,
+		usb_pause_mtx(NULL,
 		    USB_MS_TO_TICKS(USB_BUS_RESET_DELAY));
 	}
 
@@ -186,7 +186,7 @@ reset:
 	DPRINTF("%s: resetting\n", device_get_nameunit(sc->sc_bus.bdev));
 	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
 
-	usb2_pause_mtx(NULL,
+	usb_pause_mtx(NULL,
 	    USB_MS_TO_TICKS(USB_BUS_RESET_DELAY));
 
 	/* we now own the host controller and the bus has been reset */
@@ -214,13 +214,13 @@ reset:
 	/* The controller is now in SUSPEND state, we have 2ms to finish. */
 
 	/* set up HC registers */
-	usb2_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res);
 	OWRITE4(sc, OHCI_HCCA, buf_res.physaddr);
 
-	usb2_get_page(&sc->sc_hw.ctrl_start_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.ctrl_start_pc, 0, &buf_res);
 	OWRITE4(sc, OHCI_CONTROL_HEAD_ED, buf_res.physaddr);
 
-	usb2_get_page(&sc->sc_hw.bulk_start_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.bulk_start_pc, 0, &buf_res);
 	OWRITE4(sc, OHCI_BULK_HEAD_ED, buf_res.physaddr);
 
 	/* disable all interrupts and then switch on all desired interrupts */
@@ -249,7 +249,7 @@ reset:
 	desca = OREAD4(sc, OHCI_RH_DESCRIPTOR_A);
 	OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca | OHCI_NOCP);
 	OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC);	/* Enable port power */
-	usb2_pause_mtx(NULL,
+	usb_pause_mtx(NULL,
 	    USB_MS_TO_TICKS(OHCI_ENABLE_POWER_DELAY));
 	OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca);
 
@@ -259,7 +259,7 @@ reset:
 	 */
 	sc->sc_noport = 0;
 	for (i = 0; (i < 10) && (sc->sc_noport == 0); i++) {
-		usb2_pause_mtx(NULL,
+		usb_pause_mtx(NULL,
 		    USB_MS_TO_TICKS(OHCI_READ_DESC_DELAY));
 		sc->sc_noport = OHCI_GET_NDP(OREAD4(sc, OHCI_RH_DESCRIPTOR_A));
 	}
@@ -278,7 +278,7 @@ ohci_init_ed(struct usb_page_cache *pc)
 	struct usb_page_search buf_res;
 	struct ohci_ed *ed;
 
-	usb2_get_page(pc, 0, &buf_res);
+	usbd_get_page(pc, 0, &buf_res);
 
 	ed = buf_res.buffer;
 
@@ -359,7 +359,7 @@ ohci_init(ohci_softc_t *sc)
 		ed_int->next = ed_isc;
 		ed_int->ed_next = ed_isc->ed_self;
 	}
-	usb2_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res);
 
 	sc->sc_hcca_p = buf_res.buffer;
 
@@ -373,12 +373,12 @@ ohci_init(ohci_softc_t *sc)
 	}
 	/* flush all cache into memory */
 
-	usb2_bus_mem_flush_all(&sc->sc_bus, &ohci_iterate_hw_softc);
+	usb_bus_mem_flush_all(&sc->sc_bus, &ohci_iterate_hw_softc);
 
 	/* set up the bus struct */
 	sc->sc_bus.methods = &ohci_bus_methods;
 
-	usb2_callout_init_mtx(&sc->sc_tmo_rhsc, &sc->sc_bus.bus_mtx, 0);
+	usb_callout_init_mtx(&sc->sc_tmo_rhsc, &sc->sc_bus.bus_mtx, 0);
 
 #if USB_DEBUG
 	if (ohcidebug > 15) {
@@ -410,7 +410,7 @@ ohci_detach(struct ohci_softc *sc)
 {
 	USB_BUS_LOCK(&sc->sc_bus);
 
-	usb2_callout_stop(&sc->sc_tmo_rhsc);
+	usb_callout_stop(&sc->sc_tmo_rhsc);
 
 	OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS);
 	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
@@ -418,9 +418,9 @@ ohci_detach(struct ohci_softc *sc)
 	USB_BUS_UNLOCK(&sc->sc_bus);
 
 	/* XXX let stray task complete */
-	usb2_pause_mtx(NULL, hz / 20);
+	usb_pause_mtx(NULL, hz / 20);
 
-	usb2_callout_drain(&sc->sc_tmo_rhsc);
+	usb_callout_drain(&sc->sc_tmo_rhsc);
 }
 
 /* NOTE: suspend/resume is called from
@@ -452,7 +452,7 @@ ohci_suspend(ohci_softc_t *sc)
 	ctl |= OHCI_HCFS_SUSPEND;
 	OWRITE4(sc, OHCI_CONTROL, ctl);
 
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+	usb_pause_mtx(&sc->sc_bus.bus_mtx,
 	    USB_MS_TO_TICKS(USB_RESUME_WAIT));
 
 	USB_BUS_UNLOCK(&sc->sc_bus);
@@ -483,11 +483,11 @@ ohci_resume(ohci_softc_t *sc)
 		ctl = OREAD4(sc, OHCI_CONTROL);
 	ctl |= OHCI_HCFS_RESUME;
 	OWRITE4(sc, OHCI_CONTROL, ctl);
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+	usb_pause_mtx(&sc->sc_bus.bus_mtx,
 	    USB_MS_TO_TICKS(USB_RESUME_DELAY));
 	ctl = (ctl & ~OHCI_HCFS_MASK) | OHCI_HCFS_OPERATIONAL;
 	OWRITE4(sc, OHCI_CONTROL, ctl);
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, 
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, 
 	    USB_MS_TO_TICKS(USB_RESUME_RECOVERY));
 	sc->sc_control = sc->sc_intre = 0;
 
@@ -557,7 +557,7 @@ ohci_dump_td(ohci_td_t *std)
 	uint32_t td_flags;
 	uint8_t temp;
 
-	usb2_pc_cpu_invalidate(std->page_cache);
+	usb_pc_cpu_invalidate(std->page_cache);
 
 	td_flags = le32toh(std->td_flags);
 	temp = (std->td_next == 0);
@@ -587,7 +587,7 @@ ohci_dump_itd(ohci_itd_t *sitd)
 	uint16_t i;
 	uint8_t temp;
 
-	usb2_pc_cpu_invalidate(sitd->page_cache);
+	usb_pc_cpu_invalidate(sitd->page_cache);
 
 	itd_flags = le32toh(sitd->itd_flags);
 	temp = (sitd->itd_next == 0);
@@ -627,7 +627,7 @@ ohci_dump_ed(ohci_ed_t *sed)
 	uint32_t ed_flags;
 	uint32_t ed_headp;
 
-	usb2_pc_cpu_invalidate(sed->page_cache);
+	usb_pc_cpu_invalidate(sed->page_cache);
 
 	ed_flags = le32toh(sed->ed_flags);
 	ed_headp = le32toh(sed->ed_headp);
@@ -660,11 +660,11 @@ ohci_transfer_intr_enqueue(struct usb_xfer *xfer)
 		return;
 	}
 	/* put transfer on interrupt queue */
-	usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+	usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 	/* start timeout, if any */
 	if (xfer->timeout != 0) {
-		usb2_transfer_timeout_ms(xfer, &ohci_timeout, xfer->timeout);
+		usbd_transfer_timeout_ms(xfer, &ohci_timeout, xfer->timeout);
 	}
 }
 
@@ -687,7 +687,7 @@ _ohci_append_qh(ohci_ed_t *sed, ohci_ed_t *last)
 
 	sed->prev = last;
 
-	usb2_pc_cpu_flush(sed->page_cache);
+	usb_pc_cpu_flush(sed->page_cache);
 
 	/*
 	 * the last->next->prev is never followed: sed->next->prev = sed;
@@ -696,7 +696,7 @@ _ohci_append_qh(ohci_ed_t *sed, ohci_ed_t *last)
 	last->next = sed;
 	last->ed_next = sed->ed_self;
 
-	usb2_pc_cpu_flush(last->page_cache);
+	usb_pc_cpu_flush(last->page_cache);
 
 	return (sed);
 }
@@ -715,17 +715,17 @@ _ohci_remove_qh(ohci_ed_t *sed, ohci_ed_t *last)
 		sed->prev->next = sed->next;
 		sed->prev->ed_next = sed->ed_next;
 
-		usb2_pc_cpu_flush(sed->prev->page_cache);
+		usb_pc_cpu_flush(sed->prev->page_cache);
 
 		if (sed->next) {
 			sed->next->prev = sed->prev;
-			usb2_pc_cpu_flush(sed->next->page_cache);
+			usb_pc_cpu_flush(sed->next->page_cache);
 		}
 		last = ((last == sed) ? sed->prev : last);
 
 		sed->prev = 0;
 
-		usb2_pc_cpu_flush(sed->page_cache);
+		usb_pc_cpu_flush(sed->page_cache);
 	}
 	return (last);
 }
@@ -750,7 +750,7 @@ ohci_isoc_done(struct usb_xfer *xfer)
 			ohci_dump_itd(td);
 		}
 #endif
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 
 		nframes = td->frames;
 		olen = &td->itd_offset[0];
@@ -832,7 +832,7 @@ ohci_non_isoc_done_sub(struct usb_xfer *xfer)
 	}
 	while (1) {
 
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		phy_start = le32toh(td->td_cbp);
 		td_flags = le32toh(td->td_flags);
 		cc = OHCI_TD_GET_CC(td_flags);
@@ -971,7 +971,7 @@ ohci_check_transfer_sub(struct usb_xfer *xfer)
 
 	while (1) {
 
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		phy_start = le32toh(td->td_cbp);
 		td_flags = le32toh(td->td_flags);
 		td_next = le32toh(td->td_next);
@@ -1011,7 +1011,7 @@ ohci_check_transfer_sub(struct usb_xfer *xfer)
 		ed = xfer->qh_start[xfer->flags_int.curr_dma_set];
 
 		ed->ed_headp = td->td_self;
-		usb2_pc_cpu_flush(ed->page_cache);
+		usb_pc_cpu_flush(ed->page_cache);
 
 		DPRINTFN(13, "xfer=%p following alt next\n", xfer);
 
@@ -1052,7 +1052,7 @@ ohci_check_transfer(struct usb_xfer *xfer)
 
 	ed = xfer->qh_start[xfer->flags_int.curr_dma_set];
 
-	usb2_pc_cpu_invalidate(ed->page_cache);
+	usb_pc_cpu_invalidate(ed->page_cache);
 	ed_headp = le32toh(ed->ed_headp);
 	ed_tailp = le32toh(ed->ed_tailp);
 
@@ -1169,7 +1169,7 @@ ohci_interrupt(ohci_softc_t *sc)
 		}
 		hcca->hcca_done_head = 0;
 
-		usb2_pc_cpu_flush(&sc->sc_hw.hcca_pc);
+		usb_pc_cpu_flush(&sc->sc_hw.hcca_pc);
 	} else {
 		status = OREAD4(sc, OHCI_INTERRUPT_STATUS) & ~OHCI_WDH;
 	}
@@ -1215,7 +1215,7 @@ ohci_interrupt(ohci_softc_t *sc)
 			ohci_root_intr(sc);
 
 			/* do not allow RHSC interrupts > 1 per second */
-			usb2_callout_reset(&sc->sc_tmo_rhsc, hz,
+			usb_callout_reset(&sc->sc_tmo_rhsc, hz,
 			    (void *)&ohci_rhsc_enable, sc);
 		}
 	}
@@ -1351,11 +1351,11 @@ restart:
 
 		} else {
 
-			usb2_get_page(temp->pc, buf_offset, &buf_res);
+			usbd_get_page(temp->pc, buf_offset, &buf_res);
 			td->td_cbp = htole32(buf_res.physaddr);
 			buf_offset += (average - 1);
 
-			usb2_get_page(temp->pc, buf_offset, &buf_res);
+			usbd_get_page(temp->pc, buf_offset, &buf_res);
 			td->td_be = htole32(buf_res.physaddr);
 			buf_offset++;
 
@@ -1380,7 +1380,7 @@ restart:
 
 		td->alt_next = td_alt_next;
 
-		usb2_pc_cpu_flush(td->page_cache);
+		usb_pc_cpu_flush(td->page_cache);
 	}
 
 	if (precompute) {
@@ -1416,7 +1416,7 @@ ohci_setup_standard_chain(struct usb_xfer *xfer, ohci_ed_t **ed_last)
 
 	DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpointno),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.average = xfer->max_hc_frame_size;
 	temp.max_frame_size = xfer->max_frame_size;
@@ -1558,7 +1558,7 @@ ohci_setup_standard_chain(struct usb_xfer *xfer, ohci_ed_t **ed_last)
 	td->td_flags &= ~htole32(OHCI_TD_INTR_MASK);
 	td->td_flags |= htole32(OHCI_TD_SET_DI(1));
 
-	usb2_pc_cpu_flush(td->page_cache);
+	usb_pc_cpu_flush(td->page_cache);
 
 	/* must have at least one frame! */
 
@@ -1604,7 +1604,7 @@ ohci_setup_standard_chain(struct usb_xfer *xfer, ohci_ed_t **ed_last)
 			OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
 		}
 	} else {
-		usb2_pc_cpu_flush(ed->page_cache);
+		usb_pc_cpu_flush(ed->page_cache);
 	}
 }
 
@@ -1659,7 +1659,7 @@ ohci_device_done(struct usb_xfer *xfer, usb_error_t error)
 
 	ed = xfer->qh_start[xfer->flags_int.curr_dma_set];
 	if (ed) {
-		usb2_pc_cpu_invalidate(ed->page_cache);
+		usb_pc_cpu_invalidate(ed->page_cache);
 	}
 	if (methods == &ohci_device_bulk_methods) {
 		OHCI_REMOVE_QH(ed, sc->sc_bulk_p_last);
@@ -1677,7 +1677,7 @@ ohci_device_done(struct usb_xfer *xfer, usb_error_t error)
 	xfer->td_transfer_last = NULL;
 
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 /*------------------------------------------------------------------------*
@@ -1897,7 +1897,7 @@ ohci_device_isoc_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    (usb2_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset +
+	    (usb_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset +
 	    xfer->nframes);
 
 	/* get the real number of frames */
@@ -1957,12 +1957,12 @@ ohci_device_isoc_enter(struct usb_xfer *xfer)
 					    htole16(OHCI_ITD_MK_OFFS(0));
 				}
 			} else {
-				usb2_get_page(xfer->frbuffers, buf_offset - length, &buf_res);
+				usbd_get_page(xfer->frbuffers, buf_offset - length, &buf_res);
 				length = OHCI_PAGE_MASK(buf_res.physaddr);
 				buf_res.physaddr =
 				    OHCI_PAGE(buf_res.physaddr);
 				td->itd_bp0 = htole32(buf_res.physaddr);
-				usb2_get_page(xfer->frbuffers, buf_offset - 1, &buf_res);
+				usbd_get_page(xfer->frbuffers, buf_offset - 1, &buf_res);
 				td->itd_be = htole32(buf_res.physaddr);
 
 				while (ncur--) {
@@ -1982,7 +1982,7 @@ ohci_device_isoc_enter(struct usb_xfer *xfer)
 				/* link the last TD with the next one */
 				td_last->itd_next = td->itd_self;
 			}
-			usb2_pc_cpu_flush(td_last->page_cache);
+			usb_pc_cpu_flush(td_last->page_cache);
 		}
 	}
 
@@ -1991,7 +1991,7 @@ ohci_device_isoc_enter(struct usb_xfer *xfer)
 	td_last->itd_flags |= htole32(OHCI_ITD_SET_DI(0));
 	td_last->itd_next = 0;
 
-	usb2_pc_cpu_flush(td_last->page_cache);
+	usb_pc_cpu_flush(td_last->page_cache);
 
 	xfer->td_transfer_last = td_last;
 
@@ -2189,7 +2189,7 @@ ohci_roothub_exec(struct usb_device *udev,
 				break;
 			}
 
-			len = usb2_make_str_desc(
+			len = usb_make_str_desc(
 			    sc->sc_hub_desc.temp,
 			    sizeof(sc->sc_hub_desc.temp),
 			    str_ptr);
@@ -2365,7 +2365,7 @@ ohci_roothub_exec(struct usb_device *udev,
 			OWRITE4(sc, port, UPS_RESET);
 			for (v = 0;; v++) {
 				if (v < 12) {
-					usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+					usb_pause_mtx(&sc->sc_bus.bus_mtx,
 					    USB_MS_TO_TICKS(USB_PORT_ROOT_RESET_DELAY));
 
 					if ((OREAD4(sc, port) & UPS_RESET) == 0) {
@@ -2424,7 +2424,7 @@ ohci_xfer_setup(struct usb_setup_params *parm)
 	if (parm->methods == &ohci_device_ctrl_methods) {
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nitd = 0;
 		ntd = ((2 * xfer->nframes) + 1	/* STATUS */
@@ -2434,7 +2434,7 @@ ohci_xfer_setup(struct usb_setup_params *parm)
 	} else if (parm->methods == &ohci_device_bulk_methods) {
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nitd = 0;
 		ntd = ((2 * xfer->nframes)
@@ -2444,7 +2444,7 @@ ohci_xfer_setup(struct usb_setup_params *parm)
 	} else if (parm->methods == &ohci_device_intr_methods) {
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nitd = 0;
 		ntd = ((2 * xfer->nframes)
@@ -2454,7 +2454,7 @@ ohci_xfer_setup(struct usb_setup_params *parm)
 	} else if (parm->methods == &ohci_device_isoc_methods) {
 		xfer->flags_int.bdma_enable = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nitd = ((xfer->max_data_length / OHCI_PAGE_SIZE) +
 		    ((xfer->nframes + OHCI_ITD_NOFFSET - 1) / OHCI_ITD_NOFFSET) +
@@ -2464,7 +2464,7 @@ ohci_xfer_setup(struct usb_setup_params *parm)
 
 	} else {
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nitd = 0;
 		ntd = 0;
@@ -2478,7 +2478,7 @@ alloc_dma_set:
 	}
 	last_obj = NULL;
 
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(ohci_td_t),
 	    OHCI_TD_ALIGN, ntd)) {
 		parm->err = USB_ERR_NOMEM;
@@ -2488,7 +2488,7 @@ alloc_dma_set:
 		for (n = 0; n != ntd; n++) {
 			ohci_td_t *td;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			td = page_info.buffer;
 
@@ -2499,10 +2499,10 @@ alloc_dma_set:
 
 			last_obj = td;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(ohci_itd_t),
 	    OHCI_ITD_ALIGN, nitd)) {
 		parm->err = USB_ERR_NOMEM;
@@ -2512,7 +2512,7 @@ alloc_dma_set:
 		for (n = 0; n != nitd; n++) {
 			ohci_itd_t *itd;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			itd = page_info.buffer;
 
@@ -2523,14 +2523,14 @@ alloc_dma_set:
 
 			last_obj = itd;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
 	xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj;
 
 	last_obj = NULL;
 
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(ohci_ed_t),
 	    OHCI_ED_ALIGN, nqh)) {
 		parm->err = USB_ERR_NOMEM;
@@ -2540,7 +2540,7 @@ alloc_dma_set:
 		for (n = 0; n != nqh; n++) {
 			ohci_ed_t *ed;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			ed = page_info.buffer;
 
@@ -2551,7 +2551,7 @@ alloc_dma_set:
 
 			last_obj = ed;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
 	xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj;
diff --git a/sys/dev/usb/controller/ohci_atmelarm.c b/sys/dev/usb/controller/ohci_atmelarm.c
index 0f213c5..a757611 100644
--- a/sys/dev/usb/controller/ohci_atmelarm.c
+++ b/sys/dev/usb/controller/ohci_atmelarm.c
@@ -73,7 +73,7 @@ ohci_atmelarm_attach(device_t dev)
 	sc->sc_ohci.sc_bus.devices_max = OHCI_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_ohci.sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_ohci.sc_bus,
 	    USB_GET_DMA_TAG(dev), &ohci_iterate_hw_softc)) {
 		return (ENOMEM);
 	}
@@ -191,7 +191,7 @@ ohci_atmelarm_detach(device_t dev)
 		    sc->sc_ohci.sc_io_res);
 		sc->sc_ohci.sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_ohci.sc_bus, &ohci_iterate_hw_softc);
+	usb_bus_mem_free_all(&sc->sc_ohci.sc_bus, &ohci_iterate_hw_softc);
 
 	return (0);
 }
diff --git a/sys/dev/usb/controller/ohci_pci.c b/sys/dev/usb/controller/ohci_pci.c
index 031be52..76943c4 100644
--- a/sys/dev/usb/controller/ohci_pci.c
+++ b/sys/dev/usb/controller/ohci_pci.c
@@ -199,7 +199,7 @@ ohci_pci_attach(device_t self)
 	sc->sc_bus.devices_max = OHCI_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self),
+	if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self),
 	    &ohci_iterate_hw_softc)) {
 		return (ENOMEM);
 	}
@@ -353,7 +353,7 @@ ohci_pci_detach(device_t self)
 		    sc->sc_io_res);
 		sc->sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_bus, &ohci_iterate_hw_softc);
+	usb_bus_mem_free_all(&sc->sc_bus, &ohci_iterate_hw_softc);
 
 	return (0);
 }
diff --git a/sys/dev/usb/controller/uhci.c b/sys/dev/usb/controller/uhci.c
index d1ec1d1..6d6a67e 100644
--- a/sys/dev/usb/controller/uhci.c
+++ b/sys/dev/usb/controller/uhci.c
@@ -191,13 +191,13 @@ uhci_mem_layout_init(struct uhci_mem_layout *ml, struct usb_xfer *xfer)
 static void
 uhci_mem_layout_fixup(struct uhci_mem_layout *ml, struct uhci_td *td)
 {
-	usb2_get_page(ml->buf_pc, ml->buf_offset, &ml->buf_res);
+	usbd_get_page(ml->buf_pc, ml->buf_offset, &ml->buf_res);
 
 	if (ml->buf_res.length < td->len) {
 
 		/* need to do a fixup */
 
-		usb2_get_page(ml->fix_pc, 0, &ml->fix_res);
+		usbd_get_page(ml->fix_pc, 0, &ml->fix_res);
 
 		td->td_buffer = htole32(ml->fix_res.physaddr);
 
@@ -219,17 +219,17 @@ uhci_mem_layout_fixup(struct uhci_mem_layout *ml, struct uhci_td *td)
 		if ((td->td_token & htole32(UHCI_TD_PID)) ==
 		    htole32(UHCI_TD_PID_IN)) {
 			td->fix_pc = ml->fix_pc;
-			usb2_pc_cpu_invalidate(ml->fix_pc);
+			usb_pc_cpu_invalidate(ml->fix_pc);
 
 		} else {
 			td->fix_pc = NULL;
 
 			/* copy data to fixup location */
 
-			usb2_copy_out(ml->buf_pc, ml->buf_offset,
+			usbd_copy_out(ml->buf_pc, ml->buf_offset,
 			    ml->fix_res.buffer, td->len);
 
-			usb2_pc_cpu_flush(ml->fix_pc);
+			usb_pc_cpu_flush(ml->fix_pc);
 		}
 
 		/* prepare next fixup */
@@ -266,7 +266,7 @@ uhci_restart(uhci_softc_t *sc)
 
 	DPRINTFN(2, "Restarting\n");
 
-	usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
+	usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
 
 	/* Reload fresh base address */
 	UWRITE4(sc, UHCI_FLBASEADDR, buf_res.physaddr);
@@ -278,7 +278,7 @@ uhci_restart(uhci_softc_t *sc)
 
 	/* wait 10 milliseconds */
 
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
 
 	/* check that controller has started */
 
@@ -308,7 +308,7 @@ uhci_reset(uhci_softc_t *sc)
 
 	/* wait */
 
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+	usb_pause_mtx(&sc->sc_bus.bus_mtx,
 	    USB_MS_TO_TICKS(USB_BUS_RESET_DELAY));
 
 	/* terminate all transfers */
@@ -321,7 +321,7 @@ uhci_reset(uhci_softc_t *sc)
 	while (n--) {
 		/* wait one millisecond */
 
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
+		usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
 
 		if (!(UREAD2(sc, UHCI_CMD) & UHCI_CMD_HCRESET)) {
 			goto done_1;
@@ -337,7 +337,7 @@ done_1:
 	while (n--) {
 		/* wait one millisecond */
 
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
+		usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000);
 
 		/* check if HC is stopped */
 		if (UREAD2(sc, UHCI_STS) & UHCI_STS_HCH) {
@@ -357,7 +357,7 @@ done_2:
 	USB_BUS_UNLOCK(&sc->sc_bus);
 
 	/* stop root interrupt */
-	usb2_callout_drain(&sc->sc_root_intr);
+	usb_callout_drain(&sc->sc_root_intr);
 
 	USB_BUS_LOCK(&sc->sc_bus);
 }
@@ -392,7 +392,7 @@ uhci_init_qh(struct usb_page_cache *pc)
 	struct usb_page_search buf_res;
 	struct uhci_qh *qh;
 
-	usb2_get_page(pc, 0, &buf_res);
+	usbd_get_page(pc, 0, &buf_res);
 
 	qh = buf_res.buffer;
 
@@ -411,7 +411,7 @@ uhci_init_td(struct usb_page_cache *pc)
 	struct usb_page_search buf_res;
 	struct uhci_td *td;
 
-	usb2_get_page(pc, 0, &buf_res);
+	usbd_get_page(pc, 0, &buf_res);
 
 	td = buf_res.buffer;
 
@@ -433,7 +433,7 @@ uhci_init(uhci_softc_t *sc)
 
 	DPRINTF("start\n");
 
-	usb2_callout_init_mtx(&sc->sc_root_intr, &sc->sc_bus.bus_mtx, 0);
+	usb_callout_init_mtx(&sc->sc_root_intr, &sc->sc_bus.bus_mtx, 0);
 
 #if USB_DEBUG
 	if (uhcidebug > 2) {
@@ -594,7 +594,7 @@ uhci_init(uhci_softc_t *sc)
 		struct usb_page_search buf_res;
 		uint32_t *pframes;
 
-		usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
+		usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res);
 
 		pframes = buf_res.buffer;
 
@@ -616,7 +616,7 @@ uhci_init(uhci_softc_t *sc)
 	}
 	/* flush all cache into memory */
 
-	usb2_bus_mem_flush_all(&sc->sc_bus, &uhci_iterate_hw_softc);
+	usb_bus_mem_flush_all(&sc->sc_bus, &uhci_iterate_hw_softc);
 
 	/* set up the bus struct */
 	sc->sc_bus.methods = &uhci_bus_methods;
@@ -662,7 +662,7 @@ uhci_suspend(uhci_softc_t *sc)
 
 	UHCICMD(sc, UHCI_CMD_EGSM);
 
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, 
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, 
 	    USB_MS_TO_TICKS(USB_RESUME_WAIT));
 
 	USB_BUS_UNLOCK(&sc->sc_bus);
@@ -681,7 +681,7 @@ uhci_resume(uhci_softc_t *sc)
 
 	UHCICMD(sc, UHCI_CMD_FGR);
 
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+	usb_pause_mtx(&sc->sc_bus.bus_mtx,
 	    USB_MS_TO_TICKS(USB_RESUME_DELAY));
 
 	/* and start traffic again */
@@ -725,7 +725,7 @@ uhci_dump_td(uhci_td_t *p)
 	uint32_t td_token;
 	uint8_t temp;
 
-	usb2_pc_cpu_invalidate(p->page_cache);
+	usb_pc_cpu_invalidate(p->page_cache);
 
 	td_next = le32toh(p->td_next);
 	td_status = le32toh(p->td_status);
@@ -781,7 +781,7 @@ uhci_dump_qh(uhci_qh_t *sqh)
 	uint32_t qh_h_next;
 	uint32_t qh_e_next;
 
-	usb2_pc_cpu_invalidate(sqh->page_cache);
+	usb_pc_cpu_invalidate(sqh->page_cache);
 
 	qh_h_next = le32toh(sqh->qh_h_next);
 	qh_e_next = le32toh(sqh->qh_e_next);
@@ -872,7 +872,7 @@ uhci_add_loop(uhci_softc_t *sc)
 		/* NOTE: we don't loop back the soft pointer */
 
 		qh_lst->qh_h_next = qh_rec->qh_self;
-		usb2_pc_cpu_flush(qh_lst->page_cache);
+		usb_pc_cpu_flush(qh_lst->page_cache);
 	}
 }
 
@@ -891,7 +891,7 @@ uhci_rem_loop(uhci_softc_t *sc)
 
 		qh_lst = sc->sc_last_qh_p;
 		qh_lst->qh_h_next = htole32(UHCI_PTR_T);
-		usb2_pc_cpu_flush(qh_lst->page_cache);
+		usb_pc_cpu_flush(qh_lst->page_cache);
 	}
 }
 
@@ -903,11 +903,11 @@ uhci_transfer_intr_enqueue(struct usb_xfer *xfer)
 		return;
 	}
 	/* put transfer on interrupt queue */
-	usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+	usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 	/* start timeout, if any */
 	if (xfer->timeout != 0) {
-		usb2_transfer_timeout_ms(xfer, &uhci_timeout, xfer->timeout);
+		usbd_transfer_timeout_ms(xfer, &uhci_timeout, xfer->timeout);
 	}
 }
 
@@ -924,7 +924,7 @@ _uhci_append_td(uhci_td_t *std, uhci_td_t *last)
 
 	std->prev = last;
 
-	usb2_pc_cpu_flush(std->page_cache);
+	usb_pc_cpu_flush(std->page_cache);
 
 	/*
 	 * the last->next->prev is never followed: std->next->prev = std;
@@ -932,7 +932,7 @@ _uhci_append_td(uhci_td_t *std, uhci_td_t *last)
 	last->next = std;
 	last->td_next = std->td_self;
 
-	usb2_pc_cpu_flush(last->page_cache);
+	usb_pc_cpu_flush(last->page_cache);
 
 	return (std);
 }
@@ -955,7 +955,7 @@ _uhci_append_qh(uhci_qh_t *sqh, uhci_qh_t *last)
 
 	sqh->h_prev = last;
 
-	usb2_pc_cpu_flush(sqh->page_cache);
+	usb_pc_cpu_flush(sqh->page_cache);
 
 	/*
 	 * The "last->h_next->h_prev" is never followed:
@@ -966,7 +966,7 @@ _uhci_append_qh(uhci_qh_t *sqh, uhci_qh_t *last)
 	last->h_next = sqh;
 	last->qh_h_next = sqh->qh_self;
 
-	usb2_pc_cpu_flush(last->page_cache);
+	usb_pc_cpu_flush(last->page_cache);
 
 	return (sqh);
 }
@@ -984,11 +984,11 @@ _uhci_remove_td(uhci_td_t *std, uhci_td_t *last)
 	std->prev->next = std->next;
 	std->prev->td_next = std->td_next;
 
-	usb2_pc_cpu_flush(std->prev->page_cache);
+	usb_pc_cpu_flush(std->prev->page_cache);
 
 	if (std->next) {
 		std->next->prev = std->prev;
-		usb2_pc_cpu_flush(std->next->page_cache);
+		usb_pc_cpu_flush(std->next->page_cache);
 	}
 	return ((last == std) ? std->prev : last);
 }
@@ -1007,17 +1007,17 @@ _uhci_remove_qh(uhci_qh_t *sqh, uhci_qh_t *last)
 		sqh->h_prev->h_next = sqh->h_next;
 		sqh->h_prev->qh_h_next = sqh->qh_h_next;
 
-		usb2_pc_cpu_flush(sqh->h_prev->page_cache);
+		usb_pc_cpu_flush(sqh->h_prev->page_cache);
 
 		if (sqh->h_next) {
 			sqh->h_next->h_prev = sqh->h_prev;
-			usb2_pc_cpu_flush(sqh->h_next->page_cache);
+			usb_pc_cpu_flush(sqh->h_next->page_cache);
 		}
 		last = ((last == sqh) ? sqh->h_prev : last);
 
 		sqh->h_prev = 0;
 
-		usb2_pc_cpu_flush(sqh->page_cache);
+		usb_pc_cpu_flush(sqh->page_cache);
 	}
 	return (last);
 }
@@ -1039,7 +1039,7 @@ uhci_isoc_done(uhci_softc_t *sc, struct usb_xfer *xfer)
 
 	/* sync any DMA memory before doing fixups */
 
-	usb2_bdma_post_sync(xfer);
+	usb_bdma_post_sync(xfer);
 
 	while (nframes--) {
 		if (td == NULL) {
@@ -1055,7 +1055,7 @@ uhci_isoc_done(uhci_softc_t *sc, struct usb_xfer *xfer)
 			uhci_dump_td(td);
 		}
 #endif
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status = le32toh(td->td_status);
 
 		len = UHCI_TD_GET_ACTLEN(status);
@@ -1065,13 +1065,13 @@ uhci_isoc_done(uhci_softc_t *sc, struct usb_xfer *xfer)
 		}
 		if (td->fix_pc) {
 
-			usb2_get_page(td->fix_pc, 0, &res);
+			usbd_get_page(td->fix_pc, 0, &res);
 
 			/* copy data from fixup location to real location */
 
-			usb2_pc_cpu_invalidate(td->fix_pc);
+			usb_pc_cpu_invalidate(td->fix_pc);
 
-			usb2_copy_in(xfer->frbuffers, offset,
+			usbd_copy_in(xfer->frbuffers, offset,
 			    res.buffer, len);
 		}
 		offset += *plen;
@@ -1107,7 +1107,7 @@ uhci_non_isoc_done_sub(struct usb_xfer *xfer)
 	}
 	while (1) {
 
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status = le32toh(td->td_status);
 		token = le32toh(td->td_token);
 
@@ -1127,16 +1127,16 @@ uhci_non_isoc_done_sub(struct usb_xfer *xfer)
 
 			if (td->fix_pc) {
 
-				usb2_get_page(td->fix_pc, 0, &res);
+				usbd_get_page(td->fix_pc, 0, &res);
 
 				/*
 				 * copy data from fixup location to real
 				 * location
 				 */
 
-				usb2_pc_cpu_invalidate(td->fix_pc);
+				usb_pc_cpu_invalidate(td->fix_pc);
 
-				usb2_copy_in(xfer->frbuffers + xfer->aframes,
+				usbd_copy_in(xfer->frbuffers + xfer->aframes,
 				    xfer->frlengths[xfer->aframes], res.buffer, len);
 			}
 			/* update actual length */
@@ -1218,7 +1218,7 @@ uhci_non_isoc_done(struct usb_xfer *xfer)
 
 	/* sync any DMA memory before doing fixups */
 
-	usb2_bdma_post_sync(xfer);
+	usb_bdma_post_sync(xfer);
 
 	/* reset scanner */
 
@@ -1291,7 +1291,7 @@ uhci_check_transfer_sub(struct usb_xfer *xfer)
 	while (1) {
 
 		td->td_token ^= htole32(UHCI_TD_SET_DT(1));
-		usb2_pc_cpu_flush(td->page_cache);
+		usb_pc_cpu_flush(td->page_cache);
 
 		if (td == xfer->td_transfer_last) {
 			/* last transfer */
@@ -1308,7 +1308,7 @@ skip:
 
 	/* update the QH */
 	qh->qh_e_next = td_self;
-	usb2_pc_cpu_flush(qh->page_cache);
+	usb_pc_cpu_flush(qh->page_cache);
 
 	DPRINTFN(13, "xfer=%p following alt next\n", xfer);
 }
@@ -1334,14 +1334,14 @@ uhci_check_transfer(struct usb_xfer *xfer)
 
 		td = xfer->td_transfer_last;
 
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status = le32toh(td->td_status);
 
 		/* check also if the first is complete */
 
 		td = xfer->td_transfer_first;
 
-		usb2_pc_cpu_invalidate(td->page_cache);
+		usb_pc_cpu_invalidate(td->page_cache);
 		status |= le32toh(td->td_status);
 
 		if (!(status & UHCI_TD_ACTIVE)) {
@@ -1359,7 +1359,7 @@ uhci_check_transfer(struct usb_xfer *xfer)
 		td = xfer->td_transfer_cache;
 
 		while (1) {
-			usb2_pc_cpu_invalidate(td->page_cache);
+			usb_pc_cpu_invalidate(td->page_cache);
 			status = le32toh(td->td_status);
 			token = le32toh(td->td_token);
 
@@ -1652,7 +1652,7 @@ restart:
 			}
 		}
 
-		usb2_pc_cpu_flush(td->page_cache);
+		usb_pc_cpu_flush(td->page_cache);
 	}
 
 	if (precompute) {
@@ -1684,7 +1684,7 @@ uhci_setup_standard_chain(struct usb_xfer *xfer)
 
 	DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpointno),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.average = xfer->max_frame_size;
 	temp.max_frame_size = xfer->max_frame_size;
@@ -1836,7 +1836,7 @@ uhci_setup_standard_chain(struct usb_xfer *xfer)
 
 	td->td_status |= htole32(UHCI_TD_IOC);
 
-	usb2_pc_cpu_flush(td->page_cache);
+	usb_pc_cpu_flush(td->page_cache);
 
 	/* must have at least one frame! */
 
@@ -1870,7 +1870,7 @@ uhci_device_done(struct usb_xfer *xfer, usb_error_t error)
 
 	qh = xfer->qh_start[xfer->flags_int.curr_dma_set];
 	if (qh) {
-		usb2_pc_cpu_invalidate(qh->page_cache);
+		usb_pc_cpu_invalidate(qh->page_cache);
 	}
 	if (xfer->flags_int.bandwidth_reclaimed) {
 		xfer->flags_int.bandwidth_reclaimed = 0;
@@ -1902,7 +1902,7 @@ uhci_device_done(struct usb_xfer *xfer, usb_error_t error)
 		xfer->td_transfer_last = NULL;
 	}
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 /*------------------------------------------------------------------------*
@@ -1947,7 +1947,7 @@ uhci_device_bulk_start(struct usb_xfer *xfer)
 		uhci_add_loop(sc);
 		xfer->flags_int.bandwidth_reclaimed = 1;
 	} else {
-		usb2_pc_cpu_flush(qh->page_cache);
+		usb_pc_cpu_flush(qh->page_cache);
 	}
 
 	/* put transfer on interrupt queue */
@@ -2010,7 +2010,7 @@ uhci_device_ctrl_start(struct usb_xfer *xfer)
 			UHCI_APPEND_QH(qh, sc->sc_fs_ctl_p_last);
 		}
 	} else {
-		usb2_pc_cpu_flush(qh->page_cache);
+		usb_pc_cpu_flush(qh->page_cache);
 	}
 	/* put transfer on interrupt queue */
 	uhci_transfer_intr_enqueue(xfer);
@@ -2096,7 +2096,7 @@ uhci_device_intr_start(struct usb_xfer *xfer)
 		/* 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);
+		usb_pc_cpu_flush(qh->page_cache);
 	}
 
 	/* put transfer on interrupt queue */
@@ -2138,7 +2138,7 @@ uhci_device_isoc_open(struct usb_xfer *xfer)
 			td->td_status = htole32(UHCI_TD_IOS);
 			td->td_token = td_token;
 
-			usb2_pc_cpu_flush(td->page_cache);
+			usb_pc_cpu_flush(td->page_cache);
 		}
 	}
 }
@@ -2197,7 +2197,7 @@ uhci_device_isoc_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp +
+	    usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
 	    xfer->nframes;
 
 	/* get the real number of frames */
@@ -2280,7 +2280,7 @@ uhci_device_isoc_enter(struct usb_xfer *xfer)
 			    UHCI_TD_IOS));
 		}
 
-		usb2_pc_cpu_flush(td->page_cache);
+		usb_pc_cpu_flush(td->page_cache);
 
 #if USB_DEBUG
 		if (uhcidebug > 5) {
@@ -2415,7 +2415,7 @@ uhci_portreset(uhci_softc_t *sc, uint16_t index)
 	x = URWMASK(UREAD2(sc, port));
 	UWRITE2(sc, port, x | UHCI_PORTSC_PR);
 
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+	usb_pause_mtx(&sc->sc_bus.bus_mtx,
 	    USB_MS_TO_TICKS(USB_PORT_ROOT_RESET_DELAY));
 
 	DPRINTFN(4, "uhci port %d reset, status0 = 0x%04x\n",
@@ -2443,7 +2443,7 @@ uhci_portreset(uhci_softc_t *sc, uint16_t index)
 
 	for (lim = 0; lim < 12; lim++) {
 
-		usb2_pause_mtx(&sc->sc_bus.bus_mtx,
+		usb_pause_mtx(&sc->sc_bus.bus_mtx,
 		    USB_MS_TO_TICKS(USB_PORT_RESET_DELAY));
 
 		x = UREAD2(sc, port);
@@ -2577,7 +2577,7 @@ uhci_roothub_exec(struct usb_device *udev,
 				break;
 			}
 
-			len = usb2_make_str_desc
+			len = usb_make_str_desc
 			    (sc->sc_hub_desc.temp,
 			    sizeof(sc->sc_hub_desc.temp),
 			    str_ptr);
@@ -2738,14 +2738,14 @@ uhci_roothub_exec(struct usb_device *udev,
 			UWRITE2(sc, port, URWMASK(x));
 
 			/* wait 20ms for resume sequence to complete */
-			usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50);
+			usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50);
 
 			/* 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, hz / 500);
+			usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 500);
 
 			sc->sc_isresumed |= (1 << index);
 
@@ -2837,7 +2837,7 @@ uhci_root_intr(uhci_softc_t *sc)
 	}
 
 	/* restart timer */
-	usb2_callout_reset(&sc->sc_root_intr, hz,
+	usb_callout_reset(&sc->sc_root_intr, hz,
 	    (void *)&uhci_root_intr, sc);
 
 	if (sc->sc_hub_idata[0] != 0) {
@@ -2874,7 +2874,7 @@ uhci_xfer_setup(struct usb_setup_params *parm)
 		xfer->flags_int.bdma_enable = 1;
 		xfer->flags_int.bdma_no_post_sync = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		/* see EHCI HC driver for proof of "ntd" formula */
 
@@ -2886,7 +2886,7 @@ uhci_xfer_setup(struct usb_setup_params *parm)
 		xfer->flags_int.bdma_enable = 1;
 		xfer->flags_int.bdma_no_post_sync = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nqh = 1;
 		ntd = ((2 * xfer->nframes)
@@ -2896,7 +2896,7 @@ uhci_xfer_setup(struct usb_setup_params *parm)
 		xfer->flags_int.bdma_enable = 1;
 		xfer->flags_int.bdma_no_post_sync = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nqh = 1;
 		ntd = ((2 * xfer->nframes)
@@ -2906,14 +2906,14 @@ uhci_xfer_setup(struct usb_setup_params *parm)
 		xfer->flags_int.bdma_enable = 1;
 		xfer->flags_int.bdma_no_post_sync = 1;
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nqh = 0;
 		ntd = xfer->nframes;
 
 	} else {
 
-		usb2_transfer_setup_sub(parm);
+		usbd_transfer_setup_sub(parm);
 
 		nqh = 0;
 		ntd = 0;
@@ -2957,7 +2957,7 @@ uhci_xfer_setup(struct usb_setup_params *parm)
 	}
 	align = (1 << n);
 
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, xfer->max_frame_size,
 	    align, nfixup)) {
 		parm->err = USB_ERR_NOMEM;
@@ -2972,7 +2972,7 @@ alloc_dma_set:
 	}
 	last_obj = NULL;
 
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(uhci_td_t),
 	    UHCI_TD_ALIGN, ntd)) {
 		parm->err = USB_ERR_NOMEM;
@@ -2982,7 +2982,7 @@ alloc_dma_set:
 		for (n = 0; n != ntd; n++) {
 			uhci_td_t *td;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			td = page_info.buffer;
 
@@ -3003,14 +3003,14 @@ alloc_dma_set:
 
 			last_obj = td;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
 	xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj;
 
 	last_obj = NULL;
 
-	if (usb2_transfer_setup_sub_malloc(
+	if (usbd_transfer_setup_sub_malloc(
 	    parm, &pc, sizeof(uhci_qh_t),
 	    UHCI_QH_ALIGN, nqh)) {
 		parm->err = USB_ERR_NOMEM;
@@ -3020,7 +3020,7 @@ alloc_dma_set:
 		for (n = 0; n != nqh; n++) {
 			uhci_qh_t *qh;
 
-			usb2_get_page(pc + n, 0, &page_info);
+			usbd_get_page(pc + n, 0, &page_info);
 
 			qh = page_info.buffer;
 
@@ -3031,7 +3031,7 @@ alloc_dma_set:
 
 			last_obj = qh;
 
-			usb2_pc_cpu_flush(pc + n);
+			usb_pc_cpu_flush(pc + n);
 		}
 	}
 	xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj;
diff --git a/sys/dev/usb/controller/uhci_pci.c b/sys/dev/usb/controller/uhci_pci.c
index 061a178..ed7819e 100644
--- a/sys/dev/usb/controller/uhci_pci.c
+++ b/sys/dev/usb/controller/uhci_pci.c
@@ -250,7 +250,7 @@ uhci_pci_attach(device_t self)
 	sc->sc_bus.devices_max = UHCI_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self),
+	if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self),
 	    &uhci_iterate_hw_softc)) {
 		return ENOMEM;
 	}
@@ -409,7 +409,7 @@ uhci_pci_detach(device_t self)
 		    sc->sc_io_res);
 		sc->sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_bus, &uhci_iterate_hw_softc);
+	usb_bus_mem_free_all(&sc->sc_bus, &uhci_iterate_hw_softc);
 
 	return (0);
 }
diff --git a/sys/dev/usb/controller/usb_controller.c b/sys/dev/usb/controller/usb_controller.c
index 1e91643..3e7c0a7 100644
--- a/sys/dev/usb/controller/usb_controller.c
+++ b/sys/dev/usb/controller/usb_controller.c
@@ -28,7 +28,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb.h>
 
-#define	USB_DEBUG_VAR usb2_ctrl_debug
+#define	USB_DEBUG_VAR usb_ctrl_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -43,66 +43,66 @@
 
 /* function prototypes  */
 
-static device_probe_t usb2_probe;
-static device_attach_t usb2_attach;
-static device_detach_t usb2_detach;
+static device_probe_t usb_probe;
+static device_attach_t usb_attach;
+static device_detach_t usb_detach;
 
-static void	usb2_attach_sub(device_t, struct usb_bus *);
-static void	usb2_post_init(void *);
+static void	usb_attach_sub(device_t, struct usb_bus *);
+static void	usb_post_init(void *);
 
 /* static variables */
 
 #if USB_DEBUG
-static int usb2_ctrl_debug = 0;
+static int usb_ctrl_debug = 0;
 
 SYSCTL_NODE(_hw_usb, OID_AUTO, ctrl, CTLFLAG_RW, 0, "USB controller");
-SYSCTL_INT(_hw_usb_ctrl, OID_AUTO, debug, CTLFLAG_RW, &usb2_ctrl_debug, 0,
+SYSCTL_INT(_hw_usb_ctrl, OID_AUTO, debug, CTLFLAG_RW, &usb_ctrl_debug, 0,
     "Debug level");
 #endif
 
-static uint8_t usb2_post_init_called = 0;
+static uint8_t usb_post_init_called = 0;
 
-static devclass_t usb2_devclass;
+static devclass_t usb_devclass;
 
-static device_method_t usb2_methods[] = {
-	DEVMETHOD(device_probe, usb2_probe),
-	DEVMETHOD(device_attach, usb2_attach),
-	DEVMETHOD(device_detach, usb2_detach),
+static device_method_t usb_methods[] = {
+	DEVMETHOD(device_probe, usb_probe),
+	DEVMETHOD(device_attach, usb_attach),
+	DEVMETHOD(device_detach, usb_detach),
 	DEVMETHOD(device_suspend, bus_generic_suspend),
 	DEVMETHOD(device_resume, bus_generic_resume),
 	DEVMETHOD(device_shutdown, bus_generic_shutdown),
 	{0, 0}
 };
 
-static driver_t usb2_driver = {
+static driver_t usb_driver = {
 	.name = "usbus",
-	.methods = usb2_methods,
+	.methods = usb_methods,
 	.size = 0,
 };
 
-DRIVER_MODULE(usbus, ohci, usb2_driver, usb2_devclass, 0, 0);
-DRIVER_MODULE(usbus, uhci, usb2_driver, usb2_devclass, 0, 0);
-DRIVER_MODULE(usbus, ehci, usb2_driver, usb2_devclass, 0, 0);
-DRIVER_MODULE(usbus, at91_udp, usb2_driver, usb2_devclass, 0, 0);
-DRIVER_MODULE(usbus, uss820, usb2_driver, usb2_devclass, 0, 0);
+DRIVER_MODULE(usbus, ohci, usb_driver, usb_devclass, 0, 0);
+DRIVER_MODULE(usbus, uhci, usb_driver, usb_devclass, 0, 0);
+DRIVER_MODULE(usbus, ehci, usb_driver, usb_devclass, 0, 0);
+DRIVER_MODULE(usbus, at91_udp, usb_driver, usb_devclass, 0, 0);
+DRIVER_MODULE(usbus, uss820, usb_driver, usb_devclass, 0, 0);
 
 /*------------------------------------------------------------------------*
- *	usb2_probe
+ *	usb_probe
  *
  * This function is called from "{ehci,ohci,uhci}_pci_attach()".
  *------------------------------------------------------------------------*/
 static int
-usb2_probe(device_t dev)
+usb_probe(device_t dev)
 {
 	DPRINTF("\n");
 	return (0);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_attach
+ *	usb_attach
  *------------------------------------------------------------------------*/
 static int
-usb2_attach(device_t dev)
+usb_attach(device_t dev)
 {
 	struct usb_bus *bus = device_get_ivars(dev);
 
@@ -116,20 +116,20 @@ usb2_attach(device_t dev)
 	/* delay vfs_mountroot until the bus is explored */
 	bus->bus_roothold = root_mount_hold(device_get_nameunit(dev));
 
-	if (usb2_post_init_called) {
+	if (usb_post_init_called) {
 		mtx_lock(&Giant);
-		usb2_attach_sub(dev, bus);
+		usb_attach_sub(dev, bus);
 		mtx_unlock(&Giant);
-		usb2_needs_explore(bus, 1);
+		usb_needs_explore(bus, 1);
 	}
 	return (0);			/* return success */
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_detach
+ *	usb_detach
  *------------------------------------------------------------------------*/
 static int
-usb2_detach(device_t dev)
+usb_detach(device_t dev)
 {
 	struct usb_bus *bus = device_get_softc(dev);
 
@@ -140,7 +140,7 @@ usb2_detach(device_t dev)
 		return (0);
 	}
 	/* Stop power watchdog */
-	usb2_callout_drain(&bus->power_wdog);
+	usb_callout_drain(&bus->power_wdog);
 
 	/* Let the USB explore process detach all devices. */
 	if (bus->bus_roothold != NULL) {
@@ -149,40 +149,40 @@ usb2_detach(device_t dev)
 	}
 
 	USB_BUS_LOCK(bus);
-	if (usb2_proc_msignal(&bus->explore_proc,
+	if (usb_proc_msignal(&bus->explore_proc,
 	    &bus->detach_msg[0], &bus->detach_msg[1])) {
 		/* ignore */
 	}
 	/* Wait for detach to complete */
 
-	usb2_proc_mwait(&bus->explore_proc,
+	usb_proc_mwait(&bus->explore_proc,
 	    &bus->detach_msg[0], &bus->detach_msg[1]);
 
 	USB_BUS_UNLOCK(bus);
 
 	/* Get rid of USB callback processes */
 
-	usb2_proc_free(&bus->giant_callback_proc);
-	usb2_proc_free(&bus->non_giant_callback_proc);
+	usb_proc_free(&bus->giant_callback_proc);
+	usb_proc_free(&bus->non_giant_callback_proc);
 
 	/* Get rid of USB explore process */
 
-	usb2_proc_free(&bus->explore_proc);
+	usb_proc_free(&bus->explore_proc);
 
 	/* Get rid of control transfer process */
 
-	usb2_proc_free(&bus->control_xfer_proc);
+	usb_proc_free(&bus->control_xfer_proc);
 
 	return (0);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_explore
+ *	usb_bus_explore
  *
  * This function is used to explore the device tree from the root.
  *------------------------------------------------------------------------*/
 static void
-usb2_bus_explore(struct usb_proc_msg *pm)
+usb_bus_explore(struct usb_proc_msg *pm)
 {
 	struct usb_bus *bus;
 	struct usb_device *udev;
@@ -207,7 +207,7 @@ usb2_bus_explore(struct usb_proc_msg *pm)
 		/*
 		 * First update the USB power state!
 		 */
-		usb2_bus_powerd(bus);
+		usb_bus_powerd(bus);
 		/*
 		 * Explore the Root USB HUB. This call can sleep,
 		 * exiting Giant, which is actually Giant.
@@ -225,12 +225,12 @@ usb2_bus_explore(struct usb_proc_msg *pm)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_detach
+ *	usb_bus_detach
  *
  * This function is used to detach the device tree from the root.
  *------------------------------------------------------------------------*/
 static void
-usb2_bus_detach(struct usb_proc_msg *pm)
+usb_bus_detach(struct usb_proc_msg *pm)
 {
 	struct usb_bus *bus;
 	struct usb_device *udev;
@@ -252,7 +252,7 @@ usb2_bus_detach(struct usb_proc_msg *pm)
 	 * Free USB Root device, but not any sub-devices, hence they
 	 * are freed by the caller of this function:
 	 */
-	usb2_free_device(udev,
+	usb_free_device(udev,
 	    USB_UNCFG_FLAG_FREE_EP0);
 
 	mtx_unlock(&Giant);
@@ -262,29 +262,29 @@ usb2_bus_detach(struct usb_proc_msg *pm)
 }
 
 static void
-usb2_power_wdog(void *arg)
+usb_power_wdog(void *arg)
 {
 	struct usb_bus *bus = arg;
 
 	USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
 
-	usb2_callout_reset(&bus->power_wdog,
-	    4 * hz, usb2_power_wdog, arg);
+	usb_callout_reset(&bus->power_wdog,
+	    4 * hz, usb_power_wdog, arg);
 
 	USB_BUS_UNLOCK(bus);
 
-	usb2_bus_power_update(bus);
+	usb_bus_power_update(bus);
 
 	USB_BUS_LOCK(bus);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_attach
+ *	usb_bus_attach
  *
  * This function attaches USB in context of the explore thread.
  *------------------------------------------------------------------------*/
 static void
-usb2_bus_attach(struct usb_proc_msg *pm)
+usb_bus_attach(struct usb_proc_msg *pm)
 {
 	struct usb_bus *bus;
 	struct usb_device *child;
@@ -342,10 +342,10 @@ usb2_bus_attach(struct usb_proc_msg *pm)
 
 	/* Allocate the Root USB device */
 
-	child = usb2_alloc_device(bus->bdev, bus, NULL, 0, 0, 1,
+	child = usb_alloc_device(bus->bdev, bus, NULL, 0, 0, 1,
 	    speed, USB_MODE_HOST);
 	if (child) {
-		err = usb2_probe_and_attach(child,
+		err = usb_probe_and_attach(child,
 		    USB_IFACE_INDEX_ANY);
 		if (!err) {
 			if ((bus->devices[USB_ROOT_HUB_ADDR] == NULL) ||
@@ -362,68 +362,68 @@ usb2_bus_attach(struct usb_proc_msg *pm)
 
 	if (err) {
 		device_printf(bus->bdev, "Root HUB problem, error=%s\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 	}
 
 	/* set softc - we are ready */
 	device_set_softc(dev, bus);
 
 	/* start watchdog */
-	usb2_power_wdog(bus);
+	usb_power_wdog(bus);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_attach_sub
+ *	usb_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.
+ * "usb_post_init". During hot-plug it is called directly from the
+ * "usb_attach()" method.
  *------------------------------------------------------------------------*/
 static void
-usb2_attach_sub(device_t dev, struct usb_bus *bus)
+usb_attach_sub(device_t dev, struct usb_bus *bus)
 {
 	const char *pname = device_get_nameunit(dev);
 
 	/* Initialise USB process messages */
-	bus->explore_msg[0].hdr.pm_callback = &usb2_bus_explore;
+	bus->explore_msg[0].hdr.pm_callback = &usb_bus_explore;
 	bus->explore_msg[0].bus = bus;
-	bus->explore_msg[1].hdr.pm_callback = &usb2_bus_explore;
+	bus->explore_msg[1].hdr.pm_callback = &usb_bus_explore;
 	bus->explore_msg[1].bus = bus;
 
-	bus->detach_msg[0].hdr.pm_callback = &usb2_bus_detach;
+	bus->detach_msg[0].hdr.pm_callback = &usb_bus_detach;
 	bus->detach_msg[0].bus = bus;
-	bus->detach_msg[1].hdr.pm_callback = &usb2_bus_detach;
+	bus->detach_msg[1].hdr.pm_callback = &usb_bus_detach;
 	bus->detach_msg[1].bus = bus;
 
-	bus->attach_msg[0].hdr.pm_callback = &usb2_bus_attach;
+	bus->attach_msg[0].hdr.pm_callback = &usb_bus_attach;
 	bus->attach_msg[0].bus = bus;
-	bus->attach_msg[1].hdr.pm_callback = &usb2_bus_attach;
+	bus->attach_msg[1].hdr.pm_callback = &usb_bus_attach;
 	bus->attach_msg[1].bus = bus;
 
 	/* Create USB explore and callback processes */
 
-	if (usb2_proc_create(&bus->giant_callback_proc,
+	if (usb_proc_create(&bus->giant_callback_proc,
 	    &bus->bus_mtx, pname, USB_PRI_MED)) {
 		printf("WARNING: Creation of USB Giant "
 		    "callback process failed.\n");
-	} else if (usb2_proc_create(&bus->non_giant_callback_proc,
+	} else if (usb_proc_create(&bus->non_giant_callback_proc,
 	    &bus->bus_mtx, pname, USB_PRI_HIGH)) {
 		printf("WARNING: Creation of USB non-Giant "
 		    "callback process failed.\n");
-	} else if (usb2_proc_create(&bus->explore_proc,
+	} else if (usb_proc_create(&bus->explore_proc,
 	    &bus->bus_mtx, pname, USB_PRI_MED)) {
 		printf("WARNING: Creation of USB explore "
 		    "process failed.\n");
-	} else if (usb2_proc_create(&bus->control_xfer_proc,
+	} else if (usb_proc_create(&bus->control_xfer_proc,
 	    &bus->bus_mtx, pname, USB_PRI_MED)) {
 		printf("WARNING: Creation of USB control transfer "
 		    "process failed.\n");
 	} else {
 		/* Get final attach going */
 		USB_BUS_LOCK(bus);
-		if (usb2_proc_msignal(&bus->explore_proc,
+		if (usb_proc_msignal(&bus->explore_proc,
 		    &bus->attach_msg[0], &bus->attach_msg[1])) {
 			/* ignore */
 		}
@@ -432,13 +432,13 @@ usb2_attach_sub(device_t dev, struct usb_bus *bus)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_post_init
+ *	usb_post_init
  *
  * This function is called to attach all USB busses that were found
  * during bootup.
  *------------------------------------------------------------------------*/
 static void
-usb2_post_init(void *arg)
+usb_post_init(void *arg)
 {
 	struct usb_bus *bus;
 	devclass_t dc;
@@ -448,9 +448,9 @@ usb2_post_init(void *arg)
 
 	mtx_lock(&Giant);
 
-	usb2_devclass_ptr = devclass_find("usbus");
+	usb_devclass_ptr = devclass_find("usbus");
 
-	dc = usb2_devclass_ptr;
+	dc = usb_devclass_ptr;
 	if (dc) {
 		max = devclass_get_maxunit(dc) + 1;
 		for (n = 0; n != max; n++) {
@@ -459,7 +459,7 @@ usb2_post_init(void *arg)
 				bus = device_get_ivars(dev);
 				if (bus) {
 					mtx_lock(&Giant);
-					usb2_attach_sub(dev, bus);
+					usb_attach_sub(dev, bus);
 					mtx_unlock(&Giant);
 				}
 			}
@@ -467,69 +467,69 @@ usb2_post_init(void *arg)
 	} else {
 		DPRINTFN(0, "no devclass\n");
 	}
-	usb2_post_init_called = 1;
+	usb_post_init_called = 1;
 
 	/* explore all USB busses in parallell */
 
-	usb2_needs_explore_all();
+	usb_needs_explore_all();
 
 	mtx_unlock(&Giant);
 }
 
-SYSINIT(usb2_post_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb2_post_init, NULL);
-SYSUNINIT(usb2_bus_unload, SI_SUB_KLD, SI_ORDER_ANY, usb2_bus_unload, NULL);
+SYSINIT(usb_post_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb_post_init, NULL);
+SYSUNINIT(usb_bus_unload, SI_SUB_KLD, SI_ORDER_ANY, usb_bus_unload, NULL);
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_mem_flush_all_cb
+ *	usb_bus_mem_flush_all_cb
  *------------------------------------------------------------------------*/
 #if USB_HAVE_BUSDMA
 static void
-usb2_bus_mem_flush_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
+usb_bus_mem_flush_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
     struct usb_page *pg, usb_size_t size, usb_size_t align)
 {
-	usb2_pc_cpu_flush(pc);
+	usb_pc_cpu_flush(pc);
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_mem_flush_all - factored out code
+ *	usb_bus_mem_flush_all - factored out code
  *------------------------------------------------------------------------*/
 #if USB_HAVE_BUSDMA
 void
-usb2_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb)
+usb_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb)
 {
 	if (cb) {
-		cb(bus, &usb2_bus_mem_flush_all_cb);
+		cb(bus, &usb_bus_mem_flush_all_cb);
 	}
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_mem_alloc_all_cb
+ *	usb_bus_mem_alloc_all_cb
  *------------------------------------------------------------------------*/
 #if USB_HAVE_BUSDMA
 static void
-usb2_bus_mem_alloc_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
+usb_bus_mem_alloc_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
     struct usb_page *pg, usb_size_t size, usb_size_t align)
 {
 	/* need to initialize the page cache */
 	pc->tag_parent = bus->dma_parent_tag;
 
-	if (usb2_pc_alloc_mem(pc, pg, size, align)) {
+	if (usb_pc_alloc_mem(pc, pg, size, align)) {
 		bus->alloc_failed = 1;
 	}
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_mem_alloc_all - factored out code
+ *	usb_bus_mem_alloc_all - factored out code
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat,
+usb_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat,
     usb_bus_mem_cb_t *cb)
 {
 	bus->alloc_failed = 0;
@@ -537,13 +537,13 @@ usb2_bus_mem_alloc_all(struct usb_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,
+	usb_callout_init_mtx(&bus->power_wdog,
 	    &bus->bus_mtx, 0);
 
 	TAILQ_INIT(&bus->intr_q.head);
 
 #if USB_HAVE_BUSDMA
-	usb2_dma_tag_setup(bus->dma_parent_tag, bus->dma_tags,
+	usb_dma_tag_setup(bus->dma_parent_tag, bus->dma_tags,
 	    dmat, &bus->bus_mtx, NULL, 32, USB_BUS_DMA_TAG_MAX);
 #endif
 	if ((bus->devices_max > USB_MAX_DEVICES) ||
@@ -555,38 +555,38 @@ usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat,
 	}
 #if USB_HAVE_BUSDMA
 	if (cb) {
-		cb(bus, &usb2_bus_mem_alloc_all_cb);
+		cb(bus, &usb_bus_mem_alloc_all_cb);
 	}
 #endif
 	if (bus->alloc_failed) {
-		usb2_bus_mem_free_all(bus, cb);
+		usb_bus_mem_free_all(bus, cb);
 	}
 	return (bus->alloc_failed);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_mem_free_all_cb
+ *	usb_bus_mem_free_all_cb
  *------------------------------------------------------------------------*/
 #if USB_HAVE_BUSDMA
 static void
-usb2_bus_mem_free_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
+usb_bus_mem_free_all_cb(struct usb_bus *bus, struct usb_page_cache *pc,
     struct usb_page *pg, usb_size_t size, usb_size_t align)
 {
-	usb2_pc_free_mem(pc);
+	usb_pc_free_mem(pc);
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_mem_free_all - factored out code
+ *	usb_bus_mem_free_all - factored out code
  *------------------------------------------------------------------------*/
 void
-usb2_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb)
+usb_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb)
 {
 #if USB_HAVE_BUSDMA
 	if (cb) {
-		cb(bus, &usb2_bus_mem_free_all_cb);
+		cb(bus, &usb_bus_mem_free_all_cb);
 	}
-	usb2_dma_tag_unsetup(bus->dma_parent_tag);
+	usb_dma_tag_unsetup(bus->dma_parent_tag);
 #endif
 
 	mtx_destroy(&bus->bus_mtx);
diff --git a/sys/dev/usb/controller/uss820dci.c b/sys/dev/usb/controller/uss820dci.c
index f3078d3..9f29bbf 100644
--- a/sys/dev/usb/controller/uss820dci.c
+++ b/sys/dev/usb/controller/uss820dci.c
@@ -303,7 +303,7 @@ uss820dci_setup_rx(struct uss820dci_td *td)
 	    USS820_RXCON, temp);
 
 	/* copy data into real buffer */
-	usb2_copy_in(td->pc, 0, &req, sizeof(req));
+	usbd_copy_in(td->pc, 0, &req, sizeof(req));
 
 	td->offset = sizeof(req);
 	td->remainder = 0;
@@ -446,7 +446,7 @@ repeat:
 		return (0);		/* we are complete */
 	}
 	while (count > 0) {
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -545,7 +545,7 @@ repeat:
 	count_copy = count;
 	while (count > 0) {
 
-		usb2_get_page(td->pc, td->offset, &buf_res);
+		usbd_get_page(td->pc, td->offset, &buf_res);
 
 		/* get correct length */
 		if (buf_res.length > count) {
@@ -830,7 +830,7 @@ uss820dci_setup_standard_chain(struct usb_xfer *xfer)
 
 	DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
 	    xfer->address, UE_GET_ADDR(xfer->endpointno),
-	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
+	    xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
 
 	temp.max_frame_size = xfer->max_frame_size;
 
@@ -1030,11 +1030,11 @@ uss820dci_start_standard_chain(struct usb_xfer *xfer)
 		uss820dci_intr_set(xfer, 1);
 
 		/* put transfer on interrupt queue */
-		usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
+		usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
 
 		/* start timeout, if any */
 		if (xfer->timeout != 0) {
-			usb2_transfer_timeout_ms(xfer,
+			usbd_transfer_timeout_ms(xfer,
 			    &uss820dci_timeout, xfer->timeout);
 		}
 	}
@@ -1179,7 +1179,7 @@ uss820dci_device_done(struct usb_xfer *xfer, usb_error_t error)
 		uss820dci_intr_set(xfer, 0);
 	}
 	/* dequeue transfer and start next transfer */
-	usb2_transfer_done(xfer, error);
+	usbd_transfer_done(xfer, error);
 }
 
 static void
@@ -1341,7 +1341,7 @@ uss820dci_init(struct uss820dci_softc *sc)
 	uss820dci_pull_down(sc);
 
 	/* wait 10ms for pulldown to stabilise */
-	usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
+	usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
 
 	/* check hardware revision */
 	temp = USS820_READ_1(sc, USS820_REV);
@@ -1676,7 +1676,7 @@ uss820dci_device_isoc_fs_enter(struct usb_xfer *xfer)
 	 * pre-compute when the isochronous transfer will be finished:
 	 */
 	xfer->isoc_time_complete =
-	    usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp +
+	    usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
 	    xfer->nframes;
 
 	/* compute frame number for next insertion */
@@ -2201,7 +2201,7 @@ uss820dci_xfer_setup(struct usb_setup_params *parm)
 	parm->hc_max_packet_count = 1;
 	parm->hc_max_frame_size = 0x500;
 
-	usb2_transfer_setup_sub(parm);
+	usbd_transfer_setup_sub(parm);
 
 	/*
 	 * compute maximum number of TDs
@@ -2228,7 +2228,7 @@ uss820dci_xfer_setup(struct usb_setup_params *parm)
 	}
 
 	/*
-	 * check if "usb2_transfer_setup_sub" set an error
+	 * check if "usbd_transfer_setup_sub" set an error
 	 */
 	if (parm->err) {
 		return;
diff --git a/sys/dev/usb/controller/uss820dci_atmelarm.c b/sys/dev/usb/controller/uss820dci_atmelarm.c
index 18b0eb3..f8988b8 100644
--- a/sys/dev/usb/controller/uss820dci_atmelarm.c
+++ b/sys/dev/usb/controller/uss820dci_atmelarm.c
@@ -137,7 +137,7 @@ uss820_atmelarm_attach(device_t dev)
 	sc->sc_bus.devices_max = USS820_MAX_DEVICES;
 
 	/* get all DMA memory */
-	if (usb2_bus_mem_alloc_all(&sc->sc_bus,
+	if (usb_bus_mem_alloc_all(&sc->sc_bus,
 	    USB_GET_DMA_TAG(dev), NULL)) {
 		return (ENOMEM);
 	}
@@ -227,7 +227,7 @@ uss820_atmelarm_detach(device_t dev)
 		    sc->sc_io_res);
 		sc->sc_io_res = NULL;
 	}
-	usb2_bus_mem_free_all(&sc->sc_bus, NULL);
+	usb_bus_mem_free_all(&sc->sc_bus, NULL);
 
 	return (0);
 }
diff --git a/sys/dev/usb/input/uhid.c b/sys/dev/usb/input/uhid.c
index ae5a63c..9390a69 100644
--- a/sys/dev/usb/input/uhid.c
+++ b/sys/dev/usb/input/uhid.c
@@ -159,7 +159,7 @@ uhid_intr_callback(struct usb_xfer *xfer)
 		DPRINTF("transferred!\n");
 
 		if (xfer->actlen >= sc->sc_isize) {
-			usb2_fifo_put_data(
+			usb_fifo_put_data(
 			    sc->sc_fifo.fp[USB_FIFO_RX],
 			    xfer->frbuffers,
 			    0, sc->sc_isize, 1);
@@ -171,10 +171,10 @@ uhid_intr_callback(struct usb_xfer *xfer)
 
 	case USB_ST_SETUP:
 re_submit:
-		if (usb2_fifo_put_bytes_max(
+		if (usb_fifo_put_bytes_max(
 		    sc->sc_fifo.fp[USB_FIFO_RX]) != 0) {
 			xfer->frlengths[0] = sc->sc_isize;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -227,14 +227,14 @@ uhid_write_callback(struct usb_xfer *xfer)
 		/* try to extract the ID byte */
 		if (sc->sc_oid) {
 
-			if (usb2_fifo_get_data(
+			if (usb_fifo_get_data(
 			    sc->sc_fifo.fp[USB_FIFO_TX],
 			    xfer->frbuffers,
 			    0, 1, &actlen, 0)) {
 				if (actlen != 1) {
 					goto tr_error;
 				}
-				usb2_copy_out(xfer->frbuffers, 0, &id, 1);
+				usbd_copy_out(xfer->frbuffers, 0, &id, 1);
 
 			} else {
 				return;
@@ -246,7 +246,7 @@ uhid_write_callback(struct usb_xfer *xfer)
 			id = 0;
 		}
 
-		if (usb2_fifo_get_data(
+		if (usb_fifo_get_data(
 		    sc->sc_fifo.fp[USB_FIFO_TX],
 		    xfer->frbuffers + 1,
 		    0, UHID_BSIZE, &actlen, 1)) {
@@ -257,19 +257,19 @@ uhid_write_callback(struct usb_xfer *xfer)
 			    (&req, sc->sc_iface_no,
 			    UHID_OUTPUT_REPORT, id, size);
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 			xfer->frlengths[0] = sizeof(req);
 			xfer->frlengths[1] = size;
 			xfer->nframes = xfer->frlengths[1] ? 2 : 1;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
 	default:
 tr_error:
 		/* bomb out */
-		usb2_fifo_get_data_error(sc->sc_fifo.fp[USB_FIFO_TX]);
+		usb_fifo_get_data_error(sc->sc_fifo.fp[USB_FIFO_TX]);
 		return;
 	}
 }
@@ -282,30 +282,30 @@ uhid_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_fifo_put_data(sc->sc_fifo.fp[USB_FIFO_RX], xfer->frbuffers,
+		usb_fifo_put_data(sc->sc_fifo.fp[USB_FIFO_RX], xfer->frbuffers,
 		    sizeof(req), sc->sc_isize, 1);
 		return;
 
 	case USB_ST_SETUP:
 
-		if (usb2_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) > 0) {
+		if (usb_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) > 0) {
 
 			uhid_fill_get_report
 			    (&req, sc->sc_iface_no, UHID_INPUT_REPORT,
 			    sc->sc_iid, sc->sc_isize);
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 			xfer->frlengths[0] = sizeof(req);
 			xfer->frlengths[1] = sc->sc_isize;
 			xfer->nframes = xfer->frlengths[1] ? 2 : 1;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
 	default:			/* Error */
 		/* bomb out */
-		usb2_fifo_put_data_error(sc->sc_fifo.fp[USB_FIFO_RX]);
+		usb_fifo_put_data_error(sc->sc_fifo.fp[USB_FIFO_RX]);
 		return;
 	}
 }
@@ -346,9 +346,9 @@ uhid_start_read(struct usb_fifo *fifo)
 	struct uhid_softc *sc = fifo->priv_sc0;
 
 	if (sc->sc_flags & UHID_FLAG_IMMED) {
-		usb2_transfer_start(sc->sc_xfer[UHID_CTRL_DT_RD]);
+		usbd_transfer_start(sc->sc_xfer[UHID_CTRL_DT_RD]);
 	} else {
-		usb2_transfer_start(sc->sc_xfer[UHID_INTR_DT_RD]);
+		usbd_transfer_start(sc->sc_xfer[UHID_INTR_DT_RD]);
 	}
 }
 
@@ -357,8 +357,8 @@ uhid_stop_read(struct usb_fifo *fifo)
 {
 	struct uhid_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_RD]);
-	usb2_transfer_stop(sc->sc_xfer[UHID_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UHID_INTR_DT_RD]);
 }
 
 static void
@@ -366,7 +366,7 @@ uhid_start_write(struct usb_fifo *fifo)
 {
 	struct uhid_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[UHID_CTRL_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UHID_CTRL_DT_WR]);
 }
 
 static void
@@ -374,7 +374,7 @@ uhid_stop_write(struct usb_fifo *fifo)
 {
 	struct uhid_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_WR]);
 }
 
 static int
@@ -393,7 +393,7 @@ uhid_get_report(struct uhid_softc *sc, uint8_t type,
 		}
 		free_data = 1;
 	}
-	err = usb2_req_get_report(sc->sc_udev, NULL, kern_data,
+	err = usbd_req_get_report(sc->sc_udev, NULL, kern_data,
 	    len, sc->sc_iface_index, type, id);
 	if (err) {
 		err = ENXIO;
@@ -433,7 +433,7 @@ uhid_set_report(struct uhid_softc *sc, uint8_t type,
 			goto done;
 		}
 	}
-	err = usb2_req_set_report(sc->sc_udev, NULL, kern_data,
+	err = usbd_req_set_report(sc->sc_udev, NULL, kern_data,
 	    len, sc->sc_iface_index, type, id);
 	if (err) {
 		err = ENXIO;
@@ -459,13 +459,13 @@ uhid_open(struct usb_fifo *fifo, int fflags)
 		/* reset flags */
 		sc->sc_flags &= ~UHID_FLAG_IMMED;
 
-		if (usb2_fifo_alloc_buffer(fifo,
+		if (usb_fifo_alloc_buffer(fifo,
 		    sc->sc_isize + 1, UHID_FRAME_NUM)) {
 			return (ENOMEM);
 		}
 	}
 	if (fflags & FWRITE) {
-		if (usb2_fifo_alloc_buffer(fifo,
+		if (usb_fifo_alloc_buffer(fifo,
 		    sc->sc_osize + 1, UHID_FRAME_NUM)) {
 			return (ENOMEM);
 		}
@@ -477,7 +477,7 @@ static void
 uhid_close(struct usb_fifo *fifo, int fflags)
 {
 	if (fflags & (FREAD | FWRITE)) {
-		usb2_fifo_free_buffer(fifo);
+		usb_fifo_free_buffer(fifo);
 	}
 }
 
@@ -616,7 +616,7 @@ uhid_probe(device_t dev)
 			return (ENXIO);
 		}
 	}
-	if (usb2_test_quirk(uaa, UQ_HID_IGNORE)) {
+	if (usb_test_quirk(uaa, UQ_HID_IGNORE)) {
 		return (ENXIO);
 	}
 	return (0);
@@ -632,7 +632,7 @@ uhid_attach(device_t dev)
 
 	DPRINTFN(10, "sc=%p\n", sc);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, "uhid lock", NULL, MTX_DEF | MTX_RECURSE);
 
@@ -641,12 +641,12 @@ uhid_attach(device_t dev)
 	sc->sc_iface_no = uaa->info.bIfaceNum;
 	sc->sc_iface_index = uaa->info.bIfaceIndex;
 
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &uaa->info.bIfaceIndex, sc->sc_xfer, uhid_config,
 	    UHID_N_TRANSFER, sc, &sc->sc_mtx);
 
 	if (error) {
-		DPRINTF("error=%s\n", usb2_errstr(error));
+		DPRINTF("error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 	if (uaa->info.idVendor == USB_VENDOR_WACOM) {
@@ -668,13 +668,13 @@ uhid_attach(device_t dev)
 			 * feature report ID 2 before it'll start
 			 * returning digitizer data.
 			 */
-			error = usb2_req_set_report(uaa->device, NULL,
+			error = usbd_req_set_report(uaa->device, NULL,
 			    reportbuf, sizeof(reportbuf),
 			    uaa->info.bIfaceIndex, UHID_FEATURE_REPORT, 2);
 
 			if (error) {
 				DPRINTF("set report failed, error=%s (ignored)\n",
-				    usb2_errstr(error));
+				    usbd_errstr(error));
 			}
 			sc->sc_repdesc_size = sizeof(uhid_graphire3_4x5_report_descr);
 			sc->sc_repdesc_ptr = USB_ADD_BYTES(uhid_graphire3_4x5_report_descr, 0);
@@ -691,7 +691,7 @@ uhid_attach(device_t dev)
 	}
 	if (sc->sc_repdesc_ptr == NULL) {
 
-		error = usb2_req_get_hid_desc(uaa->device, NULL,
+		error = usbd_req_get_hid_desc(uaa->device, NULL,
 		    &sc->sc_repdesc_ptr, &sc->sc_repdesc_size,
 		    M_USBDEV, uaa->info.bIfaceIndex);
 
@@ -700,12 +700,12 @@ uhid_attach(device_t dev)
 			goto detach;
 		}
 	}
-	error = usb2_req_set_idle(uaa->device, NULL,
+	error = usbd_req_set_idle(uaa->device, NULL,
 	    uaa->info.bIfaceIndex, 0, 0);
 
 	if (error) {
 		DPRINTF("set idle failed, error=%s (ignored)\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 	sc->sc_isize = hid_report_size
 	    (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_input, &sc->sc_iid);
@@ -735,7 +735,7 @@ uhid_attach(device_t dev)
 		sc->sc_fsize = UHID_BSIZE;
 	}
 
-	error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx,
+	error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 	    &uhid_fifo_methods, &sc->sc_fifo,
 	    unit, 0 - 1, uaa->info.bIfaceIndex,
 	    UID_ROOT, GID_OPERATOR, 0644);
@@ -754,9 +754,9 @@ uhid_detach(device_t dev)
 {
 	struct uhid_softc *sc = device_get_softc(dev);
 
-	usb2_fifo_detach(&sc->sc_fifo);
+	usb_fifo_detach(&sc->sc_fifo);
 
-	usb2_transfer_unsetup(sc->sc_xfer, UHID_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, UHID_N_TRANSFER);
 
 	if (sc->sc_repdesc_ptr) {
 		if (!(sc->sc_flags & UHID_FLAG_STATIC_DESC)) {
diff --git a/sys/dev/usb/input/ukbd.c b/sys/dev/usb/input/ukbd.c
index 52b2176..52062fc 100644
--- a/sys/dev/usb/input/ukbd.c
+++ b/sys/dev/usb/input/ukbd.c
@@ -297,14 +297,14 @@ ukbd_get_key(struct ukbd_softc *sc, uint8_t wait)
 
 	if (sc->sc_inputs == 0) {
 		/* start transfer, if not already started */
-		usb2_transfer_start(sc->sc_xfer[UKBD_INTR_DT]);
+		usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]);
 	}
 	if (sc->sc_flags & UKBD_FLAG_POLLING) {
 		DPRINTFN(2, "polling\n");
 
 		while (sc->sc_inputs == 0) {
 
-			usb2_do_poll(sc->sc_xfer, UKBD_N_TRANSFER);
+			usbd_do_poll(sc->sc_xfer, UKBD_N_TRANSFER);
 
 			DELAY(1000);	/* delay 1 ms */
 
@@ -454,7 +454,7 @@ ukbd_timeout(void *arg)
 	}
 	ukbd_interrupt(sc);
 
-	usb2_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc);
+	usb_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc);
 }
 
 static uint8_t
@@ -501,7 +501,7 @@ ukbd_intr_callback(struct usb_xfer *xfer)
 
 		if (sc->sc_kbd_id != 0) {
 			/* check and remove HID ID byte */
-			usb2_copy_out(xfer->frbuffers, 0, &id, 1);
+			usbd_copy_out(xfer->frbuffers, 0, &id, 1);
 			if (id != sc->sc_kbd_id) {
 				DPRINTF("wrong HID ID\n");
 				goto tr_setup;
@@ -518,7 +518,7 @@ ukbd_intr_callback(struct usb_xfer *xfer)
 
 		if (len) {
 			memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata));
-			usb2_copy_out(xfer->frbuffers, offset, 
+			usbd_copy_out(xfer->frbuffers, offset, 
 			    &sc->sc_ndata, len);
 
 			if ((sc->sc_flags & UKBD_FLAG_APPLE_EJECT) &&
@@ -568,14 +568,14 @@ ukbd_intr_callback(struct usb_xfer *xfer)
 tr_setup:
 		if (sc->sc_inputs < UKBD_IN_BUF_FULL) {
 			xfer->frlengths[0] = xfer->max_data_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		} else {
 			DPRINTF("input queue is full!\n");
 		}
 		break;
 
 	default:			/* Error */
-		DPRINTF("error=%s\n", usb2_errstr(xfer->error));
+		DPRINTF("error=%s\n", usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -617,18 +617,18 @@ ukbd_set_leds_callback(struct usb_xfer *xfer)
 				buf[1] = 0;
 			}
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
-			usb2_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf));
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf));
 
 			xfer->frlengths[0] = sizeof(req);
 			xfer->frlengths[1] = req.wLength[0];
 			xfer->nframes = 2;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
 	default:			/* Error */
-		DPRINTFN(0, "error=%s\n", usb2_errstr(xfer->error));
+		DPRINTFN(0, "error=%s\n", usbd_errstr(xfer->error));
 		return;
 	}
 }
@@ -677,13 +677,13 @@ ukbd_probe(device_t dev)
 
 	if ((uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) &&
 	    (uaa->info.bInterfaceProtocol == UPROTO_BOOT_KEYBOARD)) {
-		if (usb2_test_quirk(uaa, UQ_KBD_IGNORE))
+		if (usb_test_quirk(uaa, UQ_KBD_IGNORE))
 			return (ENXIO);
 		else
 			return (0);
 	}
 
-	error = usb2_req_get_hid_desc(uaa->device, NULL,
+	error = usbd_req_get_hid_desc(uaa->device, NULL,
 	    &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex);
 
 	if (error)
@@ -691,7 +691,7 @@ ukbd_probe(device_t dev)
 
 	if (hid_is_collection(d_ptr, d_len,
 	    HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD))) {
-		if (usb2_test_quirk(uaa, UQ_KBD_IGNORE))
+		if (usb_test_quirk(uaa, UQ_KBD_IGNORE))
 			error = ENXIO;
 		else
 			error = 0;
@@ -721,7 +721,7 @@ ukbd_attach(device_t dev)
 
 	kbd->kb_data = (void *)sc;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	sc->sc_udev = uaa->device;
 	sc->sc_iface = uaa->iface;
@@ -729,14 +729,14 @@ ukbd_attach(device_t dev)
 	sc->sc_iface_no = uaa->info.bIfaceNum;
 	sc->sc_mode = K_XLATE;
 
-	usb2_callout_init_mtx(&sc->sc_callout, &Giant, 0);
+	usb_callout_init_mtx(&sc->sc_callout, &Giant, 0);
 
-	err = usb2_transfer_setup(uaa->device,
+	err = usbd_transfer_setup(uaa->device,
 	    &uaa->info.bIfaceIndex, sc->sc_xfer, ukbd_config,
 	    UKBD_N_TRANSFER, sc, &Giant);
 
 	if (err) {
-		DPRINTF("error=%s\n", usb2_errstr(err));
+		DPRINTF("error=%s\n", usbd_errstr(err));
 		goto detach;
 	}
 	/* setup default keyboard maps */
@@ -761,7 +761,7 @@ ukbd_attach(device_t dev)
 	KBD_PROBE_DONE(kbd);
 
 	/* figure out if there is an ID byte in the data */
-	err = usb2_req_get_hid_desc(uaa->device, NULL, &hid_ptr,
+	err = usbd_req_get_hid_desc(uaa->device, NULL, &hid_ptr,
 	    &hid_len, M_TEMP, uaa->info.bIfaceIndex);
 	if (err == 0) {
 		uint8_t temp_id;
@@ -801,7 +801,7 @@ ukbd_attach(device_t dev)
 	}
 
 	/* ignore if SETIDLE fails, hence it is not crucial */
-	err = usb2_req_set_idle(sc->sc_udev, &Giant, sc->sc_iface_index, 0, 0);
+	err = usbd_req_set_idle(sc->sc_udev, &Giant, sc->sc_iface_index, 0, 0);
 
 	ukbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state);
 
@@ -830,7 +830,7 @@ ukbd_attach(device_t dev)
 
 	/* start the keyboard */
 
-	usb2_transfer_start(sc->sc_xfer[UKBD_INTR_DT]);
+	usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]);
 
 	/* start the timer */
 
@@ -858,7 +858,7 @@ ukbd_detach(device_t dev)
 	}
 	sc->sc_flags |= UKBD_FLAG_GONE;
 
-	usb2_callout_stop(&sc->sc_callout);
+	usb_callout_stop(&sc->sc_callout);
 
 	ukbd_disable(&sc->sc_kbd);
 
@@ -882,9 +882,9 @@ ukbd_detach(device_t dev)
 	}
 	sc->sc_kbd.kb_flags = 0;
 
-	usb2_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER);
 
-	usb2_callout_drain(&sc->sc_callout);
+	usb_callout_drain(&sc->sc_callout);
 
 	DPRINTF("%s: disconnected\n",
 	    device_get_nameunit(dev));
@@ -1492,7 +1492,7 @@ ukbd_set_leds(struct ukbd_softc *sc, uint8_t leds)
 
 	/* start transfer, if not already started */
 
-	usb2_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]);
+	usbd_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]);
 }
 
 static int
diff --git a/sys/dev/usb/input/ums.c b/sys/dev/usb/input/ums.c
index cf8ef5f..4eff1f2 100644
--- a/sys/dev/usb/input/ums.c
+++ b/sys/dev/usb/input/ums.c
@@ -197,7 +197,7 @@ ums_intr_callback(struct usb_xfer *xfer)
 		if (len == 0)
 			goto tr_setup;
 
-		usb2_copy_out(xfer->frbuffers, 0, buf, len);
+		usbd_copy_out(xfer->frbuffers, 0, buf, len);
 
 		DPRINTFN(6, "data = %02x %02x %02x %02x "
 		    "%02x %02x %02x %02x\n",
@@ -287,11 +287,11 @@ ums_intr_callback(struct usb_xfer *xfer)
 			    (dx == 0) && (dy == 0) && (dz == 0) && (dt == 0) &&
 			    (dw == 0) && (buttons == 0)) {
 
-				usb2_callout_reset(&sc->sc_callout, hz / 20,
+				usb_callout_reset(&sc->sc_callout, hz / 20,
 				    &ums_put_queue_timeout, sc);
 			} else {
 
-				usb2_callout_stop(&sc->sc_callout);
+				usb_callout_stop(&sc->sc_callout);
 
 				ums_put_queue(sc, dx, dy, dz, dt, buttons);
 			}
@@ -299,10 +299,10 @@ ums_intr_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 tr_setup:
 		/* check if we can put more data into the FIFO */
-		if (usb2_fifo_put_bytes_max(
+		if (usb_fifo_put_bytes_max(
 		    sc->sc_fifo.fp[USB_FIFO_RX]) != 0) {
 			xfer->frlengths[0] = xfer->max_data_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
@@ -348,7 +348,7 @@ ums_probe(device_t dev)
 	    (uaa->info.bInterfaceProtocol == UIPROTO_MOUSE))
 		return (0);
 
-	error = usb2_req_get_hid_desc(uaa->device, NULL,
+	error = usbd_req_get_hid_desc(uaa->device, NULL,
 	    &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex);
 
 	if (error)
@@ -476,11 +476,11 @@ ums_attach(device_t dev)
 
 	DPRINTFN(11, "sc=%p\n", sc);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, "ums lock", NULL, MTX_DEF | MTX_RECURSE);
 
-	usb2_callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0);
+	usb_callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0);
 
 	/*
          * Force the report (non-boot) protocol.
@@ -488,18 +488,18 @@ ums_attach(device_t dev)
          * Mice without boot protocol support may choose not to implement
          * Set_Protocol at all; Ignore any error.
          */
-	err = usb2_req_set_protocol(uaa->device, NULL,
+	err = usbd_req_set_protocol(uaa->device, NULL,
 	    uaa->info.bIfaceIndex, 1);
 
-	err = usb2_transfer_setup(uaa->device,
+	err = usbd_transfer_setup(uaa->device,
 	    &uaa->info.bIfaceIndex, sc->sc_xfer, ums_config,
 	    UMS_N_TRANSFER, sc, &sc->sc_mtx);
 
 	if (err) {
-		DPRINTF("error=%s\n", usb2_errstr(err));
+		DPRINTF("error=%s\n", usbd_errstr(err));
 		goto detach;
 	}
-	err = usb2_req_get_hid_desc(uaa->device, NULL, &d_ptr,
+	err = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
 	    &d_len, M_TEMP, uaa->info.bIfaceIndex);
 
 	if (err) {
@@ -515,7 +515,7 @@ ums_attach(device_t dev)
 	 * all of its other button positions are all off. It also reports that
 	 * it has two addional buttons and a tilt wheel.
 	 */
-	if (usb2_test_quirk(uaa, UQ_MS_BAD_CLASS)) {
+	if (usb_test_quirk(uaa, UQ_MS_BAD_CLASS)) {
 		info = &sc->sc_info[0];
 		info->sc_flags = (UMS_FLAG_X_AXIS |
 		    UMS_FLAG_Y_AXIS |
@@ -542,7 +542,7 @@ ums_attach(device_t dev)
 		}
 	}
 
-	if (usb2_test_quirk(uaa, UQ_MS_REVZ)) {
+	if (usb_test_quirk(uaa, UQ_MS_REVZ)) {
 		info = &sc->sc_info[0];
 		/* Some wheels need the Z axis reversed. */
 		info->sc_flags |= UMS_FLAG_REVZ;
@@ -599,7 +599,7 @@ ums_attach(device_t dev)
 	sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
 	sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
 
-	err = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx,
+	err = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 	    &ums_fifo_methods, &sc->sc_fifo,
 	    device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex,
   	    UID_ROOT, GID_OPERATOR, 0644);
@@ -623,11 +623,11 @@ ums_detach(device_t self)
 
 	DPRINTF("sc=%p\n", sc);
 
-	usb2_fifo_detach(&sc->sc_fifo);
+	usb_fifo_detach(&sc->sc_fifo);
 
-	usb2_transfer_unsetup(sc->sc_xfer, UMS_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, UMS_N_TRANSFER);
 
-	usb2_callout_drain(&sc->sc_callout);
+	usb_callout_drain(&sc->sc_callout);
 
 	mtx_destroy(&sc->sc_mtx);
 
@@ -639,7 +639,7 @@ ums_start_read(struct usb_fifo *fifo)
 {
 	struct ums_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[UMS_INTR_DT]);
+	usbd_transfer_start(sc->sc_xfer[UMS_INTR_DT]);
 }
 
 static void
@@ -647,8 +647,8 @@ ums_stop_read(struct usb_fifo *fifo)
 {
 	struct ums_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[UMS_INTR_DT]);
-	usb2_callout_stop(&sc->sc_callout);
+	usbd_transfer_stop(sc->sc_xfer[UMS_INTR_DT]);
+	usb_callout_stop(&sc->sc_callout);
 }
 
 
@@ -694,7 +694,7 @@ ums_put_queue(struct ums_softc *sc, int32_t dx, int32_t dy,
 			buf[6] = dz - (dz >> 1);
 			buf[7] = (((~buttons) >> 3) & MOUSE_SYS_EXTBUTTONS);
 		}
-		usb2_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf,
+		usb_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf,
 		    sc->sc_mode.packetsize, 1);
 
 	} else {
@@ -706,7 +706,7 @@ static void
 ums_reset_buf(struct ums_softc *sc)
 {
 	/* reset read queue */
-	usb2_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]);
+	usb_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]);
 }
 
 static int
@@ -728,7 +728,7 @@ ums_open(struct usb_fifo *fifo, int fflags)
 		sc->sc_status.dz = 0;
 		/* sc->sc_status.dt = 0; */
 
-		if (usb2_fifo_alloc_buffer(fifo,
+		if (usb_fifo_alloc_buffer(fifo,
 		    UMS_BUF_SIZE, UMS_IFQ_MAXLEN)) {
 			return (ENOMEM);
 		}
@@ -740,7 +740,7 @@ static void
 ums_close(struct usb_fifo *fifo, int fflags)
 {
 	if (fflags & FREAD) {
-		usb2_fifo_free_buffer(fifo);
+		usb_fifo_free_buffer(fifo);
 	}
 }
 
diff --git a/sys/dev/usb/misc/udbp.c b/sys/dev/usb/misc/udbp.c
index b17f587..e856296c 100644
--- a/sys/dev/usb/misc/udbp.c
+++ b/sys/dev/usb/misc/udbp.c
@@ -317,17 +317,17 @@ udbp_attach(device_t dev)
 	struct udbp_softc *sc = device_get_softc(dev);
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	snprintf(sc->sc_name, sizeof(sc->sc_name),
 	    "%s", device_get_nameunit(dev));
 
 	mtx_init(&sc->sc_mtx, "udbp lock", NULL, MTX_DEF | MTX_RECURSE);
 
-	error = usb2_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
+	error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
 	    sc->sc_xfer, udbp_config, UDBP_T_MAX, sc, &sc->sc_mtx);
 	if (error) {
-		DPRINTF("error=%s\n", usb2_errstr(error));
+		DPRINTF("error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 	NG_BT_MBUFQ_INIT(&sc->sc_xmitq, UDBP_Q_MAXLEN);
@@ -376,7 +376,7 @@ udbp_detach(device_t dev)
 	}
 	/* free USB transfers, if any */
 
-	usb2_transfer_unsetup(sc->sc_xfer, UDBP_T_MAX);
+	usbd_transfer_unsetup(sc->sc_xfer, UDBP_T_MAX);
 
 	mtx_destroy(&sc->sc_mtx);
 
@@ -418,7 +418,7 @@ udbp_bulk_read_callback(struct usb_xfer *xfer)
 		}
 		m->m_pkthdr.len = m->m_len = xfer->actlen;
 
-		usb2_copy_out(xfer->frbuffers, 0, m->m_data, xfer->actlen);
+		usbd_copy_out(xfer->frbuffers, 0, m->m_data, xfer->actlen);
 
 		sc->sc_bulk_in_buffer = m;
 
@@ -432,18 +432,18 @@ tr_setup:
 			return;
 		}
 		if (sc->sc_flags & UDBP_FLAG_READ_STALL) {
-			usb2_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]);
+			usbd_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]);
 			return;
 		}
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
 			sc->sc_flags |= UDBP_FLAG_READ_STALL;
-			usb2_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]);
+			usbd_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]);
 		}
 		return;
 
@@ -456,10 +456,10 @@ udbp_bulk_read_clear_stall_callback(struct usb_xfer *xfer)
 	struct udbp_softc *sc = xfer->priv_sc;
 	struct usb_xfer *xfer_other = sc->sc_xfer[UDBP_T_RD];
 
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTF("stall cleared\n");
 		sc->sc_flags &= ~UDBP_FLAG_READ_STALL;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -498,7 +498,7 @@ done:
 	}
 	/* start USB bulk-in transfer, if not already started */
 
-	usb2_transfer_start(sc->sc_xfer[UDBP_T_RD]);
+	usbd_transfer_start(sc->sc_xfer[UDBP_T_RD]);
 
 	mtx_unlock(&sc->sc_mtx);
 }
@@ -516,7 +516,7 @@ udbp_bulk_write_callback(struct usb_xfer *xfer)
 
 	case USB_ST_SETUP:
 		if (sc->sc_flags & UDBP_FLAG_WRITE_STALL) {
-			usb2_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]);
+			usbd_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]);
 			return;
 		}
 		/* get next mbuf, if any */
@@ -535,7 +535,7 @@ udbp_bulk_write_callback(struct usb_xfer *xfer)
 			    MCLBYTES);
 			m->m_pkthdr.len = MCLBYTES;
 		}
-		usb2_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len);
+		usbd_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len);
 
 		xfer->frlengths[0] = m->m_pkthdr.len;
 
@@ -544,14 +544,14 @@ udbp_bulk_write_callback(struct usb_xfer *xfer)
 		DPRINTF("packet out: %d bytes\n",
 		    xfer->frlengths[0]);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
 			sc->sc_flags |= UDBP_FLAG_WRITE_STALL;
-			usb2_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]);
+			usbd_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]);
 		}
 		return;
 
@@ -564,10 +564,10 @@ udbp_bulk_write_clear_stall_callback(struct usb_xfer *xfer)
 	struct udbp_softc *sc = xfer->priv_sc;
 	struct usb_xfer *xfer_other = sc->sc_xfer[UDBP_T_WR];
 
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTF("stall cleared\n");
 		sc->sc_flags &= ~UDBP_FLAG_WRITE_STALL;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -725,7 +725,7 @@ ng_udbp_rcvdata(hook_p hook, item_p item)
 		/*
 		 * start bulk-out transfer, if not already started:
 		 */
-		usb2_transfer_start(sc->sc_xfer[UDBP_T_WR]);
+		usbd_transfer_start(sc->sc_xfer[UDBP_T_WR]);
 		error = 0;
 	}
 
@@ -793,10 +793,10 @@ ng_udbp_connect(hook_p hook)
 	    UDBP_FLAG_WRITE_STALL);
 
 	/* start bulk-in transfer */
-	usb2_transfer_start(sc->sc_xfer[UDBP_T_RD]);
+	usbd_transfer_start(sc->sc_xfer[UDBP_T_RD]);
 
 	/* start bulk-out transfer */
-	usb2_transfer_start(sc->sc_xfer[UDBP_T_WR]);
+	usbd_transfer_start(sc->sc_xfer[UDBP_T_WR]);
 
 	mtx_unlock(&sc->sc_mtx);
 
@@ -823,12 +823,12 @@ ng_udbp_disconnect(hook_p hook)
 		} else {
 
 			/* stop bulk-in transfer */
-			usb2_transfer_stop(sc->sc_xfer[UDBP_T_RD_CS]);
-			usb2_transfer_stop(sc->sc_xfer[UDBP_T_RD]);
+			usbd_transfer_stop(sc->sc_xfer[UDBP_T_RD_CS]);
+			usbd_transfer_stop(sc->sc_xfer[UDBP_T_RD]);
 
 			/* stop bulk-out transfer */
-			usb2_transfer_stop(sc->sc_xfer[UDBP_T_WR_CS]);
-			usb2_transfer_stop(sc->sc_xfer[UDBP_T_WR]);
+			usbd_transfer_stop(sc->sc_xfer[UDBP_T_WR_CS]);
+			usbd_transfer_stop(sc->sc_xfer[UDBP_T_WR]);
 
 			/* cleanup queues */
 			NG_BT_MBUFQ_DRAIN(&sc->sc_xmitq);
diff --git a/sys/dev/usb/misc/ufm.c b/sys/dev/usb/misc/ufm.c
index 1a95702..d8e4a9e 100644
--- a/sys/dev/usb/misc/ufm.c
+++ b/sys/dev/usb/misc/ufm.c
@@ -38,7 +38,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_error.h>
 #include <dev/usb/ufm_ioctl.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -137,9 +137,9 @@ ufm_attach(device_t dev)
 
 	mtx_init(&sc->sc_mtx, "ufm lock", NULL, MTX_DEF | MTX_RECURSE);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
-	error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx,
+	error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 	    &ufm_fifo_methods, &sc->sc_fifo,
 	    device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex,
 	    UID_ROOT, GID_OPERATOR, 0644);
@@ -158,7 +158,7 @@ ufm_detach(device_t dev)
 {
 	struct ufm_softc *sc = device_get_softc(dev);
 
-	usb2_fifo_detach(&sc->sc_fifo);
+	usb_fifo_detach(&sc->sc_fifo);
 
 	mtx_destroy(&sc->sc_mtx);
 
@@ -189,7 +189,7 @@ ufm_do_req(struct ufm_softc *sc, uint8_t request,
 	USETW(req.wIndex, index);
 	USETW(req.wLength, 1);
 
-	error = usb2_do_request(sc->sc_udev, NULL, &req, buf);
+	error = usbd_do_request(sc->sc_udev, NULL, &req, buf);
 
 	if (retbuf) {
 		*retbuf = buf[0];
@@ -284,7 +284,7 @@ ufm_get_stat(struct ufm_softc *sc, void *addr)
 	 * Note, there's a 240ms settle time before the status
 	 * will be valid, so sleep that amount.
 	 */
-	usb2_pause_mtx(NULL, hz / 4);
+	usb_pause_mtx(NULL, hz / 4);
 
 	if (ufm_do_req(sc, UFM_CMD0,
 	    0x00, 0x24, &ret)) {
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_ */
diff --git a/sys/dev/usb/quirk/usb_quirk.c b/sys/dev/usb/quirk/usb_quirk.c
index fa7ab11..3228aa2 100644
--- a/sys/dev/usb/quirk/usb_quirk.c
+++ b/sys/dev/usb/quirk/usb_quirk.c
@@ -31,7 +31,7 @@
 #include <dev/usb/usb_mfunc.h>
 #include "usbdevs.h"
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_lookup.h>
@@ -52,7 +52,7 @@ MODULE_VERSION(usb_quirk, 1);
 #define	USB_DEV_QUIRKS_MAX 128
 #define	USB_SUB_QUIRKS_MAX 8
 
-struct usb2_quirk_entry {
+struct usb_quirk_entry {
 	uint16_t vid;
 	uint16_t pid;
 	uint16_t lo_rev;
@@ -60,9 +60,9 @@ struct usb2_quirk_entry {
 	uint16_t quirks[USB_SUB_QUIRKS_MAX];
 };
 
-static struct mtx usb2_quirk_mtx;
+static struct mtx usb_quirk_mtx;
 
-static struct usb2_quirk_entry usb2_quirks[USB_DEV_QUIRKS_MAX] = {
+static struct usb_quirk_entry usb_quirks[USB_DEV_QUIRKS_MAX] = {
 	{USB_QUIRK_ENTRY(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_LCM, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
 	{USB_QUIRK_ENTRY(USB_VENDOR_INSIDEOUT, USB_PRODUCT_INSIDEOUT_EDGEPORT4, 0x094, 0x094, UQ_SWAP_UNICODE, UQ_NONE)},
 	{USB_QUIRK_ENTRY(USB_VENDOR_DALLAS, USB_PRODUCT_DALLAS_J6502, 0x0a2, 0x0a2, UQ_BAD_ADC, UQ_NONE)},
@@ -137,26 +137,26 @@ static const char *usb_quirk_str[USB_QUIRK_MAX] = {
 };
 
 /*------------------------------------------------------------------------*
- *	usb2_quirkstr
+ *	usb_quirkstr
  *
  * This function converts an USB quirk code into a string.
  *------------------------------------------------------------------------*/
 static const char *
-usb2_quirkstr(uint16_t quirk)
+usb_quirkstr(uint16_t quirk)
 {
 	return ((quirk < USB_QUIRK_MAX) ?
 	    usb_quirk_str[quirk] : "USB_QUIRK_UNKNOWN");
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_test_quirk_by_info
+ *	usb_test_quirk_by_info
  *
  * Returns:
  * 0: Quirk not found
  * Else: Quirk found
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_test_quirk_by_info(const struct usb_lookup_info *info, uint16_t quirk)
+usb_test_quirk_by_info(const struct usbd_lookup_info *info, uint16_t quirk)
 {
 	uint16_t x;
 	uint16_t y;
@@ -164,53 +164,53 @@ usb2_test_quirk_by_info(const struct usb_lookup_info *info, uint16_t quirk)
 	if (quirk == UQ_NONE) {
 		return (0);
 	}
-	mtx_lock(&usb2_quirk_mtx);
+	mtx_lock(&usb_quirk_mtx);
 
 	for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
 		/* see if quirk information does not match */
-		if ((usb2_quirks[x].vid != info->idVendor) ||
-		    (usb2_quirks[x].pid != info->idProduct) ||
-		    (usb2_quirks[x].lo_rev > info->bcdDevice) ||
-		    (usb2_quirks[x].hi_rev < info->bcdDevice)) {
+		if ((usb_quirks[x].vid != info->idVendor) ||
+		    (usb_quirks[x].pid != info->idProduct) ||
+		    (usb_quirks[x].lo_rev > info->bcdDevice) ||
+		    (usb_quirks[x].hi_rev < info->bcdDevice)) {
 			continue;
 		}
 		/* lookup quirk */
 		for (y = 0; y != USB_SUB_QUIRKS_MAX; y++) {
-			if (usb2_quirks[x].quirks[y] == quirk) {
-				mtx_unlock(&usb2_quirk_mtx);
-				DPRINTF("Found quirk '%s'.\n", usb2_quirkstr(quirk));
+			if (usb_quirks[x].quirks[y] == quirk) {
+				mtx_unlock(&usb_quirk_mtx);
+				DPRINTF("Found quirk '%s'.\n", usb_quirkstr(quirk));
 				return (1);
 			}
 		}
 		/* no quirk found */
 		break;
 	}
-	mtx_unlock(&usb2_quirk_mtx);
+	mtx_unlock(&usb_quirk_mtx);
 	return (0);
 }
 
-static struct usb2_quirk_entry *
-usb2_quirk_get_entry(uint16_t vid, uint16_t pid,
+static struct usb_quirk_entry *
+usb_quirk_get_entry(uint16_t vid, uint16_t pid,
     uint16_t lo_rev, uint16_t hi_rev, uint8_t do_alloc)
 {
 	uint16_t x;
 
-	mtx_assert(&usb2_quirk_mtx, MA_OWNED);
+	mtx_assert(&usb_quirk_mtx, MA_OWNED);
 
 	if ((vid | pid | lo_rev | hi_rev) == 0) {
 		/* all zero - special case */
-		return (usb2_quirks + USB_DEV_QUIRKS_MAX - 1);
+		return (usb_quirks + USB_DEV_QUIRKS_MAX - 1);
 	}
 	/* search for an existing entry */
 	for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
 		/* see if quirk information does not match */
-		if ((usb2_quirks[x].vid != vid) ||
-		    (usb2_quirks[x].pid != pid) ||
-		    (usb2_quirks[x].lo_rev != lo_rev) ||
-		    (usb2_quirks[x].hi_rev != hi_rev)) {
+		if ((usb_quirks[x].vid != vid) ||
+		    (usb_quirks[x].pid != pid) ||
+		    (usb_quirks[x].lo_rev != lo_rev) ||
+		    (usb_quirks[x].hi_rev != hi_rev)) {
 			continue;
 		}
-		return (usb2_quirks + x);
+		return (usb_quirks + x);
 	}
 
 	if (do_alloc == 0) {
@@ -220,18 +220,18 @@ usb2_quirk_get_entry(uint16_t vid, uint16_t pid,
 	/* search for a free entry */
 	for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
 		/* see if quirk information does not match */
-		if ((usb2_quirks[x].vid |
-		    usb2_quirks[x].pid |
-		    usb2_quirks[x].lo_rev |
-		    usb2_quirks[x].hi_rev) != 0) {
+		if ((usb_quirks[x].vid |
+		    usb_quirks[x].pid |
+		    usb_quirks[x].lo_rev |
+		    usb_quirks[x].hi_rev) != 0) {
 			continue;
 		}
-		usb2_quirks[x].vid = vid;
-		usb2_quirks[x].pid = pid;
-		usb2_quirks[x].lo_rev = lo_rev;
-		usb2_quirks[x].hi_rev = hi_rev;
+		usb_quirks[x].vid = vid;
+		usb_quirks[x].pid = pid;
+		usb_quirks[x].lo_rev = lo_rev;
+		usb_quirks[x].hi_rev = hi_rev;
 
-		return (usb2_quirks + x);
+		return (usb_quirks + x);
 	}
 
 	/* no entry found */
@@ -239,18 +239,18 @@ usb2_quirk_get_entry(uint16_t vid, uint16_t pid,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_quirk_ioctl - handle quirk IOCTLs
+ *	usb_quirk_ioctl - handle quirk IOCTLs
  *
  * Returns:
  * 0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static int
-usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
+usb_quirk_ioctl(unsigned long cmd, caddr_t data,
     int fflag, struct thread *td)
 {
 	struct usb_gen_quirk *pgq;
-	struct usb2_quirk_entry *pqe;
+	struct usb_quirk_entry *pqe;
 	uint32_t x;
 	uint32_t y;
 	int err;
@@ -263,16 +263,16 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 		if (y >= USB_DEV_QUIRKS_MAX) {
 			return (EINVAL);
 		}
-		mtx_lock(&usb2_quirk_mtx);
+		mtx_lock(&usb_quirk_mtx);
 		/* copy out data */
-		pgq->vid = usb2_quirks[y].vid;
-		pgq->pid = usb2_quirks[y].pid;
-		pgq->bcdDeviceLow = usb2_quirks[y].lo_rev;
-		pgq->bcdDeviceHigh = usb2_quirks[y].hi_rev;
+		pgq->vid = usb_quirks[y].vid;
+		pgq->pid = usb_quirks[y].pid;
+		pgq->bcdDeviceLow = usb_quirks[y].lo_rev;
+		pgq->bcdDeviceHigh = usb_quirks[y].hi_rev;
 		strlcpy(pgq->quirkname,
-		    usb2_quirkstr(usb2_quirks[y].quirks[x]),
+		    usb_quirkstr(usb_quirks[y].quirks[x]),
 		    sizeof(pgq->quirkname));
-		mtx_unlock(&usb2_quirk_mtx);
+		mtx_unlock(&usb_quirk_mtx);
 		return (0);		/* success */
 
 	case USB_QUIRK_NAME_GET:
@@ -282,7 +282,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 			return (EINVAL);
 		}
 		strlcpy(pgq->quirkname,
-		    usb2_quirkstr(x), sizeof(pgq->quirkname));
+		    usb_quirkstr(x), sizeof(pgq->quirkname));
 		return (0);		/* success */
 
 	case USB_DEV_QUIRK_ADD:
@@ -295,7 +295,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 		}
 		/* convert quirk string into numerical */
 		for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) {
-			if (strcmp(pgq->quirkname, usb2_quirkstr(y)) == 0) {
+			if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) {
 				break;
 			}
 		}
@@ -305,8 +305,8 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 		if (y == UQ_NONE) {
 			return (EINVAL);
 		}
-		mtx_lock(&usb2_quirk_mtx);
-		pqe = usb2_quirk_get_entry(pgq->vid, pgq->pid,
+		mtx_lock(&usb_quirk_mtx);
+		pqe = usb_quirk_get_entry(pgq->vid, pgq->pid,
 		    pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 1);
 		for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
 			if (pqe->quirks[x] == UQ_NONE) {
@@ -314,7 +314,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 				break;
 			}
 		}
-		mtx_unlock(&usb2_quirk_mtx);
+		mtx_unlock(&usb_quirk_mtx);
 		if (x == USB_SUB_QUIRKS_MAX) {
 			return (ENOMEM);
 		}
@@ -329,7 +329,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 		}
 		/* convert quirk string into numerical */
 		for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) {
-			if (strcmp(pgq->quirkname, usb2_quirkstr(y)) == 0) {
+			if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) {
 				break;
 			}
 		}
@@ -339,8 +339,8 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 		if (y == UQ_NONE) {
 			return (EINVAL);
 		}
-		mtx_lock(&usb2_quirk_mtx);
-		pqe = usb2_quirk_get_entry(pgq->vid, pgq->pid,
+		mtx_lock(&usb_quirk_mtx);
+		pqe = usb_quirk_get_entry(pgq->vid, pgq->pid,
 		    pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 0);
 		for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
 			if (pqe->quirks[x] == y) {
@@ -349,7 +349,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 			}
 		}
 		if (x == USB_SUB_QUIRKS_MAX) {
-			mtx_unlock(&usb2_quirk_mtx);
+			mtx_unlock(&usb_quirk_mtx);
 			return (ENOMEM);
 		}
 		for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
@@ -361,7 +361,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 			/* all quirk entries are unused - release */
 			memset(pqe, 0, sizeof(pqe));
 		}
-		mtx_unlock(&usb2_quirk_mtx);
+		mtx_unlock(&usb_quirk_mtx);
 		return (0);		/* success */
 
 	default:
@@ -371,24 +371,24 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data,
 }
 
 static void
-usb2_quirk_init(void *arg)
+usb_quirk_init(void *arg)
 {
 	/* initialize mutex */
-	mtx_init(&usb2_quirk_mtx, "USB quirk", NULL, MTX_DEF);
+	mtx_init(&usb_quirk_mtx, "USB quirk", NULL, MTX_DEF);
 
 	/* register our function */
-	usb2_test_quirk_p = &usb2_test_quirk_by_info;
-	usb2_quirk_ioctl_p = &usb2_quirk_ioctl;
+	usb_test_quirk_p = &usb_test_quirk_by_info;
+	usb_quirk_ioctl_p = &usb_quirk_ioctl;
 }
 
 static void
-usb2_quirk_uninit(void *arg)
+usb_quirk_uninit(void *arg)
 {
-	usb2_quirk_unload(arg);
+	usb_quirk_unload(arg);
 
 	/* destroy mutex */
-	mtx_destroy(&usb2_quirk_mtx);
+	mtx_destroy(&usb_quirk_mtx);
 }
 
-SYSINIT(usb2_quirk_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb2_quirk_init, NULL);
-SYSUNINIT(usb2_quirk_uninit, SI_SUB_LOCK, SI_ORDER_ANY, usb2_quirk_uninit, NULL);
+SYSINIT(usb_quirk_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_quirk_init, NULL);
+SYSUNINIT(usb_quirk_uninit, SI_SUB_LOCK, SI_ORDER_ANY, usb_quirk_uninit, NULL);
diff --git a/sys/dev/usb/serial/u3g.c b/sys/dev/usb/serial/u3g.c
index 91190d4..fb25936 100644
--- a/sys/dev/usb/serial/u3g.c
+++ b/sys/dev/usb/serial/u3g.c
@@ -131,10 +131,10 @@ static const struct usb_config u3g_config[U3G_N_TRANSFER] = {
 };
 
 static const struct ucom_callback u3g_callback = {
-	.usb2_com_start_read = &u3g_start_read,
-	.usb2_com_stop_read = &u3g_stop_read,
-	.usb2_com_start_write = &u3g_start_write,
-	.usb2_com_stop_write = &u3g_stop_write,
+	.ucom_start_read = &u3g_start_read,
+	.ucom_stop_read = &u3g_stop_read,
+	.ucom_start_write = &u3g_start_write,
+	.ucom_stop_write = &u3g_stop_write,
 };
 
 static device_method_t u3g_methods[] = {
@@ -238,7 +238,7 @@ u3g_sierra_init(struct usb_device *udev)
 	USETW(req.wIndex, UHF_PORT_CONNECTION);
 	USETW(req.wLength, 0);
 
-	if (usb2_do_request_flags(udev, NULL, &req,
+	if (usbd_do_request_flags(udev, NULL, &req,
 	    NULL, 0, NULL, USB_MS_HZ)) {
 		/* ignore any errors */
 	}
@@ -258,7 +258,7 @@ u3g_huawei_init(struct usb_device *udev)
 	USETW(req.wIndex, UHF_PORT_SUSPEND);
 	USETW(req.wLength, 0);
 
-	if (usb2_do_request_flags(udev, NULL, &req,
+	if (usbd_do_request_flags(udev, NULL, &req,
 	    NULL, 0, NULL, USB_MS_HZ)) {
 		/* ignore any errors */
 	}
@@ -306,7 +306,7 @@ u3g_sael_m460_init(struct usb_device *udev)
 
 	DPRINTFN(1, "\n");
 
-	if (usb2_req_set_alt_interface_no(udev, NULL, 0, 0)) {
+	if (usbd_req_set_alt_interface_no(udev, NULL, 0, 0)) {
 		DPRINTFN(0, "Alt setting 0 failed\n");
 		return;
 	}
@@ -321,13 +321,13 @@ u3g_sael_m460_init(struct usb_device *udev)
 				DPRINTFN(0, "too small buffer\n");
 				continue;
 			}
-			err = usb2_do_request(udev, NULL, &req, buf);
+			err = usbd_do_request(udev, NULL, &req, buf);
 		} else {
 			if (len > (sizeof(setup[0]) - 8)) {
 				DPRINTFN(0, "too small buffer\n");
 				continue;
 			}
-			err = usb2_do_request(udev, NULL, &req, 
+			err = usbd_do_request(udev, NULL, &req, 
 			    __DECONST(uint8_t *, &setup[n][8]));
 		}
 		if (err) {
@@ -349,7 +349,7 @@ static int
 u3g_lookup_huawei(struct usb_attach_arg *uaa)
 {
 	/* Calling the lookup function will also set the driver info! */
-	return (usb2_lookup_id_by_uaa(u3g_devs, sizeof(u3g_devs), uaa));
+	return (usbd_lookup_id_by_uaa(u3g_devs, sizeof(u3g_devs), uaa));
 }
 
 /*
@@ -369,7 +369,7 @@ u3g_test_huawei_autoinst(struct usb_device *udev,
 	if (udev == NULL) {
 		return (USB_ERR_INVAL);
 	}
-	iface = usb2_get_iface(udev, 0);
+	iface = usbd_get_iface(udev, 0);
 	if (iface == NULL) {
 		return (USB_ERR_INVAL);
 	}
@@ -389,7 +389,7 @@ u3g_test_huawei_autoinst(struct usb_device *udev,
 	if (flags & U3GFL_HUAWEI_INIT) {
 		u3g_huawei_init(udev);
 	} else if (flags & U3GFL_SCSI_EJECT) {
-		return (usb2_test_autoinstall(udev, 0, 1));
+		return (usb_test_autoinstall(udev, 0, 1));
 	} else if (flags & U3GFL_SIERRA_INIT) {
 		u3g_sierra_init(udev);
 	} else {
@@ -405,10 +405,10 @@ u3g_driver_loaded(struct module *mod, int what, void *arg)
 	switch (what) {
 	case MOD_LOAD:
 		/* register our autoinstall handler */
-		usb2_test_huawei_autoinst_p = &u3g_test_huawei_autoinst;
+		usb_test_huawei_autoinst_p = &u3g_test_huawei_autoinst;
 		break;
 	case MOD_UNLOAD:
-		usb2_test_huawei_unload(NULL);
+		usb_test_huawei_unload(NULL);
 		break;
 	default:
 		return (EOPNOTSUPP);
@@ -457,7 +457,7 @@ u3g_attach(device_t dev)
 	for (n = 0; n != U3G_N_TRANSFER; n++) 
 		u3g_config_tmp[n] = u3g_config[n];
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "u3g", NULL, MTX_DEF);
 
 	sc->sc_udev = uaa->device;
@@ -465,13 +465,13 @@ u3g_attach(device_t dev)
 	/* Claim all interfaces on the device */
 	iface_valid = 0;
 	for (i = uaa->info.bIfaceIndex; i < USB_IFACE_MAX; i++) {
-		iface = usb2_get_iface(uaa->device, i);
+		iface = usbd_get_iface(uaa->device, i);
 		if (iface == NULL)
 			break;
-		id = usb2_get_interface_descriptor(iface);
+		id = usbd_get_interface_descriptor(iface);
 		if (id == NULL || id->bInterfaceClass != UICLASS_VENDOR)
 			continue;
-		usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
+		usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
 		iface_valid |= (1<<i);
 	}
 
@@ -489,7 +489,7 @@ u3g_attach(device_t dev)
 			u3g_config_tmp[n].ep_index = ep;
 
 		/* try to allocate a set of BULK endpoints */
-		error = usb2_transfer_setup(uaa->device, &i,
+		error = usbd_transfer_setup(uaa->device, &i,
 		    sc->sc_xfer[nports], u3g_config_tmp, U3G_N_TRANSFER,
 		    &sc->sc_ucom[nports], &sc->sc_mtx);
 		if (error) {
@@ -501,8 +501,8 @@ u3g_attach(device_t dev)
 
 		/* set stall by default */
 		mtx_lock(&sc->sc_mtx);
-		usb2_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_WR]);
-		usb2_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_RD]);
+		usbd_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_WR]);
+		usbd_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_RD]);
 		mtx_unlock(&sc->sc_mtx);
 
 		nports++;	/* found one port */
@@ -516,10 +516,10 @@ u3g_attach(device_t dev)
 	}
 	sc->sc_numports = nports;
 
-	error = usb2_com_attach(&sc->sc_super_ucom, sc->sc_ucom,
+	error = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom,
 	    sc->sc_numports, sc, &u3g_callback, &sc->sc_mtx);
 	if (error) {
-		DPRINTF("usb2_com_attach failed\n");
+		DPRINTF("ucom_attach failed\n");
 		goto detach;
 	}
 	if (sc->sc_numports > 1)
@@ -540,10 +540,10 @@ u3g_detach(device_t dev)
 	DPRINTF("sc=%p\n", sc);
 
 	/* NOTE: It is not dangerous to detach more ports than attached! */
-	usb2_com_detach(&sc->sc_super_ucom, sc->sc_ucom, U3G_MAXPORTS);
+	ucom_detach(&sc->sc_super_ucom, sc->sc_ucom, U3G_MAXPORTS);
 
 	for (m = 0; m != U3G_MAXPORTS; m++)
-		usb2_transfer_unsetup(sc->sc_xfer[m], U3G_N_TRANSFER);
+		usbd_transfer_unsetup(sc->sc_xfer[m], U3G_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -555,7 +555,7 @@ u3g_start_read(struct ucom_softc *ucom)
 	struct u3g_softc *sc = ucom->sc_parent;
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]);
+	usbd_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]);
 	return;
 }
 
@@ -565,7 +565,7 @@ u3g_stop_read(struct ucom_softc *ucom)
 	struct u3g_softc *sc = ucom->sc_parent;
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]);
+	usbd_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]);
 	return;
 }
 
@@ -574,7 +574,7 @@ u3g_start_write(struct ucom_softc *ucom)
 {
 	struct u3g_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]);
 	return;
 }
 
@@ -583,7 +583,7 @@ u3g_stop_write(struct ucom_softc *ucom)
 {
 	struct u3g_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]);
+	usbd_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]);
 	return;
 }
 
@@ -597,10 +597,10 @@ u3g_write_callback(struct usb_xfer *xfer)
 	case USB_ST_TRANSFERRED:
 	case USB_ST_SETUP:
 tr_setup:
-		if (usb2_com_get_data(ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(ucom, xfer->frbuffers, 0,
 		    U3G_BSIZE, &actlen)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
@@ -622,12 +622,12 @@ u3g_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/uark.c b/sys/dev/usb/serial/uark.c
index 69c5602..04861ba 100644
--- a/sys/dev/usb/serial/uark.c
+++ b/sys/dev/usb/serial/uark.c
@@ -29,7 +29,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb_cdc.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -122,14 +122,14 @@ static const struct usb_config
 };
 
 static const struct ucom_callback uark_callback = {
-	.usb2_com_cfg_get_status = &uark_cfg_get_status,
-	.usb2_com_cfg_set_break = &uark_cfg_set_break,
-	.usb2_com_cfg_param = &uark_cfg_param,
-	.usb2_com_pre_param = &uark_pre_param,
-	.usb2_com_start_read = &uark_start_read,
-	.usb2_com_stop_read = &uark_stop_read,
-	.usb2_com_start_write = &uark_start_write,
-	.usb2_com_stop_write = &uark_stop_write,
+	.ucom_cfg_get_status = &uark_cfg_get_status,
+	.ucom_cfg_set_break = &uark_cfg_set_break,
+	.ucom_cfg_param = &uark_cfg_param,
+	.ucom_pre_param = &uark_pre_param,
+	.ucom_start_read = &uark_start_read,
+	.ucom_stop_read = &uark_stop_read,
+	.ucom_start_write = &uark_start_write,
+	.ucom_stop_write = &uark_stop_write,
 };
 
 static device_method_t uark_methods[] = {
@@ -170,7 +170,7 @@ uark_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UARK_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(uark_devs, sizeof(uark_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uark_devs, sizeof(uark_devs), uaa));
 }
 
 static int
@@ -181,13 +181,13 @@ uark_attach(device_t dev)
 	int32_t error;
 	uint8_t iface_index;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "uark", NULL, MTX_DEF);
 
 	sc->sc_udev = uaa->device;
 
 	iface_index = UARK_IFACE_INDEX;
-	error = usb2_transfer_setup
+	error = usbd_transfer_setup
 	    (uaa->device, &iface_index, sc->sc_xfer,
 	    uark_xfer_config, UARK_N_TRANSFER, sc, &sc->sc_mtx);
 
@@ -198,14 +198,14 @@ uark_attach(device_t dev)
 	}
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uark_callback, &sc->sc_mtx);
 	if (error) {
-		DPRINTF("usb2_com_attach failed\n");
+		DPRINTF("ucom_attach failed\n");
 		goto detach;
 	}
 	return (0);			/* success */
@@ -220,8 +220,8 @@ uark_detach(device_t dev)
 {
 	struct uark_softc *sc = device_get_softc(dev);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UARK_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UARK_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -237,10 +237,10 @@ uark_bulk_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UARK_BUF_SIZE, &actlen)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -262,13 +262,13 @@ uark_bulk_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -286,7 +286,7 @@ uark_start_read(struct ucom_softc *ucom)
 {
 	struct uark_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UARK_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_RD]);
 }
 
 static void
@@ -294,7 +294,7 @@ uark_stop_read(struct ucom_softc *ucom)
 {
 	struct uark_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UARK_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_RD]);
 }
 
 static void
@@ -302,7 +302,7 @@ uark_start_write(struct ucom_softc *ucom)
 {
 	struct uark_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UARK_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_WR]);
 }
 
 static void
@@ -310,7 +310,7 @@ uark_stop_write(struct ucom_softc *ucom)
 {
 	struct uark_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UARK_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_WR]);
 }
 
 static int
@@ -402,10 +402,10 @@ uark_cfg_write(struct uark_softc *sc, uint16_t index, uint16_t value)
 	USETW(req.wIndex, index);
 	USETW(req.wLength, 0);
 
-	err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 	if (err) {
 		DPRINTFN(0, "device request failed, err=%s "
-		    "(ignored)\n", usb2_errstr(err));
+		    "(ignored)\n", usbd_errstr(err));
 	}
 }
diff --git a/sys/dev/usb/serial/ubsa.c b/sys/dev/usb/serial/ubsa.c
index cb7a337..cc584c3 100644
--- a/sys/dev/usb/serial/ubsa.c
+++ b/sys/dev/usb/serial/ubsa.c
@@ -213,16 +213,16 @@ static const struct usb_config ubsa_config[UBSA_N_TRANSFER] = {
 };
 
 static const struct ucom_callback ubsa_callback = {
-	.usb2_com_cfg_get_status = &ubsa_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &ubsa_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &ubsa_cfg_set_rts,
-	.usb2_com_cfg_set_break = &ubsa_cfg_set_break,
-	.usb2_com_cfg_param = &ubsa_cfg_param,
-	.usb2_com_pre_param = &ubsa_pre_param,
-	.usb2_com_start_read = &ubsa_start_read,
-	.usb2_com_stop_read = &ubsa_stop_read,
-	.usb2_com_start_write = &ubsa_start_write,
-	.usb2_com_stop_write = &ubsa_stop_write,
+	.ucom_cfg_get_status = &ubsa_cfg_get_status,
+	.ucom_cfg_set_dtr = &ubsa_cfg_set_dtr,
+	.ucom_cfg_set_rts = &ubsa_cfg_set_rts,
+	.ucom_cfg_set_break = &ubsa_cfg_set_break,
+	.ucom_cfg_param = &ubsa_cfg_param,
+	.ucom_pre_param = &ubsa_pre_param,
+	.ucom_start_read = &ubsa_start_read,
+	.ucom_stop_read = &ubsa_stop_read,
+	.ucom_start_write = &ubsa_start_write,
+	.ucom_stop_write = &ubsa_stop_write,
 };
 
 static const struct usb_device_id ubsa_devs[] = {
@@ -277,7 +277,7 @@ ubsa_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UBSA_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(ubsa_devs, sizeof(ubsa_devs), uaa));
+	return (usbd_lookup_id_by_uaa(ubsa_devs, sizeof(ubsa_devs), uaa));
 }
 
 static int
@@ -289,14 +289,14 @@ ubsa_attach(device_t dev)
 
 	DPRINTF("sc=%p\n", sc);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "ubsa", NULL, MTX_DEF);
 
 	sc->sc_udev = uaa->device;
 	sc->sc_iface_no = uaa->info.bIfaceNum;
 	sc->sc_iface_index = UBSA_IFACE_INDEX;
 
-	error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index,
+	error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index,
 	    sc->sc_xfer, ubsa_config, UBSA_N_TRANSFER, sc, &sc->sc_mtx);
 
 	if (error) {
@@ -305,14 +305,14 @@ ubsa_attach(device_t dev)
 	}
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &ubsa_callback, &sc->sc_mtx);
 	if (error) {
-		DPRINTF("usb2_com_attach failed\n");
+		DPRINTF("ucom_attach failed\n");
 		goto detach;
 	}
 	return (0);
@@ -329,8 +329,8 @@ ubsa_detach(device_t dev)
 
 	DPRINTF("sc=%p\n", sc);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UBSA_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UBSA_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -349,11 +349,11 @@ ubsa_cfg_request(struct ubsa_softc *sc, uint8_t index, uint16_t value)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 	if (err) {
 		DPRINTFN(0, "device request failed, err=%s "
-		    "(ignored)\n", usb2_errstr(err));
+		    "(ignored)\n", usbd_errstr(err));
 	}
 }
 
@@ -491,10 +491,10 @@ ubsa_start_read(struct ucom_softc *ucom)
 	struct ubsa_softc *sc = ucom->sc_parent;
 
 	/* start interrupt endpoint */
-	usb2_transfer_start(sc->sc_xfer[UBSA_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UBSA_INTR_DT_RD]);
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[UBSA_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UBSA_BULK_DT_RD]);
 }
 
 static void
@@ -503,10 +503,10 @@ ubsa_stop_read(struct ucom_softc *ucom)
 	struct ubsa_softc *sc = ucom->sc_parent;
 
 	/* stop interrupt endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UBSA_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UBSA_INTR_DT_RD]);
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_RD]);
 }
 
 static void
@@ -514,7 +514,7 @@ ubsa_start_write(struct ucom_softc *ucom)
 {
 	struct ubsa_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UBSA_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UBSA_BULK_DT_WR]);
 }
 
 static void
@@ -522,7 +522,7 @@ ubsa_stop_write(struct ucom_softc *ucom)
 {
 	struct ubsa_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_WR]);
 }
 
 static void
@@ -546,11 +546,11 @@ ubsa_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UBSA_BSIZE, &actlen)) {
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -572,12 +572,12 @@ ubsa_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -602,7 +602,7 @@ ubsa_intr_callback(struct usb_xfer *xfer)
 
 		if (xfer->actlen >= sizeof(buf)) {
 
-			usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+			usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
 
 			/*
 			 * incidentally, Belkin adapter status bits match
@@ -614,7 +614,7 @@ ubsa_intr_callback(struct usb_xfer *xfer)
 			DPRINTF("lsr = 0x%02x, msr = 0x%02x\n",
 			    sc->sc_lsr, sc->sc_msr);
 
-			usb2_com_status_change(&sc->sc_ucom);
+			ucom_status_change(&sc->sc_ucom);
 		} else {
 			DPRINTF("ignoring short packet, %d bytes\n",
 			    xfer->actlen);
@@ -623,7 +623,7 @@ ubsa_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 */
diff --git a/sys/dev/usb/serial/ubser.c b/sys/dev/usb/serial/ubser.c
index 3857a5a..f184ecd 100644
--- a/sys/dev/usb/serial/ubser.c
+++ b/sys/dev/usb/serial/ubser.c
@@ -172,13 +172,13 @@ static const struct usb_config ubser_config[UBSER_N_TRANSFER] = {
 };
 
 static const struct ucom_callback ubser_callback = {
-	.usb2_com_cfg_set_break = &ubser_cfg_set_break,
-	.usb2_com_cfg_get_status = &ubser_cfg_get_status,
-	.usb2_com_pre_param = &ubser_pre_param,
-	.usb2_com_start_read = &ubser_start_read,
-	.usb2_com_stop_read = &ubser_stop_read,
-	.usb2_com_start_write = &ubser_start_write,
-	.usb2_com_stop_write = &ubser_stop_write,
+	.ucom_cfg_set_break = &ubser_cfg_set_break,
+	.ucom_cfg_get_status = &ubser_cfg_get_status,
+	.ucom_pre_param = &ubser_pre_param,
+	.ucom_start_read = &ubser_start_read,
+	.ucom_stop_read = &ubser_stop_read,
+	.ucom_start_write = &ubser_start_write,
+	.ucom_stop_write = &ubser_stop_write,
 };
 
 static device_method_t ubser_methods[] = {
@@ -226,7 +226,7 @@ ubser_attach(device_t dev)
 	uint8_t n;
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "ubser", NULL, MTX_DEF);
 
 	snprintf(sc->sc_name, sizeof(sc->sc_name), "%s",
@@ -243,14 +243,14 @@ ubser_attach(device_t dev)
 	req.wIndex[0] = sc->sc_iface_no;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 1);
-	error = usb2_do_request_flags(uaa->device, NULL,
+	error = usbd_do_request_flags(uaa->device, NULL,
 	    &req, &sc->sc_numser,
 	    0, NULL, USB_DEFAULT_TIMEOUT);
 
 	if (error || (sc->sc_numser == 0)) {
 		device_printf(dev, "failed to get number "
 		    "of serial ports: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 		goto detach;
 	}
 	if (sc->sc_numser > UBSER_UNIT_MAX)
@@ -258,7 +258,7 @@ ubser_attach(device_t dev)
 
 	device_printf(dev, "found %i serials\n", sc->sc_numser);
 
-	error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index,
+	error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index,
 	    sc->sc_xfer, ubser_config, UBSER_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -275,16 +275,16 @@ ubser_attach(device_t dev)
 		sc->sc_ucom[n].sc_portno = n;
 	}
 
-	error = usb2_com_attach(&sc->sc_super_ucom, sc->sc_ucom,
+	error = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom,
 	    sc->sc_numser, sc, &ubser_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
 	}
 
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_RD]);
-	usb2_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
 	return (0);			/* success */
@@ -301,8 +301,8 @@ ubser_detach(device_t dev)
 
 	DPRINTF("\n");
 
-	usb2_com_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_numser);
-	usb2_transfer_unsetup(sc->sc_xfer, UBSER_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_numser);
+	usbd_transfer_unsetup(sc->sc_xfer, UBSER_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -379,16 +379,16 @@ ubser_write_callback(struct usb_xfer *xfer)
 	case USB_ST_TRANSFERRED:
 tr_setup:
 		do {
-			if (usb2_com_get_data(sc->sc_ucom + sc->sc_curr_tx_unit,
+			if (ucom_get_data(sc->sc_ucom + sc->sc_curr_tx_unit,
 			    xfer->frbuffers, 1, sc->sc_tx_size - 1,
 			    &actlen)) {
 
 				buf[0] = sc->sc_curr_tx_unit;
 
-				usb2_copy_in(xfer->frbuffers, 0, buf, 1);
+				usbd_copy_in(xfer->frbuffers, 0, buf, 1);
 
 				xfer->frlengths[0] = actlen + 1;
-				usb2_start_hardware(xfer);
+				usbd_transfer_submit(xfer);
 
 				ubser_inc_tx_unit(sc);	/* round robin */
 
@@ -423,19 +423,19 @@ ubser_read_callback(struct usb_xfer *xfer)
 			DPRINTF("invalid actlen=0!\n");
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, buf, 1);
+		usbd_copy_out(xfer->frbuffers, 0, buf, 1);
 
 		if (buf[0] >= sc->sc_numser) {
 			DPRINTF("invalid serial number!\n");
 			goto tr_setup;
 		}
-		usb2_com_put_data(sc->sc_ucom + buf[0],
+		ucom_put_data(sc->sc_ucom + buf[0],
 		    xfer->frbuffers, 1, xfer->actlen - 1);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -467,11 +467,11 @@ ubser_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 		req.wIndex[1] = 0;
 		USETW(req.wLength, 0);
 
-		err = usb2_com_cfg_do_request(sc->sc_udev, ucom, 
+		err = ucom_cfg_do_request(sc->sc_udev, ucom, 
 		    &req, NULL, 0, 1000);
 		if (err) {
 			DPRINTFN(0, "send break failed, error=%s\n",
-			    usb2_errstr(err));
+			    usbd_errstr(err));
 		}
 	}
 }
@@ -489,7 +489,7 @@ ubser_start_read(struct ucom_softc *ucom)
 {
 	struct ubser_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]);
 }
 
 static void
@@ -497,7 +497,7 @@ ubser_stop_read(struct ucom_softc *ucom)
 {
 	struct ubser_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_RD]);
 }
 
 static void
@@ -505,7 +505,7 @@ ubser_start_write(struct ucom_softc *ucom)
 {
 	struct ubser_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UBSER_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UBSER_BULK_DT_WR]);
 }
 
 static void
@@ -513,5 +513,5 @@ ubser_stop_write(struct ucom_softc *ucom)
 {
 	struct ubser_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_WR]);
 }
diff --git a/sys/dev/usb/serial/uchcom.c b/sys/dev/usb/serial/uchcom.c
index 6ed4905..009a37d 100644
--- a/sys/dev/usb/serial/uchcom.c
+++ b/sys/dev/usb/serial/uchcom.c
@@ -258,16 +258,16 @@ static const struct usb_config uchcom_config_data[UCHCOM_N_TRANSFER] = {
 };
 
 static struct ucom_callback uchcom_callback = {
-	.usb2_com_cfg_get_status = &uchcom_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &uchcom_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &uchcom_cfg_set_rts,
-	.usb2_com_cfg_set_break = &uchcom_cfg_set_break,
-	.usb2_com_cfg_param = &uchcom_cfg_param,
-	.usb2_com_pre_param = &uchcom_pre_param,
-	.usb2_com_start_read = &uchcom_start_read,
-	.usb2_com_stop_read = &uchcom_stop_read,
-	.usb2_com_start_write = &uchcom_start_write,
-	.usb2_com_stop_write = &uchcom_stop_write,
+	.ucom_cfg_get_status = &uchcom_cfg_get_status,
+	.ucom_cfg_set_dtr = &uchcom_cfg_set_dtr,
+	.ucom_cfg_set_rts = &uchcom_cfg_set_rts,
+	.ucom_cfg_set_break = &uchcom_cfg_set_break,
+	.ucom_cfg_param = &uchcom_cfg_param,
+	.ucom_pre_param = &uchcom_pre_param,
+	.ucom_start_read = &uchcom_start_read,
+	.ucom_stop_read = &uchcom_stop_read,
+	.ucom_start_write = &uchcom_start_write,
+	.ucom_stop_write = &uchcom_stop_write,
 };
 
 /* ----------------------------------------------------------------------
@@ -290,7 +290,7 @@ uchcom_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UCHCOM_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(uchcom_devs, sizeof(uchcom_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uchcom_devs, sizeof(uchcom_devs), uaa));
 }
 
 static int
@@ -303,7 +303,7 @@ uchcom_attach(device_t dev)
 
 	DPRINTFN(11, "\n");
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "uchcom", NULL, MTX_DEF);
 
 	sc->sc_udev = uaa->device;
@@ -318,13 +318,13 @@ uchcom_attach(device_t dev)
 	}
 
 	iface_index = UCHCOM_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &iface_index, sc->sc_xfer, uchcom_config_data,
 	    UCHCOM_N_TRANSFER, sc, &sc->sc_mtx);
 
 	if (error) {
 		DPRINTF("one or more missing USB endpoints, "
-		    "error=%s\n", usb2_errstr(error));
+		    "error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 	/*
@@ -341,11 +341,11 @@ uchcom_attach(device_t dev)
 
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uchcom_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -364,8 +364,8 @@ uchcom_detach(device_t dev)
 
 	DPRINTFN(11, "\n");
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UCHCOM_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UCHCOM_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -387,7 +387,7 @@ uchcom_ctrl_write(struct uchcom_softc *sc, uint8_t reqno,
 	USETW(req.wIndex, index);
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev,
+	ucom_cfg_do_request(sc->sc_udev,
 	    &sc->sc_ucom, &req, NULL, 0, 1000);
 }
 
@@ -403,7 +403,7 @@ uchcom_ctrl_read(struct uchcom_softc *sc, uint8_t reqno,
 	USETW(req.wIndex, index);
 	USETW(req.wLength, buflen);
 
-	usb2_com_cfg_do_request(sc->sc_udev,
+	ucom_cfg_do_request(sc->sc_udev,
 	    &sc->sc_ucom, &req, buf, USB_SHORT_XFER_OK, 1000);
 }
 
@@ -734,10 +734,10 @@ uchcom_start_read(struct ucom_softc *ucom)
 	struct uchcom_softc *sc = ucom->sc_parent;
 
 	/* start interrupt endpoint */
-	usb2_transfer_start(sc->sc_xfer[UCHCOM_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UCHCOM_INTR_DT_RD]);
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
 }
 
 static void
@@ -746,10 +746,10 @@ uchcom_stop_read(struct ucom_softc *ucom)
 	struct uchcom_softc *sc = ucom->sc_parent;
 
 	/* stop interrupt endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UCHCOM_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UCHCOM_INTR_DT_RD]);
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
 }
 
 static void
@@ -757,7 +757,7 @@ uchcom_start_write(struct ucom_softc *ucom)
 {
 	struct uchcom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
 }
 
 static void
@@ -765,7 +765,7 @@ uchcom_stop_write(struct ucom_softc *ucom)
 {
 	struct uchcom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
 }
 
 /* ----------------------------------------------------------------------
@@ -783,7 +783,7 @@ uchcom_intr_callback(struct usb_xfer *xfer)
 		DPRINTF("actlen = %u\n", xfer->actlen);
 
 		if (xfer->actlen >= UCHCOM_INTR_LEAST) {
-			usb2_copy_out(xfer->frbuffers, 0, buf,
+			usbd_copy_out(xfer->frbuffers, 0, buf,
 			    UCHCOM_INTR_LEAST);
 
 			DPRINTF("data = 0x%02X 0x%02X 0x%02X 0x%02X\n",
@@ -791,12 +791,12 @@ uchcom_intr_callback(struct usb_xfer *xfer)
 			    (unsigned)buf[2], (unsigned)buf[3]);
 
 			uchcom_convert_status(sc, buf[UCHCOM_INTR_STAT1]);
-			usb2_com_status_change(&sc->sc_ucom);
+			ucom_status_change(&sc->sc_ucom);
 		}
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -819,13 +819,13 @@ uchcom_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UCHCOM_BULK_BUF_SIZE, &actlen)) {
 
 			DPRINTF("actlen = %d\n", actlen);
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -847,12 +847,12 @@ uchcom_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/ucycom.c b/sys/dev/usb/serial/ucycom.c
index 794b86c..7825a22 100644
--- a/sys/dev/usb/serial/ucycom.c
+++ b/sys/dev/usb/serial/ucycom.c
@@ -42,7 +42,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_ioctl.h>
 #include <dev/usb/usbhid.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -136,13 +136,13 @@ static const struct usb_config ucycom_config[UCYCOM_N_TRANSFER] = {
 };
 
 static const struct ucom_callback ucycom_callback = {
-	.usb2_com_cfg_param = &ucycom_cfg_param,
-	.usb2_com_cfg_open = &ucycom_cfg_open,
-	.usb2_com_pre_param = &ucycom_pre_param,
-	.usb2_com_start_read = &ucycom_start_read,
-	.usb2_com_stop_read = &ucycom_stop_read,
-	.usb2_com_start_write = &ucycom_start_write,
-	.usb2_com_stop_write = &ucycom_stop_write,
+	.ucom_cfg_param = &ucycom_cfg_param,
+	.ucom_cfg_open = &ucycom_cfg_open,
+	.ucom_pre_param = &ucycom_pre_param,
+	.ucom_start_read = &ucycom_start_read,
+	.ucom_stop_read = &ucycom_stop_read,
+	.ucom_start_write = &ucycom_start_write,
+	.ucom_stop_write = &ucycom_stop_write,
 };
 
 static device_method_t ucycom_methods[] = {
@@ -188,7 +188,7 @@ ucycom_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UCYCOM_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(ucycom_devs, sizeof(ucycom_devs), uaa));
+	return (usbd_lookup_id_by_uaa(ucycom_devs, sizeof(ucycom_devs), uaa));
 }
 
 static int
@@ -203,7 +203,7 @@ ucycom_attach(device_t dev)
 
 	sc->sc_udev = uaa->device;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "ucycom", NULL, MTX_DEF);
 
 	snprintf(sc->sc_name, sizeof(sc->sc_name),
@@ -221,14 +221,14 @@ ucycom_attach(device_t dev)
 
 	/* get report descriptor */
 
-	error = usb2_req_get_hid_desc(uaa->device, NULL,
+	error = usbd_req_get_hid_desc(uaa->device, NULL,
 	    &urd_ptr, &urd_len, M_USBDEV,
 	    UCYCOM_IFACE_INDEX);
 
 	if (error) {
 		device_printf(dev, "failed to get report "
 		    "descriptor: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 		goto detach;
 	}
 	/* get report sizes */
@@ -248,7 +248,7 @@ ucycom_attach(device_t dev)
 	sc->sc_iface_no = uaa->info.bIfaceNum;
 
 	iface_index = UCYCOM_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, ucycom_config, UCYCOM_N_TRANSFER,
 	    sc, &sc->sc_mtx);
 	if (error) {
@@ -256,7 +256,7 @@ ucycom_attach(device_t dev)
 		    "transfers failed!\n");
 		goto detach;
 	}
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &ucycom_callback, &sc->sc_mtx);
 
 	if (error) {
@@ -280,8 +280,8 @@ ucycom_detach(device_t dev)
 {
 	struct ucycom_softc *sc = device_get_softc(dev);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UCYCOM_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UCYCOM_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -301,7 +301,7 @@ ucycom_start_read(struct ucom_softc *ucom)
 {
 	struct ucycom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UCYCOM_INTR_RD]);
+	usbd_transfer_start(sc->sc_xfer[UCYCOM_INTR_RD]);
 }
 
 static void
@@ -309,7 +309,7 @@ ucycom_stop_read(struct ucom_softc *ucom)
 {
 	struct ucycom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UCYCOM_INTR_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UCYCOM_INTR_RD]);
 }
 
 static void
@@ -317,7 +317,7 @@ ucycom_start_write(struct ucom_softc *ucom)
 {
 	struct ucycom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UCYCOM_CTRL_RD]);
+	usbd_transfer_start(sc->sc_xfer[UCYCOM_CTRL_RD]);
 }
 
 static void
@@ -325,7 +325,7 @@ ucycom_stop_write(struct ucom_softc *ucom)
 {
 	struct ucycom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UCYCOM_CTRL_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UCYCOM_CTRL_RD]);
 }
 
 static void
@@ -354,7 +354,7 @@ tr_transferred:
 			break;
 		}
 
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers + 1, offset,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers + 1, offset,
 		    sc->sc_olen - offset, &actlen)) {
 
 			req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
@@ -376,13 +376,13 @@ tr_transferred:
 				break;
 			}
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
-			usb2_copy_in(xfer->frbuffers + 1, 0, data, offset);
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers + 1, 0, data, offset);
 
 			xfer->frlengths[0] = sizeof(req);
 			xfer->frlengths[1] = sc->sc_olen;
 			xfer->nframes = xfer->frlengths[1] ? 2 : 1;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -391,7 +391,7 @@ tr_transferred:
 			return;
 		}
 		DPRINTF("error=%s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 		goto tr_transferred;
 	}
 }
@@ -422,11 +422,11 @@ ucycom_cfg_write(struct ucycom_softc *sc, uint32_t baud, uint8_t cfg)
 	sc->sc_temp_cfg[3] = (baud >> 24) & 0xff;
 	sc->sc_temp_cfg[4] = cfg;
 
-	err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
+	err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 	    &req, sc->sc_temp_cfg, 0, 1000);
 	if (err) {
 		DPRINTFN(0, "device request failed, err=%s "
-		    "(ignored)\n", usb2_errstr(err));
+		    "(ignored)\n", usbd_errstr(err));
 	}
 }
 
@@ -508,7 +508,7 @@ ucycom_intr_read_callback(struct usb_xfer *xfer)
 			if (xfer->actlen < 1) {
 				goto tr_setup;
 			}
-			usb2_copy_out(xfer->frbuffers, 0, buf, 1);
+			usbd_copy_out(xfer->frbuffers, 0, buf, 1);
 
 			sc->sc_ist = buf[0] & ~0x07;
 			len = buf[0] & 0x07;
@@ -523,7 +523,7 @@ ucycom_intr_read_callback(struct usb_xfer *xfer)
 			if (xfer->actlen < 2) {
 				goto tr_setup;
 			}
-			usb2_copy_out(xfer->frbuffers, 0, buf, 2);
+			usbd_copy_out(xfer->frbuffers, 0, buf, 2);
 
 			sc->sc_ist = buf[0] & ~0x07;
 			len = buf[1];
@@ -543,13 +543,13 @@ ucycom_intr_read_callback(struct usb_xfer *xfer)
 			len = xfer->actlen;
 		}
 		if (len) {
-			usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers,
+			ucom_put_data(&sc->sc_ucom, xfer->frbuffers,
 			    offset, len);
 		}
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = sc->sc_ilen;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/ufoma.c b/sys/dev/usb/serial/ufoma.c
index 3e1f134..89285ed 100644
--- a/sys/dev/usb/serial/ufoma.c
+++ b/sys/dev/usb/serial/ufoma.c
@@ -88,7 +88,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb_cdc.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -109,7 +109,7 @@ typedef struct ufoma_mobile_acm_descriptor {
 	uint8_t	bDescriptorSubtype;
 	uint8_t	bType;
 	uint8_t	bMode[1];
-} __packed usb2_mcpc_acm_descriptor;
+} __packed usb_mcpc_acm_descriptor;
 
 #define	UISUBCLASS_MCPC 0x88
 
@@ -280,18 +280,18 @@ static const struct usb_config
 };
 
 static const struct ucom_callback ufoma_callback = {
-	.usb2_com_cfg_get_status = &ufoma_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &ufoma_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &ufoma_cfg_set_rts,
-	.usb2_com_cfg_set_break = &ufoma_cfg_set_break,
-	.usb2_com_cfg_param = &ufoma_cfg_param,
-	.usb2_com_cfg_open = &ufoma_cfg_open,
-	.usb2_com_cfg_close = &ufoma_cfg_close,
-	.usb2_com_pre_param = &ufoma_pre_param,
-	.usb2_com_start_read = &ufoma_start_read,
-	.usb2_com_stop_read = &ufoma_stop_read,
-	.usb2_com_start_write = &ufoma_start_write,
-	.usb2_com_stop_write = &ufoma_stop_write,
+	.ucom_cfg_get_status = &ufoma_cfg_get_status,
+	.ucom_cfg_set_dtr = &ufoma_cfg_set_dtr,
+	.ucom_cfg_set_rts = &ufoma_cfg_set_rts,
+	.ucom_cfg_set_break = &ufoma_cfg_set_break,
+	.ucom_cfg_param = &ufoma_cfg_param,
+	.ucom_cfg_open = &ufoma_cfg_open,
+	.ucom_cfg_close = &ufoma_cfg_close,
+	.ucom_pre_param = &ufoma_pre_param,
+	.ucom_start_read = &ufoma_start_read,
+	.ucom_stop_read = &ufoma_stop_read,
+	.ucom_start_write = &ufoma_start_write,
+	.ucom_stop_write = &ufoma_stop_write,
 };
 
 static device_method_t ufoma_methods[] = {
@@ -320,13 +320,13 @@ ufoma_probe(device_t dev)
 	struct usb_attach_arg *uaa = device_get_ivars(dev);
 	struct usb_interface_descriptor *id;
 	struct usb_config_descriptor *cd;
-	usb2_mcpc_acm_descriptor *mad;
+	usb_mcpc_acm_descriptor *mad;
 
 	if (uaa->usb_mode != USB_MODE_HOST) {
 		return (ENXIO);
 	}
-	id = usb2_get_interface_descriptor(uaa->iface);
-	cd = usb2_get_config_descriptor(uaa->device);
+	id = usbd_get_interface_descriptor(uaa->iface);
+	cd = usbd_get_config_descriptor(uaa->device);
 
 	if ((id == NULL) ||
 	    (cd == NULL) ||
@@ -357,7 +357,7 @@ ufoma_attach(device_t dev)
 	struct sysctl_ctx_list *sctx;
 	struct sysctl_oid *soid;
 
-	usb2_mcpc_acm_descriptor *mad;
+	usb_mcpc_acm_descriptor *mad;
 	uint8_t elements;
 	int32_t error;
 
@@ -368,7 +368,7 @@ ufoma_attach(device_t dev)
 	mtx_init(&sc->sc_mtx, "ufoma", NULL, MTX_DEF);
 	cv_init(&sc->sc_cv, "CWAIT");
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	snprintf(sc->sc_name, sizeof(sc->sc_name),
 	    "%s", device_get_nameunit(dev));
@@ -377,12 +377,12 @@ ufoma_attach(device_t dev)
 
 	/* setup control transfers */
 
-	cd = usb2_get_config_descriptor(uaa->device);
-	id = usb2_get_interface_descriptor(uaa->iface);
+	cd = usbd_get_config_descriptor(uaa->device);
+	id = usbd_get_interface_descriptor(uaa->iface);
 	sc->sc_ctrl_iface_no = id->bInterfaceNumber;
 	sc->sc_ctrl_iface_index = uaa->info.bIfaceIndex;
 
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &sc->sc_ctrl_iface_index, sc->sc_ctrl_xfer,
 	    ufoma_ctrl_config, UFOMA_CTRL_ENDPT_MAX, sc, &sc->sc_mtx);
 
@@ -426,14 +426,14 @@ ufoma_attach(device_t dev)
 
 	/* clear stall at first run, if any */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
-	usb2_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
+	usbd_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
+	usbd_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &ufoma_callback, &sc->sc_mtx);
 	if (error) {
-		DPRINTF("usb2_com_attach failed\n");
+		DPRINTF("ucom_attach failed\n");
 		goto detach;
 	}
 	/*Sysctls*/
@@ -467,9 +467,9 @@ ufoma_detach(device_t dev)
 {
 	struct ufoma_softc *sc = device_get_softc(dev);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_ctrl_xfer, UFOMA_CTRL_ENDPT_MAX);
-	usb2_transfer_unsetup(sc->sc_bulk_xfer, UFOMA_BULK_ENDPT_MAX);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_ctrl_xfer, UFOMA_CTRL_ENDPT_MAX);
+	usbd_transfer_unsetup(sc->sc_bulk_xfer, UFOMA_BULK_ENDPT_MAX);
 
 	if (sc->sc_modetable) {
 		free(sc->sc_modetable, M_USBDEV);
@@ -486,7 +486,7 @@ ufoma_get_intconf(struct usb_config_descriptor *cd, struct usb_interface_descrip
 {
 	struct usb_descriptor *desc = (void *)id;
 
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 
 		if (desc->bDescriptorType == UDESC_INTERFACE) {
 			return (NULL);
@@ -511,7 +511,7 @@ ufoma_cfg_link_state(struct ufoma_softc *sc)
 	USETW(req.wIndex, sc->sc_ctrl_iface_no);
 	USETW(req.wLength, sc->sc_modetable[0]);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, sc->sc_modetable, 0, 1000);
 
 	error = cv_timedwait(&sc->sc_cv, &sc->sc_mtx, hz);
@@ -533,7 +533,7 @@ ufoma_cfg_activate_state(struct ufoma_softc *sc, uint16_t state)
 	USETW(req.wIndex, sc->sc_ctrl_iface_no);
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 
 	error = cv_timedwait(&sc->sc_cv, &sc->sc_mtx,
@@ -556,7 +556,7 @@ tr_transferred:
 			goto tr_setup;
 		}
 		if (xfer->frlengths[1] > 0) {
-			usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers + 1,
+			ucom_put_data(&sc->sc_ucom, xfer->frbuffers + 1,
 			    0, xfer->frlengths[1]);
 		}
 	case USB_ST_SETUP:
@@ -570,18 +570,18 @@ tr_setup:
 			USETW(req.wValue, 0);
 			USETW(req.wLength, UFOMA_CMD_BUF_SIZE);
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 			xfer->frlengths[0] = sizeof(req);
 			xfer->frlengths[1] = UFOMA_CMD_BUF_SIZE;
 			xfer->nframes = 2;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
 	default:			/* Error */
 		DPRINTF("error = %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error == USB_ERR_CANCELLED) {
 			return;
@@ -605,7 +605,7 @@ ufoma_ctrl_write_callback(struct usb_xfer *xfer)
 tr_transferred:
 	case USB_ST_SETUP:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers + 1,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers + 1,
 		    0, 1, &actlen)) {
 
 			req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
@@ -614,19 +614,19 @@ tr_setup:
 			USETW(req.wValue, 0);
 			USETW(req.wLength, 1);
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 			xfer->frlengths[0] = sizeof(req);
 			xfer->frlengths[1] = 1;
 			xfer->nframes = 2;
 
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
 	default:			/* Error */
 		DPRINTF("error = %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error == USB_ERR_CANCELLED) {
 			return;
@@ -657,7 +657,7 @@ ufoma_intr_callback(struct usb_xfer *xfer)
 			DPRINTF("truncating message\n");
 			xfer->actlen = sizeof(pkt);
 		}
-		usb2_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen);
+		usbd_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen);
 
 		xfer->actlen -= 8;
 
@@ -686,7 +686,7 @@ ufoma_intr_callback(struct usb_xfer *xfer)
 			if (sc->sc_num_msg != 0xFF) {
 				sc->sc_num_msg++;
 			}
-			usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]);
+			usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]);
 			break;
 
 		case UCDC_N_SERIAL_STATE:
@@ -721,7 +721,7 @@ ufoma_intr_callback(struct usb_xfer *xfer)
 			if (mstatus & UCDC_N_SERIAL_DCD) {
 				sc->sc_msr |= SER_DCD;
 			}
-			usb2_com_status_change(&sc->sc_ucom);
+			ucom_status_change(&sc->sc_ucom);
 			break;
 
 		default:
@@ -731,7 +731,7 @@ ufoma_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 */
@@ -754,10 +754,10 @@ ufoma_bulk_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UFOMA_BULK_BUF_SIZE, &actlen)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -778,13 +778,13 @@ ufoma_bulk_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -846,7 +846,7 @@ ufoma_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -875,7 +875,7 @@ ufoma_cfg_set_line_state(struct ufoma_softc *sc)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -972,7 +972,7 @@ ufoma_cfg_param(struct ucom_softc *ucom, struct termios *t)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, UCDC_LINE_STATE_LENGTH);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, &ls, 0, 1000);
 }
 
@@ -988,8 +988,8 @@ ufoma_modem_setup(device_t dev, struct ufoma_softc *sc,
 	uint8_t i;
 	int32_t error;
 
-	cd = usb2_get_config_descriptor(uaa->device);
-	id = usb2_get_interface_descriptor(uaa->iface);
+	cd = usbd_get_config_descriptor(uaa->device);
+	id = usbd_get_interface_descriptor(uaa->iface);
 
 	cmd = ufoma_get_intconf(cd, id, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM);
 
@@ -1018,15 +1018,15 @@ ufoma_modem_setup(device_t dev, struct ufoma_softc *sc,
 
 	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_data_iface_index = i;
-				usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
+				usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
 				break;
 			}
 		} else {
@@ -1035,7 +1035,7 @@ ufoma_modem_setup(device_t dev, struct ufoma_softc *sc,
 		}
 	}
 
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &sc->sc_data_iface_index, sc->sc_bulk_xfer,
 	    ufoma_bulk_config, UFOMA_BULK_ENDPT_MAX, sc, &sc->sc_mtx);
 
@@ -1053,13 +1053,13 @@ ufoma_start_read(struct ucom_softc *ucom)
 	struct ufoma_softc *sc = ucom->sc_parent;
 
 	/* start interrupt transfer */
-	usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]);
+	usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]);
 
 	/* start data transfer */
 	if (sc->sc_nobulk) {
-		usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]);
+		usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]);
 	} else {
-		usb2_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
+		usbd_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
 	}
 }
 
@@ -1069,13 +1069,13 @@ ufoma_stop_read(struct ucom_softc *ucom)
 	struct ufoma_softc *sc = ucom->sc_parent;
 
 	/* stop interrupt transfer */
-	usb2_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]);
+	usbd_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]);
 
 	/* stop data transfer */
 	if (sc->sc_nobulk) {
-		usb2_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]);
+		usbd_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]);
 	} else {
-		usb2_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
+		usbd_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
 	}
 }
 
@@ -1085,9 +1085,9 @@ ufoma_start_write(struct ucom_softc *ucom)
 	struct ufoma_softc *sc = ucom->sc_parent;
 
 	if (sc->sc_nobulk) {
-		usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]);
+		usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]);
 	} else {
-		usb2_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
+		usbd_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
 	}
 }
 
@@ -1097,9 +1097,9 @@ ufoma_stop_write(struct ucom_softc *ucom)
 	struct ufoma_softc *sc = ucom->sc_parent;
 
 	if (sc->sc_nobulk) {
-		usb2_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]);
+		usbd_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]);
 	} else {
-		usb2_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
+		usbd_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
 	}
 }
 
diff --git a/sys/dev/usb/serial/uftdi.c b/sys/dev/usb/serial/uftdi.c
index 7726abd..700d68b 100644
--- a/sys/dev/usb/serial/uftdi.c
+++ b/sys/dev/usb/serial/uftdi.c
@@ -166,17 +166,17 @@ static const struct usb_config uftdi_config[UFTDI_N_TRANSFER] = {
 };
 
 static const struct ucom_callback uftdi_callback = {
-	.usb2_com_cfg_get_status = &uftdi_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &uftdi_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &uftdi_cfg_set_rts,
-	.usb2_com_cfg_set_break = &uftdi_cfg_set_break,
-	.usb2_com_cfg_param = &uftdi_cfg_param,
-	.usb2_com_cfg_open = &uftdi_cfg_open,
-	.usb2_com_pre_param = &uftdi_pre_param,
-	.usb2_com_start_read = &uftdi_start_read,
-	.usb2_com_stop_read = &uftdi_stop_read,
-	.usb2_com_start_write = &uftdi_start_write,
-	.usb2_com_stop_write = &uftdi_stop_write,
+	.ucom_cfg_get_status = &uftdi_cfg_get_status,
+	.ucom_cfg_set_dtr = &uftdi_cfg_set_dtr,
+	.ucom_cfg_set_rts = &uftdi_cfg_set_rts,
+	.ucom_cfg_set_break = &uftdi_cfg_set_break,
+	.ucom_cfg_param = &uftdi_cfg_param,
+	.ucom_cfg_open = &uftdi_cfg_open,
+	.ucom_pre_param = &uftdi_pre_param,
+	.ucom_start_read = &uftdi_start_read,
+	.ucom_stop_read = &uftdi_stop_read,
+	.ucom_start_write = &uftdi_start_write,
+	.ucom_stop_write = &uftdi_stop_write,
 };
 
 static device_method_t uftdi_methods[] = {
@@ -248,7 +248,7 @@ uftdi_probe(device_t dev)
 	}
 	/* attach to all present interfaces */
 
-	return (usb2_lookup_id_by_uaa(uftdi_devs, sizeof(uftdi_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uftdi_devs, sizeof(uftdi_devs), uaa));
 }
 
 static int
@@ -262,7 +262,7 @@ uftdi_attach(device_t dev)
 	sc->sc_dev = dev;
 	sc->sc_unit = device_get_unit(dev);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "uftdi", NULL, MTX_DEF);
 
 	snprintf(sc->sc_name, sizeof(sc->sc_name),
@@ -283,7 +283,7 @@ uftdi_attach(device_t dev)
 		break;
 	}
 
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &sc->sc_iface_index, sc->sc_xfer, uftdi_config,
 	    UFTDI_N_TRANSFER, sc, &sc->sc_mtx);
 
@@ -296,8 +296,8 @@ uftdi_attach(device_t dev)
 
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
 	/* set a valid "lcr" value */
@@ -307,7 +307,7 @@ uftdi_attach(device_t dev)
 	    FTDI_SIO_SET_DATA_PARITY_NONE |
 	    FTDI_SIO_SET_DATA_BITS(8));
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uftdi_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -324,8 +324,8 @@ uftdi_detach(device_t dev)
 {
 	struct uftdi_softc *sc = device_get_softc(dev);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UFTDI_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UFTDI_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -347,7 +347,7 @@ uftdi_cfg_open(struct ucom_softc *ucom)
 	USETW(req.wValue, FTDI_SIO_RESET_SIO);
 	USETW(req.wIndex, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 
 	/* turn on RTS/CTS flow control */
@@ -357,7 +357,7 @@ uftdi_cfg_open(struct ucom_softc *ucom)
 	USETW(req.wValue, 0);
 	USETW2(req.wIndex, FTDI_SIO_RTS_CTS_HS, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 
 	/*
@@ -378,17 +378,17 @@ uftdi_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers,
 		    sc->sc_hdrlen, UFTDI_OBUFSIZE - sc->sc_hdrlen,
 		    &actlen)) {
 
 			if (sc->sc_hdrlen > 0) {
 				buf[0] =
 				    FTDI_OUT_TAG(actlen, sc->sc_ucom.sc_portno);
-				usb2_copy_in(xfer->frbuffers, 0, buf, 1);
+				usbd_copy_in(xfer->frbuffers, 0, buf, 1);
 			}
 			xfer->frlengths[0] = actlen + sc->sc_hdrlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -417,7 +417,7 @@ uftdi_read_callback(struct usb_xfer *xfer)
 		if (xfer->actlen < 2) {
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, buf, 2);
+		usbd_copy_out(xfer->frbuffers, 0, buf, 2);
 
 		ftdi_msr = FTDI_GET_MSR(buf);
 		lsr = FTDI_GET_LSR(buf);
@@ -441,18 +441,18 @@ uftdi_read_callback(struct usb_xfer *xfer)
 			sc->sc_msr = msr;
 			sc->sc_lsr = lsr;
 
-			usb2_com_status_change(&sc->sc_ucom);
+			ucom_status_change(&sc->sc_ucom);
 		}
 		xfer->actlen -= 2;
 
 		if (xfer->actlen > 0) {
-			usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 2,
+			ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 2,
 			    xfer->actlen);
 		}
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -480,7 +480,7 @@ uftdi_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff)
 	USETW(req.wValue, wValue);
 	USETW(req.wIndex, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -499,7 +499,7 @@ uftdi_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff)
 	USETW(req.wValue, wValue);
 	USETW(req.wIndex, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -524,7 +524,7 @@ uftdi_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 	USETW(req.wValue, wValue);
 	USETW(req.wIndex, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -657,7 +657,7 @@ uftdi_cfg_param(struct ucom_softc *ucom, struct termios *t)
 	USETW(req.wValue, cfg.rate);
 	USETW(req.wIndex, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
@@ -665,7 +665,7 @@ uftdi_cfg_param(struct ucom_softc *ucom, struct termios *t)
 	USETW(req.wValue, cfg.lcr);
 	USETW(req.wIndex, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
@@ -673,7 +673,7 @@ uftdi_cfg_param(struct ucom_softc *ucom, struct termios *t)
 	USETW2(req.wValue, cfg.v_stop, cfg.v_start);
 	USETW2(req.wIndex, cfg.v_flow, wIndex);
 	USETW(req.wLength, 0);
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -694,7 +694,7 @@ uftdi_start_read(struct ucom_softc *ucom)
 {
 	struct uftdi_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_RD]);
 }
 
 static void
@@ -702,7 +702,7 @@ uftdi_stop_read(struct ucom_softc *ucom)
 {
 	struct uftdi_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_RD]);
 }
 
 static void
@@ -710,7 +710,7 @@ uftdi_start_write(struct ucom_softc *ucom)
 {
 	struct uftdi_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_WR]);
 }
 
 static void
@@ -718,7 +718,7 @@ uftdi_stop_write(struct ucom_softc *ucom)
 {
 	struct uftdi_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_WR]);
 }
 
 /*------------------------------------------------------------------------*
diff --git a/sys/dev/usb/serial/ugensa.c b/sys/dev/usb/serial/ugensa.c
index 1a16ab5..eada5da 100644
--- a/sys/dev/usb/serial/ugensa.c
+++ b/sys/dev/usb/serial/ugensa.c
@@ -48,7 +48,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb_cdc.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -72,7 +72,7 @@ enum {
 };
 
 struct ugensa_sub_softc {
-	struct ucom_softc *sc_usb2_com_ptr;
+	struct ucom_softc *sc_ucom_ptr;
 	struct usb_xfer *sc_xfer[UGENSA_N_TRANSFER];
 };
 
@@ -122,10 +122,10 @@ static const struct usb_config
 };
 
 static const struct ucom_callback ugensa_callback = {
-	.usb2_com_start_read = &ugensa_start_read,
-	.usb2_com_stop_read = &ugensa_stop_read,
-	.usb2_com_start_write = &ugensa_start_write,
-	.usb2_com_stop_write = &ugensa_stop_write,
+	.ucom_start_read = &ugensa_start_read,
+	.ucom_stop_read = &ugensa_stop_read,
+	.ucom_start_write = &ugensa_start_write,
+	.ucom_stop_write = &ugensa_stop_write,
 };
 
 static device_method_t ugensa_methods[] = {
@@ -170,7 +170,7 @@ ugensa_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != 0) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(ugensa_devs, sizeof(ugensa_devs), uaa));
+	return (usbd_lookup_id_by_uaa(ugensa_devs, sizeof(ugensa_devs), uaa));
 }
 
 static int
@@ -184,13 +184,13 @@ ugensa_attach(device_t dev)
 	uint8_t iface_index;
 	int x, cnt;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "ugensa", NULL, MTX_DEF);
 
 	/* Figure out how many interfaces this device has got */
 	for (cnt = 0; cnt < UGENSA_IFACE_MAX; cnt++) {
-		if ((usb2_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 0) == NULL) ||
-		    (usb2_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 1) == NULL)) {
+		if ((usbd_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 0) == NULL) ||
+		    (usbd_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 1) == NULL)) {
 			/* we have reached the end */
 			break;
 		}
@@ -201,16 +201,16 @@ ugensa_attach(device_t dev)
 		goto detach;
 	}
 	for (x = 0; x < cnt; x++) {
-		iface = usb2_get_iface(uaa->device, x);
+		iface = usbd_get_iface(uaa->device, x);
 		if (iface->idesc->bInterfaceClass != UICLASS_VENDOR)
 			/* Not a serial port, most likely a SD reader */
 			continue;
 
 		ssc = sc->sc_sub + sc->sc_niface;
-		ssc->sc_usb2_com_ptr = sc->sc_ucom + sc->sc_niface;
+		ssc->sc_ucom_ptr = sc->sc_ucom + sc->sc_niface;
 
 		iface_index = (UGENSA_IFACE_INDEX + x);
-		error = usb2_transfer_setup(uaa->device,
+		error = usbd_transfer_setup(uaa->device,
 		    &iface_index, ssc->sc_xfer, ugensa_xfer_config,
 		    UGENSA_N_TRANSFER, ssc, &sc->sc_mtx);
 
@@ -221,20 +221,20 @@ ugensa_attach(device_t dev)
 		}
 		/* clear stall at first run */
 		mtx_lock(&sc->sc_mtx);
-		usb2_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
-		usb2_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
+		usbd_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
+		usbd_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
 		mtx_unlock(&sc->sc_mtx);
 
 		/* initialize port number */
-		ssc->sc_usb2_com_ptr->sc_portno = sc->sc_niface;
+		ssc->sc_ucom_ptr->sc_portno = sc->sc_niface;
 		sc->sc_niface++;
 		if (x != uaa->info.bIfaceIndex)
-			usb2_set_parent_iface(uaa->device, x,
+			usbd_set_parent_iface(uaa->device, x,
 			    uaa->info.bIfaceIndex);
 	}
 	device_printf(dev, "Found %d interfaces.\n", sc->sc_niface);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface, sc,
+	error = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface, sc,
 	    &ugensa_callback, &sc->sc_mtx);
 	if (error) {
 		DPRINTF("attach failed\n");
@@ -253,10 +253,10 @@ ugensa_detach(device_t dev)
 	struct ugensa_softc *sc = device_get_softc(dev);
 	uint8_t x;
 
-	usb2_com_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface);
+	ucom_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface);
 
 	for (x = 0; x < sc->sc_niface; x++) {
-		usb2_transfer_unsetup(sc->sc_sub[x].sc_xfer, UGENSA_N_TRANSFER);
+		usbd_transfer_unsetup(sc->sc_sub[x].sc_xfer, UGENSA_N_TRANSFER);
 	}
 	mtx_destroy(&sc->sc_mtx);
 
@@ -273,10 +273,10 @@ ugensa_bulk_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(ssc->sc_usb2_com_ptr, xfer->frbuffers, 0,
+		if (ucom_get_data(ssc->sc_ucom_ptr, xfer->frbuffers, 0,
 		    UGENSA_BUF_SIZE, &actlen)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -297,13 +297,13 @@ ugensa_bulk_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(ssc->sc_usb2_com_ptr, xfer->frbuffers, 0,
+		ucom_put_data(ssc->sc_ucom_ptr, xfer->frbuffers, 0,
 		    xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -322,7 +322,7 @@ ugensa_start_read(struct ucom_softc *ucom)
 	struct ugensa_softc *sc = ucom->sc_parent;
 	struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno;
 
-	usb2_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
+	usbd_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
 }
 
 static void
@@ -331,7 +331,7 @@ ugensa_stop_read(struct ucom_softc *ucom)
 	struct ugensa_softc *sc = ucom->sc_parent;
 	struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno;
 
-	usb2_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
+	usbd_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
 }
 
 static void
@@ -340,7 +340,7 @@ ugensa_start_write(struct ucom_softc *ucom)
 	struct ugensa_softc *sc = ucom->sc_parent;
 	struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno;
 
-	usb2_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
+	usbd_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
 }
 
 static void
@@ -349,5 +349,5 @@ ugensa_stop_write(struct ucom_softc *ucom)
 	struct ugensa_softc *sc = ucom->sc_parent;
 	struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno;
 
-	usb2_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
+	usbd_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
 }
diff --git a/sys/dev/usb/serial/uipaq.c b/sys/dev/usb/serial/uipaq.c
index 3ac9942..ca66866 100644
--- a/sys/dev/usb/serial/uipaq.c
+++ b/sys/dev/usb/serial/uipaq.c
@@ -57,7 +57,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb_cdc.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -131,13 +131,13 @@ static const struct usb_config uipaq_config_data[UIPAQ_N_TRANSFER] = {
 };
 
 static const struct ucom_callback uipaq_callback = {
-	.usb2_com_cfg_set_dtr = &uipaq_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &uipaq_cfg_set_rts,
-	.usb2_com_cfg_set_break = &uipaq_cfg_set_break,
-	.usb2_com_start_read = &uipaq_start_read,
-	.usb2_com_stop_read = &uipaq_stop_read,
-	.usb2_com_start_write = &uipaq_start_write,
-	.usb2_com_stop_write = &uipaq_stop_write,
+	.ucom_cfg_set_dtr = &uipaq_cfg_set_dtr,
+	.ucom_cfg_set_rts = &uipaq_cfg_set_rts,
+	.ucom_cfg_set_break = &uipaq_cfg_set_break,
+	.ucom_start_read = &uipaq_start_read,
+	.ucom_stop_read = &uipaq_stop_read,
+	.ucom_start_write = &uipaq_start_write,
+	.ucom_stop_write = &uipaq_stop_write,
 };
 
 /*
@@ -1089,7 +1089,7 @@ uipaq_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UIPAQ_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(uipaq_devs, sizeof(uipaq_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uipaq_devs, sizeof(uipaq_devs), uaa));
 }
 
 static int
@@ -1104,7 +1104,7 @@ uipaq_attach(device_t dev)
 
 	sc->sc_udev = uaa->device;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "uipaq", NULL, MTX_DEF);
 
 	/*
@@ -1119,15 +1119,15 @@ uipaq_attach(device_t dev)
 	USETW(req.wLength, 0);
 	for (i = 0; i != 64; i++) {
 		error =
-		    usb2_do_request_flags(uaa->device, NULL, &req,
+		    usbd_do_request_flags(uaa->device, NULL, &req,
 		    NULL, 0, NULL, 100);
 		if (error == 0)
 			break;
-		usb2_pause_mtx(NULL, hz / 10);
+		usb_pause_mtx(NULL, hz / 10);
 	}
 
 	iface_index = UIPAQ_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, uipaq_config_data,
 	    UIPAQ_N_TRANSFER, sc, &sc->sc_mtx);
 
@@ -1136,11 +1136,11 @@ uipaq_attach(device_t dev)
 	}
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uipaq_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -1157,8 +1157,8 @@ uipaq_detach(device_t dev)
 {
 	struct uipaq_softc *sc = device_get_softc(dev);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UIPAQ_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UIPAQ_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -1170,7 +1170,7 @@ uipaq_start_read(struct ucom_softc *ucom)
 	struct uipaq_softc *sc = ucom->sc_parent;
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
 }
 
 static void
@@ -1179,7 +1179,7 @@ uipaq_stop_read(struct ucom_softc *ucom)
 	struct uipaq_softc *sc = ucom->sc_parent;
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
 }
 
 static void
@@ -1187,7 +1187,7 @@ uipaq_start_write(struct ucom_softc *ucom)
 {
 	struct uipaq_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
 }
 
 static void
@@ -1195,7 +1195,7 @@ uipaq_stop_write(struct ucom_softc *ucom)
 {
 	struct uipaq_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
 }
 
 static void
@@ -1218,7 +1218,7 @@ uipaq_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -1242,7 +1242,7 @@ uipaq_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -1262,7 +1262,7 @@ uipaq_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -1276,10 +1276,10 @@ uipaq_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UIPAQ_BUF_SIZE, &actlen)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -1300,13 +1300,13 @@ uipaq_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/ulpt.c b/sys/dev/usb/serial/ulpt.c
index 056b48a..b7b622d 100644
--- a/sys/dev/usb/serial/ulpt.c
+++ b/sys/dev/usb/serial/ulpt.c
@@ -177,10 +177,10 @@ ulpt_reset(struct ulpt_softc *sc)
 
 	mtx_lock(&sc->sc_mtx);
 	req.bmRequestType = UT_WRITE_CLASS_OTHER;
-	if (usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx,
+	if (usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
 	    &req, NULL, 0, NULL, 2 * USB_MS_HZ)) {	/* 1.0 */
 		req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
-		if (usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx,
+		if (usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
 		    &req, NULL, 0, NULL, 2 * USB_MS_HZ)) {	/* 1.1 */
 			/* ignore error */
 		}
@@ -207,10 +207,10 @@ ulpt_write_callback(struct usb_xfer *xfer)
 	case USB_ST_TRANSFERRED:
 	case USB_ST_SETUP:
 tr_setup:
-		if (usb2_fifo_get_data(f, xfer->frbuffers,
+		if (usb_fifo_get_data(f, xfer->frbuffers,
 		    0, xfer->max_data_length, &actlen, 0)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
@@ -255,14 +255,14 @@ ulpt_read_callback(struct usb_xfer *xfer)
 			sc->sc_zlps = 0;
 		}
 
-		usb2_fifo_put_data(f, xfer->frbuffers,
+		usb_fifo_put_data(f, xfer->frbuffers,
 		    0, xfer->actlen, 1);
 
 	case USB_ST_SETUP:
 tr_setup:
-		if (usb2_fifo_put_bytes_max(f) != 0) {
+		if (usb_fifo_put_bytes_max(f) != 0) {
 			xfer->frlengths[0] = xfer->max_data_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
@@ -291,7 +291,7 @@ ulpt_status_callback(struct usb_xfer *xfer)
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
 
-		usb2_copy_out(xfer->frbuffers + 1, 0, &cur_status, 1);
+		usbd_copy_out(xfer->frbuffers + 1, 0, &cur_status, 1);
 
 		cur_status = (cur_status ^ LPS_INVERT) & LPS_MASK;
 		new_status = cur_status & ~sc->sc_last_status;
@@ -316,16 +316,16 @@ ulpt_status_callback(struct usb_xfer *xfer)
 		req.wIndex[1] = 0;
 		USETW(req.wLength, 1);
 
-		usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+		usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 		xfer->frlengths[0] = sizeof(req);
 		xfer->frlengths[1] = 1;
 		xfer->nframes = 2;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
-		DPRINTF("error=%s\n", usb2_errstr(xfer->error));
+		DPRINTF("error=%s\n", usbd_errstr(xfer->error));
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* wait for next watchdog timeout */
 		}
@@ -367,7 +367,7 @@ ulpt_start_read(struct usb_fifo *fifo)
 {
 	struct ulpt_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[ULPT_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[ULPT_BULK_DT_RD]);
 }
 
 static void
@@ -375,7 +375,7 @@ ulpt_stop_read(struct usb_fifo *fifo)
 {
 	struct ulpt_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_RD]);
 }
 
 static void
@@ -383,7 +383,7 @@ ulpt_start_write(struct usb_fifo *fifo)
 {
 	struct ulpt_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[ULPT_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[ULPT_BULK_DT_WR]);
 }
 
 static void
@@ -391,7 +391,7 @@ ulpt_stop_write(struct usb_fifo *fifo)
 {
 	struct ulpt_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_WR]);
 }
 
 static int
@@ -418,9 +418,9 @@ unlpt_open(struct usb_fifo *fifo, int fflags)
 	if (fflags & FREAD) {
 		/* clear stall first */
 		mtx_lock(&sc->sc_mtx);
-		usb2_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_RD]);
+		usbd_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_RD]);
 		mtx_unlock(&sc->sc_mtx);
-		if (usb2_fifo_alloc_buffer(fifo,
+		if (usb_fifo_alloc_buffer(fifo,
 		    sc->sc_xfer[ULPT_BULK_DT_RD]->max_data_length,
 		    ULPT_IFQ_MAXLEN)) {
 			return (ENOMEM);
@@ -431,9 +431,9 @@ unlpt_open(struct usb_fifo *fifo, int fflags)
 	if (fflags & FWRITE) {
 		/* clear stall first */
 		mtx_lock(&sc->sc_mtx);
-		usb2_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_WR]);
+		usbd_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_WR]);
 		mtx_unlock(&sc->sc_mtx);
-		if (usb2_fifo_alloc_buffer(fifo,
+		if (usb_fifo_alloc_buffer(fifo,
 		    sc->sc_xfer[ULPT_BULK_DT_WR]->max_data_length,
 		    ULPT_IFQ_MAXLEN)) {
 			return (ENOMEM);
@@ -453,7 +453,7 @@ ulpt_close(struct usb_fifo *fifo, int fflags)
 	sc->sc_fflags &= ~(fflags & (FREAD | FWRITE));
 
 	if (fflags & (FREAD | FWRITE)) {
-		usb2_fifo_free_buffer(fifo);
+		usb_fifo_free_buffer(fifo);
 	}
 }
 
@@ -500,15 +500,15 @@ ulpt_attach(device_t dev)
 	sc->sc_dev = dev;
 	sc->sc_udev = uaa->device;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, "ulpt lock", NULL, MTX_DEF | MTX_RECURSE);
 
-	usb2_callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0);
+	usb_callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0);
 
 	/* search through all the descriptors looking for bidir mode */
 
-	id = usb2_get_interface_descriptor(uaa->iface);
+	id = usbd_get_interface_descriptor(uaa->iface);
 	alt_index = 0 - 1;
 	while (1) {
 		if (id == NULL) {
@@ -527,8 +527,8 @@ ulpt_attach(device_t dev)
 				}
 			}
 		}
-		id = (void *)usb2_desc_foreach(
-		    usb2_get_config_descriptor(uaa->device), (void *)id);
+		id = (void *)usb_desc_foreach(
+		    usbd_get_config_descriptor(uaa->device), (void *)id);
 	}
 	goto detach;
 
@@ -539,22 +539,22 @@ found:
 
 	if (alt_index) {
 
-		error = usb2_set_alt_interface_index
+		error = usbd_set_alt_interface_index
 		    (uaa->device, iface_index, alt_index);
 
 		if (error) {
 			DPRINTF("could not set alternate "
-			    "config, error=%s\n", usb2_errstr(error));
+			    "config, error=%s\n", usbd_errstr(error));
 			goto detach;
 		}
 	}
 	sc->sc_iface_no = id->bInterfaceNumber;
 
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, ulpt_config, ULPT_N_TRANSFER,
 	    sc, &sc->sc_mtx);
 	if (error) {
-		DPRINTF("error=%s\n", usb2_errstr(error));
+		DPRINTF("error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 	device_printf(sc->sc_dev, "using bi-directional mode\n");
@@ -566,7 +566,7 @@ found:
  * UHCI and less often with OHCI.  *sigh*
  */
 	{
-		struct usb_config_descriptor *cd = usb2_get_config_descriptor(dev);
+		struct usb_config_descriptor *cd = usbd_get_config_descriptor(dev);
 		struct usb_device_request req;
 		int len, alen;
 
@@ -575,7 +575,7 @@ found:
 		USETW(req.wValue, cd->bConfigurationValue);
 		USETW2(req.wIndex, id->bInterfaceNumber, id->bAlternateSetting);
 		USETW(req.wLength, sizeof devinfo - 1);
-		error = usb2_do_request_flags(dev, &req, devinfo, USB_SHORT_XFER_OK,
+		error = usbd_do_request_flags(dev, &req, devinfo, USB_SHORT_XFER_OK,
 		    &alen, USB_DEFAULT_TIMEOUT);
 		if (error) {
 			device_printf(sc->sc_dev, "cannot get device id\n");
@@ -595,14 +595,14 @@ found:
 	}
 #endif
 
-	error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx,
+	error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 	    &ulpt_fifo_methods, &sc->sc_fifo,
 	    unit, 0 - 1, uaa->info.bIfaceIndex,
 	    UID_ROOT, GID_OPERATOR, 0644);
 	if (error) {
 		goto detach;
 	}
-	error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx,
+	error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 	    &unlpt_fifo_methods, &sc->sc_fifo_noreset,
 	    unit, 0 - 1, uaa->info.bIfaceIndex,
 	    UID_ROOT, GID_OPERATOR, 0644);
@@ -628,15 +628,15 @@ ulpt_detach(device_t dev)
 
 	DPRINTF("sc=%p\n", sc);
 
-	usb2_fifo_detach(&sc->sc_fifo);
-	usb2_fifo_detach(&sc->sc_fifo_noreset);
+	usb_fifo_detach(&sc->sc_fifo);
+	usb_fifo_detach(&sc->sc_fifo_noreset);
 
 	mtx_lock(&sc->sc_mtx);
-	usb2_callout_stop(&sc->sc_watchdog);
+	usb_callout_stop(&sc->sc_watchdog);
 	mtx_unlock(&sc->sc_mtx);
 
-	usb2_transfer_unsetup(sc->sc_xfer, ULPT_N_TRANSFER);
-	usb2_callout_drain(&sc->sc_watchdog);
+	usbd_transfer_unsetup(sc->sc_xfer, ULPT_N_TRANSFER);
+	usb_callout_drain(&sc->sc_watchdog);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -696,9 +696,9 @@ ulpt_watchdog(void *arg)
 
 	mtx_assert(&sc->sc_mtx, MA_OWNED);
 
-	usb2_transfer_start(sc->sc_xfer[ULPT_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[ULPT_INTR_DT_RD]);
 
-	usb2_callout_reset(&sc->sc_watchdog,
+	usb_callout_reset(&sc->sc_watchdog,
 	    hz, &ulpt_watchdog, sc);
 }
 
diff --git a/sys/dev/usb/serial/umct.c b/sys/dev/usb/serial/umct.c
index eff8ec2..879b090 100644
--- a/sys/dev/usb/serial/umct.c
+++ b/sys/dev/usb/serial/umct.c
@@ -50,7 +50,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb_cdc.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -164,16 +164,16 @@ static const struct usb_config umct_config[UMCT_N_TRANSFER] = {
 };
 
 static const struct ucom_callback umct_callback = {
-	.usb2_com_cfg_get_status = &umct_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &umct_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &umct_cfg_set_rts,
-	.usb2_com_cfg_set_break = &umct_cfg_set_break,
-	.usb2_com_cfg_param = &umct_cfg_param,
-	.usb2_com_pre_param = &umct_pre_param,
-	.usb2_com_start_read = &umct_start_read,
-	.usb2_com_stop_read = &umct_stop_read,
-	.usb2_com_start_write = &umct_start_write,
-	.usb2_com_stop_write = &umct_stop_write,
+	.ucom_cfg_get_status = &umct_cfg_get_status,
+	.ucom_cfg_set_dtr = &umct_cfg_set_dtr,
+	.ucom_cfg_set_rts = &umct_cfg_set_rts,
+	.ucom_cfg_set_break = &umct_cfg_set_break,
+	.ucom_cfg_param = &umct_cfg_param,
+	.ucom_pre_param = &umct_pre_param,
+	.ucom_start_read = &umct_start_read,
+	.ucom_stop_read = &umct_stop_read,
+	.ucom_start_write = &umct_start_write,
+	.ucom_stop_write = &umct_stop_write,
 };
 
 static const struct usb_device_id umct_devs[] = {
@@ -217,7 +217,7 @@ umct_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UMCT_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(umct_devs, sizeof(umct_devs), uaa));
+	return (usbd_lookup_id_by_uaa(umct_devs, sizeof(umct_devs), uaa));
 }
 
 static int
@@ -232,7 +232,7 @@ umct_attach(device_t dev)
 	sc->sc_udev = uaa->device;
 	sc->sc_unit = device_get_unit(dev);
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "umct", NULL, MTX_DEF);
 
 	snprintf(sc->sc_name, sizeof(sc->sc_name),
@@ -241,7 +241,7 @@ umct_attach(device_t dev)
 	sc->sc_iface_no = uaa->info.bIfaceNum;
 
 	iface_index = UMCT_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, umct_config, UMCT_N_TRANSFER, sc, &sc->sc_mtx);
 
 	if (error) {
@@ -274,7 +274,7 @@ umct_attach(device_t dev)
 			sc->sc_obufsize = 16;
 		}
 	}
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &umct_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -291,8 +291,8 @@ umct_detach(device_t dev)
 {
 	struct umct_softc *sc = device_get_softc(dev);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UMCT_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UMCT_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -316,11 +316,11 @@ umct_cfg_do_request(struct umct_softc *sc, uint8_t request,
 	USETW(req.wLength, len);
 	USETDW(temp, value);
 
-	err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, temp, 0, 1000);
 	if (err) {
 		DPRINTFN(0, "device request failed, err=%s "
-		    "(ignored)\n", usb2_errstr(err));
+		    "(ignored)\n", usbd_errstr(err));
 	}
 	return;
 }
@@ -337,17 +337,17 @@ umct_intr_callback(struct usb_xfer *xfer)
 			DPRINTF("too short message\n");
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+		usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
 
 		sc->sc_msr = buf[0];
 		sc->sc_lsr = buf[1];
 
-		usb2_com_status_change(&sc->sc_ucom);
+		ucom_status_change(&sc->sc_ucom);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -491,10 +491,10 @@ umct_start_read(struct ucom_softc *ucom)
 	struct umct_softc *sc = ucom->sc_parent;
 
 	/* start interrupt endpoint */
-	usb2_transfer_start(sc->sc_xfer[UMCT_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UMCT_INTR_DT_RD]);
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[UMCT_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UMCT_BULK_DT_RD]);
 }
 
 static void
@@ -503,10 +503,10 @@ umct_stop_read(struct ucom_softc *ucom)
 	struct umct_softc *sc = ucom->sc_parent;
 
 	/* stop interrupt endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UMCT_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UMCT_INTR_DT_RD]);
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_RD]);
 }
 
 static void
@@ -514,7 +514,7 @@ umct_start_write(struct ucom_softc *ucom)
 {
 	struct umct_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UMCT_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UMCT_BULK_DT_WR]);
 }
 
 static void
@@ -522,7 +522,7 @@ umct_stop_write(struct ucom_softc *ucom)
 {
 	struct umct_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_WR]);
 }
 
 static void
@@ -535,11 +535,11 @@ umct_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    sc->sc_obufsize, &actlen)) {
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -560,13 +560,13 @@ umct_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers,
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers,
 		    0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/umodem.c b/sys/dev/usb/serial/umodem.c
index 55a9d29..13cdeea 100644
--- a/sys/dev/usb/serial/umodem.c
+++ b/sys/dev/usb/serial/umodem.c
@@ -216,17 +216,17 @@ static const struct usb_config umodem_config[UMODEM_N_TRANSFER] = {
 };
 
 static const struct ucom_callback umodem_callback = {
-	.usb2_com_cfg_get_status = &umodem_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &umodem_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &umodem_cfg_set_rts,
-	.usb2_com_cfg_set_break = &umodem_cfg_set_break,
-	.usb2_com_cfg_param = &umodem_cfg_param,
-	.usb2_com_pre_param = &umodem_pre_param,
-	.usb2_com_ioctl = &umodem_ioctl,
-	.usb2_com_start_read = &umodem_start_read,
-	.usb2_com_stop_read = &umodem_stop_read,
-	.usb2_com_start_write = &umodem_start_write,
-	.usb2_com_stop_write = &umodem_stop_write,
+	.ucom_cfg_get_status = &umodem_cfg_get_status,
+	.ucom_cfg_set_dtr = &umodem_cfg_set_dtr,
+	.ucom_cfg_set_rts = &umodem_cfg_set_rts,
+	.ucom_cfg_set_break = &umodem_cfg_set_break,
+	.ucom_cfg_param = &umodem_cfg_param,
+	.ucom_pre_param = &umodem_pre_param,
+	.ucom_ioctl = &umodem_ioctl,
+	.ucom_start_read = &umodem_start_read,
+	.ucom_stop_read = &umodem_stop_read,
+	.ucom_start_write = &umodem_start_write,
+	.ucom_stop_write = &umodem_stop_write,
 };
 
 static device_method_t umodem_methods[] = {
@@ -260,7 +260,7 @@ umodem_probe(device_t dev)
 	if (uaa->usb_mode != USB_MODE_HOST) {
 		return (ENXIO);
 	}
-	error = usb2_lookup_id_by_uaa(umodem_devs, sizeof(umodem_devs), uaa);
+	error = usbd_lookup_id_by_uaa(umodem_devs, sizeof(umodem_devs), uaa);
 	return (error);
 }
 
@@ -274,7 +274,7 @@ umodem_attach(device_t dev)
 	uint8_t i;
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "umodem", NULL, MTX_DEF);
 
 	sc->sc_ctrl_iface_no = uaa->info.bIfaceNum;
@@ -315,15 +315,15 @@ umodem_attach(device_t dev)
 		struct usb_interface *iface;
 		struct usb_interface_descriptor *id;
 
-		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_iface_index[0] = i;
-				usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
+				usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
 				break;
 			}
 		} else {
@@ -343,7 +343,7 @@ umodem_attach(device_t dev)
 		}
 		sc->sc_cm_over_data = 1;
 	}
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    sc->sc_iface_index, sc->sc_xfer,
 	    umodem_config, UMODEM_N_TRANSFER,
 	    sc, &sc->sc_mtx);
@@ -353,11 +353,11 @@ umodem_attach(device_t dev)
 
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &umodem_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -375,10 +375,10 @@ umodem_start_read(struct ucom_softc *ucom)
 	struct umodem_softc *sc = ucom->sc_parent;
 
 	/* start interrupt endpoint, if any */
-	usb2_transfer_start(sc->sc_xfer[UMODEM_INTR_RD]);
+	usbd_transfer_start(sc->sc_xfer[UMODEM_INTR_RD]);
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[UMODEM_BULK_RD]);
+	usbd_transfer_start(sc->sc_xfer[UMODEM_BULK_RD]);
 }
 
 static void
@@ -387,10 +387,10 @@ umodem_stop_read(struct ucom_softc *ucom)
 	struct umodem_softc *sc = ucom->sc_parent;
 
 	/* stop interrupt endpoint, if any */
-	usb2_transfer_stop(sc->sc_xfer[UMODEM_INTR_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UMODEM_INTR_RD]);
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UMODEM_BULK_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UMODEM_BULK_RD]);
 }
 
 static void
@@ -398,7 +398,7 @@ umodem_start_write(struct ucom_softc *ucom)
 {
 	struct umodem_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UMODEM_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[UMODEM_BULK_WR]);
 }
 
 static void
@@ -406,7 +406,7 @@ umodem_stop_write(struct ucom_softc *ucom)
 {
 	struct umodem_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UMODEM_BULK_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UMODEM_BULK_WR]);
 }
 
 static void
@@ -493,7 +493,7 @@ umodem_cfg_param(struct ucom_softc *ucom, struct termios *t)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, sizeof(ls));
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, &ls, 0, 1000);
 }
 
@@ -546,7 +546,7 @@ umodem_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -570,7 +570,7 @@ umodem_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -594,7 +594,7 @@ umodem_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 		req.wIndex[1] = 0;
 		USETW(req.wLength, 0);
 
-		usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+		ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 		    &req, NULL, 0, 1000);
 	}
 }
@@ -618,7 +618,7 @@ umodem_intr_callback(struct usb_xfer *xfer)
 			DPRINTF("truncating message\n");
 			xfer->actlen = sizeof(pkt);
 		}
-		usb2_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen);
+		usbd_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen);
 
 		xfer->actlen -= 8;
 
@@ -660,7 +660,7 @@ umodem_intr_callback(struct usb_xfer *xfer)
 			if (pkt.data[0] & UCDC_N_SERIAL_DCD) {
 				sc->sc_msr |= SER_DCD;
 			}
-			usb2_com_status_change(&sc->sc_ucom);
+			ucom_status_change(&sc->sc_ucom);
 			break;
 
 		default:
@@ -672,7 +672,7 @@ umodem_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 */
@@ -696,11 +696,11 @@ umodem_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UMODEM_BUF_SIZE, &actlen)) {
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -724,13 +724,13 @@ umodem_read_callback(struct usb_xfer *xfer)
 
 		DPRINTF("actlen=%d\n", xfer->actlen);
 
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -768,7 +768,7 @@ umodem_set_comm_feature(struct usb_device *udev, uint8_t iface_no,
 	USETW(req.wLength, UCDC_ABSTRACT_STATE_LENGTH);
 	USETW(ast.wState, state);
 
-	return (usb2_do_request(udev, NULL, &req, &ast));
+	return (usbd_do_request(udev, NULL, &req, &ast));
 }
 
 static int
@@ -778,8 +778,8 @@ umodem_detach(device_t dev)
 
 	DPRINTF("sc=%p\n", sc);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UMODEM_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UMODEM_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
diff --git a/sys/dev/usb/serial/umoscom.c b/sys/dev/usb/serial/umoscom.c
index 22a497d..7fd52c3 100644
--- a/sys/dev/usb/serial/umoscom.c
+++ b/sys/dev/usb/serial/umoscom.c
@@ -230,20 +230,20 @@ static const struct usb_config umoscom_config_data[UMOSCOM_N_TRANSFER] = {
 
 static const struct ucom_callback umoscom_callback = {
 	/* configuration callbacks */
-	.usb2_com_cfg_get_status = &umoscom_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &umoscom_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &umoscom_cfg_set_rts,
-	.usb2_com_cfg_set_break = &umoscom_cfg_set_break,
-	.usb2_com_cfg_param = &umoscom_cfg_param,
-	.usb2_com_cfg_open = &umoscom_cfg_open,
-	.usb2_com_cfg_close = &umoscom_cfg_close,
+	.ucom_cfg_get_status = &umoscom_cfg_get_status,
+	.ucom_cfg_set_dtr = &umoscom_cfg_set_dtr,
+	.ucom_cfg_set_rts = &umoscom_cfg_set_rts,
+	.ucom_cfg_set_break = &umoscom_cfg_set_break,
+	.ucom_cfg_param = &umoscom_cfg_param,
+	.ucom_cfg_open = &umoscom_cfg_open,
+	.ucom_cfg_close = &umoscom_cfg_close,
 
 	/* other callbacks */
-	.usb2_com_pre_param = &umoscom_pre_param,
-	.usb2_com_start_read = &umoscom_start_read,
-	.usb2_com_stop_read = &umoscom_stop_read,
-	.usb2_com_start_write = &umoscom_start_write,
-	.usb2_com_stop_write = &umoscom_stop_write,
+	.ucom_pre_param = &umoscom_pre_param,
+	.ucom_start_read = &umoscom_start_read,
+	.ucom_stop_read = &umoscom_stop_read,
+	.ucom_start_write = &umoscom_start_write,
+	.ucom_stop_write = &umoscom_stop_write,
 };
 
 static device_method_t umoscom_methods[] = {
@@ -283,7 +283,7 @@ umoscom_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UMOSCOM_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(umoscom_devs, sizeof(umoscom_devs), uaa));
+	return (usbd_lookup_id_by_uaa(umoscom_devs, sizeof(umoscom_devs), uaa));
 }
 
 static int
@@ -304,7 +304,7 @@ umoscom_attach(device_t dev)
 	mtx_init(&sc->sc_mtx, "umoscom", NULL, MTX_DEF);
 
 	iface_index = UMOSCOM_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, umoscom_config_data,
 	    UMOSCOM_N_TRANSFER, sc, &sc->sc_mtx);
 
@@ -313,11 +313,11 @@ umoscom_attach(device_t dev)
 	}
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &umoscom_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -325,7 +325,7 @@ umoscom_attach(device_t dev)
 	return (0);
 
 detach:
-	device_printf(dev, "attach error: %s\n", usb2_errstr(error));
+	device_printf(dev, "attach error: %s\n", usbd_errstr(error));
 	umoscom_detach(dev);
 	return (ENXIO);
 }
@@ -335,8 +335,8 @@ umoscom_detach(device_t dev)
 {
 	struct umoscom_softc *sc = device_get_softc(dev);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UMOSCOM_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UMOSCOM_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -517,7 +517,7 @@ umoscom_cfg_write(struct umoscom_softc *sc, uint16_t reg, uint16_t val)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 	    &req, NULL, 0, 1000);
 }
 
@@ -533,7 +533,7 @@ umoscom_cfg_read(struct umoscom_softc *sc, uint16_t reg)
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 1);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, &val, 0, 1000);
 
 	DPRINTF("reg=0x%04x, val=0x%02x\n", reg, val);
@@ -548,10 +548,10 @@ umoscom_start_read(struct ucom_softc *ucom)
 
 #if 0
 	/* start interrupt endpoint */
-	usb2_transfer_start(sc->sc_xfer[UMOSCOM_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UMOSCOM_INTR_DT_RD]);
 #endif
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
 }
 
 static void
@@ -560,10 +560,10 @@ umoscom_stop_read(struct ucom_softc *ucom)
 	struct umoscom_softc *sc = ucom->sc_parent;
 
 	/* stop interrupt transfer */
-	usb2_transfer_stop(sc->sc_xfer[UMOSCOM_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UMOSCOM_INTR_DT_RD]);
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
 }
 
 static void
@@ -571,7 +571,7 @@ umoscom_start_write(struct ucom_softc *ucom)
 {
 	struct umoscom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
 }
 
 static void
@@ -579,7 +579,7 @@ umoscom_stop_write(struct ucom_softc *ucom)
 {
 	struct umoscom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
 }
 
 static void
@@ -594,11 +594,11 @@ umoscom_write_callback(struct usb_xfer *xfer)
 tr_setup:
 		DPRINTF("\n");
 
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UMOSCOM_BUFSIZE, &actlen)) {
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -621,14 +621,14 @@ umoscom_read_callback(struct usb_xfer *xfer)
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
 		DPRINTF("got %d bytes\n", xfer->actlen);
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		DPRINTF("\n");
 
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -653,12 +653,12 @@ umoscom_intr_callback(struct usb_xfer *xfer)
 			DPRINTF("too short message\n");
 			goto tr_setup;
 		}
-		usb2_com_status_change(&sc->sc_ucom);
+		ucom_status_change(&sc->sc_ucom);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/uplcom.c b/sys/dev/usb/serial/uplcom.c
index 23d18c0..0604b42 100644
--- a/sys/dev/usb/serial/uplcom.c
+++ b/sys/dev/usb/serial/uplcom.c
@@ -215,16 +215,16 @@ static const struct usb_config uplcom_config_data[UPLCOM_N_TRANSFER] = {
 };
 
 static struct ucom_callback uplcom_callback = {
-	.usb2_com_cfg_get_status = &uplcom_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &uplcom_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &uplcom_cfg_set_rts,
-	.usb2_com_cfg_set_break = &uplcom_cfg_set_break,
-	.usb2_com_cfg_param = &uplcom_cfg_param,
-	.usb2_com_pre_param = &uplcom_pre_param,
-	.usb2_com_start_read = &uplcom_start_read,
-	.usb2_com_stop_read = &uplcom_stop_read,
-	.usb2_com_start_write = &uplcom_start_write,
-	.usb2_com_stop_write = &uplcom_stop_write,
+	.ucom_cfg_get_status = &uplcom_cfg_get_status,
+	.ucom_cfg_set_dtr = &uplcom_cfg_set_dtr,
+	.ucom_cfg_set_rts = &uplcom_cfg_set_rts,
+	.ucom_cfg_set_break = &uplcom_cfg_set_break,
+	.ucom_cfg_param = &uplcom_cfg_param,
+	.ucom_pre_param = &uplcom_pre_param,
+	.ucom_start_read = &uplcom_start_read,
+	.ucom_stop_read = &uplcom_stop_read,
+	.ucom_start_write = &uplcom_start_write,
+	.ucom_stop_write = &uplcom_stop_write,
 };
 
 #define	USB_UPL(v,p,rl,rh,t)				\
@@ -315,7 +315,7 @@ uplcom_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UPLCOM_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(uplcom_devs, sizeof(uplcom_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uplcom_devs, sizeof(uplcom_devs), uaa));
 }
 
 static int
@@ -329,7 +329,7 @@ uplcom_attach(device_t dev)
 
 	DPRINTFN(11, "\n");
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "uplcom", NULL, MTX_DEF);
 
 	DPRINTF("sc = %p\n", sc);
@@ -357,43 +357,43 @@ uplcom_attach(device_t dev)
 	sc->sc_ctrl_iface_no = uaa->info.bIfaceNum;
 	sc->sc_iface_index[1] = UPLCOM_IFACE_INDEX;
 
-	iface = usb2_get_iface(uaa->device, UPLCOM_SECOND_IFACE_INDEX);
+	iface = usbd_get_iface(uaa->device, UPLCOM_SECOND_IFACE_INDEX);
 	if (iface) {
-		id = usb2_get_interface_descriptor(iface);
+		id = usbd_get_interface_descriptor(iface);
 		if (id == NULL) {
 			device_printf(dev, "no interface descriptor (2)!\n");
 			goto detach;
 		}
 		sc->sc_data_iface_no = id->bInterfaceNumber;
 		sc->sc_iface_index[0] = UPLCOM_SECOND_IFACE_INDEX;
-		usb2_set_parent_iface(uaa->device,
+		usbd_set_parent_iface(uaa->device,
 		    UPLCOM_SECOND_IFACE_INDEX, uaa->info.bIfaceIndex);
 	} else {
 		sc->sc_data_iface_no = sc->sc_ctrl_iface_no;
 		sc->sc_iface_index[0] = UPLCOM_IFACE_INDEX;
 	}
 
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    sc->sc_iface_index, sc->sc_xfer, uplcom_config_data,
 	    UPLCOM_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		DPRINTF("one or more missing USB endpoints, "
-		    "error=%s\n", usb2_errstr(error));
+		    "error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 	error = uplcom_reset(sc, uaa->device);
 	if (error) {
 		device_printf(dev, "reset failed, error=%s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 		goto detach;
 	}
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uplcom_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -422,8 +422,8 @@ uplcom_detach(device_t dev)
 
 	DPRINTF("sc=%p\n", sc);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UPLCOM_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UPLCOM_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -441,7 +441,7 @@ uplcom_reset(struct uplcom_softc *sc, struct usb_device *udev)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	return (usb2_do_request(udev, NULL, &req, NULL));
+	return (usbd_do_request(udev, NULL, &req, NULL));
 }
 
 struct pl2303x_init {
@@ -485,9 +485,9 @@ uplcom_pl2303x_init(struct usb_device *udev)
 		USETW(req.wIndex, pl2303x[i].index);
 		USETW(req.wLength, pl2303x[i].length);
 
-		err = usb2_do_request(udev, NULL, &req, buf);
+		err = usbd_do_request(udev, NULL, &req, buf);
 		if (err) {
-			DPRINTF("error=%s\n", usb2_errstr(err));
+			DPRINTF("error=%s\n", usbd_errstr(err));
 			return (EIO);
 		}
 	}
@@ -514,7 +514,7 @@ uplcom_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -538,7 +538,7 @@ uplcom_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -560,7 +560,7 @@ uplcom_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 }
 
@@ -655,7 +655,7 @@ uplcom_cfg_param(struct ucom_softc *ucom, struct termios *t)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, UCDC_LINE_STATE_LENGTH);
 
-	usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, &ls, 0, 1000);
 
 	if (t->c_cflag & CRTSCTS) {
@@ -671,7 +671,7 @@ uplcom_cfg_param(struct ucom_softc *ucom, struct termios *t)
 			USETW(req.wIndex, UPLCOM_SET_CRTSCTS);
 		USETW(req.wLength, 0);
 
-		usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+		ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 		    &req, NULL, 0, 1000);
 	} else {
 		req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
@@ -679,7 +679,7 @@ uplcom_cfg_param(struct ucom_softc *ucom, struct termios *t)
 		USETW(req.wValue, 0);
 		USETW(req.wIndex, 0);
 		USETW(req.wLength, 0);
-		usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+		ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 		    &req, NULL, 0, 1000);
 	}
 }
@@ -690,10 +690,10 @@ uplcom_start_read(struct ucom_softc *ucom)
 	struct uplcom_softc *sc = ucom->sc_parent;
 
 	/* start interrupt endpoint */
-	usb2_transfer_start(sc->sc_xfer[UPLCOM_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UPLCOM_INTR_DT_RD]);
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
 }
 
 static void
@@ -702,10 +702,10 @@ uplcom_stop_read(struct ucom_softc *ucom)
 	struct uplcom_softc *sc = ucom->sc_parent;
 
 	/* stop interrupt endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UPLCOM_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UPLCOM_INTR_DT_RD]);
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
 }
 
 static void
@@ -713,7 +713,7 @@ uplcom_start_write(struct ucom_softc *ucom)
 {
 	struct uplcom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
 }
 
 static void
@@ -721,7 +721,7 @@ uplcom_stop_write(struct ucom_softc *ucom)
 {
 	struct uplcom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
 }
 
 static void
@@ -748,7 +748,7 @@ uplcom_intr_callback(struct usb_xfer *xfer)
 
 		if (xfer->actlen >= 9) {
 
-			usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+			usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
 
 			DPRINTF("status = 0x%02x\n", buf[8]);
 
@@ -764,12 +764,12 @@ uplcom_intr_callback(struct usb_xfer *xfer)
 			if (buf[8] & RSAQ_STATUS_DCD) {
 				sc->sc_msr |= SER_DCD;
 			}
-			usb2_com_status_change(&sc->sc_ucom);
+			ucom_status_change(&sc->sc_ucom);
 		}
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -792,13 +792,13 @@ uplcom_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UPLCOM_BULK_BUF_SIZE, &actlen)) {
 
 			DPRINTF("actlen = %d\n", actlen);
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -819,12 +819,12 @@ uplcom_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/usb_serial.c b/sys/dev/usb/serial/usb_serial.c
index 6bb0f6d..d6c4c1a 100644
--- a/sys/dev/usb/serial/usb_serial.c
+++ b/sys/dev/usb/serial/usb_serial.c
@@ -73,7 +73,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_cdc.h>
 #include <dev/usb/usb_ioctl.h>
 
-#define	USB_DEBUG_VAR usb2_com_debug
+#define	USB_DEBUG_VAR ucom_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -85,49 +85,49 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/serial/usb_serial.h>
 
 #if USB_DEBUG
-static int usb2_com_debug = 0;
+static int ucom_debug = 0;
 
 SYSCTL_NODE(_hw_usb, OID_AUTO, ucom, CTLFLAG_RW, 0, "USB ucom");
 SYSCTL_INT(_hw_usb_ucom, OID_AUTO, debug, CTLFLAG_RW,
-    &usb2_com_debug, 0, "ucom debug level");
+    &ucom_debug, 0, "ucom debug level");
 #endif
 
-static usb_proc_callback_t usb2_com_cfg_start_transfers;
-static usb_proc_callback_t usb2_com_cfg_open;
-static usb_proc_callback_t usb2_com_cfg_close;
-static usb_proc_callback_t usb2_com_cfg_line_state;
-static usb_proc_callback_t usb2_com_cfg_status_change;
-static usb_proc_callback_t usb2_com_cfg_param;
-
-static uint8_t	usb2_com_units_alloc(uint32_t, uint32_t *);
-static void	usb2_com_units_free(uint32_t, uint32_t);
-static int	usb2_com_attach_tty(struct ucom_softc *, uint32_t);
-static void	usb2_com_detach_tty(struct ucom_softc *);
-static void	usb2_com_queue_command(struct ucom_softc *,
+static usb_proc_callback_t ucom_cfg_start_transfers;
+static usb_proc_callback_t ucom_cfg_open;
+static usb_proc_callback_t ucom_cfg_close;
+static usb_proc_callback_t ucom_cfg_line_state;
+static usb_proc_callback_t ucom_cfg_status_change;
+static usb_proc_callback_t ucom_cfg_param;
+
+static uint8_t	ucom_units_alloc(uint32_t, uint32_t *);
+static void	ucom_units_free(uint32_t, uint32_t);
+static int	ucom_attach_tty(struct ucom_softc *, uint32_t);
+static void	ucom_detach_tty(struct ucom_softc *);
+static void	ucom_queue_command(struct ucom_softc *,
 		    usb_proc_callback_t *, struct termios *pt,
 		    struct usb_proc_msg *t0, struct usb_proc_msg *t1);
-static void	usb2_com_shutdown(struct ucom_softc *);
-static void	usb2_com_break(struct ucom_softc *, uint8_t);
-static void	usb2_com_dtr(struct ucom_softc *, uint8_t);
-static void	usb2_com_rts(struct ucom_softc *, uint8_t);
-
-static tsw_open_t usb2_com_open;
-static tsw_close_t usb2_com_close;
-static tsw_ioctl_t usb2_com_ioctl;
-static tsw_modem_t usb2_com_modem;
-static tsw_param_t usb2_com_param;
-static tsw_outwakeup_t usb2_com_outwakeup;
-static tsw_free_t usb2_com_free;
-
-static struct ttydevsw usb2_com_class = {
+static void	ucom_shutdown(struct ucom_softc *);
+static void	ucom_break(struct ucom_softc *, uint8_t);
+static void	ucom_dtr(struct ucom_softc *, uint8_t);
+static void	ucom_rts(struct ucom_softc *, uint8_t);
+
+static tsw_open_t ucom_open;
+static tsw_close_t ucom_close;
+static tsw_ioctl_t ucom_ioctl;
+static tsw_modem_t ucom_modem;
+static tsw_param_t ucom_param;
+static tsw_outwakeup_t ucom_outwakeup;
+static tsw_free_t ucom_free;
+
+static struct ttydevsw ucom_class = {
 	.tsw_flags = TF_INITLOCK | TF_CALLOUT,
-	.tsw_open = usb2_com_open,
-	.tsw_close = usb2_com_close,
-	.tsw_outwakeup = usb2_com_outwakeup,
-	.tsw_ioctl = usb2_com_ioctl,
-	.tsw_param = usb2_com_param,
-	.tsw_modem = usb2_com_modem,
-	.tsw_free = usb2_com_free,
+	.tsw_open = ucom_open,
+	.tsw_close = ucom_close,
+	.tsw_outwakeup = ucom_outwakeup,
+	.tsw_ioctl = ucom_ioctl,
+	.tsw_param = ucom_param,
+	.tsw_modem = ucom_modem,
+	.tsw_free = ucom_free,
 };
 
 MODULE_DEPEND(ucom, usb, 1, 1, 1);
@@ -136,10 +136,10 @@ MODULE_VERSION(ucom, 1);
 #define	UCOM_UNIT_MAX 0x1000		/* exclusive */
 #define	UCOM_SUB_UNIT_MAX 0x100		/* exclusive */
 
-static uint8_t usb2_com_bitmap[(UCOM_UNIT_MAX + 7) / 8];
+static uint8_t ucom_bitmap[(UCOM_UNIT_MAX + 7) / 8];
 
 static uint8_t
-usb2_com_units_alloc(uint32_t sub_units, uint32_t *p_root_unit)
+ucom_units_alloc(uint32_t sub_units, uint32_t *p_root_unit)
 {
 	uint32_t n;
 	uint32_t o;
@@ -157,7 +157,7 @@ usb2_com_units_alloc(uint32_t sub_units, uint32_t *p_root_unit)
 
 			x = n + o;
 
-			if (usb2_com_bitmap[x / 8] & (1 << (x % 8))) {
+			if (ucom_bitmap[x / 8] & (1 << (x % 8))) {
 				goto skip;
 			}
 		}
@@ -168,7 +168,7 @@ usb2_com_units_alloc(uint32_t sub_units, uint32_t *p_root_unit)
 
 			x = n + o;
 
-			usb2_com_bitmap[x / 8] |= (1 << (x % 8));
+			ucom_bitmap[x / 8] |= (1 << (x % 8));
 		}
 
 		error = 0;
@@ -190,7 +190,7 @@ skip:		;
 }
 
 static void
-usb2_com_units_free(uint32_t root_unit, uint32_t sub_units)
+ucom_units_free(uint32_t root_unit, uint32_t sub_units)
 {
 	uint32_t x;
 
@@ -198,7 +198,7 @@ usb2_com_units_free(uint32_t root_unit, uint32_t sub_units)
 
 	while (sub_units--) {
 		x = root_unit + sub_units;
-		usb2_com_bitmap[x / 8] &= ~(1 << (x % 8));
+		ucom_bitmap[x / 8] &= ~(1 << (x % 8));
 	}
 
 	mtx_unlock(&Giant);
@@ -215,7 +215,7 @@ usb2_com_units_free(uint32_t root_unit, uint32_t sub_units)
  * before calling into the ucom-layer!
  */
 int
-usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc,
+ucom_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc,
     uint32_t sub_units, void *parent,
     const struct ucom_callback *callback, struct mtx *mtx)
 {
@@ -231,13 +231,13 @@ usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc,
 	}
 
 	/* XXX unit management does not really belong here */
-	if (usb2_com_units_alloc(sub_units, &root_unit)) {
+	if (ucom_units_alloc(sub_units, &root_unit)) {
 		return (ENOMEM);
 	}
 
-	error = usb2_proc_create(&ssc->sc_tq, mtx, "ucom", USB_PRI_MED);
+	error = usb_proc_create(&ssc->sc_tq, mtx, "ucom", USB_PRI_MED);
 	if (error) {
-		usb2_com_units_free(root_unit, sub_units);
+		ucom_units_free(root_unit, sub_units);
 		return (error);
 	}
 
@@ -249,10 +249,10 @@ usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc,
 		sc->sc_parent = parent;
 		sc->sc_callback = callback;
 
-		error = usb2_com_attach_tty(sc, sub_units);
+		error = ucom_attach_tty(sc, sub_units);
 		if (error) {
-			usb2_com_detach(ssc, sc - n, n);
-			usb2_com_units_free(root_unit + n, sub_units - n);
+			ucom_detach(ssc, sc - n, n);
+			ucom_units_free(root_unit + n, sub_units - n);
 			return (error);
 		}
 		sc->sc_flag |= UCOM_FLAG_ATTACHED;
@@ -265,35 +265,35 @@ usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc,
  * the structure pointed to by "ssc" and "sc" is zero.
  */
 void
-usb2_com_detach(struct ucom_super_softc *ssc, struct ucom_softc *sc,
+ucom_detach(struct ucom_super_softc *ssc, struct ucom_softc *sc,
     uint32_t sub_units)
 {
 	uint32_t n;
 
-	usb2_proc_drain(&ssc->sc_tq);
+	usb_proc_drain(&ssc->sc_tq);
 
 	for (n = 0; n != sub_units; n++, sc++) {
 		if (sc->sc_flag & UCOM_FLAG_ATTACHED) {
 
-			usb2_com_detach_tty(sc);
+			ucom_detach_tty(sc);
 
-			usb2_com_units_free(sc->sc_unit, 1);
+			ucom_units_free(sc->sc_unit, 1);
 
 			/* avoid duplicate detach: */
 			sc->sc_flag &= ~UCOM_FLAG_ATTACHED;
 		}
 	}
-	usb2_proc_free(&ssc->sc_tq);
+	usb_proc_free(&ssc->sc_tq);
 }
 
 static int
-usb2_com_attach_tty(struct ucom_softc *sc, uint32_t sub_units)
+ucom_attach_tty(struct ucom_softc *sc, uint32_t sub_units)
 {
 	struct tty *tp;
 	int error = 0;
 	char buf[32];			/* temporary TTY device name buffer */
 
-	tp = tty_alloc_mutex(&usb2_com_class, sc, sc->sc_mtx);
+	tp = tty_alloc_mutex(&ucom_class, sc, sc->sc_mtx);
 	if (tp == NULL) {
 		error = ENOMEM;
 		goto done;
@@ -303,8 +303,8 @@ usb2_com_attach_tty(struct ucom_softc *sc, uint32_t sub_units)
 	buf[0] = 0;			/* set some default value */
 
 	/* Check if the client has a custom TTY name */
-	if (sc->sc_callback->usb2_com_tty_name) {
-		sc->sc_callback->usb2_com_tty_name(sc, buf,
+	if (sc->sc_callback->ucom_tty_name) {
+		sc->sc_callback->ucom_tty_name(sc, buf,
 		    sizeof(buf), sc->sc_local_unit);
 	}
 	if (buf[0] == 0) {
@@ -328,14 +328,14 @@ usb2_com_attach_tty(struct ucom_softc *sc, uint32_t sub_units)
 	sc->sc_tty = tp;
 
 	DPRINTF("ttycreate: %s\n", buf);
-	cv_init(&sc->sc_cv, "usb2_com");
+	cv_init(&sc->sc_cv, "ucom");
 
 done:
 	return (error);
 }
 
 static void
-usb2_com_detach_tty(struct ucom_softc *sc)
+ucom_detach_tty(struct ucom_softc *sc)
 {
 	struct tty *tp = sc->sc_tty;
 
@@ -351,7 +351,7 @@ usb2_com_detach_tty(struct ucom_softc *sc)
 	if (tp) {
 		tty_lock(tp);
 
-		usb2_com_close(tp);	/* close, if any */
+		ucom_close(tp);	/* close, if any */
 
 		tty_rel_gone(tp);
 
@@ -362,11 +362,11 @@ usb2_com_detach_tty(struct ucom_softc *sc)
 		/*
 		 * make sure that read and write transfers are stopped
 		 */
-		if (sc->sc_callback->usb2_com_stop_read) {
-			(sc->sc_callback->usb2_com_stop_read) (sc);
+		if (sc->sc_callback->ucom_stop_read) {
+			(sc->sc_callback->ucom_stop_read) (sc);
 		}
-		if (sc->sc_callback->usb2_com_stop_write) {
-			(sc->sc_callback->usb2_com_stop_write) (sc);
+		if (sc->sc_callback->ucom_stop_write) {
+			(sc->sc_callback->ucom_stop_write) (sc);
 		}
 		mtx_unlock(sc->sc_mtx);
 	}
@@ -374,7 +374,7 @@ usb2_com_detach_tty(struct ucom_softc *sc)
 }
 
 static void
-usb2_com_queue_command(struct ucom_softc *sc,
+ucom_queue_command(struct ucom_softc *sc,
     usb_proc_callback_t *fn, struct termios *pt,
     struct usb_proc_msg *t0, struct usb_proc_msg *t1)
 {
@@ -383,7 +383,7 @@ usb2_com_queue_command(struct ucom_softc *sc,
 
 	mtx_assert(sc->sc_mtx, MA_OWNED);
 
-	if (usb2_proc_is_gone(&ssc->sc_tq)) {
+	if (usb_proc_is_gone(&ssc->sc_tq)) {
 		DPRINTF("proc is gone\n");
 		return;         /* nothing to do */
 	}
@@ -393,7 +393,7 @@ usb2_com_queue_command(struct ucom_softc *sc,
 	 * structure after that the message got queued.
 	 */
 	task = (struct ucom_param_task *)
-	  usb2_proc_msignal(&ssc->sc_tq, t0, t1);
+	  usb_proc_msignal(&ssc->sc_tq, t0, t1);
 
 	/* Setup callback and softc pointers */
 	task->hdr.pm_callback = fn;
@@ -409,19 +409,19 @@ usb2_com_queue_command(struct ucom_softc *sc,
 	/*
 	 * Closing the device should be synchronous.
 	 */
-	if (fn == usb2_com_cfg_close)
-		usb2_proc_mwait(&ssc->sc_tq, t0, t1);
+	if (fn == ucom_cfg_close)
+		usb_proc_mwait(&ssc->sc_tq, t0, t1);
 
 	/*
 	 * In case of multiple configure requests,
 	 * keep track of the last one!
 	 */
-	if (fn == usb2_com_cfg_start_transfers)
+	if (fn == ucom_cfg_start_transfers)
 		sc->sc_last_start_xfer = &task->hdr;
 }
 
 static void
-usb2_com_shutdown(struct ucom_softc *sc)
+ucom_shutdown(struct ucom_softc *sc)
 {
 	struct tty *tp = sc->sc_tty;
 
@@ -433,7 +433,7 @@ usb2_com_shutdown(struct ucom_softc *sc)
 	 * Hang up if necessary:
 	 */
 	if (tp->t_termios.c_cflag & HUPCL) {
-		usb2_com_modem(tp, 0, SER_DTR);
+		ucom_modem(tp, 0, SER_DTR);
 	}
 }
 
@@ -443,15 +443,15 @@ usb2_com_shutdown(struct ucom_softc *sc)
  * else: taskqueue is draining or gone
  */
 uint8_t
-usb2_com_cfg_is_gone(struct ucom_softc *sc)
+ucom_cfg_is_gone(struct ucom_softc *sc)
 {
 	struct ucom_super_softc *ssc = sc->sc_super;
 
-	return (usb2_proc_is_gone(&ssc->sc_tq));
+	return (usb_proc_is_gone(&ssc->sc_tq));
 }
 
 static void
-usb2_com_cfg_start_transfers(struct usb_proc_msg *_task)
+ucom_cfg_start_transfers(struct usb_proc_msg *_task)
 {
 	struct ucom_cfg_task *task = 
 	    (struct ucom_cfg_task *)_task;
@@ -468,16 +468,16 @@ usb2_com_cfg_start_transfers(struct usb_proc_msg *_task)
 	if (_task == sc->sc_last_start_xfer)
 		sc->sc_flag |= UCOM_FLAG_GP_DATA;
 
-	if (sc->sc_callback->usb2_com_start_read) {
-		(sc->sc_callback->usb2_com_start_read) (sc);
+	if (sc->sc_callback->ucom_start_read) {
+		(sc->sc_callback->ucom_start_read) (sc);
 	}
-	if (sc->sc_callback->usb2_com_start_write) {
-		(sc->sc_callback->usb2_com_start_write) (sc);
+	if (sc->sc_callback->ucom_start_write) {
+		(sc->sc_callback->ucom_start_write) (sc);
 	}
 }
 
 static void
-usb2_com_start_transfers(struct ucom_softc *sc)
+ucom_start_transfers(struct ucom_softc *sc)
 {
 	if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) {
 		return;
@@ -486,16 +486,16 @@ usb2_com_start_transfers(struct ucom_softc *sc)
 	 * Make sure that data transfers are started in both
 	 * directions:
 	 */
-	if (sc->sc_callback->usb2_com_start_read) {
-		(sc->sc_callback->usb2_com_start_read) (sc);
+	if (sc->sc_callback->ucom_start_read) {
+		(sc->sc_callback->ucom_start_read) (sc);
 	}
-	if (sc->sc_callback->usb2_com_start_write) {
-		(sc->sc_callback->usb2_com_start_write) (sc);
+	if (sc->sc_callback->ucom_start_write) {
+		(sc->sc_callback->ucom_start_write) (sc);
 	}
 }
 
 static void
-usb2_com_cfg_open(struct usb_proc_msg *_task)
+ucom_cfg_open(struct usb_proc_msg *_task)
 {
 	struct ucom_cfg_task *task = 
 	    (struct ucom_cfg_task *)_task;
@@ -511,17 +511,17 @@ usb2_com_cfg_open(struct usb_proc_msg *_task)
 
 		sc->sc_flag |= UCOM_FLAG_LL_READY;
 
-		if (sc->sc_callback->usb2_com_cfg_open) {
-			(sc->sc_callback->usb2_com_cfg_open) (sc);
+		if (sc->sc_callback->ucom_cfg_open) {
+			(sc->sc_callback->ucom_cfg_open) (sc);
 
 			/* wait a little */
-			usb2_pause_mtx(sc->sc_mtx, hz / 10);
+			usb_pause_mtx(sc->sc_mtx, hz / 10);
 		}
 	}
 }
 
 static int
-usb2_com_open(struct tty *tp)
+ucom_open(struct tty *tp)
 {
 	struct ucom_softc *sc = tty_softc(tp);
 	int error;
@@ -537,12 +537,12 @@ usb2_com_open(struct tty *tp)
 	}
 	DPRINTF("tp = %p\n", tp);
 
-	if (sc->sc_callback->usb2_com_pre_open) {
+	if (sc->sc_callback->ucom_pre_open) {
 		/*
 		 * give the lower layer a chance to disallow TTY open, for
 		 * example if the device is not present:
 		 */
-		error = (sc->sc_callback->usb2_com_pre_open) (sc);
+		error = (sc->sc_callback->ucom_pre_open) (sc);
 		if (error) {
 			return (error);
 		}
@@ -561,26 +561,26 @@ usb2_com_open(struct tty *tp)
 	sc->sc_pls_set = 0;
 	sc->sc_pls_clr = 0;
 
-	usb2_com_queue_command(sc, usb2_com_cfg_open, NULL,
+	ucom_queue_command(sc, ucom_cfg_open, NULL,
 	    &sc->sc_open_task[0].hdr,
 	    &sc->sc_open_task[1].hdr);
 
 	/* Queue transfer enable command last */
-	usb2_com_queue_command(sc, usb2_com_cfg_start_transfers, NULL,
+	ucom_queue_command(sc, ucom_cfg_start_transfers, NULL,
 	    &sc->sc_start_task[0].hdr, 
 	    &sc->sc_start_task[1].hdr);
 
-	usb2_com_modem(tp, SER_DTR | SER_RTS, 0);
+	ucom_modem(tp, SER_DTR | SER_RTS, 0);
 
-	usb2_com_break(sc, 0);
+	ucom_break(sc, 0);
 
-	usb2_com_status_change(sc);
+	ucom_status_change(sc);
 
 	return (0);
 }
 
 static void
-usb2_com_cfg_close(struct usb_proc_msg *_task)
+ucom_cfg_close(struct usb_proc_msg *_task)
 {
 	struct ucom_cfg_task *task = 
 	    (struct ucom_cfg_task *)_task;
@@ -590,15 +590,15 @@ usb2_com_cfg_close(struct usb_proc_msg *_task)
 
 	if (sc->sc_flag & UCOM_FLAG_LL_READY) {
 		sc->sc_flag &= ~UCOM_FLAG_LL_READY;
-		if (sc->sc_callback->usb2_com_cfg_close)
-			(sc->sc_callback->usb2_com_cfg_close) (sc);
+		if (sc->sc_callback->ucom_cfg_close)
+			(sc->sc_callback->ucom_cfg_close) (sc);
 	} else {
 		/* already closed */
 	}
 }
 
 static void
-usb2_com_close(struct tty *tp)
+ucom_close(struct tty *tp)
 {
 	struct ucom_softc *sc = tty_softc(tp);
 
@@ -610,21 +610,21 @@ usb2_com_close(struct tty *tp)
 		DPRINTF("tp=%p already closed\n", tp);
 		return;
 	}
-	usb2_com_shutdown(sc);
+	ucom_shutdown(sc);
 
-	usb2_com_queue_command(sc, usb2_com_cfg_close, NULL,
+	ucom_queue_command(sc, ucom_cfg_close, NULL,
 	    &sc->sc_close_task[0].hdr,
 	    &sc->sc_close_task[1].hdr);
 
 	sc->sc_flag &= ~(UCOM_FLAG_HL_READY | UCOM_FLAG_RTS_IFLOW);
 
-	if (sc->sc_callback->usb2_com_stop_read) {
-		(sc->sc_callback->usb2_com_stop_read) (sc);
+	if (sc->sc_callback->ucom_stop_read) {
+		(sc->sc_callback->ucom_stop_read) (sc);
 	}
 }
 
 static int
-usb2_com_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td)
+ucom_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td)
 {
 	struct ucom_softc *sc = tty_softc(tp);
 	int error;
@@ -638,16 +638,16 @@ usb2_com_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td)
 
 	switch (cmd) {
 	case TIOCSBRK:
-		usb2_com_break(sc, 1);
+		ucom_break(sc, 1);
 		error = 0;
 		break;
 	case TIOCCBRK:
-		usb2_com_break(sc, 0);
+		ucom_break(sc, 0);
 		error = 0;
 		break;
 	default:
-		if (sc->sc_callback->usb2_com_ioctl) {
-			error = (sc->sc_callback->usb2_com_ioctl)
+		if (sc->sc_callback->ucom_ioctl) {
+			error = (sc->sc_callback->ucom_ioctl)
 			    (sc, cmd, data, 0, td);
 		} else {
 			error = ENOIOCTL;
@@ -658,7 +658,7 @@ usb2_com_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td)
 }
 
 static int
-usb2_com_modem(struct tty *tp, int sigon, int sigoff)
+ucom_modem(struct tty *tp, int sigon, int sigoff)
 {
 	struct ucom_softc *sc = tty_softc(tp);
 	uint8_t onoff;
@@ -703,16 +703,16 @@ usb2_com_modem(struct tty *tp, int sigon, int sigoff)
 		sc->sc_mcr &= ~SER_RTS;
 	}
 	onoff = (sc->sc_mcr & SER_DTR) ? 1 : 0;
-	usb2_com_dtr(sc, onoff);
+	ucom_dtr(sc, onoff);
 
 	onoff = (sc->sc_mcr & SER_RTS) ? 1 : 0;
-	usb2_com_rts(sc, onoff);
+	ucom_rts(sc, onoff);
 
 	return (0);
 }
 
 static void
-usb2_com_cfg_line_state(struct usb_proc_msg *_task)
+ucom_cfg_line_state(struct usb_proc_msg *_task)
 {
 	struct ucom_cfg_task *task = 
 	    (struct ucom_cfg_task *)_task;
@@ -729,11 +729,11 @@ usb2_com_cfg_line_state(struct usb_proc_msg *_task)
 
 	mask = 0;
 	/* compute callback mask */
-	if (sc->sc_callback->usb2_com_cfg_set_dtr)
+	if (sc->sc_callback->ucom_cfg_set_dtr)
 		mask |= UCOM_LS_DTR;
-	if (sc->sc_callback->usb2_com_cfg_set_rts)
+	if (sc->sc_callback->ucom_cfg_set_rts)
 		mask |= UCOM_LS_RTS;
-	if (sc->sc_callback->usb2_com_cfg_set_break)
+	if (sc->sc_callback->ucom_cfg_set_break)
 		mask |= UCOM_LS_BREAK;
 
 	/* compute the bits we are to program */
@@ -749,29 +749,29 @@ usb2_com_cfg_line_state(struct usb_proc_msg *_task)
 
 	/* ensure that we don't loose any levels */
 	if (notch_bits & UCOM_LS_DTR)
-		sc->sc_callback->usb2_com_cfg_set_dtr(sc,
+		sc->sc_callback->ucom_cfg_set_dtr(sc,
 		    (prev_value & UCOM_LS_DTR) ? 1 : 0);
 	if (notch_bits & UCOM_LS_RTS)
-		sc->sc_callback->usb2_com_cfg_set_rts(sc,
+		sc->sc_callback->ucom_cfg_set_rts(sc,
 		    (prev_value & UCOM_LS_RTS) ? 1 : 0);
 	if (notch_bits & UCOM_LS_BREAK)
-		sc->sc_callback->usb2_com_cfg_set_break(sc,
+		sc->sc_callback->ucom_cfg_set_break(sc,
 		    (prev_value & UCOM_LS_BREAK) ? 1 : 0);
 
 	/* set last value */
 	if (any_bits & UCOM_LS_DTR)
-		sc->sc_callback->usb2_com_cfg_set_dtr(sc,
+		sc->sc_callback->ucom_cfg_set_dtr(sc,
 		    (last_value & UCOM_LS_DTR) ? 1 : 0);
 	if (any_bits & UCOM_LS_RTS)
-		sc->sc_callback->usb2_com_cfg_set_rts(sc,
+		sc->sc_callback->ucom_cfg_set_rts(sc,
 		    (last_value & UCOM_LS_RTS) ? 1 : 0);
 	if (any_bits & UCOM_LS_BREAK)
-		sc->sc_callback->usb2_com_cfg_set_break(sc,
+		sc->sc_callback->ucom_cfg_set_break(sc,
 		    (last_value & UCOM_LS_BREAK) ? 1 : 0);
 }
 
 static void
-usb2_com_line_state(struct ucom_softc *sc,
+ucom_line_state(struct ucom_softc *sc,
     uint8_t set_bits, uint8_t clear_bits)
 {
 	mtx_assert(sc->sc_mtx, MA_OWNED);
@@ -789,46 +789,46 @@ usb2_com_line_state(struct ucom_softc *sc,
 	sc->sc_pls_clr |= clear_bits;
 
 	/* defer driver programming */
-	usb2_com_queue_command(sc, usb2_com_cfg_line_state, NULL,
+	ucom_queue_command(sc, ucom_cfg_line_state, NULL,
 	    &sc->sc_line_state_task[0].hdr, 
 	    &sc->sc_line_state_task[1].hdr);
 }
 
 static void
-usb2_com_break(struct ucom_softc *sc, uint8_t onoff)
+ucom_break(struct ucom_softc *sc, uint8_t onoff)
 {
 	DPRINTF("onoff = %d\n", onoff);
 
 	if (onoff)
-		usb2_com_line_state(sc, UCOM_LS_BREAK, 0);
+		ucom_line_state(sc, UCOM_LS_BREAK, 0);
 	else
-		usb2_com_line_state(sc, 0, UCOM_LS_BREAK);
+		ucom_line_state(sc, 0, UCOM_LS_BREAK);
 }
 
 static void
-usb2_com_dtr(struct ucom_softc *sc, uint8_t onoff)
+ucom_dtr(struct ucom_softc *sc, uint8_t onoff)
 {
 	DPRINTF("onoff = %d\n", onoff);
 
 	if (onoff)
-		usb2_com_line_state(sc, UCOM_LS_DTR, 0);
+		ucom_line_state(sc, UCOM_LS_DTR, 0);
 	else
-		usb2_com_line_state(sc, 0, UCOM_LS_DTR);
+		ucom_line_state(sc, 0, UCOM_LS_DTR);
 }
 
 static void
-usb2_com_rts(struct ucom_softc *sc, uint8_t onoff)
+ucom_rts(struct ucom_softc *sc, uint8_t onoff)
 {
 	DPRINTF("onoff = %d\n", onoff);
 
 	if (onoff)
-		usb2_com_line_state(sc, UCOM_LS_RTS, 0);
+		ucom_line_state(sc, UCOM_LS_RTS, 0);
 	else
-		usb2_com_line_state(sc, 0, UCOM_LS_RTS);
+		ucom_line_state(sc, 0, UCOM_LS_RTS);
 }
 
 static void
-usb2_com_cfg_status_change(struct usb_proc_msg *_task)
+ucom_cfg_status_change(struct usb_proc_msg *_task)
 {
 	struct ucom_cfg_task *task = 
 	    (struct ucom_cfg_task *)_task;
@@ -845,7 +845,7 @@ usb2_com_cfg_status_change(struct usb_proc_msg *_task)
 	if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) {
 		return;
 	}
-	if (sc->sc_callback->usb2_com_cfg_get_status == NULL) {
+	if (sc->sc_callback->ucom_cfg_get_status == NULL) {
 		return;
 	}
 	/* get status */
@@ -853,7 +853,7 @@ usb2_com_cfg_status_change(struct usb_proc_msg *_task)
 	new_msr = 0;
 	new_lsr = 0;
 
-	(sc->sc_callback->usb2_com_cfg_get_status) (sc, &new_lsr, &new_msr);
+	(sc->sc_callback->ucom_cfg_get_status) (sc, &new_lsr, &new_msr);
 
 	if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) {
 		/* TTY device closed */
@@ -875,7 +875,7 @@ usb2_com_cfg_status_change(struct usb_proc_msg *_task)
 }
 
 void
-usb2_com_status_change(struct ucom_softc *sc)
+ucom_status_change(struct ucom_softc *sc)
 {
 	mtx_assert(sc->sc_mtx, MA_OWNED);
 
@@ -884,13 +884,13 @@ usb2_com_status_change(struct ucom_softc *sc)
 	}
 	DPRINTF("\n");
 
-	usb2_com_queue_command(sc, usb2_com_cfg_status_change, NULL,
+	ucom_queue_command(sc, ucom_cfg_status_change, NULL,
 	    &sc->sc_status_task[0].hdr,
 	    &sc->sc_status_task[1].hdr);
 }
 
 static void
-usb2_com_cfg_param(struct usb_proc_msg *_task)
+ucom_cfg_param(struct usb_proc_msg *_task)
 {
 	struct ucom_param_task *task = 
 	    (struct ucom_param_task *)_task;
@@ -899,18 +899,18 @@ usb2_com_cfg_param(struct usb_proc_msg *_task)
 	if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) {
 		return;
 	}
-	if (sc->sc_callback->usb2_com_cfg_param == NULL) {
+	if (sc->sc_callback->ucom_cfg_param == NULL) {
 		return;
 	}
 
-	(sc->sc_callback->usb2_com_cfg_param) (sc, &task->termios_copy);
+	(sc->sc_callback->ucom_cfg_param) (sc, &task->termios_copy);
 
 	/* wait a little */
-	usb2_pause_mtx(sc->sc_mtx, hz / 10);
+	usb_pause_mtx(sc->sc_mtx, hz / 10);
 }
 
 static int
-usb2_com_param(struct tty *tp, struct termios *t)
+ucom_param(struct tty *tp, struct termios *t)
 {
 	struct ucom_softc *sc = tty_softc(tp);
 	uint8_t opened;
@@ -925,7 +925,7 @@ usb2_com_param(struct tty *tp, struct termios *t)
 
 		/* XXX the TTY layer should call "open()" first! */
 
-		error = usb2_com_open(tp);
+		error = ucom_open(tp);
 		if (error) {
 			goto done;
 		}
@@ -946,9 +946,9 @@ usb2_com_param(struct tty *tp, struct termios *t)
 	}
 	t->c_ispeed = t->c_ospeed;
 
-	if (sc->sc_callback->usb2_com_pre_param) {
+	if (sc->sc_callback->ucom_pre_param) {
 		/* Let the lower layer verify the parameters */
-		error = (sc->sc_callback->usb2_com_pre_param) (sc, t);
+		error = (sc->sc_callback->ucom_pre_param) (sc, t);
 		if (error) {
 			DPRINTF("callback error = %d\n", error);
 			goto done;
@@ -959,12 +959,12 @@ usb2_com_param(struct tty *tp, struct termios *t)
 	sc->sc_flag &= ~UCOM_FLAG_GP_DATA;
 
 	/* Queue baud rate programming command first */
-	usb2_com_queue_command(sc, usb2_com_cfg_param, t,
+	ucom_queue_command(sc, ucom_cfg_param, t,
 	    &sc->sc_param_task[0].hdr,
 	    &sc->sc_param_task[1].hdr);
 
 	/* Queue transfer enable command last */
-	usb2_com_queue_command(sc, usb2_com_cfg_start_transfers, NULL,
+	ucom_queue_command(sc, ucom_cfg_start_transfers, NULL,
 	    &sc->sc_start_task[0].hdr, 
 	    &sc->sc_start_task[1].hdr);
 
@@ -972,19 +972,19 @@ usb2_com_param(struct tty *tp, struct termios *t)
 		sc->sc_flag |= UCOM_FLAG_RTS_IFLOW;
 	} else if (sc->sc_flag & UCOM_FLAG_RTS_IFLOW) {
 		sc->sc_flag &= ~UCOM_FLAG_RTS_IFLOW;
-		usb2_com_modem(tp, SER_RTS, 0);
+		ucom_modem(tp, SER_RTS, 0);
 	}
 done:
 	if (error) {
 		if (opened) {
-			usb2_com_close(tp);
+			ucom_close(tp);
 		}
 	}
 	return (error);
 }
 
 static void
-usb2_com_outwakeup(struct tty *tp)
+ucom_outwakeup(struct tty *tp)
 {
 	struct ucom_softc *sc = tty_softc(tp);
 
@@ -996,18 +996,18 @@ usb2_com_outwakeup(struct tty *tp)
 		/* The higher layer is not ready */
 		return;
 	}
-	usb2_com_start_transfers(sc);
+	ucom_start_transfers(sc);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_com_get_data
+ *	ucom_get_data
  *
  * Return values:
  * 0: No data is available.
  * Else: Data is available.
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_com_get_data(struct ucom_softc *sc, struct usb_page_cache *pc,
+ucom_get_data(struct ucom_softc *sc, struct usb_page_cache *pc,
     uint32_t offset, uint32_t len, uint32_t *actlen)
 {
 	struct usb_page_search res;
@@ -1026,7 +1026,7 @@ usb2_com_get_data(struct ucom_softc *sc, struct usb_page_cache *pc,
 
 	while (len != 0) {
 
-		usb2_get_page(pc, offset, &res);
+		usbd_get_page(pc, offset, &res);
 
 		if (res.length > len) {
 			res.length = len;
@@ -1054,7 +1054,7 @@ usb2_com_get_data(struct ucom_softc *sc, struct usb_page_cache *pc,
 }
 
 void
-usb2_com_put_data(struct ucom_softc *sc, struct usb_page_cache *pc,
+ucom_put_data(struct ucom_softc *sc, struct usb_page_cache *pc,
     uint32_t offset, uint32_t len)
 {
 	struct usb_page_search res;
@@ -1074,7 +1074,7 @@ usb2_com_put_data(struct ucom_softc *sc, struct usb_page_cache *pc,
 
 	while (len > 0) {
 
-		usb2_get_page(pc, offset, &res);
+		usbd_get_page(pc, offset, &res);
 
 		if (res.length > len) {
 			res.length = len;
@@ -1111,7 +1111,7 @@ usb2_com_put_data(struct ucom_softc *sc, struct usb_page_cache *pc,
 }
 
 static void
-usb2_com_free(void *xsc)
+ucom_free(void *xsc)
 {
 	struct ucom_softc *sc = xsc;
 
diff --git a/sys/dev/usb/serial/usb_serial.h b/sys/dev/usb/serial/usb_serial.h
index 6f896ce..66a65da 100644
--- a/sys/dev/usb/serial/usb_serial.h
+++ b/sys/dev/usb/serial/usb_serial.h
@@ -85,26 +85,26 @@ struct usb_device_request;
 struct thread;
 
 /*
- * NOTE: There is no guarantee that "usb2_com_cfg_close()" will
- * be called after "usb2_com_cfg_open()" if the device is detached
+ * NOTE: There is no guarantee that "ucom_cfg_close()" will
+ * be called after "ucom_cfg_open()" if the device is detached
  * while it is open!
  */
 struct ucom_callback {
-	void    (*usb2_com_cfg_get_status) (struct ucom_softc *, uint8_t *plsr, uint8_t *pmsr);
-	void    (*usb2_com_cfg_set_dtr) (struct ucom_softc *, uint8_t);
-	void    (*usb2_com_cfg_set_rts) (struct ucom_softc *, uint8_t);
-	void    (*usb2_com_cfg_set_break) (struct ucom_softc *, uint8_t);
-	void    (*usb2_com_cfg_param) (struct ucom_softc *, struct termios *);
-	void    (*usb2_com_cfg_open) (struct ucom_softc *);
-	void    (*usb2_com_cfg_close) (struct ucom_softc *);
-	int     (*usb2_com_pre_open) (struct ucom_softc *);
-	int     (*usb2_com_pre_param) (struct ucom_softc *, struct termios *);
-	int     (*usb2_com_ioctl) (struct ucom_softc *, uint32_t, caddr_t, int, struct thread *);
-	void    (*usb2_com_start_read) (struct ucom_softc *);
-	void    (*usb2_com_stop_read) (struct ucom_softc *);
-	void    (*usb2_com_start_write) (struct ucom_softc *);
-	void    (*usb2_com_stop_write) (struct ucom_softc *);
-	void    (*usb2_com_tty_name) (struct ucom_softc *, char *pbuf, uint16_t buflen, uint16_t local_subunit);
+	void    (*ucom_cfg_get_status) (struct ucom_softc *, uint8_t *plsr, uint8_t *pmsr);
+	void    (*ucom_cfg_set_dtr) (struct ucom_softc *, uint8_t);
+	void    (*ucom_cfg_set_rts) (struct ucom_softc *, uint8_t);
+	void    (*ucom_cfg_set_break) (struct ucom_softc *, uint8_t);
+	void    (*ucom_cfg_param) (struct ucom_softc *, struct termios *);
+	void    (*ucom_cfg_open) (struct ucom_softc *);
+	void    (*ucom_cfg_close) (struct ucom_softc *);
+	int     (*ucom_pre_open) (struct ucom_softc *);
+	int     (*ucom_pre_param) (struct ucom_softc *, struct termios *);
+	int     (*ucom_ioctl) (struct ucom_softc *, uint32_t, caddr_t, int, struct thread *);
+	void    (*ucom_start_read) (struct ucom_softc *);
+	void    (*ucom_stop_read) (struct ucom_softc *);
+	void    (*ucom_start_write) (struct ucom_softc *);
+	void    (*ucom_stop_write) (struct ucom_softc *);
+	void    (*ucom_tty_name) (struct ucom_softc *, char *pbuf, uint16_t buflen, uint16_t local_subunit);
 };
 
 /* Line status register */
@@ -182,18 +182,18 @@ struct ucom_softc {
 #define	UCOM_LS_BREAK	0x04
 };
 
-#define	usb2_com_cfg_do_request(udev,com,req,ptr,flags,timo) \
-    usb2_do_request_proc(udev,&(com)->sc_super->sc_tq,req,ptr,flags,NULL,timo)
+#define	ucom_cfg_do_request(udev,com,req,ptr,flags,timo) \
+    usbd_do_request_proc(udev,&(com)->sc_super->sc_tq,req,ptr,flags,NULL,timo)
 
-int	usb2_com_attach(struct ucom_super_softc *,
+int	ucom_attach(struct ucom_super_softc *,
 	    struct ucom_softc *, uint32_t, void *,
 	    const struct ucom_callback *callback, struct mtx *);
-void	usb2_com_detach(struct ucom_super_softc *,
+void	ucom_detach(struct ucom_super_softc *,
 	    struct ucom_softc *, uint32_t);
-void	usb2_com_status_change(struct ucom_softc *);
-uint8_t	usb2_com_get_data(struct ucom_softc *, struct usb_page_cache *,
+void	ucom_status_change(struct ucom_softc *);
+uint8_t	ucom_get_data(struct ucom_softc *, struct usb_page_cache *,
 	    uint32_t, uint32_t, uint32_t *);
-void	usb2_com_put_data(struct ucom_softc *, struct usb_page_cache *,
+void	ucom_put_data(struct ucom_softc *, struct usb_page_cache *,
 	    uint32_t, uint32_t);
-uint8_t	usb2_com_cfg_is_gone(struct ucom_softc *);
+uint8_t	ucom_cfg_is_gone(struct ucom_softc *);
 #endif					/* _USB2_SERIAL_H_ */
diff --git a/sys/dev/usb/serial/uslcom.c b/sys/dev/usb/serial/uslcom.c
index 66d9461..2047cb2 100644
--- a/sys/dev/usb/serial/uslcom.c
+++ b/sys/dev/usb/serial/uslcom.c
@@ -144,18 +144,18 @@ static const struct usb_config uslcom_config[USLCOM_N_TRANSFER] = {
 };
 
 static struct ucom_callback uslcom_callback = {
-	.usb2_com_cfg_open = &uslcom_open,
-	.usb2_com_cfg_close = &uslcom_close,
-	.usb2_com_cfg_get_status = &uslcom_get_status,
-	.usb2_com_cfg_set_dtr = &uslcom_set_dtr,
-	.usb2_com_cfg_set_rts = &uslcom_set_rts,
-	.usb2_com_cfg_set_break = &uslcom_set_break,
-	.usb2_com_cfg_param = &uslcom_param,
-	.usb2_com_pre_param = &uslcom_pre_param,
-	.usb2_com_start_read = &uslcom_start_read,
-	.usb2_com_stop_read = &uslcom_stop_read,
-	.usb2_com_start_write = &uslcom_start_write,
-	.usb2_com_stop_write = &uslcom_stop_write,
+	.ucom_cfg_open = &uslcom_open,
+	.ucom_cfg_close = &uslcom_close,
+	.ucom_cfg_get_status = &uslcom_get_status,
+	.ucom_cfg_set_dtr = &uslcom_set_dtr,
+	.ucom_cfg_set_rts = &uslcom_set_rts,
+	.ucom_cfg_set_break = &uslcom_set_break,
+	.ucom_cfg_param = &uslcom_param,
+	.ucom_pre_param = &uslcom_pre_param,
+	.ucom_start_read = &uslcom_start_read,
+	.ucom_stop_read = &uslcom_stop_read,
+	.ucom_start_write = &uslcom_start_write,
+	.ucom_stop_write = &uslcom_stop_write,
 };
 
 static const struct usb_device_id uslcom_devs[] = {
@@ -215,7 +215,7 @@ uslcom_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != USLCOM_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(uslcom_devs, sizeof(uslcom_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uslcom_devs, sizeof(uslcom_devs), uaa));
 }
 
 static int
@@ -227,26 +227,26 @@ uslcom_attach(device_t dev)
 
 	DPRINTFN(11, "\n");
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "uslcom", NULL, MTX_DEF);
 
 	sc->sc_udev = uaa->device;
 
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &uaa->info.bIfaceIndex, sc->sc_xfer, uslcom_config,
 	    USLCOM_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		DPRINTF("one or more missing USB endpoints, "
-		    "error=%s\n", usb2_errstr(error));
+		    "error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uslcom_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
@@ -265,8 +265,8 @@ uslcom_detach(device_t dev)
 
 	DPRINTF("sc=%p\n", sc);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, USLCOM_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, USLCOM_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -284,7 +284,7 @@ uslcom_open(struct ucom_softc *ucom)
 	USETW(req.wIndex, USLCOM_PORT_NO);
 	USETW(req.wLength, 0);
 
-        if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+        if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000)) {
 		DPRINTF("UART enable failed (ignored)\n");
 	}
@@ -302,7 +302,7 @@ uslcom_close(struct ucom_softc *ucom)
 	USETW(req.wIndex, USLCOM_PORT_NO);
 	USETW(req.wLength, 0);
 
-        if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+        if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000)) {
 		DPRINTF("UART disable failed (ignored)\n");
 	}
@@ -326,7 +326,7 @@ uslcom_set_dtr(struct ucom_softc *ucom, uint8_t onoff)
 	USETW(req.wIndex, USLCOM_PORT_NO);
 	USETW(req.wLength, 0);
 
-        if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+        if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000)) {
 		DPRINTF("Setting DTR failed (ignored)\n");
 	}
@@ -350,7 +350,7 @@ uslcom_set_rts(struct ucom_softc *ucom, uint8_t onoff)
 	USETW(req.wIndex, USLCOM_PORT_NO);
 	USETW(req.wLength, 0);
 
-        if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+        if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000)) {
 		DPRINTF("Setting DTR failed (ignored)\n");
 	}
@@ -379,7 +379,7 @@ uslcom_param(struct ucom_softc *ucom, struct termios *t)
 	USETW(req.wIndex, USLCOM_PORT_NO);
 	USETW(req.wLength, 0);
 
-        if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+        if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000)) {
 		DPRINTF("Set baudrate failed (ignored)\n");
 	}
@@ -416,7 +416,7 @@ uslcom_param(struct ucom_softc *ucom, struct termios *t)
 	USETW(req.wIndex, USLCOM_PORT_NO);
 	USETW(req.wLength, 0);
 
-        if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+        if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000)) {
 		DPRINTF("Set format failed (ignored)\n");
 	}
@@ -447,7 +447,7 @@ uslcom_set_break(struct ucom_softc *ucom, uint8_t onoff)
 	USETW(req.wIndex, USLCOM_PORT_NO);
 	USETW(req.wLength, 0);
 
-        if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+        if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000)) {
 		DPRINTF("Set BREAK failed (ignored)\n");
 	}
@@ -463,13 +463,13 @@ uslcom_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    USLCOM_BULK_BUF_SIZE, &actlen)) {
 
 			DPRINTF("actlen = %d\n", actlen);
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -490,12 +490,12 @@ uslcom_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -514,7 +514,7 @@ uslcom_start_read(struct ucom_softc *ucom)
 	struct uslcom_softc *sc = ucom->sc_parent;
 
 	/* start read endpoint */
-	usb2_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_RD]);
 }
 
 static void
@@ -523,7 +523,7 @@ uslcom_stop_read(struct ucom_softc *ucom)
 	struct uslcom_softc *sc = ucom->sc_parent;
 
 	/* stop read endpoint */
-	usb2_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_RD]);
 }
 
 static void
@@ -531,7 +531,7 @@ uslcom_start_write(struct ucom_softc *ucom)
 {
 	struct uslcom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_WR]);
 }
 
 static void
@@ -539,5 +539,5 @@ uslcom_stop_write(struct ucom_softc *ucom)
 {
 	struct uslcom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_WR]);
 }
diff --git a/sys/dev/usb/serial/uvisor.c b/sys/dev/usb/serial/uvisor.c
index 11d8fad..1e39947 100644
--- a/sys/dev/usb/serial/uvisor.c
+++ b/sys/dev/usb/serial/uvisor.c
@@ -212,12 +212,12 @@ static const struct usb_config uvisor_config[UVISOR_N_TRANSFER] = {
 };
 
 static const struct ucom_callback uvisor_callback = {
-	.usb2_com_cfg_open = &uvisor_cfg_open,
-	.usb2_com_cfg_close = &uvisor_cfg_close,
-	.usb2_com_start_read = &uvisor_start_read,
-	.usb2_com_stop_read = &uvisor_stop_read,
-	.usb2_com_start_write = &uvisor_start_write,
-	.usb2_com_stop_write = &uvisor_stop_write,
+	.ucom_cfg_open = &uvisor_cfg_open,
+	.ucom_cfg_close = &uvisor_cfg_close,
+	.ucom_start_read = &uvisor_start_read,
+	.ucom_stop_read = &uvisor_stop_read,
+	.ucom_start_write = &uvisor_start_write,
+	.ucom_stop_write = &uvisor_stop_write,
 };
 
 static device_method_t uvisor_methods[] = {
@@ -282,7 +282,7 @@ uvisor_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UVISOR_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(uvisor_devs, sizeof(uvisor_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uvisor_devs, sizeof(uvisor_devs), uaa));
 }
 
 static int
@@ -296,7 +296,7 @@ uvisor_attach(device_t dev)
 	DPRINTF("sc=%p\n", sc);
 	bcopy(uvisor_config, uvisor_config_copy,
 	    sizeof(uvisor_config_copy));
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, "uvisor", NULL, MTX_DEF);
 
@@ -312,10 +312,10 @@ uvisor_attach(device_t dev)
 
 	if (error) {
 		DPRINTF("init failed, error=%s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 		goto detach;
 	}
-	error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index,
+	error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index,
 	    sc->sc_xfer, uvisor_config_copy, UVISOR_N_TRANSFER,
 	    sc, &sc->sc_mtx);
 	if (error) {
@@ -324,14 +324,14 @@ uvisor_attach(device_t dev)
 	}
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uvisor_callback, &sc->sc_mtx);
 	if (error) {
-		DPRINTF("usb2_com_attach failed\n");
+		DPRINTF("ucom_attach failed\n");
 		goto detach;
 	}
 	return (0);
@@ -348,8 +348,8 @@ uvisor_detach(device_t dev)
 
 	DPRINTF("sc=%p\n", sc);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UVISOR_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UVISOR_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -373,7 +373,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config
 		USETW(req.wValue, 0);
 		USETW(req.wIndex, 0);
 		USETW(req.wLength, UVISOR_CONNECTION_INFO_SIZE);
-		err = usb2_do_request_flags(udev, NULL,
+		err = usbd_do_request_flags(udev, NULL,
 		    &req, &coninfo, USB_SHORT_XFER_OK,
 		    &actlen, USB_DEFAULT_TIMEOUT);
 
@@ -426,7 +426,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config
 		USETW(req.wIndex, 0);
 		USETW(req.wLength, UVISOR_GET_PALM_INFORMATION_LEN);
 
-		err = usb2_do_request_flags
+		err = usbd_do_request_flags
 		    (udev, NULL, &req, &pconinfo, USB_SHORT_XFER_OK,
 		    &actlen, USB_DEFAULT_TIMEOUT);
 
@@ -453,7 +453,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config
 		USETW(req.wValue, 0);
 		USETW(req.wIndex, 0);
 		USETW(req.wLength, UVISOR_GET_PALM_INFORMATION_LEN);
-		err = usb2_do_request(udev, &req, buffer);
+		err = usbd_do_request(udev, &req, buffer);
 		if (err) {
 			goto done;
 		}
@@ -468,7 +468,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config
 		USETW(req.wIndex, 0);
 		USETW(req.wLength, 1);
 
-		err = usb2_do_request(udev, NULL, &req, buffer);
+		err = usbd_do_request(udev, NULL, &req, buffer);
 		if (err) {
 			goto done;
 		}
@@ -479,7 +479,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config
 		USETW(req.wValue, 0);
 		USETW(req.wIndex, 0);
 		USETW(req.wLength, 1);
-		err = usb2_do_request(udev, NULL, &req, buffer);
+		err = usbd_do_request(udev, NULL, &req, buffer);
 		if (err) {
 			goto done;
 		}
@@ -490,7 +490,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, 5);
 	USETW(req.wLength, sizeof(wAvail));
-	err = usb2_do_request(udev, NULL, &req, &wAvail);
+	err = usbd_do_request(udev, NULL, &req, &wAvail);
 	if (err) {
 		goto done;
 	}
@@ -521,11 +521,11 @@ uvisor_cfg_close(struct ucom_softc *ucom)
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, UVISOR_CONNECTION_INFO_SIZE);
 
-	err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, buffer, 0, 1000);
 	if (err) {
 		DPRINTFN(0, "close notification failed, error=%s\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 	}
 }
 
@@ -534,7 +534,7 @@ uvisor_start_read(struct ucom_softc *ucom)
 {
 	struct uvisor_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_RD]);
 }
 
 static void
@@ -542,7 +542,7 @@ uvisor_stop_read(struct ucom_softc *ucom)
 {
 	struct uvisor_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_RD]);
 }
 
 static void
@@ -550,7 +550,7 @@ uvisor_start_write(struct ucom_softc *ucom)
 {
 	struct uvisor_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_WR]);
 }
 
 static void
@@ -558,7 +558,7 @@ uvisor_stop_write(struct ucom_softc *ucom)
 {
 	struct uvisor_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_WR]);
 }
 
 static void
@@ -571,11 +571,11 @@ uvisor_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UVISOR_BUFSIZE, &actlen)) {
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -596,12 +596,12 @@ uvisor_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
diff --git a/sys/dev/usb/serial/uvscom.c b/sys/dev/usb/serial/uvscom.c
index 435c738..40b09a6 100644
--- a/sys/dev/usb/serial/uvscom.c
+++ b/sys/dev/usb/serial/uvscom.c
@@ -204,19 +204,19 @@ static const struct usb_config uvscom_config[UVSCOM_N_TRANSFER] = {
 };
 
 static const struct ucom_callback uvscom_callback = {
-	.usb2_com_cfg_get_status = &uvscom_cfg_get_status,
-	.usb2_com_cfg_set_dtr = &uvscom_cfg_set_dtr,
-	.usb2_com_cfg_set_rts = &uvscom_cfg_set_rts,
-	.usb2_com_cfg_set_break = &uvscom_cfg_set_break,
-	.usb2_com_cfg_param = &uvscom_cfg_param,
-	.usb2_com_cfg_open = &uvscom_cfg_open,
-	.usb2_com_cfg_close = &uvscom_cfg_close,
-	.usb2_com_pre_open = &uvscom_pre_open,
-	.usb2_com_pre_param = &uvscom_pre_param,
-	.usb2_com_start_read = &uvscom_start_read,
-	.usb2_com_stop_read = &uvscom_stop_read,
-	.usb2_com_start_write = &uvscom_start_write,
-	.usb2_com_stop_write = &uvscom_stop_write,
+	.ucom_cfg_get_status = &uvscom_cfg_get_status,
+	.ucom_cfg_set_dtr = &uvscom_cfg_set_dtr,
+	.ucom_cfg_set_rts = &uvscom_cfg_set_rts,
+	.ucom_cfg_set_break = &uvscom_cfg_set_break,
+	.ucom_cfg_param = &uvscom_cfg_param,
+	.ucom_cfg_open = &uvscom_cfg_open,
+	.ucom_cfg_close = &uvscom_cfg_close,
+	.ucom_pre_open = &uvscom_pre_open,
+	.ucom_pre_param = &uvscom_pre_param,
+	.ucom_start_read = &uvscom_start_read,
+	.ucom_stop_read = &uvscom_stop_read,
+	.ucom_start_write = &uvscom_start_write,
+	.ucom_stop_write = &uvscom_stop_write,
 };
 
 static const struct usb_device_id uvscom_devs[] = {
@@ -266,7 +266,7 @@ uvscom_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != UVSCOM_IFACE_INDEX) {
 		return (ENXIO);
 	}
-	return (usb2_lookup_id_by_uaa(uvscom_devs, sizeof(uvscom_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uvscom_devs, sizeof(uvscom_devs), uaa));
 }
 
 static int
@@ -276,7 +276,7 @@ uvscom_attach(device_t dev)
 	struct uvscom_softc *sc = device_get_softc(dev);
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	mtx_init(&sc->sc_mtx, "uvscom", NULL, MTX_DEF);
 
 	sc->sc_udev = uaa->device;
@@ -286,7 +286,7 @@ uvscom_attach(device_t dev)
 	sc->sc_iface_no = uaa->info.bIfaceNum;
 	sc->sc_iface_index = UVSCOM_IFACE_INDEX;
 
-	error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index,
+	error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index,
 	    sc->sc_xfer, uvscom_config, UVSCOM_N_TRANSFER, sc, &sc->sc_mtx);
 
 	if (error) {
@@ -297,18 +297,18 @@ uvscom_attach(device_t dev)
 
 	/* clear stall at first run */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
-	usb2_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
+	usbd_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
-	error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
+	error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 	    &uvscom_callback, &sc->sc_mtx);
 	if (error) {
 		goto detach;
 	}
 	/* start interrupt pipe */
 	mtx_lock(&sc->sc_mtx);
-	usb2_transfer_start(sc->sc_xfer[UVSCOM_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UVSCOM_INTR_DT_RD]);
 	mtx_unlock(&sc->sc_mtx);
 
 	return (0);
@@ -328,10 +328,10 @@ uvscom_detach(device_t dev)
 	/* stop interrupt pipe */
 
 	if (sc->sc_xfer[UVSCOM_INTR_DT_RD])
-		usb2_transfer_stop(sc->sc_xfer[UVSCOM_INTR_DT_RD]);
+		usbd_transfer_stop(sc->sc_xfer[UVSCOM_INTR_DT_RD]);
 
-	usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
-	usb2_transfer_unsetup(sc->sc_xfer, UVSCOM_N_TRANSFER);
+	ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
+	usbd_transfer_unsetup(sc->sc_xfer, UVSCOM_N_TRANSFER);
 	mtx_destroy(&sc->sc_mtx);
 
 	return (0);
@@ -347,11 +347,11 @@ uvscom_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 tr_setup:
-		if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+		if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
 		    UVSCOM_BULK_BUF_SIZE, &actlen)) {
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -372,12 +372,12 @@ uvscom_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+		ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
 
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -400,7 +400,7 @@ uvscom_intr_callback(struct usb_xfer *xfer)
 	case USB_ST_TRANSFERRED:
 		if (xfer->actlen >= 2) {
 
-			usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+			usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
 
 			sc->sc_lsr = 0;
 			sc->sc_msr = 0;
@@ -425,12 +425,12 @@ uvscom_intr_callback(struct usb_xfer *xfer)
 			 * the UCOM layer will ignore this call if the TTY
 			 * device is closed!
 			 */
-			usb2_com_status_change(&sc->sc_ucom);
+			ucom_status_change(&sc->sc_ucom);
 		}
 	case USB_ST_SETUP:
 tr_setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -632,7 +632,7 @@ uvscom_start_read(struct ucom_softc *ucom)
 {
 	struct uvscom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
 }
 
 static void
@@ -640,7 +640,7 @@ uvscom_stop_read(struct ucom_softc *ucom)
 {
 	struct uvscom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
 }
 
 static void
@@ -648,7 +648,7 @@ uvscom_start_write(struct ucom_softc *ucom)
 {
 	struct uvscom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
 }
 
 static void
@@ -656,7 +656,7 @@ uvscom_stop_write(struct ucom_softc *ucom)
 {
 	struct uvscom_softc *sc = ucom->sc_parent;
 
-	usb2_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
 }
 
 static void
@@ -680,11 +680,11 @@ uvscom_cfg_write(struct uvscom_softc *sc, uint8_t index, uint16_t value)
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 0);
 
-	err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, NULL, 0, 1000);
 	if (err) {
 		DPRINTFN(0, "device request failed, err=%s "
-		    "(ignored)\n", usb2_errstr(err));
+		    "(ignored)\n", usbd_errstr(err));
 	}
 }
 
@@ -701,11 +701,11 @@ uvscom_cfg_read_status(struct uvscom_softc *sc)
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 2);
 
-	err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
+	err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 
 	    &req, data, 0, 1000);
 	if (err) {
 		DPRINTFN(0, "device request failed, err=%s "
-		    "(ignored)\n", usb2_errstr(err));
+		    "(ignored)\n", usbd_errstr(err));
 	}
 	return (data[0] | (data[1] << 8));
 }
diff --git a/sys/dev/usb/storage/umass.c b/sys/dev/usb/storage/umass.c
index 55c199f..02e60a4 100644
--- a/sys/dev/usb/storage/umass.c
+++ b/sys/dev/usb/storage/umass.c
@@ -1307,7 +1307,7 @@ umass_get_proto(struct usb_interface *iface)
 	retval = 0;
 
 	/* Check for a standards compliant device */
-	id = usb2_get_interface_descriptor(iface);
+	id = usbd_get_interface_descriptor(iface);
 	if ((id == NULL) ||
 	    (id->bInterfaceClass != UICLASS_MASS)) {
 		goto done;
@@ -1468,14 +1468,14 @@ umass_attach(device_t dev)
 	snprintf(sc->sc_name, sizeof(sc->sc_name),
 	    "%s", device_get_nameunit(dev));
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
         mtx_init(&sc->sc_mtx, device_get_nameunit(dev), 
 	    NULL, MTX_DEF | MTX_RECURSE);
 
 	/* get interface index */
 
-	id = usb2_get_interface_descriptor(uaa->iface);
+	id = usbd_get_interface_descriptor(uaa->iface);
 	if (id == NULL) {
 		device_printf(dev, "failed to get "
 		    "interface number\n");
@@ -1526,7 +1526,7 @@ umass_attach(device_t dev)
 #endif
 
 	if (sc->sc_quirks & ALT_IFACE_1) {
-		err = usb2_set_alt_interface_index
+		err = usbd_set_alt_interface_index
 		    (uaa->device, uaa->info.bIfaceIndex, 1);
 
 		if (err) {
@@ -1539,7 +1539,7 @@ umass_attach(device_t dev)
 
 	if (sc->sc_proto & UMASS_PROTO_BBB) {
 
-		err = usb2_transfer_setup(uaa->device,
+		err = usbd_transfer_setup(uaa->device,
 		    &uaa->info.bIfaceIndex, sc->sc_xfer, umass_bbb_config,
 		    UMASS_T_BBB_MAX, sc, &sc->sc_mtx);
 
@@ -1548,7 +1548,7 @@ umass_attach(device_t dev)
 
 	} else if (sc->sc_proto & (UMASS_PROTO_CBI | UMASS_PROTO_CBI_I)) {
 
-		err = usb2_transfer_setup(uaa->device,
+		err = usbd_transfer_setup(uaa->device,
 		    &uaa->info.bIfaceIndex, sc->sc_xfer, umass_cbi_config,
 		    (sc->sc_proto & UMASS_PROTO_CBI_I) ?
 		    UMASS_T_CBI_MAX : (UMASS_T_CBI_MAX - 2), sc,
@@ -1563,7 +1563,7 @@ umass_attach(device_t dev)
 
 	if (err) {
 		device_printf(dev, "could not setup required "
-		    "transfers, %s\n", usb2_errstr(err));
+		    "transfers, %s\n", usbd_errstr(err));
 		goto detach;
 	}
 	sc->sc_transform =
@@ -1594,7 +1594,7 @@ umass_attach(device_t dev)
 	 * some devices need a delay after that the configuration value is
 	 * set to function properly:
 	 */
-	usb2_pause_mtx(NULL, hz);
+	usb_pause_mtx(NULL, hz);
 
 	/* register the SIM */
 	err = umass_cam_attach_sim(sc);
@@ -1622,7 +1622,7 @@ umass_detach(device_t dev)
 
 	/* teardown our statemachine */
 
-	usb2_transfer_unsetup(sc->sc_xfer, UMASS_T_MAX);
+	usbd_transfer_unsetup(sc->sc_xfer, UMASS_T_MAX);
 
 #if (__FreeBSD_version >= 700037)
 	mtx_lock(&sc->sc_mtx);
@@ -1653,7 +1653,7 @@ umass_init_shuttle(struct umass_softc *sc)
 	req.wIndex[0] = sc->sc_iface_no;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, sizeof(status));
-	err = usb2_do_request(sc->sc_udev, NULL, &req, &status);
+	err = usbd_do_request(sc->sc_udev, NULL, &req, &status);
 
 	DPRINTF(sc, UDMASS_GEN, "Shuttle init returned 0x%02x%02x\n",
 	    status[0], status[1]);
@@ -1671,7 +1671,7 @@ umass_transfer_start(struct umass_softc *sc, uint8_t xfer_index)
 
 	if (sc->sc_xfer[xfer_index]) {
 		sc->sc_last_xfer_index = xfer_index;
-		usb2_transfer_start(sc->sc_xfer[xfer_index]);
+		usbd_transfer_start(sc->sc_xfer[xfer_index]);
 	} else {
 		umass_cancel_ccb(sc);
 	}
@@ -1685,7 +1685,7 @@ umass_reset(struct umass_softc *sc)
 	/*
 	 * stop the last transfer, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]);
+	usbd_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]);
 	umass_transfer_start(sc, 0);
 }
 
@@ -1715,7 +1715,7 @@ umass_tr_error(struct usb_xfer *xfer)
 	if (xfer->error != USB_ERR_CANCELLED) {
 
 		DPRINTF(sc, UDMASS_GEN, "transfer error, %s -> "
-		    "reset\n", usb2_errstr(xfer->error));
+		    "reset\n", usbd_errstr(xfer->error));
 	}
 	umass_cancel_ccb(sc);
 }
@@ -1759,11 +1759,11 @@ umass_t_bbb_reset1_callback(struct usb_xfer *xfer)
 		req.wIndex[1] = 0;
 		USETW(req.wLength, 0);
 
-		usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+		usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 		xfer->frlengths[0] = sizeof(req);
 		xfer->nframes = 1;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -1801,7 +1801,7 @@ tr_transferred:
 		return;
 
 	case USB_ST_SETUP:
-		if (usb2_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) {
+		if (usbd_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) {
 			goto tr_transferred;
 		}
 		return;
@@ -1881,10 +1881,10 @@ umass_t_bbb_command_callback(struct usb_xfer *xfer)
 
 			DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw));
 
-			usb2_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw));
+			usbd_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw));
 
 			xfer->frlengths[0] = sizeof(sc->cbw);
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -1904,7 +1904,7 @@ umass_t_bbb_data_read_callback(struct usb_xfer *xfer)
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
 		if (!xfer->flags.ext_buffer) {
-			usb2_copy_out(xfer->frbuffers, 0,
+			usbd_copy_out(xfer->frbuffers, 0,
 			    sc->sc_transfer.data_ptr, xfer->actlen);
 		}
 		sc->sc_transfer.data_rem -= xfer->actlen;
@@ -1930,9 +1930,9 @@ umass_t_bbb_data_read_callback(struct usb_xfer *xfer)
 		xfer->frlengths[0] = max_bulk;
 
 		if (xfer->flags.ext_buffer) {
-			usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
+			usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -1984,13 +1984,13 @@ umass_t_bbb_data_write_callback(struct usb_xfer *xfer)
 		xfer->frlengths[0] = max_bulk;
 
 		if (xfer->flags.ext_buffer) {
-			usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
+			usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
 		} else {
-			usb2_copy_in(xfer->frbuffers, 0,
+			usbd_copy_in(xfer->frbuffers, 0,
 			    sc->sc_transfer.data_ptr, max_bulk);
 		}
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -2031,7 +2031,7 @@ umass_t_bbb_status_callback(struct usb_xfer *xfer)
 		if (xfer->actlen < sizeof(sc->csw)) {
 			bzero(&sc->csw, sizeof(sc->csw));
 		}
-		usb2_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen);
+		usbd_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen);
 
 		DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw));
 
@@ -2105,13 +2105,13 @@ umass_t_bbb_status_callback(struct usb_xfer *xfer)
 
 	case USB_ST_SETUP:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:
 tr_error:
 		DPRINTF(sc, UDMASS_BBB, "Failed to read CSW: %s, try %d\n",
-		    usb2_errstr(xfer->error), sc->sc_status_try);
+		    usbd_errstr(xfer->error), sc->sc_status_try);
 
 		if ((xfer->error == USB_ERR_CANCELLED) ||
 		    (sc->sc_status_try)) {
@@ -2150,7 +2150,7 @@ umass_command_start(struct umass_softc *sc, uint8_t dir,
 	sc->sc_transfer.ccb = ccb;
 
 	if (sc->sc_xfer[sc->sc_last_xfer_index]) {
-		usb2_transfer_start(sc->sc_xfer[sc->sc_last_xfer_index]);
+		usbd_transfer_start(sc->sc_xfer[sc->sc_last_xfer_index]);
 	} else {
 		ccb->ccb_h.status = CAM_TID_INVALID;
 		xpt_done(ccb);
@@ -2172,13 +2172,13 @@ umass_bbb_get_max_lun(struct umass_softc *sc)
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 1);
 
-	err = usb2_do_request(sc->sc_udev, NULL, &req, &buf);
+	err = usbd_do_request(sc->sc_udev, NULL, &req, &buf);
 	if (err) {
 		buf = 0;
 
 		/* Device doesn't support Get Max Lun request. */
 		printf("%s: Get Max Lun not supported (%s)\n",
-		    sc->sc_name, usb2_errstr(err));
+		    sc->sc_name, usbd_errstr(err));
 	}
 	return (buf);
 }
@@ -2255,13 +2255,13 @@ umass_t_cbi_reset1_callback(struct usb_xfer *xfer)
 			buf[i] = 0xff;
 		}
 
-		usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
-		usb2_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf));
+		usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+		usbd_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf));
 
 		xfer->frlengths[0] = sizeof(req);
 		xfer->frlengths[1] = sizeof(buf);
 		xfer->nframes = 2;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -2315,7 +2315,7 @@ tr_transferred:
 		return;
 
 	case USB_ST_SETUP:
-		if (usb2_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) {
+		if (usbd_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) {
 			goto tr_transferred;	/* should not happen */
 		}
 		return;
@@ -2365,8 +2365,8 @@ umass_t_cbi_command_callback(struct usb_xfer *xfer)
 			req.wLength[0] = sc->sc_transfer.cmd_len;
 			req.wLength[1] = 0;
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
-			usb2_copy_in(xfer->frbuffers + 1, 0, sc->sc_transfer.cmd_data,
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers + 1, 0, sc->sc_transfer.cmd_data,
 			    sc->sc_transfer.cmd_len);
 
 			xfer->frlengths[0] = sizeof(req);
@@ -2378,7 +2378,7 @@ umass_t_cbi_command_callback(struct usb_xfer *xfer)
 			    sc->sc_transfer.cmd_data,
 			    sc->sc_transfer.cmd_len));
 
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -2398,7 +2398,7 @@ umass_t_cbi_data_read_callback(struct usb_xfer *xfer)
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
 		if (!xfer->flags.ext_buffer) {
-			usb2_copy_out(xfer->frbuffers, 0,
+			usbd_copy_out(xfer->frbuffers, 0,
 			    sc->sc_transfer.data_ptr, xfer->actlen);
 		}
 		sc->sc_transfer.data_rem -= xfer->actlen;
@@ -2423,10 +2423,10 @@ umass_t_cbi_data_read_callback(struct usb_xfer *xfer)
 		xfer->timeout = sc->sc_transfer.data_timeout;
 
 		if (xfer->flags.ext_buffer) {
-			usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
+			usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
 		}
 		xfer->frlengths[0] = max_bulk;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -2478,14 +2478,14 @@ umass_t_cbi_data_write_callback(struct usb_xfer *xfer)
 		xfer->timeout = sc->sc_transfer.data_timeout;
 
 		if (xfer->flags.ext_buffer) {
-			usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
+			usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
 		} else {
-			usb2_copy_in(xfer->frbuffers, 0,
+			usbd_copy_in(xfer->frbuffers, 0,
 			    sc->sc_transfer.data_ptr, max_bulk);
 		}
 
 		xfer->frlengths[0] = max_bulk;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -2521,7 +2521,7 @@ umass_t_cbi_status_callback(struct usb_xfer *xfer)
 		if (xfer->actlen < sizeof(sc->sbl)) {
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, &sc->sbl, sizeof(sc->sbl));
+		usbd_copy_out(xfer->frbuffers, 0, &sc->sbl, sizeof(sc->sbl));
 
 		residue = (sc->sc_transfer.data_len -
 		    sc->sc_transfer.actlen);
@@ -2585,12 +2585,12 @@ umass_t_cbi_status_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 */
 		DPRINTF(sc, UDMASS_CBI, "Failed to read CSW: %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 		umass_tr_error(xfer);
 		return;
 
@@ -2976,7 +2976,7 @@ umass_cam_action(struct cam_sim *sim, union ccb *ccb)
 				if (sc->sc_quirks & FLOPPY_SPEED) {
 					cpi->base_transfer_speed =
 					    UMASS_FLOPPY_TRANSFER_SPEED;
-				} else if (usb2_get_speed(sc->sc_udev) ==
+				} else if (usbd_get_speed(sc->sc_udev) ==
 				    USB_SPEED_HIGH) {
 					cpi->base_transfer_speed =
 					    UMASS_HIGH_TRANSFER_SPEED;
@@ -3081,7 +3081,7 @@ umass_cam_poll(struct cam_sim *sim)
 
 	DPRINTF(sc, UDMASS_SCSI, "CAM poll\n");
 
-	usb2_do_poll(sc->sc_xfer, UMASS_T_MAX);
+	usbd_do_poll(sc->sc_xfer, UMASS_T_MAX);
 }
 
 
diff --git a/sys/dev/usb/storage/urio.c b/sys/dev/usb/storage/urio.c
index 1163b11..01502bb 100644
--- a/sys/dev/usb/storage/urio.c
+++ b/sys/dev/usb/storage/urio.c
@@ -209,7 +209,7 @@ urio_attach(device_t dev)
 	struct urio_softc *sc = device_get_softc(dev);
 	int error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	sc->sc_udev = uaa->device;
 
@@ -218,16 +218,16 @@ urio_attach(device_t dev)
 	snprintf(sc->sc_name, sizeof(sc->sc_name),
 	    "%s", device_get_nameunit(dev));
 
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &uaa->info.bIfaceIndex, sc->sc_xfer,
 	    urio_config, URIO_T_MAX, sc, &sc->sc_mtx);
 
 	if (error) {
-		DPRINTF("error=%s\n", usb2_errstr(error));
+		DPRINTF("error=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 
-	error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx,
+	error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 	    &urio_fifo_methods, &sc->sc_fifo,
 	    device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex,
 	    UID_ROOT, GID_OPERATOR, 0644);
@@ -252,14 +252,14 @@ urio_write_callback(struct usb_xfer *xfer)
 	case USB_ST_TRANSFERRED:
 	case USB_ST_SETUP:
 		if (sc->sc_flags & URIO_FLAG_WRITE_STALL) {
-			usb2_transfer_start(sc->sc_xfer[URIO_T_WR_CS]);
+			usbd_transfer_start(sc->sc_xfer[URIO_T_WR_CS]);
 			return;
 		}
-		if (usb2_fifo_get_data(f, xfer->frbuffers, 0,
+		if (usb_fifo_get_data(f, xfer->frbuffers, 0,
 		    xfer->max_data_length, &actlen, 0)) {
 
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -267,7 +267,7 @@ urio_write_callback(struct usb_xfer *xfer)
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
 			sc->sc_flags |= URIO_FLAG_WRITE_STALL;
-			usb2_transfer_start(sc->sc_xfer[URIO_T_WR_CS]);
+			usbd_transfer_start(sc->sc_xfer[URIO_T_WR_CS]);
 		}
 		return;
 	}
@@ -279,10 +279,10 @@ urio_write_clear_stall_callback(struct usb_xfer *xfer)
 	struct urio_softc *sc = xfer->priv_sc;
 	struct usb_xfer *xfer_other = sc->sc_xfer[URIO_T_WR];
 
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTF("stall cleared\n");
 		sc->sc_flags &= ~URIO_FLAG_WRITE_STALL;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -294,17 +294,17 @@ urio_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_fifo_put_data(f, xfer->frbuffers, 0,
+		usb_fifo_put_data(f, xfer->frbuffers, 0,
 		    xfer->actlen, 1);
 
 	case USB_ST_SETUP:
 		if (sc->sc_flags & URIO_FLAG_READ_STALL) {
-			usb2_transfer_start(sc->sc_xfer[URIO_T_RD_CS]);
+			usbd_transfer_start(sc->sc_xfer[URIO_T_RD_CS]);
 			return;
 		}
-		if (usb2_fifo_put_bytes_max(f) != 0) {
+		if (usb_fifo_put_bytes_max(f) != 0) {
 			xfer->frlengths[0] = xfer->max_data_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		return;
 
@@ -312,7 +312,7 @@ urio_read_callback(struct usb_xfer *xfer)
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
 			sc->sc_flags |= URIO_FLAG_READ_STALL;
-			usb2_transfer_start(sc->sc_xfer[URIO_T_RD_CS]);
+			usbd_transfer_start(sc->sc_xfer[URIO_T_RD_CS]);
 		}
 		return;
 	}
@@ -324,10 +324,10 @@ urio_read_clear_stall_callback(struct usb_xfer *xfer)
 	struct urio_softc *sc = xfer->priv_sc;
 	struct usb_xfer *xfer_other = sc->sc_xfer[URIO_T_RD];
 
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTF("stall cleared\n");
 		sc->sc_flags &= ~URIO_FLAG_READ_STALL;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -336,7 +336,7 @@ urio_start_read(struct usb_fifo *fifo)
 {
 	struct urio_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[URIO_T_RD]);
+	usbd_transfer_start(sc->sc_xfer[URIO_T_RD]);
 }
 
 static void
@@ -344,8 +344,8 @@ urio_stop_read(struct usb_fifo *fifo)
 {
 	struct urio_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[URIO_T_RD_CS]);
-	usb2_transfer_stop(sc->sc_xfer[URIO_T_RD]);
+	usbd_transfer_stop(sc->sc_xfer[URIO_T_RD_CS]);
+	usbd_transfer_stop(sc->sc_xfer[URIO_T_RD]);
 }
 
 static void
@@ -353,7 +353,7 @@ urio_start_write(struct usb_fifo *fifo)
 {
 	struct urio_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[URIO_T_WR]);
+	usbd_transfer_start(sc->sc_xfer[URIO_T_WR]);
 }
 
 static void
@@ -361,8 +361,8 @@ urio_stop_write(struct usb_fifo *fifo)
 {
 	struct urio_softc *sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[URIO_T_WR_CS]);
-	usb2_transfer_stop(sc->sc_xfer[URIO_T_WR]);
+	usbd_transfer_stop(sc->sc_xfer[URIO_T_WR_CS]);
+	usbd_transfer_stop(sc->sc_xfer[URIO_T_WR]);
 }
 
 static int
@@ -379,7 +379,7 @@ urio_open(struct usb_fifo *fifo, int fflags)
 		sc->sc_flags |= URIO_FLAG_READ_STALL;
 		mtx_unlock(&sc->sc_mtx);
 
-		if (usb2_fifo_alloc_buffer(fifo,
+		if (usb_fifo_alloc_buffer(fifo,
 		    sc->sc_xfer[URIO_T_RD]->max_data_length,
 		    URIO_IFQ_MAXLEN)) {
 			return (ENOMEM);
@@ -389,7 +389,7 @@ urio_open(struct usb_fifo *fifo, int fflags)
 		/* clear stall first */
 		sc->sc_flags |= URIO_FLAG_WRITE_STALL;
 
-		if (usb2_fifo_alloc_buffer(fifo,
+		if (usb_fifo_alloc_buffer(fifo,
 		    sc->sc_xfer[URIO_T_WR]->max_data_length,
 		    URIO_IFQ_MAXLEN)) {
 			return (ENOMEM);
@@ -402,7 +402,7 @@ static void
 urio_close(struct usb_fifo *fifo, int fflags)
 {
 	if (fflags & (FREAD | FWRITE)) {
-		usb2_fifo_free_buffer(fifo);
+		usb_fifo_free_buffer(fifo);
 	}
 }
 
@@ -465,9 +465,9 @@ urio_detach(device_t dev)
 
 	DPRINTF("\n");
 
-	usb2_fifo_detach(&sc->sc_fifo);
+	usb_fifo_detach(&sc->sc_fifo);
 
-	usb2_transfer_unsetup(sc->sc_xfer, URIO_T_MAX);
+	usbd_transfer_unsetup(sc->sc_xfer, URIO_T_MAX);
 
 	mtx_destroy(&sc->sc_mtx);
 
diff --git a/sys/dev/usb/storage/ustorage_fs.c b/sys/dev/usb/storage/ustorage_fs.c
index 80dcb9b..2af5d66 100644
--- a/sys/dev/usb/storage/ustorage_fs.c
+++ b/sys/dev/usb/storage/ustorage_fs.c
@@ -325,7 +325,7 @@ ustorage_fs_probe(device_t dev)
 		return (ENXIO);
 	}
 	/* Check for a standards compliant device */
-	id = usb2_get_interface_descriptor(uaa->iface);
+	id = usbd_get_interface_descriptor(uaa->iface);
 	if ((id == NULL) ||
 	    (id->bInterfaceClass != UICLASS_MASS) ||
 	    (id->bInterfaceSubClass != UISUBCLASS_SCSI) ||
@@ -371,14 +371,14 @@ ustorage_fs_attach(device_t dev)
 		sc->sc_lun[0].removable = 1;
 	}
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, "USTORAGE_FS lock",
 	    NULL, (MTX_DEF | MTX_RECURSE));
 
 	/* get interface index */
 
-	id = usb2_get_interface_descriptor(uaa->iface);
+	id = usbd_get_interface_descriptor(uaa->iface);
 	if (id == NULL) {
 		device_printf(dev, "failed to get "
 		    "interface number\n");
@@ -386,12 +386,12 @@ ustorage_fs_attach(device_t dev)
 	}
 	sc->sc_iface_no = id->bInterfaceNumber;
 
-	err = usb2_transfer_setup(uaa->device,
+	err = usbd_transfer_setup(uaa->device,
 	    &uaa->info.bIfaceIndex, sc->sc_xfer, ustorage_fs_bbb_config,
 	    USTORAGE_FS_T_BBB_MAX, sc, &sc->sc_mtx);
 	if (err) {
 		device_printf(dev, "could not setup required "
-		    "transfers, %s\n", usb2_errstr(err));
+		    "transfers, %s\n", usbd_errstr(err));
 		goto detach;
 	}
 	/* start Mass Storage State Machine */
@@ -414,7 +414,7 @@ ustorage_fs_detach(device_t dev)
 
 	/* teardown our statemachine */
 
-	usb2_transfer_unsetup(sc->sc_xfer, USTORAGE_FS_T_BBB_MAX);
+	usbd_transfer_unsetup(sc->sc_xfer, USTORAGE_FS_T_BBB_MAX);
 
 	mtx_destroy(&sc->sc_mtx);
 
@@ -444,16 +444,16 @@ ustorage_fs_transfer_start(struct ustorage_fs_softc *sc, uint8_t xfer_index)
 {
 	if (sc->sc_xfer[xfer_index]) {
 		sc->sc_last_xfer_index = xfer_index;
-		usb2_transfer_start(sc->sc_xfer[xfer_index]);
+		usbd_transfer_start(sc->sc_xfer[xfer_index]);
 	}
 }
 
 static void
 ustorage_fs_transfer_stop(struct ustorage_fs_softc *sc)
 {
-	usb2_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]);
+	usbd_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]);
 	mtx_unlock(&sc->sc_mtx);
-	usb2_transfer_drain(sc->sc_xfer[sc->sc_last_xfer_index]);
+	usbd_transfer_drain(sc->sc_xfer[sc->sc_last_xfer_index]);
 	mtx_lock(&sc->sc_mtx);
 }
 
@@ -585,8 +585,8 @@ tr_setup:
 		}
 
 		xfer->frlengths[0] = sizeof(sc->sc_cbw);
-		usb2_set_frame_data(xfer, &sc->sc_cbw, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, &sc->sc_cbw, 0);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -654,7 +654,7 @@ tr_setup:
 			xfer->flags.stall_pipe = 0;
 		}
 		xfer->frlengths[0] = max_bulk;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -708,8 +708,8 @@ tr_setup:
 		}
 
 		xfer->frlengths[0] = max_bulk;
-		usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -767,8 +767,8 @@ tr_setup:
 		}
 
 		xfer->frlengths[0] = max_bulk;
-		usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -812,8 +812,8 @@ tr_setup:
 		}
 
 		xfer->frlengths[0] = sizeof(sc->sc_csw);
-		usb2_set_frame_data(xfer, &sc->sc_csw, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, &sc->sc_csw, 0);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:
diff --git a/sys/dev/usb/template/usb_template.c b/sys/dev/usb/template/usb_template.c
index 167d4ef..d4c192d 100644
--- a/sys/dev/usb/template/usb_template.c
+++ b/sys/dev/usb/template/usb_template.c
@@ -34,7 +34,7 @@
 #include <dev/usb/usb_mfunc.h>
 #include <dev/usb/usb_error.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_busdma.h>
@@ -54,50 +54,50 @@ MODULE_VERSION(usb_template, 1);
 
 /* function prototypes */
 
-static void	usb2_make_raw_desc(struct usb_temp_setup *, const uint8_t *);
-static void	usb2_make_endpoint_desc(struct usb_temp_setup *,
+static void	usb_make_raw_desc(struct usb_temp_setup *, const uint8_t *);
+static void	usb_make_endpoint_desc(struct usb_temp_setup *,
 		    const struct usb_temp_endpoint_desc *);
-static void	usb2_make_interface_desc(struct usb_temp_setup *,
+static void	usb_make_interface_desc(struct usb_temp_setup *,
 		    const struct usb_temp_interface_desc *);
-static void	usb2_make_config_desc(struct usb_temp_setup *,
+static void	usb_make_config_desc(struct usb_temp_setup *,
 		    const struct usb_temp_config_desc *);
-static void	usb2_make_device_desc(struct usb_temp_setup *,
+static void	usb_make_device_desc(struct usb_temp_setup *,
 		    const struct usb_temp_device_desc *);
-static uint8_t	usb2_hw_ep_match(const struct usb_hw_ep_profile *, uint8_t,
+static uint8_t	usb_hw_ep_match(const struct usb_hw_ep_profile *, uint8_t,
 		    uint8_t);
-static uint8_t	usb2_hw_ep_find_match(struct usb_hw_ep_scratch *,
+static uint8_t	usb_hw_ep_find_match(struct usb_hw_ep_scratch *,
 		    struct usb_hw_ep_scratch_sub *, uint8_t);
-static uint8_t	usb2_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t,
+static uint8_t	usb_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t,
 		    uint8_t);
-static usb_error_t usb2_hw_ep_resolve(struct usb_device *,
+static usb_error_t usb_hw_ep_resolve(struct usb_device *,
 		    struct usb_descriptor *);
-static const struct usb_temp_device_desc *usb2_temp_get_tdd(struct usb_device *);
-static void	*usb2_temp_get_device_desc(struct usb_device *);
-static void	*usb2_temp_get_qualifier_desc(struct usb_device *);
-static void	*usb2_temp_get_config_desc(struct usb_device *, uint16_t *,
+static const struct usb_temp_device_desc *usb_temp_get_tdd(struct usb_device *);
+static void	*usb_temp_get_device_desc(struct usb_device *);
+static void	*usb_temp_get_qualifier_desc(struct usb_device *);
+static void	*usb_temp_get_config_desc(struct usb_device *, uint16_t *,
 		    uint8_t);
-static const void *usb2_temp_get_string_desc(struct usb_device *, uint16_t,
+static const void *usb_temp_get_string_desc(struct usb_device *, uint16_t,
 		    uint8_t);
-static const void *usb2_temp_get_vendor_desc(struct usb_device *,
+static const void *usb_temp_get_vendor_desc(struct usb_device *,
 		    const struct usb_device_request *);
-static const void *usb2_temp_get_hub_desc(struct usb_device *);
-static usb_error_t usb2_temp_get_desc(struct usb_device *,
+static const void *usb_temp_get_hub_desc(struct usb_device *);
+static usb_error_t usb_temp_get_desc(struct usb_device *,
 		    struct usb_device_request *, const void **, uint16_t *);
 static usb_error_t usb_temp_setup(struct usb_device *,
 		    const struct usb_temp_device_desc *);
-static void	usb2_temp_unsetup(struct usb_device *);
-static usb_error_t usb2_temp_setup_by_index(struct usb_device *,
+static void	usb_temp_unsetup(struct usb_device *);
+static usb_error_t usb_temp_setup_by_index(struct usb_device *,
 		    uint16_t index);
-static void	usb2_temp_init(void *);
+static void	usb_temp_init(void *);
 
 /*------------------------------------------------------------------------*
- *	usb2_make_raw_desc
+ *	usb_make_raw_desc
  *
  * This function will insert a raw USB descriptor into the generated
  * USB configuration.
  *------------------------------------------------------------------------*/
 static void
-usb2_make_raw_desc(struct usb_temp_setup *temp,
+usb_make_raw_desc(struct usb_temp_setup *temp,
     const uint8_t *raw)
 {
 	void *dst;
@@ -132,14 +132,14 @@ usb2_make_raw_desc(struct usb_temp_setup *temp,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_make_endpoint_desc
+ *	usb_make_endpoint_desc
  *
  * This function will generate an USB endpoint descriptor from the
  * given USB template endpoint descriptor, which will be inserted into
  * the USB configuration.
  *------------------------------------------------------------------------*/
 static void
-usb2_make_endpoint_desc(struct usb_temp_setup *temp,
+usb_make_endpoint_desc(struct usb_temp_setup *temp,
     const struct usb_temp_endpoint_desc *ted)
 {
 	struct usb_endpoint_descriptor *ed;
@@ -158,7 +158,7 @@ usb2_make_endpoint_desc(struct usb_temp_setup *temp,
 	rd = ted->ppRawDesc;
 	if (rd) {
 		while (*rd) {
-			usb2_make_raw_desc(temp, *rd);
+			usb_make_raw_desc(temp, *rd);
 			rd++;
 		}
 	}
@@ -232,14 +232,14 @@ usb2_make_endpoint_desc(struct usb_temp_setup *temp,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_make_interface_desc
+ *	usb_make_interface_desc
  *
  * This function will generate an USB interface descriptor from the
  * given USB template interface descriptor, which will be inserted
  * into the USB configuration.
  *------------------------------------------------------------------------*/
 static void
-usb2_make_interface_desc(struct usb_temp_setup *temp,
+usb_make_interface_desc(struct usb_temp_setup *temp,
     const struct usb_temp_interface_desc *tid)
 {
 	struct usb_interface_descriptor *id;
@@ -267,7 +267,7 @@ usb2_make_interface_desc(struct usb_temp_setup *temp,
 
 	if (rd) {
 		while (*rd) {
-			usb2_make_raw_desc(temp, *rd);
+			usb_make_raw_desc(temp, *rd);
 			rd++;
 		}
 	}
@@ -280,7 +280,7 @@ usb2_make_interface_desc(struct usb_temp_setup *temp,
 	ted = tid->ppEndpoints;
 	if (ted) {
 		while (*ted) {
-			usb2_make_endpoint_desc(temp, *ted);
+			usb_make_endpoint_desc(temp, *ted);
 			ted++;
 		}
 	}
@@ -303,14 +303,14 @@ usb2_make_interface_desc(struct usb_temp_setup *temp,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_make_config_desc
+ *	usb_make_config_desc
  *
  * This function will generate an USB config descriptor from the given
  * USB template config descriptor, which will be inserted into the USB
  * configuration.
  *------------------------------------------------------------------------*/
 static void
-usb2_make_config_desc(struct usb_temp_setup *temp,
+usb_make_config_desc(struct usb_temp_setup *temp,
     const struct usb_temp_config_desc *tcd)
 {
 	struct usb_config_descriptor *cd;
@@ -332,7 +332,7 @@ usb2_make_config_desc(struct usb_temp_setup *temp,
 	tid = tcd->ppIfaceDesc;
 	if (tid) {
 		while (*tid) {
-			usb2_make_interface_desc(temp, *tid);
+			usb_make_interface_desc(temp, *tid);
 			tid++;
 		}
 	}
@@ -365,13 +365,13 @@ usb2_make_config_desc(struct usb_temp_setup *temp,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_make_device_desc
+ *	usb_make_device_desc
  *
  * This function will generate an USB device descriptor from the
  * given USB template device descriptor.
  *------------------------------------------------------------------------*/
 static void
-usb2_make_device_desc(struct usb_temp_setup *temp,
+usb_make_device_desc(struct usb_temp_setup *temp,
     const struct usb_temp_device_desc *tdd)
 {
 	struct usb_temp_data *utd;
@@ -389,7 +389,7 @@ usb2_make_device_desc(struct usb_temp_setup *temp,
 	tcd = tdd->ppConfigDesc;
 	if (tcd) {
 		while (*tcd) {
-			usb2_make_config_desc(temp, *tcd);
+			usb_make_config_desc(temp, *tcd);
 			temp->bConfigurationValue++;
 			tcd++;
 		}
@@ -460,14 +460,14 @@ usb2_make_device_desc(struct usb_temp_setup *temp,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_hw_ep_match
+ *	usb_hw_ep_match
  *
  * Return values:
  *    0: The endpoint profile does not match the criterias
  * Else: The endpoint profile matches the criterias
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_hw_ep_match(const struct usb_hw_ep_profile *pf,
+usb_hw_ep_match(const struct usb_hw_ep_profile *pf,
     uint8_t ep_type, uint8_t ep_dir_in)
 {
 	if (ep_type == UE_CONTROL) {
@@ -486,7 +486,7 @@ usb2_hw_ep_match(const struct usb_hw_ep_profile *pf,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_hw_ep_find_match
+ *	usb_hw_ep_find_match
  *
  * This function is used to find the best matching endpoint profile
  * for and endpoint belonging to an USB descriptor.
@@ -496,7 +496,7 @@ usb2_hw_ep_match(const struct usb_hw_ep_profile *pf,
  * Else: Failure. No match.
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues,
+usb_hw_ep_find_match(struct usb_hw_ep_scratch *ues,
     struct usb_hw_ep_scratch_sub *ep, uint8_t is_simplex)
 {
 	const struct usb_hw_ep_profile *pf;
@@ -555,7 +555,7 @@ usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues,
 			continue;
 		}
 		/* check if HW endpoint matches */
-		if (!usb2_hw_ep_match(pf, ep->needs_ep_type, dir_in)) {
+		if (!usb_hw_ep_match(pf, ep->needs_ep_type, dir_in)) {
 			/* mismatch */
 			continue;
 		}
@@ -601,7 +601,7 @@ usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_hw_ep_get_needs
+ *	usb_hw_ep_get_needs
  *
  * This function will figure out the type and number of endpoints
  * which are needed for an USB configuration.
@@ -611,7 +611,7 @@ usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues,
  * Else: Failure.
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_hw_ep_get_needs(struct usb_hw_ep_scratch *ues,
+usb_hw_ep_get_needs(struct usb_hw_ep_scratch *ues,
     uint8_t ep_type, uint8_t is_complete)
 {
 	const struct usb_hw_ep_profile *pf;
@@ -632,11 +632,11 @@ usb2_hw_ep_get_needs(struct usb_hw_ep_scratch *ues,
 	ep_end = ues->ep + USB_EP_MAX;
 	ep_max = ues->ep_max;
 	desc = NULL;
-	speed = usb2_get_speed(ues->udev);
+	speed = usbd_get_speed(ues->udev);
 
 repeat:
 
-	while ((desc = usb2_desc_foreach(ues->cd, desc))) {
+	while ((desc = usb_desc_foreach(ues->cd, desc))) {
 
 		if ((desc->bDescriptorType == UDESC_INTERFACE) &&
 		    (desc->bLength >= sizeof(*id))) {
@@ -771,7 +771,7 @@ handle_endpoint_desc:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_hw_ep_resolve
+ *	usb_hw_ep_resolve
  *
  * This function will try to resolve endpoint requirements by the
  * given endpoint profiles that the USB hardware reports.
@@ -781,7 +781,7 @@ handle_endpoint_desc:
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_hw_ep_resolve(struct usb_device *udev,
+usb_hw_ep_resolve(struct usb_device *udev,
     struct usb_descriptor *desc)
 {
 	struct usb_hw_ep_scratch *ues;
@@ -812,7 +812,7 @@ usb2_hw_ep_resolve(struct usb_device *udev,
 		if (pf == NULL) {
 			return (USB_ERR_INVAL);
 		}
-		if (!usb2_hw_ep_match(pf, UE_CONTROL, 0)) {
+		if (!usb_hw_ep_match(pf, UE_CONTROL, 0)) {
 			DPRINTFN(0, "Endpoint 0 does not "
 			    "support control\n");
 			return (USB_ERR_INVAL);
@@ -868,10 +868,10 @@ usb2_hw_ep_resolve(struct usb_device *udev,
 
 	/* Get all the endpoints we need */
 
-	if (usb2_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) ||
-	    usb2_hw_ep_get_needs(ues, UE_INTERRUPT, 0) ||
-	    usb2_hw_ep_get_needs(ues, UE_CONTROL, 0) ||
-	    usb2_hw_ep_get_needs(ues, UE_BULK, 0)) {
+	if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) ||
+	    usb_hw_ep_get_needs(ues, UE_INTERRUPT, 0) ||
+	    usb_hw_ep_get_needs(ues, UE_CONTROL, 0) ||
+	    usb_hw_ep_get_needs(ues, UE_BULK, 0)) {
 		DPRINTFN(0, "Could not get needs\n");
 		return (USB_ERR_INVAL);
 	}
@@ -883,8 +883,8 @@ usb2_hw_ep_resolve(struct usb_device *udev,
 		         * First try to use a simplex endpoint.
 		         * Then try to use a duplex endpoint.
 		         */
-			if (usb2_hw_ep_find_match(ues, ep, 1) &&
-			    usb2_hw_ep_find_match(ues, ep, 0)) {
+			if (usb_hw_ep_find_match(ues, ep, 1) &&
+			    usb_hw_ep_find_match(ues, ep, 0)) {
 				DPRINTFN(0, "Could not find match\n");
 				return (USB_ERR_INVAL);
 			}
@@ -895,10 +895,10 @@ usb2_hw_ep_resolve(struct usb_device *udev,
 
 	/* Update all endpoint addresses */
 
-	if (usb2_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) ||
-	    usb2_hw_ep_get_needs(ues, UE_INTERRUPT, 1) ||
-	    usb2_hw_ep_get_needs(ues, UE_CONTROL, 1) ||
-	    usb2_hw_ep_get_needs(ues, UE_BULK, 1)) {
+	if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) ||
+	    usb_hw_ep_get_needs(ues, UE_INTERRUPT, 1) ||
+	    usb_hw_ep_get_needs(ues, UE_CONTROL, 1) ||
+	    usb_hw_ep_get_needs(ues, UE_BULK, 1)) {
 		DPRINTFN(0, "Could not update endpoint address\n");
 		return (USB_ERR_INVAL);
 	}
@@ -906,37 +906,37 @@ usb2_hw_ep_resolve(struct usb_device *udev,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_tdd
+ *	usb_temp_get_tdd
  *
  * Returns:
  *  NULL: No USB template device descriptor found.
  *  Else: Pointer to the USB template device descriptor.
  *------------------------------------------------------------------------*/
 static const struct usb_temp_device_desc *
-usb2_temp_get_tdd(struct usb_device *udev)
+usb_temp_get_tdd(struct usb_device *udev)
 {
-	if (udev->usb2_template_ptr == NULL) {
+	if (udev->usb_template_ptr == NULL) {
 		return (NULL);
 	}
-	return (udev->usb2_template_ptr->tdd);
+	return (udev->usb_template_ptr->tdd);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_device_desc
+ *	usb_temp_get_device_desc
  *
  * Returns:
  *  NULL: No USB device descriptor found.
  *  Else: Pointer to USB device descriptor.
  *------------------------------------------------------------------------*/
 static void *
-usb2_temp_get_device_desc(struct usb_device *udev)
+usb_temp_get_device_desc(struct usb_device *udev)
 {
 	struct usb_device_descriptor *dd;
 
-	if (udev->usb2_template_ptr == NULL) {
+	if (udev->usb_template_ptr == NULL) {
 		return (NULL);
 	}
-	dd = &udev->usb2_template_ptr->udd;
+	dd = &udev->usb_template_ptr->udd;
 	if (dd->bDescriptorType != UDESC_DEVICE) {
 		/* sanity check failed */
 		return (NULL);
@@ -945,21 +945,21 @@ usb2_temp_get_device_desc(struct usb_device *udev)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_qualifier_desc
+ *	usb_temp_get_qualifier_desc
  *
  * Returns:
  *  NULL: No USB device_qualifier descriptor found.
  *  Else: Pointer to USB device_qualifier descriptor.
  *------------------------------------------------------------------------*/
 static void *
-usb2_temp_get_qualifier_desc(struct usb_device *udev)
+usb_temp_get_qualifier_desc(struct usb_device *udev)
 {
 	struct usb_device_qualifier *dq;
 
-	if (udev->usb2_template_ptr == NULL) {
+	if (udev->usb_template_ptr == NULL) {
 		return (NULL);
 	}
-	dq = &udev->usb2_template_ptr->udq;
+	dq = &udev->usb_template_ptr->udq;
 	if (dq->bDescriptorType != UDESC_DEVICE_QUALIFIER) {
 		/* sanity check failed */
 		return (NULL);
@@ -968,25 +968,25 @@ usb2_temp_get_qualifier_desc(struct usb_device *udev)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_config_desc
+ *	usb_temp_get_config_desc
  *
  * Returns:
  *  NULL: No USB config descriptor found.
  *  Else: Pointer to USB config descriptor having index "index".
  *------------------------------------------------------------------------*/
 static void *
-usb2_temp_get_config_desc(struct usb_device *udev,
+usb_temp_get_config_desc(struct usb_device *udev,
     uint16_t *pLength, uint8_t index)
 {
 	struct usb_device_descriptor *dd;
 	struct usb_config_descriptor *cd;
 	uint16_t temp;
 
-	if (udev->usb2_template_ptr == NULL) {
+	if (udev->usb_template_ptr == NULL) {
 		return (NULL);
 	}
-	dd = &udev->usb2_template_ptr->udd;
-	cd = (void *)(udev->usb2_template_ptr + 1);
+	dd = &udev->usb_template_ptr->udd;
+	cd = (void *)(udev->usb_template_ptr + 1);
 
 	if (index >= dd->bNumConfigurations) {
 		/* out of range */
@@ -1008,19 +1008,19 @@ usb2_temp_get_config_desc(struct usb_device *udev,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_vendor_desc
+ *	usb_temp_get_vendor_desc
  *
  * Returns:
  *  NULL: No vendor descriptor found.
  *  Else: Pointer to a vendor descriptor.
  *------------------------------------------------------------------------*/
 static const void *
-usb2_temp_get_vendor_desc(struct usb_device *udev,
+usb_temp_get_vendor_desc(struct usb_device *udev,
     const struct usb_device_request *req)
 {
 	const struct usb_temp_device_desc *tdd;
 
-	tdd = usb2_temp_get_tdd(udev);
+	tdd = usb_temp_get_tdd(udev);
 	if (tdd == NULL) {
 		return (NULL);
 	}
@@ -1031,19 +1031,19 @@ usb2_temp_get_vendor_desc(struct usb_device *udev,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_string_desc
+ *	usb_temp_get_string_desc
  *
  * Returns:
  *  NULL: No string descriptor found.
  *  Else: Pointer to a string descriptor.
  *------------------------------------------------------------------------*/
 static const void *
-usb2_temp_get_string_desc(struct usb_device *udev,
+usb_temp_get_string_desc(struct usb_device *udev,
     uint16_t lang_id, uint8_t string_index)
 {
 	const struct usb_temp_device_desc *tdd;
 
-	tdd = usb2_temp_get_tdd(udev);
+	tdd = usb_temp_get_tdd(udev);
 	if (tdd == NULL) {
 		return (NULL);
 	}
@@ -1054,26 +1054,26 @@ usb2_temp_get_string_desc(struct usb_device *udev,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_hub_desc
+ *	usb_temp_get_hub_desc
  *
  * Returns:
  *  NULL: No USB HUB descriptor found.
  *  Else: Pointer to a USB HUB descriptor.
  *------------------------------------------------------------------------*/
 static const void *
-usb2_temp_get_hub_desc(struct usb_device *udev)
+usb_temp_get_hub_desc(struct usb_device *udev)
 {
 	return (NULL);			/* needs to be implemented */
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_get_desc
+ *	usb_temp_get_desc
  *
  * This function is a demultiplexer for local USB device side control
  * endpoint requests.
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_temp_get_desc(struct usb_device *udev, struct usb_device_request *req,
+usb_temp_get_desc(struct usb_device *udev, struct usb_device_request *req,
     const void **pPtr, uint16_t *pLength)
 {
 	const uint8_t *buf;
@@ -1101,7 +1101,7 @@ usb2_temp_get_desc(struct usb_device *udev, struct usb_device_request *req,
 		break;
 	case UT_READ_VENDOR_DEVICE:
 	case UT_READ_VENDOR_OTHER:
-		buf = usb2_temp_get_vendor_desc(udev, req);
+		buf = usb_temp_get_vendor_desc(udev, req);
 		goto tr_valid;
 	default:
 		goto tr_stalled;
@@ -1113,7 +1113,7 @@ tr_handle_get_descriptor:
 		if (req->wValue[0]) {
 			goto tr_stalled;
 		}
-		buf = usb2_temp_get_device_desc(udev);
+		buf = usb_temp_get_device_desc(udev);
 		goto tr_valid;
 	case UDESC_DEVICE_QUALIFIER:
 		if (udev->speed != USB_SPEED_HIGH) {
@@ -1122,18 +1122,18 @@ tr_handle_get_descriptor:
 		if (req->wValue[0]) {
 			goto tr_stalled;
 		}
-		buf = usb2_temp_get_qualifier_desc(udev);
+		buf = usb_temp_get_qualifier_desc(udev);
 		goto tr_valid;
 	case UDESC_OTHER_SPEED_CONFIGURATION:
 		if (udev->speed != USB_SPEED_HIGH) {
 			goto tr_stalled;
 		}
 	case UDESC_CONFIG:
-		buf = usb2_temp_get_config_desc(udev,
+		buf = usb_temp_get_config_desc(udev,
 		    &len, req->wValue[0]);
 		goto tr_valid;
 	case UDESC_STRING:
-		buf = usb2_temp_get_string_desc(udev,
+		buf = usb_temp_get_string_desc(udev,
 		    UGETW(req->wIndex), req->wValue[0]);
 		goto tr_valid;
 	default:
@@ -1145,7 +1145,7 @@ tr_handle_get_class_descriptor:
 	if (req->wValue[0]) {
 		goto tr_stalled;
 	}
-	buf = usb2_temp_get_hub_desc(udev);
+	buf = usb_temp_get_hub_desc(udev);
 	goto tr_valid;
 
 tr_valid:
@@ -1197,7 +1197,7 @@ usb_temp_setup(struct usb_device *udev,
 
 	/* first pass */
 
-	usb2_make_device_desc(uts, tdd);
+	usb_make_device_desc(uts, tdd);
 
 	if (uts->err) {
 		/* some error happened */
@@ -1217,12 +1217,12 @@ usb_temp_setup(struct usb_device *udev,
 
 	uts->size = 0;
 
-	usb2_make_device_desc(uts, tdd);
+	usb_make_device_desc(uts, tdd);
 
 	/*
 	 * Store a pointer to our descriptors:
 	 */
-	udev->usb2_template_ptr = uts->buf;
+	udev->usb_template_ptr = uts->buf;
 
 	if (uts->err) {
 		/* some error happened during second pass */
@@ -1231,66 +1231,66 @@ usb_temp_setup(struct usb_device *udev,
 	/*
 	 * Resolve all endpoint addresses !
 	 */
-	buf = usb2_temp_get_device_desc(udev);
-	uts->err = usb2_hw_ep_resolve(udev, buf);
+	buf = usb_temp_get_device_desc(udev);
+	uts->err = usb_hw_ep_resolve(udev, buf);
 	if (uts->err) {
 		DPRINTFN(0, "Could not resolve endpoints for "
 		    "Device Descriptor, error = %s\n",
-		    usb2_errstr(uts->err));
+		    usbd_errstr(uts->err));
 		goto error;
 	}
 	for (n = 0;; n++) {
 
-		buf = usb2_temp_get_config_desc(udev, NULL, n);
+		buf = usb_temp_get_config_desc(udev, NULL, n);
 		if (buf == NULL) {
 			break;
 		}
-		uts->err = usb2_hw_ep_resolve(udev, buf);
+		uts->err = usb_hw_ep_resolve(udev, buf);
 		if (uts->err) {
 			DPRINTFN(0, "Could not resolve endpoints for "
 			    "Config Descriptor %u, error = %s\n", n,
-			    usb2_errstr(uts->err));
+			    usbd_errstr(uts->err));
 			goto error;
 		}
 	}
 	return (uts->err);
 
 error:
-	usb2_temp_unsetup(udev);
+	usb_temp_unsetup(udev);
 	return (uts->err);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_temp_unsetup
+ *	usb_temp_unsetup
  *
  * This function frees any memory associated with the currently
  * setup template, if any.
  *------------------------------------------------------------------------*/
 static void
-usb2_temp_unsetup(struct usb_device *udev)
+usb_temp_unsetup(struct usb_device *udev)
 {
-	if (udev->usb2_template_ptr) {
+	if (udev->usb_template_ptr) {
 
-		free(udev->usb2_template_ptr, M_USB);
+		free(udev->usb_template_ptr, M_USB);
 
-		udev->usb2_template_ptr = NULL;
+		udev->usb_template_ptr = NULL;
 	}
 }
 
 static usb_error_t
-usb2_temp_setup_by_index(struct usb_device *udev, uint16_t index)
+usb_temp_setup_by_index(struct usb_device *udev, uint16_t index)
 {
 	usb_error_t err;
 
 	switch (index) {
 	case 0:
-		err = usb_temp_setup(udev, &usb2_template_msc);
+		err = usb_temp_setup(udev, &usb_template_msc);
 		break;
 	case 1:
-		err = usb_temp_setup(udev, &usb2_template_cdce);
+		err = usb_temp_setup(udev, &usb_template_cdce);
 		break;
 	case 2:
-		err = usb_temp_setup(udev, &usb2_template_mtp);
+		err = usb_temp_setup(udev, &usb_template_mtp);
 		break;
 	default:
 		return (USB_ERR_INVAL);
@@ -1300,13 +1300,13 @@ usb2_temp_setup_by_index(struct usb_device *udev, uint16_t index)
 }
 
 static void
-usb2_temp_init(void *arg)
+usb_temp_init(void *arg)
 {
 	/* register our functions */
-	usb2_temp_get_desc_p = &usb2_temp_get_desc;
-	usb2_temp_setup_by_index_p = &usb2_temp_setup_by_index;
-	usb2_temp_unsetup_p = &usb2_temp_unsetup;
+	usb_temp_get_desc_p = &usb_temp_get_desc;
+	usb_temp_setup_by_index_p = &usb_temp_setup_by_index;
+	usb_temp_unsetup_p = &usb_temp_unsetup;
 }
 
-SYSINIT(usb2_temp_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb2_temp_init, NULL);
-SYSUNINIT(usb2_temp_unload, SI_SUB_LOCK, SI_ORDER_ANY, usb2_temp_unload, NULL);
+SYSINIT(usb_temp_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_temp_init, NULL);
+SYSUNINIT(usb_temp_unload, SI_SUB_LOCK, SI_ORDER_ANY, usb_temp_unload, NULL);
diff --git a/sys/dev/usb/template/usb_template.h b/sys/dev/usb/template/usb_template.h
index 60f733b..cc9ca0c 100644
--- a/sys/dev/usb/template/usb_template.h
+++ b/sys/dev/usb/template/usb_template.h
@@ -30,8 +30,8 @@
 #ifndef _USB_TEMPLATE_H_
 #define	_USB_TEMPLATE_H_
 
-typedef const void *(usb2_temp_get_string_desc_t)(uint16_t lang_id, uint8_t string_index);
-typedef const void *(usb2_temp_get_vendor_desc_t)(const struct usb_device_request *req);
+typedef const void *(usb_temp_get_string_desc_t)(uint16_t lang_id, uint8_t string_index);
+typedef const void *(usb_temp_get_vendor_desc_t)(const struct usb_device_request *req);
 
 struct usb_temp_packet_size {
 	uint16_t mps[USB_SPEED_MAX];
@@ -72,8 +72,8 @@ struct usb_temp_config_desc {
 };
 
 struct usb_temp_device_desc {
-	usb2_temp_get_string_desc_t *getStringDesc;
-	usb2_temp_get_vendor_desc_t *getVendorDesc;
+	usb_temp_get_string_desc_t *getStringDesc;
+	usb_temp_get_vendor_desc_t *getVendorDesc;
 	const struct usb_temp_config_desc **ppConfigDesc;
 	uint16_t idVendor;
 	uint16_t idProduct;
@@ -94,9 +94,9 @@ struct usb_temp_data {
 
 /* prototypes */
 
-extern const struct usb_temp_device_desc usb2_template_cdce;
-extern const struct usb_temp_device_desc usb2_template_msc;	/* Mass Storage Class */
-extern const struct usb_temp_device_desc usb2_template_mtp;	/* Message Transfer
+extern const struct usb_temp_device_desc usb_template_cdce;
+extern const struct usb_temp_device_desc usb_template_msc;	/* Mass Storage Class */
+extern const struct usb_temp_device_desc usb_template_mtp;	/* Message Transfer
 								 * Protocol */
 
 #endif					/* _USB_TEMPLATE_H_ */
diff --git a/sys/dev/usb/template/usb_template_cdce.c b/sys/dev/usb/template/usb_template_cdce.c
index b8e0f8a..f648dd8 100644
--- a/sys/dev/usb/template/usb_template_cdce.c
+++ b/sys/dev/usb/template/usb_template_cdce.c
@@ -116,7 +116,7 @@ USB_MAKE_STRING_DESC(STRING_ETH_SERIAL, string_eth_serial);
 
 /* prototypes */
 
-static usb2_temp_get_string_desc_t eth_get_string_desc;
+static usb_temp_get_string_desc_t eth_get_string_desc;
 
 static const struct usb_cdc_union_descriptor eth_union_desc = {
 	.bLength = sizeof(eth_union_desc),
@@ -244,7 +244,7 @@ static const struct usb_temp_config_desc *eth_configs[] = {
 	NULL,
 };
 
-const struct usb_temp_device_desc usb2_template_cdce = {
+const struct usb_temp_device_desc usb_template_cdce = {
 	.getStringDesc = &eth_get_string_desc,
 	.ppConfigDesc = eth_configs,
 	.idVendor = 0x0001,
diff --git a/sys/dev/usb/template/usb_template_msc.c b/sys/dev/usb/template/usb_template_msc.c
index 8f2e7ba..b42cdb6 100644
--- a/sys/dev/usb/template/usb_template_msc.c
+++ b/sys/dev/usb/template/usb_template_msc.c
@@ -95,7 +95,7 @@ USB_MAKE_STRING_DESC(STRING_MSC_SERIAL, string_msc_serial);
 
 /* prototypes */
 
-static usb2_temp_get_string_desc_t msc_get_string_desc;
+static usb_temp_get_string_desc_t msc_get_string_desc;
 
 static const struct usb_temp_packet_size bulk_mps = {
 	.mps[USB_SPEED_FULL] = 64,
@@ -153,7 +153,7 @@ static const struct usb_temp_config_desc *msc_configs[] = {
 	NULL,
 };
 
-const struct usb_temp_device_desc usb2_template_msc = {
+const struct usb_temp_device_desc usb_template_msc = {
 	.getStringDesc = &msc_get_string_desc,
 	.ppConfigDesc = msc_configs,
 	.idVendor = 0x0001,
diff --git a/sys/dev/usb/template/usb_template_mtp.c b/sys/dev/usb/template/usb_template_mtp.c
index 1cb694f..acc088a 100644
--- a/sys/dev/usb/template/usb_template_mtp.c
+++ b/sys/dev/usb/template/usb_template_mtp.c
@@ -100,8 +100,8 @@ USB_MAKE_STRING_DESC(STRING_MTP_SERIAL, string_mtp_serial);
 
 /* prototypes */
 
-static usb2_temp_get_string_desc_t mtp_get_string_desc;
-static usb2_temp_get_vendor_desc_t mtp_get_vendor_desc;
+static usb_temp_get_string_desc_t mtp_get_string_desc;
+static usb_temp_get_vendor_desc_t mtp_get_vendor_desc;
 
 static const struct usb_temp_packet_size bulk_mps = {
 	.mps[USB_SPEED_FULL] = 64,
@@ -171,7 +171,7 @@ static const struct usb_temp_config_desc *mtp_configs[] = {
 	NULL,
 };
 
-const struct usb_temp_device_desc usb2_template_mtp = {
+const struct usb_temp_device_desc usb_template_mtp = {
 	.getStringDesc = &mtp_get_string_desc,
 	.getVendorDesc = &mtp_get_vendor_desc,
 	.ppConfigDesc = mtp_configs,
diff --git a/sys/dev/usb/usb_busdma.c b/sys/dev/usb/usb_busdma.c
index 0059303..48fb603 100644
--- a/sys/dev/usb/usb_busdma.c
+++ b/sys/dev/usb/usb_busdma.c
@@ -28,7 +28,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_busdma.h>
@@ -42,23 +42,23 @@
 #include <dev/usb/usb_bus.h>
 
 #if USB_HAVE_BUSDMA
-static void	usb2_dma_tag_create(struct usb_dma_tag *, usb_size_t, usb_size_t);
-static void	usb2_dma_tag_destroy(struct usb_dma_tag *);
-static void	usb2_dma_lock_cb(void *, bus_dma_lock_op_t);
-static void	usb2_pc_alloc_mem_cb(void *, bus_dma_segment_t *, int, int);
-static void	usb2_pc_load_mem_cb(void *, bus_dma_segment_t *, int, int);
-static void	usb2_pc_common_mem_cb(void *, bus_dma_segment_t *, int, int,
+static void	usb_dma_tag_create(struct usb_dma_tag *, usb_size_t, usb_size_t);
+static void	usb_dma_tag_destroy(struct usb_dma_tag *);
+static void	usb_dma_lock_cb(void *, bus_dma_lock_op_t);
+static void	usb_pc_alloc_mem_cb(void *, bus_dma_segment_t *, int, int);
+static void	usb_pc_load_mem_cb(void *, bus_dma_segment_t *, int, int);
+static void	usb_pc_common_mem_cb(void *, bus_dma_segment_t *, int, int,
 		    uint8_t);
 #endif
 
 /*------------------------------------------------------------------------*
- *  usb2_get_page - lookup DMA-able memory for the given offset
+ *  usbd_get_page - lookup DMA-able memory for the given offset
  *
  * NOTE: Only call this function when the "page_cache" structure has
  * been properly initialized !
  *------------------------------------------------------------------------*/
 void
-usb2_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
+usbd_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
     struct usb_page_search *res)
 {
 	struct usb_page *page;
@@ -111,17 +111,17 @@ usb2_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
 }
 
 /*------------------------------------------------------------------------*
- *  usb2_copy_in - copy directly to DMA-able memory
+ *  usbd_copy_in - copy directly to DMA-able memory
  *------------------------------------------------------------------------*/
 void
-usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
+usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
     const void *ptr, usb_frlength_t len)
 {
 	struct usb_page_search buf_res;
 
 	while (len != 0) {
 
-		usb2_get_page(cache, offset, &buf_res);
+		usbd_get_page(cache, offset, &buf_res);
 
 		if (buf_res.length > len) {
 			buf_res.length = len;
@@ -135,7 +135,7 @@ usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
 }
 
 /*------------------------------------------------------------------------*
- *  usb2_copy_in_user - copy directly to DMA-able memory from userland
+ *  usbd_copy_in_user - copy directly to DMA-able memory from userland
  *
  * Return values:
  *    0: Success
@@ -143,7 +143,7 @@ usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
  *------------------------------------------------------------------------*/
 #if USB_HAVE_USER_IO
 int
-usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
+usbd_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
     const void *ptr, usb_frlength_t len)
 {
 	struct usb_page_search buf_res;
@@ -151,7 +151,7 @@ usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
 
 	while (len != 0) {
 
-		usb2_get_page(cache, offset, &buf_res);
+		usbd_get_page(cache, offset, &buf_res);
 
 		if (buf_res.length > len) {
 			buf_res.length = len;
@@ -169,41 +169,41 @@ usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
 #endif
 
 /*------------------------------------------------------------------------*
- *  usb2_m_copy_in - copy a mbuf chain directly into DMA-able memory
+ *  usbd_m_copy_in - copy a mbuf chain directly into DMA-able memory
  *------------------------------------------------------------------------*/
 #if USB_HAVE_MBUF
-struct usb2_m_copy_in_arg {
+struct usb_m_copy_in_arg {
 	struct usb_page_cache *cache;
 	usb_frlength_t dst_offset;
 };
 
 static int
-usb2_m_copy_in_cb(void *arg, void *src, uint32_t count)
+usbd_m_copy_in_cb(void *arg, void *src, uint32_t count)
 {
-	register struct usb2_m_copy_in_arg *ua = arg;
+	register struct usb_m_copy_in_arg *ua = arg;
 
-	usb2_copy_in(ua->cache, ua->dst_offset, src, count);
+	usbd_copy_in(ua->cache, ua->dst_offset, src, count);
 	ua->dst_offset += count;
 	return (0);
 }
 
 void
-usb2_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset,
+usbd_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset,
     struct mbuf *m, usb_size_t src_offset, usb_frlength_t src_len)
 {
-	struct usb2_m_copy_in_arg arg = {cache, dst_offset};
+	struct usb_m_copy_in_arg arg = {cache, dst_offset};
 	int error;
 
-	error = m_apply(m, src_offset, src_len, &usb2_m_copy_in_cb, &arg);
+	error = m_apply(m, src_offset, src_len, &usbd_m_copy_in_cb, &arg);
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *  usb2_uiomove - factored out code
+ *  usb_uiomove - factored out code
  *------------------------------------------------------------------------*/
 #if USB_HAVE_USER_IO
 int
-usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,
+usb_uiomove(struct usb_page_cache *pc, struct uio *uio,
     usb_frlength_t pc_offset, usb_frlength_t len)
 {
 	struct usb_page_search res;
@@ -211,7 +211,7 @@ usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,
 
 	while (len != 0) {
 
-		usb2_get_page(pc, pc_offset, &res);
+		usbd_get_page(pc, pc_offset, &res);
 
 		if (res.length > len) {
 			res.length = len;
@@ -233,17 +233,17 @@ usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,
 #endif
 
 /*------------------------------------------------------------------------*
- *  usb2_copy_out - copy directly from DMA-able memory
+ *  usbd_copy_out - copy directly from DMA-able memory
  *------------------------------------------------------------------------*/
 void
-usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
+usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
     void *ptr, usb_frlength_t len)
 {
 	struct usb_page_search res;
 
 	while (len != 0) {
 
-		usb2_get_page(cache, offset, &res);
+		usbd_get_page(cache, offset, &res);
 
 		if (res.length > len) {
 			res.length = len;
@@ -257,7 +257,7 @@ usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
 }
 
 /*------------------------------------------------------------------------*
- *  usb2_copy_out_user - copy directly from DMA-able memory to userland
+ *  usbd_copy_out_user - copy directly from DMA-able memory to userland
  *
  * Return values:
  *    0: Success
@@ -265,7 +265,7 @@ usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
  *------------------------------------------------------------------------*/
 #if USB_HAVE_USER_IO
 int
-usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
+usbd_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
     void *ptr, usb_frlength_t len)
 {
 	struct usb_page_search res;
@@ -273,7 +273,7 @@ usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
 
 	while (len != 0) {
 
-		usb2_get_page(cache, offset, &res);
+		usbd_get_page(cache, offset, &res);
 
 		if (res.length > len) {
 			res.length = len;
@@ -291,17 +291,17 @@ usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
 #endif
 
 /*------------------------------------------------------------------------*
- *  usb2_bzero - zero DMA-able memory
+ *  usbd_frame_zero - zero DMA-able memory
  *------------------------------------------------------------------------*/
 void
-usb2_bzero(struct usb_page_cache *cache, usb_frlength_t offset,
+usbd_frame_zero(struct usb_page_cache *cache, usb_frlength_t offset,
     usb_frlength_t len)
 {
 	struct usb_page_search res;
 
 	while (len != 0) {
 
-		usb2_get_page(cache, offset, &res);
+		usbd_get_page(cache, offset, &res);
 
 		if (res.length > len) {
 			res.length = len;
@@ -316,22 +316,22 @@ usb2_bzero(struct usb_page_cache *cache, usb_frlength_t offset,
 #if USB_HAVE_BUSDMA
 
 /*------------------------------------------------------------------------*
- *	usb2_dma_lock_cb - dummy callback
+ *	usb_dma_lock_cb - dummy callback
  *------------------------------------------------------------------------*/
 static void
-usb2_dma_lock_cb(void *arg, bus_dma_lock_op_t op)
+usb_dma_lock_cb(void *arg, bus_dma_lock_op_t op)
 {
 	/* we use "mtx_owned()" instead of this function */
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dma_tag_create - allocate a DMA tag
+ *	usb_dma_tag_create - allocate a DMA tag
  *
  * NOTE: If the "align" parameter has a value of 1 the DMA-tag will
  * allow multi-segment mappings. Else all mappings are single-segment.
  *------------------------------------------------------------------------*/
 static void
-usb2_dma_tag_create(struct usb_dma_tag *udt,
+usb_dma_tag_create(struct usb_dma_tag *udt,
     usb_size_t size, usb_size_t align)
 {
 	bus_dma_tag_t tag;
@@ -350,7 +350,7 @@ usb2_dma_tag_create(struct usb_dma_tag *udt,
 	     /* maxsegsz  */ (align == 1) ?
 	    USB_PAGE_SIZE : size,
 	     /* flags     */ BUS_DMA_KEEP_PG_OFFSET,
-	     /* lockfn    */ &usb2_dma_lock_cb,
+	     /* lockfn    */ &usb_dma_lock_cb,
 	     /* lockarg   */ NULL,
 	    &tag)) {
 		tag = NULL;
@@ -359,39 +359,39 @@ usb2_dma_tag_create(struct usb_dma_tag *udt,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dma_tag_free - free a DMA tag
+ *	usb_dma_tag_free - free a DMA tag
  *------------------------------------------------------------------------*/
 static void
-usb2_dma_tag_destroy(struct usb_dma_tag *udt)
+usb_dma_tag_destroy(struct usb_dma_tag *udt)
 {
 	bus_dma_tag_destroy(udt->tag);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_alloc_mem_cb - BUS-DMA callback function
+ *	usb_pc_alloc_mem_cb - BUS-DMA callback function
  *------------------------------------------------------------------------*/
 static void
-usb2_pc_alloc_mem_cb(void *arg, bus_dma_segment_t *segs,
+usb_pc_alloc_mem_cb(void *arg, bus_dma_segment_t *segs,
     int nseg, int error)
 {
-	usb2_pc_common_mem_cb(arg, segs, nseg, error, 0);
+	usb_pc_common_mem_cb(arg, segs, nseg, error, 0);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_load_mem_cb - BUS-DMA callback function
+ *	usb_pc_load_mem_cb - BUS-DMA callback function
  *------------------------------------------------------------------------*/
 static void
-usb2_pc_load_mem_cb(void *arg, bus_dma_segment_t *segs,
+usb_pc_load_mem_cb(void *arg, bus_dma_segment_t *segs,
     int nseg, int error)
 {
-	usb2_pc_common_mem_cb(arg, segs, nseg, error, 1);
+	usb_pc_common_mem_cb(arg, segs, nseg, error, 1);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_common_mem_cb - BUS-DMA callback function
+ *	usb_pc_common_mem_cb - BUS-DMA callback function
  *------------------------------------------------------------------------*/
 static void
-usb2_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs,
+usb_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs,
     int nseg, int error, uint8_t isload)
 {
 	struct usb_dma_parent_tag *uptag;
@@ -452,14 +452,14 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_alloc_mem - allocate DMA'able memory
+ *	usb_pc_alloc_mem - allocate DMA'able memory
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
+usb_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
     usb_size_t size, usb_size_t align)
 {
 	struct usb_dma_parent_tag *uptag;
@@ -505,7 +505,7 @@ usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
 #endif
 	}
 	/* get the correct DMA tag */
-	utag = usb2_dma_tag_find(uptag, size, align);
+	utag = usb_dma_tag_find(uptag, size, align);
 	if (utag == NULL) {
 		goto error;
 	}
@@ -527,7 +527,7 @@ usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
 
 	/* load memory into DMA */
 	err = bus_dmamap_load(
-	    utag->tag, map, ptr, size, &usb2_pc_alloc_mem_cb,
+	    utag->tag, map, ptr, size, &usb_pc_alloc_mem_cb,
 	    pc, (BUS_DMA_WAITOK | BUS_DMA_COHERENT));
 
 	if (err == EINPROGRESS) {
@@ -542,7 +542,7 @@ usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
 	}
 	bzero(ptr, size);
 
-	usb2_pc_cpu_flush(pc);
+	usb_pc_cpu_flush(pc);
 
 	return (0);
 
@@ -558,12 +558,12 @@ error:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_free_mem - free DMA memory
+ *	usb_pc_free_mem - free DMA memory
  *
  * This function is NULL safe.
  *------------------------------------------------------------------------*/
 void
-usb2_pc_free_mem(struct usb_page_cache *pc)
+usb_pc_free_mem(struct usb_page_cache *pc)
 {
 	if (pc && pc->buffer) {
 
@@ -576,14 +576,14 @@ usb2_pc_free_mem(struct usb_page_cache *pc)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_load_mem - load virtual memory into DMA
+ *	usb_pc_load_mem - load virtual memory into DMA
  *
  * Return values:
  * 0: Success
  * Else: Error
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync)
+usb_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync)
 {
 	/* setup page cache */
 	pc->page_offset_buf = 0;
@@ -610,7 +610,7 @@ usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync)
 			 */
 			err = bus_dmamap_load(
 			    pc->tag, pc->map, pc->buffer, size,
-			    &usb2_pc_alloc_mem_cb, pc, BUS_DMA_WAITOK);
+			    &usb_pc_alloc_mem_cb, pc, BUS_DMA_WAITOK);
 			if (err == EINPROGRESS) {
 				cv_wait(uptag->cv, uptag->mtx);
 				err = 0;
@@ -632,7 +632,7 @@ usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync)
 			 */
 			if (bus_dmamap_load(
 			    pc->tag, pc->map, pc->buffer, size,
-			    &usb2_pc_load_mem_cb, pc, BUS_DMA_WAITOK)) {
+			    &usb_pc_load_mem_cb, pc, BUS_DMA_WAITOK)) {
 			}
 		}
 	} else {
@@ -649,10 +649,10 @@ usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_cpu_invalidate - invalidate CPU cache
+ *	usb_pc_cpu_invalidate - invalidate CPU cache
  *------------------------------------------------------------------------*/
 void
-usb2_pc_cpu_invalidate(struct usb_page_cache *pc)
+usb_pc_cpu_invalidate(struct usb_page_cache *pc)
 {
 	if (pc->page_offset_end == pc->page_offset_buf) {
 		/* nothing has been loaded into this page cache! */
@@ -663,10 +663,10 @@ usb2_pc_cpu_invalidate(struct usb_page_cache *pc)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_cpu_flush - flush CPU cache
+ *	usb_pc_cpu_flush - flush CPU cache
  *------------------------------------------------------------------------*/
 void
-usb2_pc_cpu_flush(struct usb_page_cache *pc)
+usb_pc_cpu_flush(struct usb_page_cache *pc)
 {
 	if (pc->page_offset_end == pc->page_offset_buf) {
 		/* nothing has been loaded into this page cache! */
@@ -677,14 +677,14 @@ usb2_pc_cpu_flush(struct usb_page_cache *pc)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_dmamap_create - create a DMA map
+ *	usb_pc_dmamap_create - create a DMA map
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size)
+usb_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size)
 {
 	struct usb_xfer_root *info;
 	struct usb_dma_tag *utag;
@@ -696,7 +696,7 @@ usb2_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size)
 	if (info == NULL) {
 		goto error;
 	}
-	utag = usb2_dma_tag_find(pc->tag_parent, size, 1);
+	utag = usb_dma_tag_find(pc->tag_parent, size, 1);
 	if (utag == NULL) {
 		goto error;
 	}
@@ -714,12 +714,12 @@ error:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pc_dmamap_destroy
+ *	usb_pc_dmamap_destroy
  *
  * This function is NULL safe.
  *------------------------------------------------------------------------*/
 void
-usb2_pc_dmamap_destroy(struct usb_page_cache *pc)
+usb_pc_dmamap_destroy(struct usb_page_cache *pc)
 {
 	if (pc && pc->tag) {
 		bus_dmamap_destroy(pc->tag, pc->map);
@@ -729,10 +729,10 @@ usb2_pc_dmamap_destroy(struct usb_page_cache *pc)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dma_tag_find - factored out code
+ *	usb_dma_tag_find - factored out code
  *------------------------------------------------------------------------*/
 struct usb_dma_tag *
-usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,
+usb_dma_tag_find(struct usb_dma_parent_tag *udpt,
     usb_size_t size, usb_size_t align)
 {
 	struct usb_dma_tag *udt;
@@ -747,7 +747,7 @@ usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,
 	while (nudt--) {
 
 		if (udt->align == 0) {
-			usb2_dma_tag_create(udt, size, align);
+			usb_dma_tag_create(udt, size, align);
 			if (udt->tag == NULL) {
 				return (NULL);
 			}
@@ -764,10 +764,10 @@ usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dma_tag_setup - initialise USB DMA tags
+ *	usb_dma_tag_setup - initialise USB DMA tags
  *------------------------------------------------------------------------*/
 void
-usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt,
+usb_dma_tag_setup(struct usb_dma_parent_tag *udpt,
     struct usb_dma_tag *udt, bus_dma_tag_t dmat,
     struct mtx *mtx, usb_dma_callback_t *func,
     uint8_t ndmabits, uint8_t nudt)
@@ -800,10 +800,10 @@ usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_tag_unsetup - factored out code
+ *	usb_bus_tag_unsetup - factored out code
  *------------------------------------------------------------------------*/
 void
-usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt)
+usb_dma_tag_unsetup(struct usb_dma_parent_tag *udpt)
 {
 	struct usb_dma_tag *udt;
 	uint8_t nudt;
@@ -815,7 +815,7 @@ usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt)
 
 		if (udt->align) {
 			/* destroy the USB DMA tag */
-			usb2_dma_tag_destroy(udt);
+			usb_dma_tag_destroy(udt);
 			udt->align = 0;
 		}
 		udt++;
@@ -828,13 +828,13 @@ usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bdma_work_loop
+ *	usb_bdma_work_loop
  *
  * This function handles loading of virtual buffers into DMA and is
  * only called when "dma_refcount" is zero.
  *------------------------------------------------------------------------*/
 void
-usb2_bdma_work_loop(struct usb_xfer_queue *pq)
+usb_bdma_work_loop(struct usb_xfer_queue *pq)
 {
 	struct usb_xfer_root *info;
 	struct usb_xfer *xfer;
@@ -848,7 +848,7 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq)
 	if (xfer->error) {
 		/* some error happened */
 		USB_BUS_LOCK(info->bus);
-		usb2_transfer_done(xfer, 0);
+		usbd_transfer_done(xfer, 0);
 		USB_BUS_UNLOCK(info->bus);
 		return;
 	}
@@ -922,7 +922,7 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq)
 	}
 	if (info->dma_error) {
 		USB_BUS_LOCK(info->bus);
-		usb2_transfer_done(xfer, USB_ERR_DMA_LOAD_FAILED);
+		usbd_transfer_done(xfer, USB_ERR_DMA_LOAD_FAILED);
 		USB_BUS_UNLOCK(info->bus);
 		return;
 	}
@@ -930,12 +930,12 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq)
 
 		if (info->dma_currframe == 0) {
 			/* special case */
-			usb2_pc_load_mem(xfer->frbuffers,
+			usb_pc_load_mem(xfer->frbuffers,
 			    info->dma_frlength_0, 0);
 		} else {
 			/* default case */
 			nframes = info->dma_currframe;
-			usb2_pc_load_mem(xfer->frbuffers + nframes,
+			usb_pc_load_mem(xfer->frbuffers + nframes,
 			    xfer->frlengths[nframes], 0);
 		}
 
@@ -945,23 +945,23 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq)
 		return;
 	}
 	/* go ahead */
-	usb2_bdma_pre_sync(xfer);
+	usb_bdma_pre_sync(xfer);
 
 	/* start loading next USB transfer, if any */
-	usb2_command_wrapper(pq, NULL);
+	usb_command_wrapper(pq, NULL);
 
 	/* finally start the hardware */
-	usb2_pipe_enter(xfer);
+	usbd_pipe_enter(xfer);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bdma_done_event
+ *	usb_bdma_done_event
  *
  * This function is called when the BUS-DMA has loaded virtual memory
  * into DMA, if any.
  *------------------------------------------------------------------------*/
 void
-usb2_bdma_done_event(struct usb_dma_parent_tag *udpt)
+usb_bdma_done_event(struct usb_dma_parent_tag *udpt)
 {
 	struct usb_xfer_root *info;
 
@@ -973,18 +973,18 @@ usb2_bdma_done_event(struct usb_dma_parent_tag *udpt)
 	info->dma_error = udpt->dma_error;
 
 	/* enter workloop again */
-	usb2_command_wrapper(&info->dma_q,
+	usb_command_wrapper(&info->dma_q,
 	    info->dma_q.curr);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bdma_pre_sync
+ *	usb_bdma_pre_sync
  *
  * This function handles DMA synchronisation that must be done before
  * an USB transfer is started.
  *------------------------------------------------------------------------*/
 void
-usb2_bdma_pre_sync(struct usb_xfer *xfer)
+usb_bdma_pre_sync(struct usb_xfer *xfer)
 {
 	struct usb_page_cache *pc;
 	usb_frcount_t nframes;
@@ -1002,22 +1002,22 @@ usb2_bdma_pre_sync(struct usb_xfer *xfer)
 	while (nframes--) {
 
 		if (pc->isread) {
-			usb2_pc_cpu_invalidate(pc);
+			usb_pc_cpu_invalidate(pc);
 		} else {
-			usb2_pc_cpu_flush(pc);
+			usb_pc_cpu_flush(pc);
 		}
 		pc++;
 	}
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bdma_post_sync
+ *	usb_bdma_post_sync
  *
  * This function handles DMA synchronisation that must be done after
  * an USB transfer is complete.
  *------------------------------------------------------------------------*/
 void
-usb2_bdma_post_sync(struct usb_xfer *xfer)
+usb_bdma_post_sync(struct usb_xfer *xfer)
 {
 	struct usb_page_cache *pc;
 	usb_frcount_t nframes;
@@ -1034,7 +1034,7 @@ usb2_bdma_post_sync(struct usb_xfer *xfer)
 
 	while (nframes--) {
 		if (pc->isread) {
-			usb2_pc_cpu_invalidate(pc);
+			usb_pc_cpu_invalidate(pc);
 		}
 		pc++;
 	}
diff --git a/sys/dev/usb/usb_busdma.h b/sys/dev/usb/usb_busdma.h
index ef2ee5d..9d7c2d6 100644
--- a/sys/dev/usb/usb_busdma.h
+++ b/sys/dev/usb/usb_busdma.h
@@ -136,40 +136,40 @@ struct usb_dma_tag {};			/* empty struct */
 
 /* function prototypes */
 
-int	usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,
+int	usb_uiomove(struct usb_page_cache *pc, struct uio *uio,
 	    usb_frlength_t pc_offset, usb_frlength_t len);
-struct usb_dma_tag *usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,
+struct usb_dma_tag *usb_dma_tag_find(struct usb_dma_parent_tag *udpt,
 	    usb_size_t size, usb_size_t align);
-uint8_t	usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
+uint8_t	usb_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
 	    usb_size_t size, usb_size_t align);
-uint8_t	usb2_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size);
-uint8_t	usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size,
+uint8_t	usb_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size);
+uint8_t	usb_pc_load_mem(struct usb_page_cache *pc, usb_size_t size,
 	    uint8_t sync);
-void	usb2_bdma_done_event(struct usb_dma_parent_tag *udpt);
-void	usb2_bdma_post_sync(struct usb_xfer *xfer);
-void	usb2_bdma_pre_sync(struct usb_xfer *xfer);
-void	usb2_bdma_work_loop(struct usb_xfer_queue *pq);
-void	usb2_bzero(struct usb_page_cache *cache, usb_frlength_t offset,
+void	usb_bdma_done_event(struct usb_dma_parent_tag *udpt);
+void	usb_bdma_post_sync(struct usb_xfer *xfer);
+void	usb_bdma_pre_sync(struct usb_xfer *xfer);
+void	usb_bdma_work_loop(struct usb_xfer_queue *pq);
+void	usbd_frame_zero(struct usb_page_cache *cache, usb_frlength_t offset,
 	    usb_frlength_t len);
-void	usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
+void	usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
 	    const void *ptr, usb_frlength_t len);
-int	usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
+int	usbd_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
 	    const void *ptr, usb_frlength_t len);
-void	usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
+void	usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
 	    void *ptr, usb_frlength_t len);
-int	usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
+int	usbd_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
 	    void *ptr, usb_frlength_t len);
-void	usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt,
+void	usb_dma_tag_setup(struct usb_dma_parent_tag *udpt,
 	    struct usb_dma_tag *udt, bus_dma_tag_t dmat, struct mtx *mtx,
 	    usb_dma_callback_t *func, uint8_t ndmabits, uint8_t nudt);
-void	usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt);
-void	usb2_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
+void	usb_dma_tag_unsetup(struct usb_dma_parent_tag *udpt);
+void	usbd_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
 	    struct usb_page_search *res);
-void	usb2_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset,
+void	usbd_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset,
 	    struct mbuf *m, usb_size_t src_offset, usb_frlength_t src_len);
-void	usb2_pc_cpu_flush(struct usb_page_cache *pc);
-void	usb2_pc_cpu_invalidate(struct usb_page_cache *pc);
-void	usb2_pc_dmamap_destroy(struct usb_page_cache *pc);
-void	usb2_pc_free_mem(struct usb_page_cache *pc);
+void	usb_pc_cpu_flush(struct usb_page_cache *pc);
+void	usb_pc_cpu_invalidate(struct usb_page_cache *pc);
+void	usb_pc_dmamap_destroy(struct usb_page_cache *pc);
+void	usb_pc_free_mem(struct usb_page_cache *pc);
 
 #endif					/* _USB2_BUSDMA_H_ */
diff --git a/sys/dev/usb/usb_compat_linux.c b/sys/dev/usb/usb_compat_linux.c
index dc3829d..f971fe3 100644
--- a/sys/dev/usb/usb_compat_linux.c
+++ b/sys/dev/usb/usb_compat_linux.c
@@ -30,7 +30,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb_ioctl.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_compat_linux.h>
@@ -254,7 +254,7 @@ usb_linux_attach(device_t dev)
 	}
 	if (usb_linux_create_usb_device(uaa->device, dev) != 0)
 		return (ENOMEM);
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	sc->sc_fbsd_udev = uaa->device;
 	sc->sc_fbsd_dev = dev;
@@ -359,7 +359,7 @@ static uint16_t
 usb_max_isoc_frames(struct usb_device *dev)
 {
 	;				/* indent fix */
-	switch (usb2_get_speed(dev)) {
+	switch (usbd_get_speed(dev)) {
 	case USB_SPEED_LOW:
 	case USB_SPEED_FULL:
 		return (USB_MAX_FULL_SPEED_ISOC_FRAMES);
@@ -403,8 +403,8 @@ usb_submit_urb(struct urb *urb, uint16_t mem_flags)
 
 		urb->status = -EINPROGRESS;
 
-		usb2_transfer_start(uhe->bsd_xfer[0]);
-		usb2_transfer_start(uhe->bsd_xfer[1]);
+		usbd_transfer_start(uhe->bsd_xfer[0]);
+		usbd_transfer_start(uhe->bsd_xfer[1]);
 	} else {
 		/* no pipes have been setup yet! */
 		urb->status = -EINVAL;
@@ -430,16 +430,16 @@ usb_unlink_bsd(struct usb_xfer *xfer,
     struct urb *urb, uint8_t drain)
 {
 	if (xfer &&
-	    usb2_transfer_pending(xfer) &&
+	    usbd_transfer_pending(xfer) &&
 	    (xfer->priv_fifo == (void *)urb)) {
 		if (drain) {
 			mtx_unlock(&Giant);
-			usb2_transfer_drain(xfer);
+			usbd_transfer_drain(xfer);
 			mtx_lock(&Giant);
 		} else {
-			usb2_transfer_stop(xfer);
+			usbd_transfer_stop(xfer);
 		}
-		usb2_transfer_start(xfer);
+		usbd_transfer_start(xfer);
 	}
 }
 
@@ -515,11 +515,11 @@ usb_clear_halt(struct usb_device *dev, struct usb_host_endpoint *uhe)
 	cfg[0].endpoint = addr & UE_ADDR;
 	cfg[0].direction = addr & (UE_DIR_OUT | UE_DIR_IN);
 
-	ep = usb2_get_endpoint(dev, uhe->bsd_iface_index, cfg);
+	ep = usbd_get_endpoint(dev, uhe->bsd_iface_index, cfg);
 	if (ep == NULL)
 		return (-EINVAL);
 
-	usb2_clear_data_toggle(dev, ep);
+	usbd_clear_data_toggle(dev, ep);
 
 	return (usb_control_msg(dev, &dev->ep0,
 	    UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT,
@@ -618,7 +618,7 @@ usb_control_msg(struct usb_device *dev, struct usb_host_endpoint *uhe,
 		 * The FreeBSD USB stack supports standard control
 		 * transfers on control endpoint zero:
 		 */
-		err = usb2_do_request_flags(dev,
+		err = usbd_do_request_flags(dev,
 		    &Giant, &req, data, USB_SHORT_XFER_OK,
 		    &actlen, timeout);
 		if (err) {
@@ -689,7 +689,7 @@ usb_set_interface(struct usb_device *dev, uint8_t iface_no, uint8_t alt_index)
 	if (alt_index >= p_ui->num_altsetting)
 		return (-EINVAL);
 	usb_linux_cleanup_interface(dev, p_ui);
-	err = -usb2_set_alt_interface_index(dev,
+	err = -usbd_set_alt_interface_index(dev,
 	    p_ui->bsd_iface_index, alt_index);
 	if (err == 0) {
 		p_ui->cur_altsetting = p_ui->altsetting + alt_index;
@@ -720,7 +720,7 @@ usb_setup_endpoint(struct usb_device *dev,
 		/* optimize */
 		return (0);
 	}
-	usb2_transfer_unsetup(uhe->bsd_xfer, 2);
+	usbd_transfer_unsetup(uhe->bsd_xfer, 2);
 
 	uhe->fbsd_buf_size = bufsize;
 
@@ -759,7 +759,7 @@ usb_setup_endpoint(struct usb_device *dev,
 
 		/* Allocate and setup two generic FreeBSD USB transfers */
 
-		if (usb2_transfer_setup(dev, &uhe->bsd_iface_index,
+		if (usbd_transfer_setup(dev, &uhe->bsd_iface_index,
 		    uhe->bsd_xfer, cfg, 2, uhe, &Giant)) {
 			return (-EINVAL);
 		}
@@ -779,7 +779,7 @@ usb_setup_endpoint(struct usb_device *dev,
 		cfg[0].flags.proxy_buffer = 1;
 		cfg[0].flags.short_xfer_ok = 1;
 
-		if (usb2_transfer_setup(dev, &uhe->bsd_iface_index,
+		if (usbd_transfer_setup(dev, &uhe->bsd_iface_index,
 		    uhe->bsd_xfer, cfg, 1, uhe, &Giant)) {
 			return (-EINVAL);
 		}
@@ -797,7 +797,7 @@ usb_setup_endpoint(struct usb_device *dev,
 static int
 usb_linux_create_usb_device(struct usb_device *udev, device_t dev)
 {
-	struct usb_config_descriptor *cd = usb2_get_config_descriptor(udev);
+	struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
 	struct usb_descriptor *desc;
 	struct usb_interface_descriptor *id;
 	struct usb_endpoint_descriptor *ed;
@@ -828,7 +828,7 @@ usb_linux_create_usb_device(struct usb_device *udev, device_t dev)
 		 * Iterate over all the USB descriptors. Use the USB config
 		 * descriptor pointer provided by the FreeBSD USB stack.
 		 */
-		while ((desc = usb2_desc_foreach(cd, desc))) {
+		while ((desc = usb_desc_foreach(cd, desc))) {
 
 			/*
 			 * Build up a tree according to the descriptors we
@@ -1065,10 +1065,10 @@ usb_buffer_alloc(struct usb_device *dev, usb_size_t size, uint16_t mem_flags, ui
 }
 
 /*------------------------------------------------------------------------*
- *	usb_get_intfdata
+ *	usbd_get_intfdata
  *------------------------------------------------------------------------*/
 void   *
-usb_get_intfdata(struct usb_interface *intf)
+usbd_get_intfdata(struct usb_interface *intf)
 {
 	return (intf->bsd_priv_sc);
 }
@@ -1091,7 +1091,7 @@ usb_linux_register(void *arg)
 	LIST_INSERT_HEAD(&usb_linux_driver_list, drv, linux_driver_list);
 	mtx_unlock(&Giant);
 
-	usb2_needs_explore_all();
+	usb_needs_explore_all();
 }
 
 /*------------------------------------------------------------------------*
@@ -1306,7 +1306,7 @@ usb_linux_isoc_callback(struct usb_xfer *xfer)
 				uipd->actual_length = xfer->frlengths[x];
 				uipd->status = 0;
 				if (!xfer->flags.ext_buffer) {
-					usb2_copy_out(xfer->frbuffers, offset,
+					usbd_copy_out(xfer->frbuffers, offset,
 					    USB_ADD_BYTES(urb->transfer_buffer,
 					    uipd->offset), uipd->actual_length);
 				}
@@ -1377,7 +1377,7 @@ tr_setup:
 				uipd = urb->iso_frame_desc + x;
 				xfer->frlengths[x] = uipd->length;
 				if (!xfer->flags.ext_buffer) {
-					usb2_copy_in(xfer->frbuffers, offset,
+					usbd_copy_in(xfer->frbuffers, offset,
 					    USB_ADD_BYTES(urb->transfer_buffer,
 					    uipd->offset), uipd->length);
 				}
@@ -1402,14 +1402,14 @@ tr_setup:
 
 		if (xfer->flags.ext_buffer) {
 			/* set virtual address to load */
-			usb2_set_frame_data(xfer,
+			usbd_set_frame_data(xfer,
 			    urb->transfer_buffer, 0);
 		}
 		xfer->priv_fifo = urb;
 		xfer->flags.force_short_xfer = 0;
 		xfer->timeout = urb->timeout;
 		xfer->nframes = urb->number_of_packets;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -1473,7 +1473,7 @@ usb_linux_non_isoc_callback(struct usb_xfer *xfer)
 		}
 		if (urb->bsd_isread && (!xfer->flags.ext_buffer)) {
 			/* copy in data with regard to the URB */
-			usb2_copy_out(xfer->frbuffers + data_frame, 0,
+			usbd_copy_out(xfer->frbuffers + data_frame, 0,
 			    urb->bsd_data_ptr, xfer->frlengths[data_frame]);
 		}
 		urb->bsd_length_rem -= xfer->frlengths[data_frame];
@@ -1524,11 +1524,11 @@ tr_setup:
 		         * First copy in the header, then copy in data!
 		         */
 			if (!xfer->flags.ext_buffer) {
-				usb2_copy_in(xfer->frbuffers, 0,
+				usbd_copy_in(xfer->frbuffers, 0,
 				    urb->setup_packet, REQ_SIZE);
 			} else {
 				/* set virtual address to load */
-				usb2_set_frame_data(xfer,
+				usbd_set_frame_data(xfer,
 				    urb->setup_packet, 0);
 			}
 
@@ -1567,11 +1567,11 @@ setup_bulk:
 
 		if (xfer->flags.ext_buffer) {
 			/* set virtual address to load */
-			usb2_set_frame_data(xfer, urb->bsd_data_ptr,
+			usbd_set_frame_data(xfer, urb->bsd_data_ptr,
 			    data_frame);
 		} else if (!urb->bsd_isread) {
 			/* copy out data with regard to the URB */
-			usb2_copy_in(xfer->frbuffers + data_frame, 0,
+			usbd_copy_in(xfer->frbuffers + data_frame, 0,
 			    urb->bsd_data_ptr, max_bulk);
 		}
 		xfer->frlengths[data_frame] = max_bulk;
@@ -1584,7 +1584,7 @@ setup_bulk:
 		} else {
 			xfer->nframes = 1;
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:
diff --git a/sys/dev/usb/usb_compat_linux.h b/sys/dev/usb/usb_compat_linux.h
index 6ac8859..5ce8196 100644
--- a/sys/dev/usb/usb_compat_linux.h
+++ b/sys/dev/usb/usb_compat_linux.h
@@ -328,7 +328,7 @@ struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, uint8_t iface_no);
 
 void   *usb_buffer_alloc(struct usb_device *dev, usb_size_t size,
 	    uint16_t mem_flags, uint8_t *dma_addr);
-void   *usb_get_intfdata(struct usb_interface *intf);
+void   *usbd_get_intfdata(struct usb_interface *intf);
 
 void	usb_buffer_free(struct usb_device *dev, usb_size_t size, void *addr, uint8_t dma_addr);
 void	usb_free_urb(struct urb *urb);
diff --git a/sys/dev/usb/usb_controller.h b/sys/dev/usb/usb_controller.h
index dbf86a6..1b5a391 100644
--- a/sys/dev/usb/usb_controller.h
+++ b/sys/dev/usb/usb_controller.h
@@ -183,11 +183,11 @@ struct usb_temp_setup {
 
 /* prototypes */
 
-void	usb2_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb);
-uint8_t	usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, usb_bus_mem_cb_t *cb);
-void	usb2_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb);
-uint16_t usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr);
-uint16_t usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, struct usb_fs_isoc_schedule **pp_start, struct usb_fs_isoc_schedule **pp_end, uint16_t isoc_time);
-uint8_t	usb2_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss, uint8_t *pstart, uint16_t len);
+void	usb_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb);
+uint8_t	usb_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, usb_bus_mem_cb_t *cb);
+void	usb_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb);
+uint16_t usb_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr);
+uint16_t usbd_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, struct usb_fs_isoc_schedule **pp_start, struct usb_fs_isoc_schedule **pp_end, uint16_t isoc_time);
+uint8_t	usbd_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss, uint8_t *pstart, uint16_t len);
 
 #endif					/* _USB2_CONTROLLER_H_ */
diff --git a/sys/dev/usb/usb_core.h b/sys/dev/usb/usb_core.h
index dd6990f..c7018af 100644
--- a/sys/dev/usb/usb_core.h
+++ b/sys/dev/usb/usb_core.h
@@ -216,7 +216,7 @@
  * The following macro will return the current state of an USB
  * transfer like defined by the "USB_ST_XXX" enums.
  */
-#define	USB_GET_STATE(xfer) ((xfer)->usb2_state)
+#define	USB_GET_STATE(xfer) ((xfer)->usb_state)
 
 /*
  * The following macro will tell if an USB transfer is currently
@@ -238,11 +238,11 @@
 
 /* macros */
 
-#define	usb2_callout_init_mtx(c,m,f) callout_init_mtx(&(c)->co,m,f)
-#define	usb2_callout_reset(c,t,f,d) callout_reset(&(c)->co,t,f,d)
-#define	usb2_callout_stop(c) callout_stop(&(c)->co)
-#define	usb2_callout_drain(c) callout_drain(&(c)->co)
-#define	usb2_callout_pending(c) callout_pending(&(c)->co)
+#define	usb_callout_init_mtx(c,m,f) callout_init_mtx(&(c)->co,m,f)
+#define	usb_callout_reset(c,t,f,d) callout_reset(&(c)->co,t,f,d)
+#define	usb_callout_stop(c) callout_stop(&(c)->co)
+#define	usb_callout_drain(c) callout_drain(&(c)->co)
+#define	usb_callout_pending(c) callout_pending(&(c)->co)
 
 #define	USB_BUS_LOCK(_b)		mtx_lock(&(_b)->bus_mtx)
 #define	USB_BUS_UNLOCK(_b)		mtx_unlock(&(_b)->bus_mtx)
@@ -446,10 +446,10 @@ struct usb_xfer {
 	uint8_t	address;		/* physical USB address */
 	uint8_t	endpointno;		/* physical USB endpoint */
 	uint8_t	max_packet_count;
-	uint8_t	usb2_smask;
-	uint8_t	usb2_cmask;
-	uint8_t	usb2_uframe;
-	uint8_t	usb2_state;
+	uint8_t	usb_smask;
+	uint8_t	usb_cmask;
+	uint8_t	usb_uframe;
+	uint8_t	usb_state;
 
 	usb_error_t error;
 
@@ -461,7 +461,7 @@ struct usb_xfer {
  * The following structure keeps information that is used to match
  * against an array of "usb_device_id" elements.
  */
-struct usb_lookup_info {
+struct usbd_lookup_info {
 	uint16_t idVendor;
 	uint16_t idProduct;
 	uint16_t bcdDevice;
@@ -480,7 +480,7 @@ struct usb_lookup_info {
 /* Structure used by probe and attach */
 
 struct usb_attach_arg {
-	struct usb_lookup_info info;
+	struct usbd_lookup_info info;
 	device_t temp_dev;		/* for internal use */
 	unsigned long driver_info;	/* for internal use */
 	void *driver_ivar;
@@ -497,49 +497,49 @@ MALLOC_DECLARE(M_USB);
 MALLOC_DECLARE(M_USBDEV);
 MALLOC_DECLARE(M_USBHC);
 
-extern struct mtx usb2_ref_lock;
+extern struct mtx usb_ref_lock;
 
 /* prototypes */
 
-const char *usb2_errstr(usb_error_t error);
-const char *usb2_statestr(enum usb_dev_state state);
-struct usb_config_descriptor *usb2_get_config_descriptor(
+const char *usbd_errstr(usb_error_t error);
+const char *usb_statestr(enum usb_dev_state state);
+struct usb_config_descriptor *usbd_get_config_descriptor(
 	    struct usb_device *udev);
-struct usb_device_descriptor *usb2_get_device_descriptor(
+struct usb_device_descriptor *usbd_get_device_descriptor(
 	    struct usb_device *udev);
-struct usb_interface *usb2_get_iface(struct usb_device *udev,
+struct usb_interface *usbd_get_iface(struct usb_device *udev,
 	    uint8_t iface_index);
-struct usb_interface_descriptor *usb2_get_interface_descriptor(
+struct usb_interface_descriptor *usbd_get_interface_descriptor(
 	    struct usb_interface *iface);
-uint8_t	usb2_clear_stall_callback(struct usb_xfer *xfer1,
+uint8_t	usbd_clear_stall_callback(struct usb_xfer *xfer1,
 	    struct usb_xfer *xfer2);
-uint8_t	usb2_get_interface_altindex(struct usb_interface *iface);
-usb_error_t usb2_set_alt_interface_index(struct usb_device *udev,
+uint8_t	usbd_get_interface_altindex(struct usb_interface *iface);
+usb_error_t usbd_set_alt_interface_index(struct usb_device *udev,
 	    uint8_t iface_index, uint8_t alt_index);
-enum usb_hc_mode	usb2_get_mode(struct usb_device *udev);
-enum usb_dev_speed	usb2_get_speed(struct usb_device *udev);
-uint32_t usb2_get_isoc_fps(struct usb_device *udev);
-usb_error_t usb2_transfer_setup(struct usb_device *udev,
+enum usb_hc_mode	usbd_get_mode(struct usb_device *udev);
+enum usb_dev_speed	usbd_get_speed(struct usb_device *udev);
+uint32_t usbd_get_isoc_fps(struct usb_device *udev);
+usb_error_t usbd_transfer_setup(struct usb_device *udev,
 	    const uint8_t *ifaces, struct usb_xfer **pxfer,
 	    const struct usb_config *setup_start, uint16_t n_setup,
 	    void *priv_sc, struct mtx *priv_mtx);
-void	usb2_set_frame_data(struct usb_xfer *xfer, void *ptr,
+void	usbd_set_frame_data(struct usb_xfer *xfer, void *ptr,
 	    usb_frcount_t frindex);
-void	usb2_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
+void	usbd_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
 	    usb_frcount_t frindex);
-void	usb2_start_hardware(struct usb_xfer *xfer);
-void	usb2_transfer_clear_stall(struct usb_xfer *xfer);
-void	usb2_transfer_drain(struct usb_xfer *xfer);
-void	usb2_transfer_set_stall(struct usb_xfer *xfer);
-uint8_t	usb2_transfer_pending(struct usb_xfer *xfer);
-void	usb2_transfer_start(struct usb_xfer *xfer);
-void	usb2_transfer_stop(struct usb_xfer *xfer);
-void	usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup);
-void	usb2_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
+void	usbd_transfer_submit(struct usb_xfer *xfer);
+void	usbd_transfer_clear_stall(struct usb_xfer *xfer);
+void	usbd_transfer_drain(struct usb_xfer *xfer);
+void	usbd_transfer_set_stall(struct usb_xfer *xfer);
+uint8_t	usbd_transfer_pending(struct usb_xfer *xfer);
+void	usbd_transfer_start(struct usb_xfer *xfer);
+void	usbd_transfer_stop(struct usb_xfer *xfer);
+void	usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup);
+void	usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
 	    uint8_t parent_index);
-uint8_t	usb2_get_bus_index(struct usb_device *udev);
-uint8_t	usb2_get_device_index(struct usb_device *udev);
-void	usb2_set_power_mode(struct usb_device *udev, uint8_t power_mode);
-uint8_t	usb2_device_attached(struct usb_device *udev);
+uint8_t	usbd_get_bus_index(struct usb_device *udev);
+uint8_t	usbd_get_device_index(struct usb_device *udev);
+void	usbd_set_power_mode(struct usb_device *udev, uint8_t power_mode);
+uint8_t	usbd_device_attached(struct usb_device *udev);
 
 #endif					/* _USB2_CORE_H_ */
diff --git a/sys/dev/usb/usb_debug.c b/sys/dev/usb/usb_debug.c
index 5a18701..d8be33a 100644
--- a/sys/dev/usb/usb_debug.c
+++ b/sys/dev/usb/usb_debug.c
@@ -37,21 +37,21 @@
  * Define this unconditionally in case a kernel module is loaded that
  * has been compiled with debugging options.
  */
-int	usb2_debug = 0;
+int	usb_debug = 0;
 
 SYSCTL_NODE(_hw, OID_AUTO, usb, CTLFLAG_RW, 0, "USB debugging");
 SYSCTL_INT(_hw_usb, OID_AUTO, debug, CTLFLAG_RW,
-    &usb2_debug, 0, "Debug level");
+    &usb_debug, 0, "Debug level");
 
 /*------------------------------------------------------------------------*
- *	usb2_dump_iface
+ *	usb_dump_iface
  *
  * This function dumps information about an USB interface.
  *------------------------------------------------------------------------*/
 void
-usb2_dump_iface(struct usb_interface *iface)
+usb_dump_iface(struct usb_interface *iface)
 {
-	printf("usb2_dump_iface: iface=%p\n", iface);
+	printf("usb_dump_iface: iface=%p\n", iface);
 	if (iface == NULL) {
 		return;
 	}
@@ -60,14 +60,14 @@ usb2_dump_iface(struct usb_interface *iface)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dump_device
+ *	usb_dump_device
  *
  * This function dumps information about an USB device.
  *------------------------------------------------------------------------*/
 void
-usb2_dump_device(struct usb_device *udev)
+usb_dump_device(struct usb_device *udev)
 {
-	printf("usb2_dump_device: dev=%p\n", udev);
+	printf("usb_dump_device: dev=%p\n", udev);
 	if (udev == NULL) {
 		return;
 	}
@@ -80,16 +80,16 @@ usb2_dump_device(struct usb_device *udev)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dump_queue
+ *	usb_dump_queue
  *
  * This function dumps the USB transfer that are queued up on an USB endpoint.
  *------------------------------------------------------------------------*/
 void
-usb2_dump_queue(struct usb_endpoint *ep)
+usb_dump_queue(struct usb_endpoint *ep)
 {
 	struct usb_xfer *xfer;
 
-	printf("usb2_dump_queue: endpoint=%p xfer: ", ep);
+	printf("usb_dump_queue: endpoint=%p xfer: ", ep);
 	TAILQ_FOREACH(xfer, &ep->endpoint_q.head, wait_entry) {
 		printf(" %p", xfer);
 	}
@@ -97,15 +97,15 @@ usb2_dump_queue(struct usb_endpoint *ep)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dump_endpoint
+ *	usb_dump_endpoint
  *
  * This function dumps information about an USB endpoint.
  *------------------------------------------------------------------------*/
 void
-usb2_dump_endpoint(struct usb_endpoint *ep)
+usb_dump_endpoint(struct usb_endpoint *ep)
 {
 	if (ep) {
-		printf("usb2_dump_endpoint: endpoint=%p", ep);
+		printf("usb_dump_endpoint: endpoint=%p", ep);
 
 		printf(" edesc=%p isoc_next=%d toggle_next=%d",
 		    ep->edesc, ep->isoc_next, ep->toggle_next);
@@ -115,22 +115,22 @@ usb2_dump_endpoint(struct usb_endpoint *ep)
 			    ep->edesc->bEndpointAddress);
 		}
 		printf("\n");
-		usb2_dump_queue(ep);
+		usb_dump_queue(ep);
 	} else {
-		printf("usb2_dump_endpoint: endpoint=NULL\n");
+		printf("usb_dump_endpoint: endpoint=NULL\n");
 	}
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dump_xfer
+ *	usb_dump_xfer
  *
  * This function dumps information about an USB transfer.
  *------------------------------------------------------------------------*/
 void
-usb2_dump_xfer(struct usb_xfer *xfer)
+usb_dump_xfer(struct usb_xfer *xfer)
 {
 	struct usb_device *udev;
-	printf("usb2_dump_xfer: xfer=%p\n", xfer);
+	printf("usb_dump_xfer: xfer=%p\n", xfer);
 	if (xfer == NULL) {
 		return;
 	}
diff --git a/sys/dev/usb/usb_debug.h b/sys/dev/usb/usb_debug.h
index d3e6127..d0b5846 100644
--- a/sys/dev/usb/usb_debug.h
+++ b/sys/dev/usb/usb_debug.h
@@ -33,7 +33,7 @@
 SYSCTL_DECL(_hw_usb);
 
 /* Declare global USB debug variable. */
-extern int usb2_debug;
+extern int usb_debug;
 
 /* Check if USB debugging is enabled. */
 #ifdef USB_DEBUG_VAR
@@ -56,10 +56,10 @@ struct usb_device;
 struct usb_endpoint;
 struct usb_xfer;
 
-void	usb2_dump_iface(struct usb_interface *iface);
-void	usb2_dump_device(struct usb_device *udev);
-void	usb2_dump_queue(struct usb_endpoint *ep);
-void	usb2_dump_endpoint(struct usb_endpoint *ep);
-void	usb2_dump_xfer(struct usb_xfer *xfer);
+void	usb_dump_iface(struct usb_interface *iface);
+void	usb_dump_device(struct usb_device *udev);
+void	usb_dump_queue(struct usb_endpoint *ep);
+void	usb_dump_endpoint(struct usb_endpoint *ep);
+void	usb_dump_xfer(struct usb_xfer *xfer);
 
 #endif					/* _USB2_DEBUG_H_ */
diff --git a/sys/dev/usb/usb_dev.c b/sys/dev/usb/usb_dev.c
index 80b7f46..39c3951 100644
--- a/sys/dev/usb/usb_dev.c
+++ b/sys/dev/usb/usb_dev.c
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  *
- * usb2_dev.c - An abstraction layer for creating devices under /dev/...
+ * usb_dev.c - An abstraction layer for creating devices under /dev/...
  */
 
 #include <dev/usb/usb.h>
@@ -32,7 +32,7 @@
 #include <dev/usb/usb_mfunc.h>
 #include <dev/usb/usb_error.h>
 
-#define	USB_DEBUG_VAR usb2_fifo_debug
+#define	USB_DEBUG_VAR usb_fifo_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_mbuf.h>
@@ -57,11 +57,11 @@
 #if USB_HAVE_UGEN
 
 #if USB_DEBUG
-static int usb2_fifo_debug = 0;
+static int usb_fifo_debug = 0;
 
 SYSCTL_NODE(_hw_usb, OID_AUTO, dev, CTLFLAG_RW, 0, "USB device");
 SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RW,
-    &usb2_fifo_debug, 0, "Debug Level");
+    &usb_fifo_debug, 0, "Debug Level");
 #endif
 
 #if ((__FreeBSD_version >= 700001) || (__FreeBSD_version == 0) || \
@@ -73,72 +73,72 @@ SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RW,
 
 /* prototypes */
 
-static int	usb2_fifo_open(struct usb_cdev_privdata *, 
+static int	usb_fifo_open(struct usb_cdev_privdata *, 
 		    struct usb_fifo *, int);
-static void	usb2_fifo_close(struct usb_fifo *, int);
-static void	usb2_dev_init(void *);
-static void	usb2_dev_init_post(void *);
-static void	usb2_dev_uninit(void *);
-static int	usb2_fifo_uiomove(struct usb_fifo *, void *, int,
+static void	usb_fifo_close(struct usb_fifo *, int);
+static void	usb_dev_init(void *);
+static void	usb_dev_init_post(void *);
+static void	usb_dev_uninit(void *);
+static int	usb_fifo_uiomove(struct usb_fifo *, void *, int,
 		    struct uio *);
-static void	usb2_fifo_check_methods(struct usb_fifo_methods *);
-static struct	usb_fifo *usb2_fifo_alloc(void);
-static struct	usb_endpoint *usb2_dev_get_ep(struct usb_device *, uint8_t,
+static void	usb_fifo_check_methods(struct usb_fifo_methods *);
+static struct	usb_fifo *usb_fifo_alloc(void);
+static struct	usb_endpoint *usb_dev_get_ep(struct usb_device *, uint8_t,
 		    uint8_t);
-static void	usb2_loc_fill(struct usb_fs_privdata *,
+static void	usb_loc_fill(struct usb_fs_privdata *,
 		    struct usb_cdev_privdata *);
-static void	usb2_close(void *);
-static usb_error_t usb2_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *, int);
-static usb_error_t usb2_usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *);
-static void	usb2_unref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *);
+static void	usb_close(void *);
+static usb_error_t usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *, int);
+static usb_error_t usb_usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *);
+static void	usb_unref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *);
 
-static d_open_t usb2_open;
-static d_ioctl_t usb2_ioctl;
-static d_read_t usb2_read;
-static d_write_t usb2_write;
-static d_poll_t usb2_poll;
+static d_open_t usb_open;
+static d_ioctl_t usb_ioctl;
+static d_read_t usb_read;
+static d_write_t usb_write;
+static d_poll_t usb_poll;
 
-static d_ioctl_t usb2_static_ioctl;
+static d_ioctl_t usb_static_ioctl;
 
-static usb_fifo_open_t usb2_fifo_dummy_open;
-static usb_fifo_close_t usb2_fifo_dummy_close;
-static usb_fifo_ioctl_t usb2_fifo_dummy_ioctl;
-static usb_fifo_cmd_t usb2_fifo_dummy_cmd;
+static usb_fifo_open_t usb_fifo_dummy_open;
+static usb_fifo_close_t usb_fifo_dummy_close;
+static usb_fifo_ioctl_t usb_fifo_dummy_ioctl;
+static usb_fifo_cmd_t usb_fifo_dummy_cmd;
 
 /* character device structure used for devices (/dev/ugenX.Y and /dev/uXXX) */
-struct cdevsw usb2_devsw = {
+struct cdevsw usb_devsw = {
 	.d_version = D_VERSION,
-	.d_open = usb2_open,
-	.d_ioctl = usb2_ioctl,
+	.d_open = usb_open,
+	.d_ioctl = usb_ioctl,
 	.d_name = "usbdev",
 	.d_flags = D_TRACKCLOSE,
-	.d_read = usb2_read,
-	.d_write = usb2_write,
-	.d_poll = usb2_poll
+	.d_read = usb_read,
+	.d_write = usb_write,
+	.d_poll = usb_poll
 };
 
-static struct cdev* usb2_dev = NULL;
+static struct cdev* usb_dev = NULL;
 
 /* character device structure used for /dev/usb */
-static struct cdevsw usb2_static_devsw = {
+static struct cdevsw usb_static_devsw = {
 	.d_version = D_VERSION,
-	.d_ioctl = usb2_static_ioctl,
+	.d_ioctl = usb_static_ioctl,
 	.d_name = "usb"
 };
 
-static TAILQ_HEAD(, usb_symlink) usb2_sym_head;
-static struct sx usb2_sym_lock;
+static TAILQ_HEAD(, usb_symlink) usb_sym_head;
+static struct sx usb_sym_lock;
 
-struct mtx usb2_ref_lock;
+struct mtx usb_ref_lock;
 
 /*------------------------------------------------------------------------*
- *	usb2_loc_fill
+ *	usb_loc_fill
  *
  * This is used to fill out a usb_cdev_privdata structure based on the
  * device's address as contained in usb_fs_privdata.
  *------------------------------------------------------------------------*/
 static void
-usb2_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd)
+usb_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd)
 {
 	cpd->bus_index = pd->bus_index;
 	cpd->dev_index = pd->dev_index;
@@ -147,7 +147,7 @@ usb2_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_ref_device
+ *	usb_ref_device
  *
  * This function is used to atomically refer an USB device by its
  * device location. If this function returns success the USB device
@@ -158,7 +158,7 @@ usb2_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd)
  *  Else: Failure.
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_ref_device(struct usb_cdev_privdata *cpd, 
+usb_ref_device(struct usb_cdev_privdata *cpd, 
     struct usb_cdev_refdata *crd, int need_uref)
 {
 	struct usb_fifo **ppf;
@@ -169,8 +169,8 @@ usb2_ref_device(struct usb_cdev_privdata *cpd,
 	/* clear all refs */
 	memset(crd, 0, sizeof(*crd));
 
-	mtx_lock(&usb2_ref_lock);
-	cpd->bus = devclass_get_softc(usb2_devclass_ptr, cpd->bus_index);
+	mtx_lock(&usb_ref_lock);
+	cpd->bus = devclass_get_softc(usb_devclass_ptr, cpd->bus_index);
 	if (cpd->bus == NULL) {
 		DPRINTFN(2, "no bus at %u\n", cpd->bus_index);
 		goto error;
@@ -188,7 +188,7 @@ usb2_ref_device(struct usb_cdev_privdata *cpd,
 		DPRINTFN(2, "ref udev - needed\n");
 		cpd->udev->refcount++;
 
-		mtx_unlock(&usb2_ref_lock);
+		mtx_unlock(&usb_ref_lock);
 
 		/*
 		 * We need to grab the sx-lock before grabbing the
@@ -196,7 +196,7 @@ usb2_ref_device(struct usb_cdev_privdata *cpd,
 		 */
 		sx_xlock(cpd->udev->default_sx + 1);
 
-		mtx_lock(&usb2_ref_lock);
+		mtx_lock(&usb_ref_lock);
 
 		/* 
 		 * Set "is_uref" after grabbing the default SX lock
@@ -250,7 +250,7 @@ usb2_ref_device(struct usb_cdev_privdata *cpd,
 		DPRINTFN(2, "ref read\n");
 		crd->rxfifo->refcount++;
 	}
-	mtx_unlock(&usb2_ref_lock);
+	mtx_unlock(&usb_ref_lock);
 
 	if (crd->is_uref) {
 		mtx_lock(&Giant);	/* XXX */
@@ -264,13 +264,13 @@ error:
 			cv_signal(cpd->udev->default_cv + 1);
 		}
 	}
-	mtx_unlock(&usb2_ref_lock);
+	mtx_unlock(&usb_ref_lock);
 	DPRINTFN(2, "fail\n");
 	return (USB_ERR_INVAL);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_usb_ref_device
+ *	usb_usb_ref_device
  *
  * This function is used to upgrade an USB reference to include the
  * USB device reference on a USB location.
@@ -280,7 +280,7 @@ error:
  *  Else: Failure.
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_usb_ref_device(struct usb_cdev_privdata *cpd,
+usb_usb_ref_device(struct usb_cdev_privdata *cpd,
     struct usb_cdev_refdata *crd)
 {
 	/*
@@ -293,19 +293,19 @@ usb2_usb_ref_device(struct usb_cdev_privdata *cpd,
 	 * To avoid deadlock at detach we need to drop the FIFO ref
 	 * and re-acquire a new ref!
 	 */
-	usb2_unref_device(cpd, crd);
+	usb_unref_device(cpd, crd);
 
-	return (usb2_ref_device(cpd, crd, 1 /* need uref */));
+	return (usb_ref_device(cpd, crd, 1 /* need uref */));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_unref_device
+ *	usb_unref_device
  *
  * This function will release the reference count by one unit for the
  * given USB device.
  *------------------------------------------------------------------------*/
 void
-usb2_unref_device(struct usb_cdev_privdata *cpd,
+usb_unref_device(struct usb_cdev_privdata *cpd,
     struct usb_cdev_refdata *crd)
 {
 
@@ -315,7 +315,7 @@ usb2_unref_device(struct usb_cdev_privdata *cpd,
 		mtx_unlock(&Giant);	/* XXX */
 		sx_unlock(cpd->udev->default_sx + 1);
 	}
-	mtx_lock(&usb2_ref_lock);
+	mtx_lock(&usb_ref_lock);
 	if (crd->is_read) {
 		if (--(crd->rxfifo->refcount) == 0) {
 			cv_signal(&crd->rxfifo->cv_drain);
@@ -334,11 +334,11 @@ usb2_unref_device(struct usb_cdev_privdata *cpd,
 		}
 		crd->is_uref = 0;
 	}
-	mtx_unlock(&usb2_ref_lock);
+	mtx_unlock(&usb_ref_lock);
 }
 
 static struct usb_fifo *
-usb2_fifo_alloc(void)
+usb_fifo_alloc(void)
 {
 	struct usb_fifo *f;
 
@@ -352,10 +352,10 @@ usb2_fifo_alloc(void)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_create
+ *	usb_fifo_create
  *------------------------------------------------------------------------*/
 static int
-usb2_fifo_create(struct usb_cdev_privdata *cpd,
+usb_fifo_create(struct usb_cdev_privdata *cpd,
     struct usb_cdev_refdata *crd)
 {
 	struct usb_device *udev = cpd->udev;
@@ -464,13 +464,13 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd,
 	/* Check TX FIFO */
 	if (is_tx &&
 	    (udev->fifo[n + USB_FIFO_TX] == NULL)) {
-		ep = usb2_dev_get_ep(udev, e, USB_FIFO_TX);
+		ep = usb_dev_get_ep(udev, e, USB_FIFO_TX);
 		DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_TX);
 		if (ep == NULL) {
 			DPRINTFN(5, "dev_get_endpoint returned NULL\n");
 			return (EINVAL);
 		}
-		f = usb2_fifo_alloc();
+		f = usb_fifo_alloc();
 		if (f == NULL) {
 			DPRINTFN(5, "could not alloc tx fifo\n");
 			return (ENOMEM);
@@ -480,24 +480,24 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd,
 		f->dev_ep_index = e;
 		f->priv_mtx = udev->default_mtx;
 		f->priv_sc0 = ep;
-		f->methods = &usb2_ugen_methods;
+		f->methods = &usb_ugen_methods;
 		f->iface_index = ep->iface_index;
 		f->udev = udev;
-		mtx_lock(&usb2_ref_lock);
+		mtx_lock(&usb_ref_lock);
 		udev->fifo[n + USB_FIFO_TX] = f;
-		mtx_unlock(&usb2_ref_lock);
+		mtx_unlock(&usb_ref_lock);
 	}
 	/* Check RX FIFO */
 	if (is_rx &&
 	    (udev->fifo[n + USB_FIFO_RX] == NULL)) {
 
-		ep = usb2_dev_get_ep(udev, e, USB_FIFO_RX);
+		ep = usb_dev_get_ep(udev, e, USB_FIFO_RX);
 		DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_RX);
 		if (ep == NULL) {
 			DPRINTFN(5, "dev_get_endpoint returned NULL\n");
 			return (EINVAL);
 		}
-		f = usb2_fifo_alloc();
+		f = usb_fifo_alloc();
 		if (f == NULL) {
 			DPRINTFN(5, "could not alloc rx fifo\n");
 			return (ENOMEM);
@@ -507,12 +507,12 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd,
 		f->dev_ep_index = e;
 		f->priv_mtx = udev->default_mtx;
 		f->priv_sc0 = ep;
-		f->methods = &usb2_ugen_methods;
+		f->methods = &usb_ugen_methods;
 		f->iface_index = ep->iface_index;
 		f->udev = udev;
-		mtx_lock(&usb2_ref_lock);
+		mtx_lock(&usb_ref_lock);
 		udev->fifo[n + USB_FIFO_RX] = f;
-		mtx_unlock(&usb2_ref_lock);
+		mtx_unlock(&usb_ref_lock);
 	}
 	if (is_tx) {
 		crd->txfifo = udev->fifo[n + USB_FIFO_TX];
@@ -530,7 +530,7 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd,
 }
 
 void
-usb2_fifo_free(struct usb_fifo *f)
+usb_fifo_free(struct usb_fifo *f)
 {
 	uint8_t n;
 
@@ -541,11 +541,11 @@ usb2_fifo_free(struct usb_fifo *f)
 	/* destroy symlink devices, if any */
 	for (n = 0; n != 2; n++) {
 		if (f->symlink[n]) {
-			usb2_free_symlink(f->symlink[n]);
+			usb_free_symlink(f->symlink[n]);
 			f->symlink[n] = NULL;
 		}
 	}
-	mtx_lock(&usb2_ref_lock);
+	mtx_lock(&usb_ref_lock);
 
 	/* delink ourselves to stop calls from userland */
 	if ((f->fifo_index < USB_FIFO_MAX) &&
@@ -562,7 +562,7 @@ usb2_fifo_free(struct usb_fifo *f)
 	f->flag_iserror = 1;
 	/* need to wait until all callers have exited */
 	while (f->refcount != 0) {
-		mtx_unlock(&usb2_ref_lock);	/* avoid LOR */
+		mtx_unlock(&usb_ref_lock);	/* avoid LOR */
 		mtx_lock(f->priv_mtx);
 		/* get I/O thread out of any sleep state */
 		if (f->flag_sleeping) {
@@ -570,15 +570,15 @@ usb2_fifo_free(struct usb_fifo *f)
 			cv_broadcast(&f->cv_io);
 		}
 		mtx_unlock(f->priv_mtx);
-		mtx_lock(&usb2_ref_lock);
+		mtx_lock(&usb_ref_lock);
 
 		/* wait for sync */
-		cv_wait(&f->cv_drain, &usb2_ref_lock);
+		cv_wait(&f->cv_drain, &usb_ref_lock);
 	}
-	mtx_unlock(&usb2_ref_lock);
+	mtx_unlock(&usb_ref_lock);
 
 	/* take care of closing the device here, if any */
-	usb2_fifo_close(f, 0);
+	usb_fifo_close(f, 0);
 
 	cv_destroy(&f->cv_io);
 	cv_destroy(&f->cv_drain);
@@ -587,7 +587,7 @@ usb2_fifo_free(struct usb_fifo *f)
 }
 
 static struct usb_endpoint *
-usb2_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir)
+usb_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir)
 {
 	struct usb_endpoint *ep;
 	uint8_t ep_dir;
@@ -608,7 +608,7 @@ usb2_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir)
 				ep_dir = UE_DIR_IN;
 			}
 		}
-		ep = usb2_get_ep_by_addr(udev, ep_index | ep_dir);
+		ep = usbd_get_ep_by_addr(udev, ep_index | ep_dir);
 	}
 
 	if (ep == NULL) {
@@ -623,14 +623,14 @@ usb2_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_open
+ *	usb_fifo_open
  *
  * Returns:
  * 0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static int
-usb2_fifo_open(struct usb_cdev_privdata *cpd, 
+usb_fifo_open(struct usb_cdev_privdata *cpd, 
     struct usb_fifo *f, int fflags)
 {
 	int err;
@@ -685,13 +685,13 @@ usb2_fifo_open(struct usb_cdev_privdata *cpd,
 	/* reset ASYNC proc flag */
 	f->async_p = NULL;
 
-	mtx_lock(&usb2_ref_lock);
+	mtx_lock(&usb_ref_lock);
 	/* flag the fifo as opened to prevent others */
 	f->curr_cpd = cpd;
-	mtx_unlock(&usb2_ref_lock);
+	mtx_unlock(&usb_ref_lock);
 
 	/* reset queue */
-	usb2_fifo_reset(f);
+	usb_fifo_reset(f);
 
 	mtx_unlock(f->priv_mtx);
 done:
@@ -699,10 +699,10 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_reset
+ *	usb_fifo_reset
  *------------------------------------------------------------------------*/
 void
-usb2_fifo_reset(struct usb_fifo *f)
+usb_fifo_reset(struct usb_fifo *f)
 {
 	struct usb_mbuf *m;
 
@@ -720,10 +720,10 @@ usb2_fifo_reset(struct usb_fifo *f)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_close
+ *	usb_fifo_close
  *------------------------------------------------------------------------*/
 static void
-usb2_fifo_close(struct usb_fifo *f, int fflags)
+usb_fifo_close(struct usb_fifo *f, int fflags)
 {
 	int err;
 
@@ -799,10 +799,10 @@ usb2_fifo_close(struct usb_fifo *f, int fflags)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_open - cdev callback
+ *	usb_open - cdev callback
  *------------------------------------------------------------------------*/
 static int
-usb2_open(struct cdev *dev, int fflags, int devtype, struct thread *td)
+usb_open(struct cdev *dev, int fflags, int devtype, struct thread *td)
 {
 	struct usb_fs_privdata* pd = (struct usb_fs_privdata*)dev->si_drv1;
 	struct usb_cdev_refdata refs;
@@ -821,8 +821,8 @@ usb2_open(struct cdev *dev, int fflags, int devtype, struct thread *td)
 	cpd = malloc(sizeof(*cpd), M_USBDEV, M_WAITOK | M_ZERO);
 	ep = cpd->ep_addr = pd->ep_addr;
 
-	usb2_loc_fill(pd, cpd);
-	err = usb2_ref_device(cpd, &refs, 1);
+	usb_loc_fill(pd, cpd);
+	err = usb_ref_device(cpd, &refs, 1);
 	if (err) {
 		DPRINTFN(2, "cannot ref device\n");
 		free(cpd, M_USBDEV);
@@ -831,46 +831,46 @@ usb2_open(struct cdev *dev, int fflags, int devtype, struct thread *td)
 	cpd->fflags = fflags;	/* access mode for open lifetime */
 
 	/* create FIFOs, if any */
-	err = usb2_fifo_create(cpd, &refs);
+	err = usb_fifo_create(cpd, &refs);
 	/* check for error */
 	if (err) {
 		DPRINTFN(2, "cannot create fifo\n");
-		usb2_unref_device(cpd, &refs);
+		usb_unref_device(cpd, &refs);
 		free(cpd, M_USBDEV);
 		return (err);
 	}
 	if (fflags & FREAD) {
-		err = usb2_fifo_open(cpd, refs.rxfifo, fflags);
+		err = usb_fifo_open(cpd, refs.rxfifo, fflags);
 		if (err) {
 			DPRINTFN(2, "read open failed\n");
-			usb2_unref_device(cpd, &refs);
+			usb_unref_device(cpd, &refs);
 			free(cpd, M_USBDEV);
 			return (err);
 		}
 	}
 	if (fflags & FWRITE) {
-		err = usb2_fifo_open(cpd, refs.txfifo, fflags);
+		err = usb_fifo_open(cpd, refs.txfifo, fflags);
 		if (err) {
 			DPRINTFN(2, "write open failed\n");
 			if (fflags & FREAD) {
-				usb2_fifo_close(refs.rxfifo, fflags);
+				usb_fifo_close(refs.rxfifo, fflags);
 			}
-			usb2_unref_device(cpd, &refs);
+			usb_unref_device(cpd, &refs);
 			free(cpd, M_USBDEV);
 			return (err);
 		}
 	}
-	usb2_unref_device(cpd, &refs);
-	devfs_set_cdevpriv(cpd, usb2_close);
+	usb_unref_device(cpd, &refs);
+	devfs_set_cdevpriv(cpd, usb_close);
 
 	return (0);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_close - cdev callback
+ *	usb_close - cdev callback
  *------------------------------------------------------------------------*/
 static void
-usb2_close(void *arg)
+usb_close(void *arg)
 {
 	struct usb_cdev_refdata refs;
 	struct usb_cdev_privdata *cpd = arg;
@@ -878,68 +878,68 @@ usb2_close(void *arg)
 
 	DPRINTFN(2, "cpd=%p\n", cpd);
 
-	err = usb2_ref_device(cpd, &refs, 1);
+	err = usb_ref_device(cpd, &refs, 1);
 	if (err) {
 		free(cpd, M_USBDEV);
 		return;
 	}
 	if (cpd->fflags & FREAD) {
-		usb2_fifo_close(refs.rxfifo, cpd->fflags);
+		usb_fifo_close(refs.rxfifo, cpd->fflags);
 	}
 	if (cpd->fflags & FWRITE) {
-		usb2_fifo_close(refs.txfifo, cpd->fflags);
+		usb_fifo_close(refs.txfifo, cpd->fflags);
 	}
 
-	usb2_unref_device(cpd, &refs);
+	usb_unref_device(cpd, &refs);
 	free(cpd, M_USBDEV);
 	return;
 }
 
 static void
-usb2_dev_init(void *arg)
+usb_dev_init(void *arg)
 {
-	mtx_init(&usb2_ref_lock, "USB ref mutex", NULL, MTX_DEF);
-	sx_init(&usb2_sym_lock, "USB sym mutex");
-	TAILQ_INIT(&usb2_sym_head);
+	mtx_init(&usb_ref_lock, "USB ref mutex", NULL, MTX_DEF);
+	sx_init(&usb_sym_lock, "USB sym mutex");
+	TAILQ_INIT(&usb_sym_head);
 
 	/* check the UGEN methods */
-	usb2_fifo_check_methods(&usb2_ugen_methods);
+	usb_fifo_check_methods(&usb_ugen_methods);
 }
 
-SYSINIT(usb2_dev_init, SI_SUB_KLD, SI_ORDER_FIRST, usb2_dev_init, NULL);
+SYSINIT(usb_dev_init, SI_SUB_KLD, SI_ORDER_FIRST, usb_dev_init, NULL);
 
 static void
-usb2_dev_init_post(void *arg)
+usb_dev_init_post(void *arg)
 {
 	/*
 	 * Create /dev/usb - this is needed for usbconfig(8), which
 	 * needs a well-known device name to access.
 	 */
-	usb2_dev = make_dev(&usb2_static_devsw, 0, UID_ROOT, GID_OPERATOR,
+	usb_dev = make_dev(&usb_static_devsw, 0, UID_ROOT, GID_OPERATOR,
 	    0644, USB_DEVICE_NAME);
-	if (usb2_dev == NULL) {
+	if (usb_dev == NULL) {
 		DPRINTFN(0, "Could not create usb bus device!\n");
 	}
 }
 
-SYSINIT(usb2_dev_init_post, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, usb2_dev_init_post, NULL);
+SYSINIT(usb_dev_init_post, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, usb_dev_init_post, NULL);
 
 static void
-usb2_dev_uninit(void *arg)
+usb_dev_uninit(void *arg)
 {
-	if (usb2_dev != NULL) {
-		destroy_dev(usb2_dev);
-		usb2_dev = NULL;
+	if (usb_dev != NULL) {
+		destroy_dev(usb_dev);
+		usb_dev = NULL;
 	
 	}
-	mtx_destroy(&usb2_ref_lock);
-	sx_destroy(&usb2_sym_lock);
+	mtx_destroy(&usb_ref_lock);
+	sx_destroy(&usb_sym_lock);
 }
 
-SYSUNINIT(usb2_dev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb2_dev_uninit, NULL);
+SYSUNINIT(usb_dev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb_dev_uninit, NULL);
 
 static int
-usb2_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr,
+usb_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr,
     struct thread *td)
 {
 	int error = 0;
@@ -984,10 +984,10 @@ usb2_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_ioctl - cdev callback
+ *	usb_ioctl - cdev callback
  *------------------------------------------------------------------------*/
 static int
-usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* td)
+usb_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* td)
 {
 	struct usb_cdev_refdata refs;
 	struct usb_cdev_privdata* cpd;
@@ -1006,7 +1006,7 @@ usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread*
 	 * don't need the USB reference first. Then we grab the USB
 	 * reference if we need it!
 	 */
-	err = usb2_ref_device(cpd, &refs, 0 /* no uref */ );
+	err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
 	if (err) {
 		return (ENXIO);
 	}
@@ -1017,18 +1017,18 @@ usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread*
 
 	if (fflags & FWRITE) {
 		f = refs.txfifo;
-		err = usb2_ioctl_f_sub(f, cmd, addr, td);
+		err = usb_ioctl_f_sub(f, cmd, addr, td);
 	}
 	if (fflags & FREAD) {
 		f = refs.rxfifo;
-		err = usb2_ioctl_f_sub(f, cmd, addr, td);
+		err = usb_ioctl_f_sub(f, cmd, addr, td);
 	}
 	KASSERT(f != NULL, ("fifo not found"));
 	if (err == ENOIOCTL) {
 		err = (f->methods->f_ioctl) (f, cmd, addr, fflags);
 		DPRINTFN(2, "f_ioctl cmd 0x%lx = %d\n", cmd, err);
 		if (err == ENOIOCTL) {
-			if (usb2_usb_ref_device(cpd, &refs)) {
+			if (usb_usb_ref_device(cpd, &refs)) {
 				err = ENXIO;
 				goto done;
 			}
@@ -1040,13 +1040,13 @@ usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread*
 		err = ENOTTY;
 	}
 done:
-	usb2_unref_device(cpd, &refs);
+	usb_unref_device(cpd, &refs);
 	return (err);
 }
 
 /* ARGSUSED */
 static int
-usb2_poll(struct cdev* dev, int events, struct thread* td)
+usb_poll(struct cdev* dev, int events, struct thread* td)
 {
 	struct usb_cdev_refdata refs;
 	struct usb_cdev_privdata* cpd;
@@ -1055,7 +1055,7 @@ usb2_poll(struct cdev* dev, int events, struct thread* td)
 	int fflags, revents;
 
 	if (devfs_get_cdevpriv((void **)&cpd) != 0 ||
-	    usb2_ref_device(cpd, &refs, 0) != 0)
+	    usb_ref_device(cpd, &refs, 0) != 0)
 		return (events &
 		    (POLLHUP|POLLIN|POLLRDNORM|POLLOUT|POLLWRNORM));
 
@@ -1146,12 +1146,12 @@ usb2_poll(struct cdev* dev, int events, struct thread* td)
 
 		mtx_unlock(f->priv_mtx);
 	}
-	usb2_unref_device(cpd, &refs);
+	usb_unref_device(cpd, &refs);
 	return (revents);
 }
 
 static int
-usb2_read(struct cdev *dev, struct uio *uio, int ioflag)
+usb_read(struct cdev *dev, struct uio *uio, int ioflag)
 {
 	struct usb_cdev_refdata refs;
 	struct usb_cdev_privdata* cpd;
@@ -1167,7 +1167,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag)
 	if (err != 0)
 		return (err);
 
-	err = usb2_ref_device(cpd, &refs, 0 /* no uref */ );
+	err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
 	if (err) {
 		return (ENXIO);
 	}
@@ -1176,7 +1176,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag)
 	f = refs.rxfifo;
 	if (f == NULL) {
 		/* should not happen */
-		usb2_unref_device(cpd, &refs);
+		usb_unref_device(cpd, &refs);
 		return (EPERM);
 	}
 
@@ -1218,7 +1218,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag)
 			}
 			DPRINTF("sleeping\n");
 
-			err = usb2_fifo_wait(f);
+			err = usb_fifo_wait(f);
 			if (err) {
 				break;
 			}
@@ -1239,7 +1239,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag)
 		DPRINTFN(2, "transfer %d bytes from %p\n",
 		    io_len, m->cur_data_ptr);
 
-		err = usb2_fifo_uiomove(f,
+		err = usb_fifo_uiomove(f,
 		    m->cur_data_ptr, io_len, uio);
 
 		m->cur_data_len -= io_len;
@@ -1268,13 +1268,13 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag)
 done:
 	mtx_unlock(f->priv_mtx);
 
-	usb2_unref_device(cpd, &refs);
+	usb_unref_device(cpd, &refs);
 
 	return (err);
 }
 
 static int
-usb2_write(struct cdev *dev, struct uio *uio, int ioflag)
+usb_write(struct cdev *dev, struct uio *uio, int ioflag)
 {
 	struct usb_cdev_refdata refs;
 	struct usb_cdev_privdata* cpd;
@@ -1292,7 +1292,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag)
 	if (err != 0)
 		return (err);
 
-	err = usb2_ref_device(cpd, &refs, 0 /* no uref */ );
+	err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
 	if (err) {
 		return (ENXIO);
 	}
@@ -1301,7 +1301,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag)
 	f = refs.txfifo;
 	if (f == NULL) {
 		/* should not happen */
-		usb2_unref_device(cpd, &refs);
+		usb_unref_device(cpd, &refs);
 		return (EPERM);
 	}
 	resid = uio->uio_resid;
@@ -1342,7 +1342,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag)
 			}
 			DPRINTF("sleeping\n");
 
-			err = usb2_fifo_wait(f);
+			err = usb_fifo_wait(f);
 			if (err) {
 				break;
 			}
@@ -1359,7 +1359,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag)
 		DPRINTFN(2, "transfer %d bytes to %p\n",
 		    io_len, m->cur_data_ptr);
 
-		err = usb2_fifo_uiomove(f,
+		err = usb_fifo_uiomove(f,
 		    m->cur_data_ptr, io_len, uio);
 
 		if (err) {
@@ -1382,13 +1382,13 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag)
 done:
 	mtx_unlock(f->priv_mtx);
 
-	usb2_unref_device(cpd, &refs);
+	usb_unref_device(cpd, &refs);
 
 	return (err);
 }
 
 int
-usb2_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
+usb_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
     struct thread *td)
 {
 	union {
@@ -1400,30 +1400,30 @@ usb2_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
 	u.data = data;
 	switch (cmd) {
 		case USB_READ_DIR:
-			err = usb2_read_symlink(u.urd->urd_data,
+			err = usb_read_symlink(u.urd->urd_data,
 			    u.urd->urd_startentry, u.urd->urd_maxlen);
 			break;
 		case USB_DEV_QUIRK_GET:
 		case USB_QUIRK_NAME_GET:
 		case USB_DEV_QUIRK_ADD:
 		case USB_DEV_QUIRK_REMOVE:
-			err = usb2_quirk_ioctl_p(cmd, data, fflag, td);
+			err = usb_quirk_ioctl_p(cmd, data, fflag, td);
 			break;
 		case USB_GET_TEMPLATE:
-			*(int *)data = usb2_template;
+			*(int *)data = usb_template;
 			break;
 		case USB_SET_TEMPLATE:
 			err = priv_check(curthread, PRIV_DRIVER);
 			if (err)
 				break;
-			usb2_template = *(int *)data;
+			usb_template = *(int *)data;
 			break;
 	}
 	return (err);
 }
 
 static int
-usb2_fifo_uiomove(struct usb_fifo *f, void *cp,
+usb_fifo_uiomove(struct usb_fifo *f, void *cp,
     int n, struct uio *uio)
 {
 	int error;
@@ -1442,7 +1442,7 @@ usb2_fifo_uiomove(struct usb_fifo *f, void *cp,
 }
 
 int
-usb2_fifo_wait(struct usb_fifo *f)
+usb_fifo_wait(struct usb_fifo *f)
 {
 	int err;
 
@@ -1464,7 +1464,7 @@ usb2_fifo_wait(struct usb_fifo *f)
 }
 
 void
-usb2_fifo_signal(struct usb_fifo *f)
+usb_fifo_signal(struct usb_fifo *f)
 {
 	if (f->flag_sleeping) {
 		f->flag_sleeping = 0;
@@ -1473,9 +1473,9 @@ usb2_fifo_signal(struct usb_fifo *f)
 }
 
 void
-usb2_fifo_wakeup(struct usb_fifo *f)
+usb_fifo_wakeup(struct usb_fifo *f)
 {
-	usb2_fifo_signal(f);
+	usb_fifo_signal(f);
 
 	if (f->flag_isselect) {
 		selwakeup(&f->selinfo);
@@ -1489,61 +1489,61 @@ usb2_fifo_wakeup(struct usb_fifo *f)
 }
 
 static int
-usb2_fifo_dummy_open(struct usb_fifo *fifo, int fflags)
+usb_fifo_dummy_open(struct usb_fifo *fifo, int fflags)
 {
 	return (0);
 }
 
 static void
-usb2_fifo_dummy_close(struct usb_fifo *fifo, int fflags)
+usb_fifo_dummy_close(struct usb_fifo *fifo, int fflags)
 {
 	return;
 }
 
 static int
-usb2_fifo_dummy_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags)
+usb_fifo_dummy_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags)
 {
 	return (ENOIOCTL);
 }
 
 static void
-usb2_fifo_dummy_cmd(struct usb_fifo *fifo)
+usb_fifo_dummy_cmd(struct usb_fifo *fifo)
 {
 	fifo->flag_flushing = 0;	/* not flushing */
 }
 
 static void
-usb2_fifo_check_methods(struct usb_fifo_methods *pm)
+usb_fifo_check_methods(struct usb_fifo_methods *pm)
 {
 	/* check that all callback functions are OK */
 
 	if (pm->f_open == NULL)
-		pm->f_open = &usb2_fifo_dummy_open;
+		pm->f_open = &usb_fifo_dummy_open;
 
 	if (pm->f_close == NULL)
-		pm->f_close = &usb2_fifo_dummy_close;
+		pm->f_close = &usb_fifo_dummy_close;
 
 	if (pm->f_ioctl == NULL)
-		pm->f_ioctl = &usb2_fifo_dummy_ioctl;
+		pm->f_ioctl = &usb_fifo_dummy_ioctl;
 
 	if (pm->f_ioctl_post == NULL)
-		pm->f_ioctl_post = &usb2_fifo_dummy_ioctl;
+		pm->f_ioctl_post = &usb_fifo_dummy_ioctl;
 
 	if (pm->f_start_read == NULL)
-		pm->f_start_read = &usb2_fifo_dummy_cmd;
+		pm->f_start_read = &usb_fifo_dummy_cmd;
 
 	if (pm->f_stop_read == NULL)
-		pm->f_stop_read = &usb2_fifo_dummy_cmd;
+		pm->f_stop_read = &usb_fifo_dummy_cmd;
 
 	if (pm->f_start_write == NULL)
-		pm->f_start_write = &usb2_fifo_dummy_cmd;
+		pm->f_start_write = &usb_fifo_dummy_cmd;
 
 	if (pm->f_stop_write == NULL)
-		pm->f_stop_write = &usb2_fifo_dummy_cmd;
+		pm->f_stop_write = &usb_fifo_dummy_cmd;
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_attach
+ *	usb_fifo_attach
  *
  * The following function will create a duplex FIFO.
  *
@@ -1552,7 +1552,7 @@ usb2_fifo_check_methods(struct usb_fifo_methods *pm)
  * Else: Failure.
  *------------------------------------------------------------------------*/
 int
-usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
+usb_fifo_attach(struct usb_device *udev, void *priv_sc,
     struct mtx *priv_mtx, struct usb_fifo_methods *pm,
     struct usb_fifo_sc *f_sc, uint16_t unit, uint16_t subunit,
     uint8_t iface_index, uid_t uid, gid_t gid, int mode)
@@ -1570,7 +1570,7 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
 		return (EINVAL);
 
 	/* check the methods */
-	usb2_fifo_check_methods(pm);
+	usb_fifo_check_methods(pm);
 
 	if (priv_mtx == NULL)
 		priv_mtx = &Giant;
@@ -1593,12 +1593,12 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
 		break;
 	}
 
-	f_tx = usb2_fifo_alloc();
-	f_rx = usb2_fifo_alloc();
+	f_tx = usb_fifo_alloc();
+	f_rx = usb_fifo_alloc();
 
 	if ((f_tx == NULL) || (f_rx == NULL)) {
-		usb2_fifo_free(f_tx);
-		usb2_fifo_free(f_rx);
+		usb_fifo_free(f_tx);
+		usb_fifo_free(f_rx);
 		return (ENOMEM);
 	}
 	/* initialise FIFO structures */
@@ -1622,10 +1622,10 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
 	f_sc->fp[USB_FIFO_TX] = f_tx;
 	f_sc->fp[USB_FIFO_RX] = f_rx;
 
-	mtx_lock(&usb2_ref_lock);
+	mtx_lock(&usb_ref_lock);
 	udev->fifo[f_tx->fifo_index] = f_tx;
 	udev->fifo[f_rx->fifo_index] = f_rx;
-	mtx_unlock(&usb2_ref_lock);
+	mtx_unlock(&usb_ref_lock);
 
 	for (n = 0; n != 4; n++) {
 
@@ -1653,10 +1653,10 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
 		 */
 		if (n & 1) {
 			f_rx->symlink[n / 2] =
-			    usb2_alloc_symlink(devname);
+			    usb_alloc_symlink(devname);
 		} else {
 			f_tx->symlink[n / 2] =
-			    usb2_alloc_symlink(devname);
+			    usb_alloc_symlink(devname);
 		}
 
 		/*
@@ -1671,7 +1671,7 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
 		pd->mode = FREAD|FWRITE;
 
 		/* Now, create the device itself */
-		f_sc->dev = make_dev(&usb2_devsw, 0, uid, gid, mode,
+		f_sc->dev = make_dev(&usb_devsw, 0, uid, gid, mode,
 		    devname);
 		/* XXX setting si_drv1 and creating the device is not atomic! */
 		f_sc->dev->si_drv1 = pd;
@@ -1682,23 +1682,23 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_alloc_buffer
+ *	usb_fifo_alloc_buffer
  *
  * Return values:
  * 0: Success
  * Else failure
  *------------------------------------------------------------------------*/
 int
-usb2_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize,
+usb_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize,
     uint16_t nbuf)
 {
-	usb2_fifo_free_buffer(f);
+	usb_fifo_free_buffer(f);
 
 	/* allocate an endpoint */
 	f->free_q.ifq_maxlen = nbuf;
 	f->used_q.ifq_maxlen = nbuf;
 
-	f->queue_data = usb2_alloc_mbufs(
+	f->queue_data = usb_alloc_mbufs(
 	    M_USBDEV, &f->free_q, bufsize, nbuf);
 
 	if ((f->queue_data == NULL) && bufsize && nbuf) {
@@ -1708,13 +1708,13 @@ usb2_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_free_buffer
+ *	usb_fifo_free_buffer
  *
  * This function will free the buffers associated with a FIFO. This
  * function can be called multiple times in a row.
  *------------------------------------------------------------------------*/
 void
-usb2_fifo_free_buffer(struct usb_fifo *f)
+usb_fifo_free_buffer(struct usb_fifo *f)
 {
 	if (f->queue_data) {
 		/* free old buffer */
@@ -1728,26 +1728,26 @@ usb2_fifo_free_buffer(struct usb_fifo *f)
 }
 
 static void
-usb2_fifo_cleanup(void* ptr) 
+usb_fifo_cleanup(void* ptr) 
 {
 	free(ptr, M_USBDEV);
 }
 
 void
-usb2_fifo_detach(struct usb_fifo_sc *f_sc)
+usb_fifo_detach(struct usb_fifo_sc *f_sc)
 {
 	if (f_sc == NULL) {
 		return;
 	}
-	usb2_fifo_free(f_sc->fp[USB_FIFO_TX]);
-	usb2_fifo_free(f_sc->fp[USB_FIFO_RX]);
+	usb_fifo_free(f_sc->fp[USB_FIFO_TX]);
+	usb_fifo_free(f_sc->fp[USB_FIFO_RX]);
 
 	f_sc->fp[USB_FIFO_TX] = NULL;
 	f_sc->fp[USB_FIFO_RX] = NULL;
 
 	if (f_sc->dev != NULL) {
 		destroy_dev_sched_cb(f_sc->dev, 
-		    usb2_fifo_cleanup, f_sc->dev->si_drv1);
+		    usb_fifo_cleanup, f_sc->dev->si_drv1);
 		f_sc->dev = NULL;
 	}
 
@@ -1755,7 +1755,7 @@ usb2_fifo_detach(struct usb_fifo_sc *f_sc)
 }
 
 usb_size_t
-usb2_fifo_put_bytes_max(struct usb_fifo *f)
+usb_fifo_put_bytes_max(struct usb_fifo *f)
 {
 	struct usb_mbuf *m;
 	usb_size_t len;
@@ -1771,14 +1771,14 @@ usb2_fifo_put_bytes_max(struct usb_fifo *f)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_put_data
+ *	usb_fifo_put_data
  *
  * what:
  *  0 - normal operation
  *  1 - set last packet flag to enforce framing
  *------------------------------------------------------------------------*/
 void
-usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc,
+usb_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc,
     usb_frlength_t offset, usb_frlength_t len, uint8_t what)
 {
 	struct usb_mbuf *m;
@@ -1793,7 +1793,7 @@ usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc,
 
 			io_len = MIN(len, m->cur_data_len);
 
-			usb2_copy_out(pc, offset, m->cur_data_ptr, io_len);
+			usbd_copy_out(pc, offset, m->cur_data_ptr, io_len);
 
 			m->cur_data_len = io_len;
 			offset += io_len;
@@ -1804,7 +1804,7 @@ usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc,
 			}
 			USB_IF_ENQUEUE(&f->used_q, m);
 
-			usb2_fifo_wakeup(f);
+			usb_fifo_wakeup(f);
 
 			if ((len == 0) || (what == 1)) {
 				break;
@@ -1816,7 +1816,7 @@ usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc,
 }
 
 void
-usb2_fifo_put_data_linear(struct usb_fifo *f, void *ptr,
+usb_fifo_put_data_linear(struct usb_fifo *f, void *ptr,
     usb_size_t len, uint8_t what)
 {
 	struct usb_mbuf *m;
@@ -1842,7 +1842,7 @@ usb2_fifo_put_data_linear(struct usb_fifo *f, void *ptr,
 			}
 			USB_IF_ENQUEUE(&f->used_q, m);
 
-			usb2_fifo_wakeup(f);
+			usb_fifo_wakeup(f);
 
 			if ((len == 0) || (what == 1)) {
 				break;
@@ -1854,7 +1854,7 @@ usb2_fifo_put_data_linear(struct usb_fifo *f, void *ptr,
 }
 
 uint8_t
-usb2_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len)
+usb_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len)
 {
 	struct usb_mbuf *m;
 
@@ -1864,21 +1864,21 @@ usb2_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len)
 		m->cur_data_len = len;
 		m->cur_data_ptr = ptr;
 		USB_IF_ENQUEUE(&f->used_q, m);
-		usb2_fifo_wakeup(f);
+		usb_fifo_wakeup(f);
 		return (1);
 	}
 	return (0);
 }
 
 void
-usb2_fifo_put_data_error(struct usb_fifo *f)
+usb_fifo_put_data_error(struct usb_fifo *f)
 {
 	f->flag_iserror = 1;
-	usb2_fifo_wakeup(f);
+	usb_fifo_wakeup(f);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_get_data
+ *	usb_fifo_get_data
  *
  * what:
  *  0 - normal operation
@@ -1889,7 +1889,7 @@ usb2_fifo_put_data_error(struct usb_fifo *f)
  *  1 - data in buffer
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,
+usb_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,
     usb_frlength_t offset, usb_frlength_t len, usb_frlength_t *actlen,
     uint8_t what)
 {
@@ -1909,7 +1909,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,
 
 			io_len = MIN(len, m->cur_data_len);
 
-			usb2_copy_in(pc, offset, m->cur_data_ptr, io_len);
+			usbd_copy_in(pc, offset, m->cur_data_ptr, io_len);
 
 			len -= io_len;
 			offset += io_len;
@@ -1920,7 +1920,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,
 			if ((m->cur_data_len == 0) || (what == 1)) {
 				USB_IF_ENQUEUE(&f->free_q, m);
 
-				usb2_fifo_wakeup(f);
+				usb_fifo_wakeup(f);
 
 				if (what == 1) {
 					break;
@@ -1943,7 +1943,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,
 				}
 				/* flushing complete */
 				f->flag_flushing = 0;
-				usb2_fifo_wakeup(f);
+				usb_fifo_wakeup(f);
 			}
 			break;
 		}
@@ -1955,7 +1955,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,
 }
 
 uint8_t
-usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr,
+usb_fifo_get_data_linear(struct usb_fifo *f, void *ptr,
     usb_size_t len, usb_size_t *actlen, uint8_t what)
 {
 	struct usb_mbuf *m;
@@ -1985,7 +1985,7 @@ usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr,
 			if ((m->cur_data_len == 0) || (what == 1)) {
 				USB_IF_ENQUEUE(&f->free_q, m);
 
-				usb2_fifo_wakeup(f);
+				usb_fifo_wakeup(f);
 
 				if (what == 1) {
 					break;
@@ -2008,7 +2008,7 @@ usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr,
 				}
 				/* flushing complete */
 				f->flag_flushing = 0;
-				usb2_fifo_wakeup(f);
+				usb_fifo_wakeup(f);
 			}
 			break;
 		}
@@ -2020,7 +2020,7 @@ usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr,
 }
 
 uint8_t
-usb2_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen)
+usb_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen)
 {
 	struct usb_mbuf *m;
 
@@ -2036,21 +2036,21 @@ usb2_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen)
 }
 
 void
-usb2_fifo_get_data_error(struct usb_fifo *f)
+usb_fifo_get_data_error(struct usb_fifo *f)
 {
 	f->flag_iserror = 1;
-	usb2_fifo_wakeup(f);
+	usb_fifo_wakeup(f);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_alloc_symlink
+ *	usb_alloc_symlink
  *
  * Return values:
  * NULL: Failure
  * Else: Pointer to symlink entry
  *------------------------------------------------------------------------*/
 struct usb_symlink *
-usb2_alloc_symlink(const char *target)
+usb_alloc_symlink(const char *target)
 {
 	struct usb_symlink *ps;
 
@@ -2064,37 +2064,37 @@ usb2_alloc_symlink(const char *target)
 	strlcpy(ps->dst_path, target, sizeof(ps->dst_path));
 	ps->dst_len = strlen(ps->dst_path);
 
-	sx_xlock(&usb2_sym_lock);
-	TAILQ_INSERT_TAIL(&usb2_sym_head, ps, sym_entry);
-	sx_unlock(&usb2_sym_lock);
+	sx_xlock(&usb_sym_lock);
+	TAILQ_INSERT_TAIL(&usb_sym_head, ps, sym_entry);
+	sx_unlock(&usb_sym_lock);
 	return (ps);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_free_symlink
+ *	usb_free_symlink
  *------------------------------------------------------------------------*/
 void
-usb2_free_symlink(struct usb_symlink *ps)
+usb_free_symlink(struct usb_symlink *ps)
 {
 	if (ps == NULL) {
 		return;
 	}
-	sx_xlock(&usb2_sym_lock);
-	TAILQ_REMOVE(&usb2_sym_head, ps, sym_entry);
-	sx_unlock(&usb2_sym_lock);
+	sx_xlock(&usb_sym_lock);
+	TAILQ_REMOVE(&usb_sym_head, ps, sym_entry);
+	sx_unlock(&usb_sym_lock);
 
 	free(ps, M_USBDEV);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_read_symlink
+ *	usb_read_symlink
  *
  * Return value:
  * 0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 int
-usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len)
+usb_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len)
 {
 	struct usb_symlink *ps;
 	uint32_t temp;
@@ -2102,9 +2102,9 @@ usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len)
 	uint8_t len;
 	int error = 0;
 
-	sx_xlock(&usb2_sym_lock);
+	sx_xlock(&usb_sym_lock);
 
-	TAILQ_FOREACH(ps, &usb2_sym_head, sym_entry) {
+	TAILQ_FOREACH(ps, &usb_sym_head, sym_entry) {
 
 		/*
 		 * Compute total length of source and destination symlink
@@ -2183,12 +2183,12 @@ usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len)
 		error = copyout(&len,
 		    USB_ADD_BYTES(user_ptr, delta), 1);
 	}
-	sx_unlock(&usb2_sym_lock);
+	sx_unlock(&usb_sym_lock);
 	return (error);
 }
 
 void
-usb2_fifo_set_close_zlp(struct usb_fifo *f, uint8_t onoff)
+usb_fifo_set_close_zlp(struct usb_fifo *f, uint8_t onoff)
 {
 	if (f == NULL)
 		return;
diff --git a/sys/dev/usb/usb_dev.h b/sys/dev/usb/usb_dev.h
index fb41e5a..0af1c79 100644
--- a/sys/dev/usb/usb_dev.h
+++ b/sys/dev/usb/usb_dev.h
@@ -167,41 +167,41 @@ struct usb_fifo_sc {
 	struct cdev* dev;
 };
 
-extern struct cdevsw usb2_devsw;
+extern struct cdevsw usb_devsw;
 
-int	usb2_fifo_wait(struct usb_fifo *fifo);
-void	usb2_fifo_signal(struct usb_fifo *fifo);
-int	usb2_fifo_alloc_buffer(struct usb_fifo *f, uint32_t bufsize,
+int	usb_fifo_wait(struct usb_fifo *fifo);
+void	usb_fifo_signal(struct usb_fifo *fifo);
+int	usb_fifo_alloc_buffer(struct usb_fifo *f, uint32_t bufsize,
 	    uint16_t nbuf);
-void	usb2_fifo_free_buffer(struct usb_fifo *f);
-int	usb2_fifo_attach(struct usb_device *udev, void *priv_sc,
+void	usb_fifo_free_buffer(struct usb_fifo *f);
+int	usb_fifo_attach(struct usb_device *udev, void *priv_sc,
 	    struct mtx *priv_mtx, struct usb_fifo_methods *pm,
 	    struct usb_fifo_sc *f_sc, uint16_t unit, uint16_t subunit,
 	    uint8_t iface_index, uid_t uid, gid_t gid, int mode);
-void	usb2_fifo_detach(struct usb_fifo_sc *f_sc);
-uint32_t usb2_fifo_put_bytes_max(struct usb_fifo *fifo);
-void	usb2_fifo_put_data(struct usb_fifo *fifo, struct usb_page_cache *pc,
+void	usb_fifo_detach(struct usb_fifo_sc *f_sc);
+uint32_t usb_fifo_put_bytes_max(struct usb_fifo *fifo);
+void	usb_fifo_put_data(struct usb_fifo *fifo, struct usb_page_cache *pc,
 	    usb_frlength_t offset, usb_frlength_t len, uint8_t what);
-void	usb2_fifo_put_data_linear(struct usb_fifo *fifo, void *ptr,
+void	usb_fifo_put_data_linear(struct usb_fifo *fifo, void *ptr,
 	    usb_size_t len, uint8_t what);
-uint8_t	usb2_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len);
-void	usb2_fifo_put_data_error(struct usb_fifo *fifo);
-uint8_t	usb2_fifo_get_data(struct usb_fifo *fifo, struct usb_page_cache *pc,
+uint8_t	usb_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len);
+void	usb_fifo_put_data_error(struct usb_fifo *fifo);
+uint8_t	usb_fifo_get_data(struct usb_fifo *fifo, struct usb_page_cache *pc,
 	    usb_frlength_t offset, usb_frlength_t len, usb_frlength_t *actlen,
 	    uint8_t what);
-uint8_t	usb2_fifo_get_data_linear(struct usb_fifo *fifo, void *ptr,
+uint8_t	usb_fifo_get_data_linear(struct usb_fifo *fifo, void *ptr,
 	    usb_size_t len, usb_size_t *actlen, uint8_t what);
-uint8_t	usb2_fifo_get_data_buffer(struct usb_fifo *f, void **pptr,
+uint8_t	usb_fifo_get_data_buffer(struct usb_fifo *f, void **pptr,
 	    usb_size_t *plen);
-void	usb2_fifo_get_data_error(struct usb_fifo *fifo);
-uint8_t	usb2_fifo_opened(struct usb_fifo *fifo);
-void	usb2_fifo_free(struct usb_fifo *f);
-void	usb2_fifo_reset(struct usb_fifo *f);
-void	usb2_fifo_wakeup(struct usb_fifo *f);
-struct usb_symlink *usb2_alloc_symlink(const char *target);
-void	usb2_free_symlink(struct usb_symlink *ps);
-int	usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry,
+void	usb_fifo_get_data_error(struct usb_fifo *fifo);
+uint8_t	usb_fifo_opened(struct usb_fifo *fifo);
+void	usb_fifo_free(struct usb_fifo *f);
+void	usb_fifo_reset(struct usb_fifo *f);
+void	usb_fifo_wakeup(struct usb_fifo *f);
+struct usb_symlink *usb_alloc_symlink(const char *target);
+void	usb_free_symlink(struct usb_symlink *ps);
+int	usb_read_symlink(uint8_t *user_ptr, uint32_t startentry,
 	    uint32_t user_len);
-void	usb2_fifo_set_close_zlp(struct usb_fifo *, uint8_t);
+void	usb_fifo_set_close_zlp(struct usb_fifo *, uint8_t);
 
 #endif					/* _USB2_DEV_H_ */
diff --git a/sys/dev/usb/usb_device.c b/sys/dev/usb/usb_device.c
index 1e7cf51..fd7a5af 100644
--- a/sys/dev/usb/usb_device.c
+++ b/sys/dev/usb/usb_device.c
@@ -30,7 +30,7 @@
 #include <dev/usb/usb_ioctl.h>
 #include "usbdevs.h"
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -57,36 +57,36 @@
 
 /* function prototypes  */
 
-static void	usb2_init_endpoint(struct usb_device *, uint8_t,
+static void	usb_init_endpoint(struct usb_device *, uint8_t,
 		    struct usb_endpoint_descriptor *, struct usb_endpoint *);
-static void	usb2_unconfigure(struct usb_device *, uint8_t);
-static void	usb2_detach_device(struct usb_device *, uint8_t, uint8_t);
-static void	usb2_detach_device_sub(struct usb_device *, device_t *,
+static void	usb_unconfigure(struct usb_device *, uint8_t);
+static void	usb_detach_device(struct usb_device *, uint8_t, uint8_t);
+static void	usb_detach_device_sub(struct usb_device *, device_t *,
 		    uint8_t);
-static uint8_t	usb2_probe_and_attach_sub(struct usb_device *,
+static uint8_t	usb_probe_and_attach_sub(struct usb_device *,
 		    struct usb_attach_arg *);
-static void	usb2_init_attach_arg(struct usb_device *,
+static void	usb_init_attach_arg(struct usb_device *,
 		    struct usb_attach_arg *);
-static void	usb2_suspend_resume_sub(struct usb_device *, device_t,
+static void	usb_suspend_resume_sub(struct usb_device *, device_t,
 		    uint8_t);
-static void	usb2_clear_stall_proc(struct usb_proc_msg *_pm);
-usb_error_t	usb2_config_parse(struct usb_device *, uint8_t, uint8_t);
-static void	usb2_set_device_strings(struct usb_device *);
+static void	usbd_clear_stall_proc(struct usb_proc_msg *_pm);
+usb_error_t	usb_config_parse(struct usb_device *, uint8_t, uint8_t);
+static void	usbd_set_device_strings(struct usb_device *);
 #if USB_HAVE_UGEN
-static void	usb2_notify_addq(const char *type, struct usb_device *);
-static void	usb2_fifo_free_wrap(struct usb_device *, uint8_t, uint8_t);
-static struct cdev *usb2_make_dev(struct usb_device *, int, int);
-static void	usb2_cdev_create(struct usb_device *);
-static void	usb2_cdev_free(struct usb_device *);
-static void	usb2_cdev_cleanup(void *);
+static void	usb_notify_addq(const char *type, struct usb_device *);
+static void	usb_fifo_free_wrap(struct usb_device *, uint8_t, uint8_t);
+static struct cdev *usb_make_dev(struct usb_device *, int, int);
+static void	usb_cdev_create(struct usb_device *);
+static void	usb_cdev_free(struct usb_device *);
+static void	usb_cdev_cleanup(void *);
 #endif
 
 /* This variable is global to allow easy access to it: */
 
-int	usb2_template = 0;
+int	usb_template = 0;
 
 SYSCTL_INT(_hw_usb, OID_AUTO, template, CTLFLAG_RW,
-    &usb2_template, 0, "Selected USB device side template");
+    &usb_template, 0, "Selected USB device side template");
 
 static const char* statestr[USB_STATE_MAX] = {
 	[USB_STATE_DETACHED]	= "DETACHED",
@@ -97,13 +97,13 @@ static const char* statestr[USB_STATE_MAX] = {
 };
 
 const char *
-usb2_statestr(enum usb_dev_state state)
+usb_statestr(enum usb_dev_state state)
 {
 	return ((state < USB_STATE_MAX) ? statestr[state] : "UNKNOWN");
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_get_ep_by_addr
+ *	usbd_get_ep_by_addr
  *
  * This function searches for an USB ep by endpoint address and
  * direction.
@@ -113,7 +113,7 @@ usb2_statestr(enum usb_dev_state state)
  * Else: Success
  *------------------------------------------------------------------------*/
 struct usb_endpoint *
-usb2_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val)
+usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val)
 {
 	struct usb_endpoint *ep = udev->endpoints;
 	struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
@@ -157,7 +157,7 @@ found:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_get_endpoint
+ *	usbd_get_endpoint
  *
  * This function searches for an USB endpoint based on the information
  * given by the passed "struct usb_config" pointer.
@@ -167,7 +167,7 @@ found:
  * Else: Pointer to "struct usb_endpoint".
  *------------------------------------------------------------------------*/
 struct usb_endpoint *
-usb2_get_endpoint(struct usb_device *udev, uint8_t iface_index,
+usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index,
     const struct usb_config *setup)
 {
 	struct usb_endpoint *ep = udev->endpoints;
@@ -277,7 +277,7 @@ found:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_interface_count
+ *	usb_interface_count
  *
  * This function stores the number of USB interfaces excluding
  * alternate settings, which the USB config descriptor reports into
@@ -288,7 +288,7 @@ found:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_interface_count(struct usb_device *udev, uint8_t *count)
+usb_interface_count(struct usb_device *udev, uint8_t *count)
 {
 	if (udev->cdesc == NULL) {
 		*count = 0;
@@ -300,14 +300,14 @@ usb2_interface_count(struct usb_device *udev, uint8_t *count)
 
 
 /*------------------------------------------------------------------------*
- *	usb2_init_endpoint
+ *	usb_init_endpoint
  *
  * This function will initialise the USB endpoint structure pointed to by
  * the "endpoint" argument. The structure pointed to by "endpoint" must be
  * zeroed before calling this function.
  *------------------------------------------------------------------------*/
 static void
-usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index,
+usb_init_endpoint(struct usb_device *udev, uint8_t iface_index,
     struct usb_endpoint_descriptor *edesc, struct usb_endpoint *ep)
 {
 	struct usb_bus_methods *methods;
@@ -320,7 +320,7 @@ usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index,
 	ep->edesc = edesc;
 	ep->iface_index = iface_index;
 	TAILQ_INIT(&ep->endpoint_q.head);
-	ep->endpoint_q.command = &usb2_pipe_start;
+	ep->endpoint_q.command = &usbd_pipe_start;
 
 	/* the pipe is not supported by the hardware */
  	if (ep->methods == NULL)
@@ -335,7 +335,7 @@ usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index,
 }
 
 /*-----------------------------------------------------------------------*
- *	usb2_endpoint_foreach
+ *	usb_endpoint_foreach
  *
  * This function will iterate all the USB endpoints except the control
  * endpoint. This function is NULL safe.
@@ -345,7 +345,7 @@ usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index,
  * Else: Pointer to next USB endpoint
  *------------------------------------------------------------------------*/
 struct usb_endpoint *
-usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep)
+usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep)
 {
 	struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
 
@@ -369,7 +369,7 @@ usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_unconfigure
+ *	usb_unconfigure
  *
  * This function will free all USB interfaces and USB endpoints belonging
  * to an USB device.
@@ -377,7 +377,7 @@ usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep)
  * Flag values, see "USB_UNCFG_FLAG_XXX".
  *------------------------------------------------------------------------*/
 static void
-usb2_unconfigure(struct usb_device *udev, uint8_t flag)
+usb_unconfigure(struct usb_device *udev, uint8_t flag)
 {
 	uint8_t do_unlock;
 
@@ -390,16 +390,16 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag)
 	}
 
 	/* detach all interface drivers */
-	usb2_detach_device(udev, USB_IFACE_INDEX_ANY, flag);
+	usb_detach_device(udev, USB_IFACE_INDEX_ANY, flag);
 
 #if USB_HAVE_UGEN
 	/* free all FIFOs except control endpoint FIFOs */
-	usb2_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag);
+	usb_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag);
 
 	/*
 	 * Free all cdev's, if any.
 	 */
-	usb2_cdev_free(udev);
+	usb_cdev_free(udev);
 #endif
 
 #if USB_HAVE_COMPAT_LINUX
@@ -410,7 +410,7 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag)
 	}
 #endif
 
-	usb2_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE);
+	usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE);
 
 	/* free "cdesc" after "ifaces" and "endpoints", if any */
 	if (udev->cdesc != NULL) {
@@ -428,7 +428,7 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_set_config_index
+ *	usbd_set_config_index
  *
  * This function selects configuration by index, independent of the
  * actual configuration number. This function should not be used by
@@ -439,7 +439,7 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag)
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_set_config_index(struct usb_device *udev, uint8_t index)
+usbd_set_config_index(struct usb_device *udev, uint8_t index)
 {
 	struct usb_status ds;
 	struct usb_config_descriptor *cdp;
@@ -459,27 +459,27 @@ usb2_set_config_index(struct usb_device *udev, uint8_t index)
 		sx_xlock(udev->default_sx + 1);
 	}
 
-	usb2_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV);
+	usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV);
 
 	if (index == USB_UNCONFIG_INDEX) {
 		/*
 		 * Leave unallocated when unconfiguring the
-		 * device. "usb2_unconfigure()" will also reset
+		 * device. "usb_unconfigure()" will also reset
 		 * the current config number and index.
 		 */
-		err = usb2_req_set_config(udev, NULL, USB_UNCONFIG_NO);
+		err = usbd_req_set_config(udev, NULL, USB_UNCONFIG_NO);
 		if (udev->state == USB_STATE_CONFIGURED)
-			usb2_set_device_state(udev, USB_STATE_ADDRESSED);
+			usb_set_device_state(udev, USB_STATE_ADDRESSED);
 		goto done;
 	}
 	/* get the full config descriptor */
 	if (udev->flags.usb_mode == USB_MODE_DEVICE) {
 		/* save some memory */
-		err = usb2_req_get_descriptor_ptr(udev, &cdp, 
+		err = usbd_req_get_descriptor_ptr(udev, &cdp, 
 		    (UDESC_CONFIG << 8) | index);
 	} else {
 		/* normal request */
-		err = usb2_req_get_config_desc_full(udev,
+		err = usbd_req_get_config_desc_full(udev,
 		    NULL, &cdp, M_USB, index);
 	}
 	if (err) {
@@ -497,11 +497,11 @@ usb2_set_config_index(struct usb_device *udev, uint8_t index)
 		/* May be self powered. */
 		if (cdp->bmAttributes & UC_BUS_POWERED) {
 			/* Must ask device. */
-			err = usb2_req_get_device_status(udev, NULL, &ds);
+			err = usbd_req_get_device_status(udev, NULL, &ds);
 			if (err) {
 				DPRINTFN(0, "could not read "
 				    "device status: %s\n",
-				    usb2_errstr(err));
+				    usbd_errstr(err));
 			} else if (UGETW(ds.wStatus) & UDS_SELF_POWERED) {
 				selfpowered = 1;
 			}
@@ -537,33 +537,33 @@ usb2_set_config_index(struct usb_device *udev, uint8_t index)
 	udev->power = power;
 	udev->curr_config_no = cdp->bConfigurationValue;
 	udev->curr_config_index = index;
-	usb2_set_device_state(udev, USB_STATE_CONFIGURED);
+	usb_set_device_state(udev, USB_STATE_CONFIGURED);
 
 	/* Set the actual configuration value. */
-	err = usb2_req_set_config(udev, NULL, cdp->bConfigurationValue);
+	err = usbd_req_set_config(udev, NULL, cdp->bConfigurationValue);
 	if (err) {
 		goto done;
 	}
 
-	err = usb2_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC);
+	err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC);
 	if (err) {
 		goto done;
 	}
 
-	err = usb2_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT);
+	err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT);
 	if (err) {
 		goto done;
 	}
 
 #if USB_HAVE_UGEN
 	/* create device nodes for each endpoint */
-	usb2_cdev_create(udev);
+	usb_cdev_create(udev);
 #endif
 
 done:
-	DPRINTF("error=%s\n", usb2_errstr(err));
+	DPRINTF("error=%s\n", usbd_errstr(err));
 	if (err) {
-		usb2_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV);
+		usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV);
 	}
 	if (do_unlock) {
 		sx_unlock(udev->default_sx + 1);
@@ -572,7 +572,7 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_config_parse
+ *	usb_config_parse
  *
  * This function will allocate and free USB interfaces and USB endpoints,
  * parse the USB configuration structure and initialise the USB endpoints
@@ -589,7 +589,7 @@ done:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
+usb_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
 {
 	struct usb_idesc_parse_state ips;
 	struct usb_interface_descriptor *id;
@@ -656,7 +656,7 @@ usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
 	ep_curr = 0;
 	ep_max = 0;
 
-	while ((id = usb2_idesc_foreach(udev->cdesc, &ips))) {
+	while ((id = usb_idesc_foreach(udev->cdesc, &ips))) {
 
 		/* check for interface overflow */
 		if (ips.iface_index == USB_IFACE_MAX)
@@ -703,7 +703,7 @@ usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
 		temp = ep_curr;
 
 		/* iterate all the endpoint descriptors */
-		while ((ed = usb2_edesc_foreach(udev->cdesc, ed))) {
+		while ((ed = usb_edesc_foreach(udev->cdesc, ed))) {
 
 			if (temp == USB_EP_MAX)
 				break;			/* crazy */
@@ -711,7 +711,7 @@ usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
 			ep = udev->endpoints + temp;
 
 			if (do_init) {
-				usb2_init_endpoint(udev, 
+				usb_init_endpoint(udev, 
 				    ips.iface_index, ed, ep);
 			}
 
@@ -781,7 +781,7 @@ cleanup:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_set_alt_interface_index
+ *	usbd_set_alt_interface_index
  *
  * This function will select an alternate interface index for the
  * given interface index. The interface should not be in use when this
@@ -795,10 +795,10 @@ cleanup:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_set_alt_interface_index(struct usb_device *udev,
+usbd_set_alt_interface_index(struct usb_device *udev,
     uint8_t iface_index, uint8_t alt_index)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	usb_error_t err;
 	uint8_t do_unlock;
 
@@ -814,7 +814,7 @@ usb2_set_alt_interface_index(struct usb_device *udev,
 		goto done;
 	}
 	if (udev->flags.usb_mode == USB_MODE_DEVICE) {
-		usb2_detach_device(udev, iface_index,
+		usb_detach_device(udev, iface_index,
 		    USB_UNCFG_FLAG_FREE_SUBDEV);
 	} else {
 		if (iface->alt_index == alt_index) {
@@ -831,14 +831,14 @@ usb2_set_alt_interface_index(struct usb_device *udev,
 	 * Free all generic FIFOs for this interface, except control
 	 * endpoint FIFOs:
 	 */
-	usb2_fifo_free_wrap(udev, iface_index, 0);
+	usb_fifo_free_wrap(udev, iface_index, 0);
 #endif
 
-	err = usb2_config_parse(udev, iface_index, alt_index);
+	err = usb_config_parse(udev, iface_index, alt_index);
 	if (err) {
 		goto done;
 	}
-	err = usb2_req_set_alt_interface_no(udev, NULL, iface_index,
+	err = usbd_req_set_alt_interface_no(udev, NULL, iface_index,
 	    iface->idesc->bAlternateSetting);
 
 done:
@@ -849,7 +849,7 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_set_endpoint_stall
+ *	usbd_set_endpoint_stall
  *
  * This function is used to make a BULK or INTERRUPT endpoint
  * send STALL tokens.
@@ -859,7 +859,7 @@ done:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep,
+usbd_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep,
     uint8_t do_stall)
 {
 	struct usb_xfer *xfer;
@@ -925,17 +925,17 @@ usb2_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep,
 		(udev->bus->methods->clear_stall) (udev, ep);
 
 		/* start up the current or next transfer, if any */
-		usb2_command_wrapper(&ep->endpoint_q, ep->endpoint_q.curr);
+		usb_command_wrapper(&ep->endpoint_q, ep->endpoint_q.curr);
 	}
 	USB_BUS_UNLOCK(udev->bus);
 	return (0);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_reset_iface_endpoints - used in USB device side mode
+ *	usb_reset_iface_endpoints - used in USB device side mode
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
+usb_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
 {
 	struct usb_endpoint *ep;
 	struct usb_endpoint *ep_end;
@@ -951,7 +951,7 @@ usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
 			continue;
 		}
 		/* simulate a clear stall from the peer */
-		err = usb2_set_endpoint_stall(udev, ep, 0);
+		err = usbd_set_endpoint_stall(udev, ep, 0);
 		if (err) {
 			/* just ignore */
 		}
@@ -960,7 +960,7 @@ usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_detach_device_sub
+ *	usb_detach_device_sub
  *
  * This function will try to detach an USB device. If it fails a panic
  * will result.
@@ -968,7 +968,7 @@ usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
  * Flag values, see "USB_UNCFG_FLAG_XXX".
  *------------------------------------------------------------------------*/
 static void
-usb2_detach_device_sub(struct usb_device *udev, device_t *ppdev,
+usb_detach_device_sub(struct usb_device *udev, device_t *ppdev,
     uint8_t flag)
 {
 	device_t dev;
@@ -1016,7 +1016,7 @@ error:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_detach_device
+ *	usb_detach_device
  *
  * The following function will detach the matching interfaces.
  * This function is NULL safe.
@@ -1024,7 +1024,7 @@ error:
  * Flag values, see "USB_UNCFG_FLAG_XXX".
  *------------------------------------------------------------------------*/
 void
-usb2_detach_device(struct usb_device *udev, uint8_t iface_index,
+usb_detach_device(struct usb_device *udev, uint8_t iface_index,
     uint8_t flag)
 {
 	struct usb_interface *iface;
@@ -1056,24 +1056,24 @@ usb2_detach_device(struct usb_device *udev, uint8_t iface_index,
 
 	for (; i != iface_index; i++) {
 
-		iface = usb2_get_iface(udev, i);
+		iface = usbd_get_iface(udev, i);
 		if (iface == NULL) {
 			/* looks like the end of the USB interfaces */
 			break;
 		}
-		usb2_detach_device_sub(udev, &iface->subdev, flag);
+		usb_detach_device_sub(udev, &iface->subdev, flag);
 	}
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_probe_and_attach_sub
+ *	usb_probe_and_attach_sub
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_probe_and_attach_sub(struct usb_device *udev,
+usb_probe_and_attach_sub(struct usb_device *udev,
     struct usb_attach_arg *uaa)
 {
 	struct usb_interface *iface;
@@ -1148,7 +1148,7 @@ usb2_probe_and_attach_sub(struct usb_device *udev,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_set_parent_iface
+ *	usbd_set_parent_iface
  *
  * Using this function will lock the alternate interface setting on an
  * interface. It is typically used for multi interface drivers. In USB
@@ -1158,19 +1158,19 @@ usb2_probe_and_attach_sub(struct usb_device *udev,
  * locked.
  *------------------------------------------------------------------------*/
 void
-usb2_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
+usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
     uint8_t parent_index)
 {
 	struct usb_interface *iface;
 
-	iface = usb2_get_iface(udev, iface_index);
+	iface = usbd_get_iface(udev, iface_index);
 	if (iface) {
 		iface->parent_iface_index = parent_index;
 	}
 }
 
 static void
-usb2_init_attach_arg(struct usb_device *udev,
+usb_init_attach_arg(struct usb_device *udev,
     struct usb_attach_arg *uaa)
 {
 	bzero(uaa, sizeof(*uaa));
@@ -1190,17 +1190,17 @@ usb2_init_attach_arg(struct usb_device *udev,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_probe_and_attach
+ *	usb_probe_and_attach
  *
  * This function is called from "uhub_explore_sub()",
- * "usb2_handle_set_config()" and "usb2_handle_request()".
+ * "usb_handle_set_config()" and "usb_handle_request()".
  *
  * Returns:
  *    0: Success
  * Else: A control transfer failed
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
+usb_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
 {
 	struct usb_attach_arg uaa;
 	struct usb_interface *iface;
@@ -1226,7 +1226,7 @@ usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
 	}
 	/* setup USB attach arguments */
 
-	usb2_init_attach_arg(udev, &uaa);
+	usb_init_attach_arg(udev, &uaa);
 
 	/* Check if only one interface should be probed: */
 	if (iface_index != USB_IFACE_INDEX_ANY) {
@@ -1240,7 +1240,7 @@ usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
 	/* Do the probe and attach */
 	for (; i != j; i++) {
 
-		iface = usb2_get_iface(udev, i);
+		iface = usbd_get_iface(udev, i);
 		if (iface == NULL) {
 			/*
 			 * Looks like the end of the USB
@@ -1276,14 +1276,14 @@ usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
 
 		/* try specific interface drivers first */
 
-		if (usb2_probe_and_attach_sub(udev, &uaa)) {
+		if (usb_probe_and_attach_sub(udev, &uaa)) {
 			/* ignore */
 		}
 		/* try generic interface drivers last */
 
 		uaa.use_generic = 1;
 
-		if (usb2_probe_and_attach_sub(udev, &uaa)) {
+		if (usb_probe_and_attach_sub(udev, &uaa)) {
 			/* ignore */
 		}
 	}
@@ -1303,13 +1303,13 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_suspend_resume_sub
+ *	usb_suspend_resume_sub
  *
  * This function is called when the suspend or resume methods should
  * be executed on an USB device.
  *------------------------------------------------------------------------*/
 static void
-usb2_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend)
+usb_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend)
 {
 	int err;
 
@@ -1331,7 +1331,7 @@ usb2_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspen
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_suspend_resume
+ *	usb_suspend_resume
  *
  * The following function will suspend or resume the USB device.
  *
@@ -1340,7 +1340,7 @@ usb2_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspen
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_suspend_resume(struct usb_device *udev, uint8_t do_suspend)
+usb_suspend_resume(struct usb_device *udev, uint8_t do_suspend)
 {
 	struct usb_interface *iface;
 	uint8_t i;
@@ -1367,23 +1367,23 @@ usb2_suspend_resume(struct usb_device *udev, uint8_t do_suspend)
 
 	for (i = 0; i != USB_IFACE_MAX; i++) {
 
-		iface = usb2_get_iface(udev, i);
+		iface = usbd_get_iface(udev, i);
 		if (iface == NULL) {
 			/* looks like the end of the USB interfaces */
 			break;
 		}
-		usb2_suspend_resume_sub(udev, iface->subdev, do_suspend);
+		usb_suspend_resume_sub(udev, iface->subdev, do_suspend);
 	}
 	return (0);
 }
 
 /*------------------------------------------------------------------------*
- *      usb2_clear_stall_proc
+ *      usbd_clear_stall_proc
  *
  * This function performs generic USB clear stall operations.
  *------------------------------------------------------------------------*/
 static void
-usb2_clear_stall_proc(struct usb_proc_msg *_pm)
+usbd_clear_stall_proc(struct usb_proc_msg *_pm)
 {
 	struct usb_clear_stall_msg *pm = (void *)_pm;
 	struct usb_device *udev = pm->udev;
@@ -1393,7 +1393,7 @@ usb2_clear_stall_proc(struct usb_proc_msg *_pm)
 	mtx_lock(udev->default_mtx);
 
 	/* Start clear stall callback */
-	usb2_transfer_start(udev->default_xfer[1]);
+	usbd_transfer_start(udev->default_xfer[1]);
 
 	/* Change lock */
 	mtx_unlock(udev->default_mtx);
@@ -1401,7 +1401,7 @@ usb2_clear_stall_proc(struct usb_proc_msg *_pm)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_alloc_device
+ *	usb_alloc_device
  *
  * This function allocates a new USB device. This function is called
  * when a new device has been put in the powered state, but not yet in
@@ -1413,7 +1413,7 @@ usb2_clear_stall_proc(struct usb_proc_msg *_pm)
  * Else: Success
  *------------------------------------------------------------------------*/
 struct usb_device *
-usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
+usb_alloc_device(device_t parent_dev, struct usb_bus *bus,
     struct usb_device *parent_hub, uint8_t depth, uint8_t port_index,
     uint8_t port_no, enum usb_dev_speed speed, enum usb_hc_mode mode)
 {
@@ -1471,9 +1471,9 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	mtx_init(udev->default_mtx, "USB device mutex", NULL, MTX_DEF);
 
 	/* initialise generic clear stall */
-	udev->cs_msg[0].hdr.pm_callback = &usb2_clear_stall_proc;
+	udev->cs_msg[0].hdr.pm_callback = &usbd_clear_stall_proc;
 	udev->cs_msg[0].udev = udev;
-	udev->cs_msg[1].hdr.pm_callback = &usb2_clear_stall_proc;
+	udev->cs_msg[1].hdr.pm_callback = &usbd_clear_stall_proc;
 	udev->cs_msg[1].udev = udev;
 
 	/* initialise some USB device fields */
@@ -1485,7 +1485,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	udev->bus = bus;
 	udev->address = USB_START_ADDR;	/* default value */
 	udev->plugtime = (usb_ticks_t)ticks;
-	usb2_set_device_state(udev, USB_STATE_POWERED);
+	usb_set_device_state(udev, USB_STATE_POWERED);
 	/*
 	 * We need to force the power mode to "on" because there are plenty
 	 * of USB devices out there that do not work very well with
@@ -1526,7 +1526,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	}
 
 	/* init the default endpoint */
-	usb2_init_endpoint(udev, 0,
+	usb_init_endpoint(udev, 0,
 	    &udev->default_ep_desc,
 	    &udev->default_ep);
 
@@ -1541,14 +1541,14 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	LIST_INIT(&udev->pd_list);
 
 	/* Create the control endpoint device */
-	udev->default_dev = usb2_make_dev(udev, 0, FREAD|FWRITE);
+	udev->default_dev = usb_make_dev(udev, 0, FREAD|FWRITE);
 
 	/* Create a link from /dev/ugenX.X to the default endpoint */
 	make_dev_alias(udev->default_dev, udev->ugen_name);
 #endif
 	if (udev->flags.usb_mode == USB_MODE_HOST) {
 
-		err = usb2_req_set_address(udev, NULL, device_index);
+		err = usbd_req_set_address(udev, NULL, device_index);
 
 		/* This is the new USB device address from now on */
 
@@ -1566,10 +1566,10 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 		if (err) {
 			DPRINTFN(0, "set address %d failed "
 			    "(%s, ignored)\n", udev->address, 
-			    usb2_errstr(err));
+			    usbd_errstr(err));
 		}
 		/* allow device time to set new address */
-		usb2_pause_mtx(NULL, 
+		usb_pause_mtx(NULL, 
 		    USB_MS_TO_TICKS(USB_SET_ADDRESS_SETTLE));
 	} else {
 		/* We are not self powered */
@@ -1580,33 +1580,33 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 		udev->curr_config_index = USB_UNCONFIG_INDEX;
 
 		/* Setup USB descriptors */
-		err = (usb2_temp_setup_by_index_p) (udev, usb2_template);
+		err = (usb_temp_setup_by_index_p) (udev, usb_template);
 		if (err) {
 			DPRINTFN(0, "setting up USB template failed maybe the USB "
 			    "template module has not been loaded\n");
 			goto done;
 		}
 	}
-	usb2_set_device_state(udev, USB_STATE_ADDRESSED);
+	usb_set_device_state(udev, USB_STATE_ADDRESSED);
 
 	/*
 	 * Get the first 8 bytes of the device descriptor !
 	 *
-	 * NOTE: "usb2_do_request" will check the device descriptor
+	 * NOTE: "usbd_do_request" will check the device descriptor
 	 * next time we do a request to see if the maximum packet size
 	 * changed! The 8 first bytes of the device descriptor
 	 * contains the maximum packet size to use on control endpoint
 	 * 0. If this value is different from "USB_MAX_IPACKET" a new
 	 * USB control request will be setup!
 	 */
-	err = usb2_req_get_desc(udev, NULL, NULL, &udev->ddesc,
+	err = usbd_req_get_desc(udev, NULL, NULL, &udev->ddesc,
 	    USB_MAX_IPACKET, USB_MAX_IPACKET, 0, UDESC_DEVICE, 0, 0);
 	if (err) {
 		DPRINTFN(0, "getting device descriptor "
 		    "at addr %d failed, %s!\n", udev->address,
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		/* XXX try to re-enumerate the device */
-		err = usb2_req_re_enumerate(udev, NULL);
+		err = usbd_req_re_enumerate(udev, NULL);
 		if (err) {
 			goto done;
 		}
@@ -1622,7 +1622,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	    udev->speed);
 
 	/* get the full device descriptor */
-	err = usb2_req_get_device_desc(udev, NULL, &udev->ddesc);
+	err = usbd_req_get_device_desc(udev, NULL, &udev->ddesc);
 	if (err) {
 		DPRINTF("addr=%d, getting full desc failed\n",
 		    udev->address);
@@ -1632,12 +1632,12 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	 * Setup temporary USB attach args so that we can figure out some
 	 * basic quirks for this device.
 	 */
-	usb2_init_attach_arg(udev, &uaa);
+	usb_init_attach_arg(udev, &uaa);
 
-	if (usb2_test_quirk(&uaa, UQ_BUS_POWERED)) {
+	if (usb_test_quirk(&uaa, UQ_BUS_POWERED)) {
 		udev->flags.uq_bus_powered = 1;
 	}
-	if (usb2_test_quirk(&uaa, UQ_NO_STRINGS)) {
+	if (usb_test_quirk(&uaa, UQ_NO_STRINGS)) {
 		udev->flags.no_strings = 1;
 	}
 	/*
@@ -1658,7 +1658,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	    udev->ddesc.iProduct ||
 	    udev->ddesc.iSerialNumber) {
 		/* read out the language ID string */
-		err = usb2_req_get_string_desc(udev, NULL,
+		err = usbd_req_get_string_desc(udev, NULL,
 		    (char *)scratch_ptr, 4, scratch_size,
 		    USB_LANGUAGE_TABLE);
 	} else {
@@ -1675,7 +1675,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 	/* assume 100mA bus powered for now. Changed when configured. */
 	udev->power = USB_MIN_POWER;
 	/* fetch the vendor and product strings from the device */
-	usb2_set_device_strings(udev);
+	usbd_set_device_strings(udev);
 
 	if (udev->flags.usb_mode == USB_MODE_HOST) {
 		uint8_t config_index;
@@ -1686,19 +1686,19 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
 		 * Most USB devices should attach to config index 0 by
 		 * default
 		 */
-		if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_0)) {
+		if (usb_test_quirk(&uaa, UQ_CFG_INDEX_0)) {
 			config_index = 0;
 			config_quirk = 1;
-		} else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_1)) {
+		} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_1)) {
 			config_index = 1;
 			config_quirk = 1;
-		} else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_2)) {
+		} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_2)) {
 			config_index = 2;
 			config_quirk = 1;
-		} else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_3)) {
+		} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_3)) {
 			config_index = 3;
 			config_quirk = 1;
-		} else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_4)) {
+		} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_4)) {
 			config_index = 4;
 			config_quirk = 1;
 		} else {
@@ -1711,13 +1711,13 @@ repeat_set_config:
 		DPRINTF("setting config %u\n", config_index);
 
 		/* get the USB device configured */
-		err = usb2_set_config_index(udev, config_index);
+		err = usbd_set_config_index(udev, config_index);
 		if (err) {
 			if (udev->ddesc.bNumConfigurations != 0) {
 				if (!set_config_failed) {
 					set_config_failed = 1;
 					/* XXX try to re-enumerate the device */
-					err = usb2_req_re_enumerate(
+					err = usbd_req_re_enumerate(
 					    udev, NULL);
 					if (err == 0)
 					    goto repeat_set_config;
@@ -1725,7 +1725,7 @@ repeat_set_config:
 				DPRINTFN(0, "Failure selecting "
 				    "configuration index %u: %s, port %u, "
 				    "addr %u (ignored)\n",
-				    config_index, usb2_errstr(err), udev->port_no,
+				    config_index, usbd_errstr(err), udev->port_no,
 				    udev->address);
 			}
 			/*
@@ -1739,7 +1739,7 @@ repeat_set_config:
 		} else if ((config_index + 1) < udev->ddesc.bNumConfigurations) {
 
 			if ((udev->cdesc->bNumInterface < 2) &&
-			    (usb2_get_no_descriptors(udev->cdesc,
+			    (usbd_get_no_descriptors(udev->cdesc,
 			    UDESC_ENDPOINT) == 0)) {
 				DPRINTFN(0, "Found no endpoints "
 				    "(trying next config)!\n");
@@ -1751,14 +1751,14 @@ repeat_set_config:
 				 * Try to figure out if we have an
 				 * auto-install disk there:
 				 */
-				if (usb2_test_autoinstall(udev, 0, 0) == 0) {
+				if (usb_test_autoinstall(udev, 0, 0) == 0) {
 					DPRINTFN(0, "Found possible auto-install "
 					    "disk (trying next config)\n");
 					config_index++;
 					goto repeat_set_config;
 				}
 			}
-		} else if (usb2_test_huawei_autoinst_p(udev, &uaa) == 0) {
+		} else if (usb_test_huawei_autoinst_p(udev, &uaa) == 0) {
 			DPRINTFN(0, "Found Huawei auto-install disk!\n");
 			err = USB_ERR_STALLED;	/* fake an error */
 		}
@@ -1770,23 +1770,23 @@ repeat_set_config:
 	    udev->address, udev, udev->parent_hub);
 
 	/* register our device - we are ready */
-	usb2_bus_port_set_device(bus, parent_hub ?
+	usb_bus_port_set_device(bus, parent_hub ?
 	    parent_hub->hub->ports + port_index : NULL, udev, device_index);
 
 #if USB_HAVE_UGEN
 	/* Symlink the ugen device name */
-	udev->ugen_symlink = usb2_alloc_symlink(udev->ugen_name);
+	udev->ugen_symlink = usb_alloc_symlink(udev->ugen_name);
 
 	/* Announce device */
 	printf("%s: <%s> at %s\n", udev->ugen_name, udev->manufacturer,
 	    device_get_nameunit(udev->bus->bdev));
 
-	usb2_notify_addq("+", udev);
+	usb_notify_addq("+", udev);
 #endif
 done:
 	if (err) {
 		/* free device  */
-		usb2_free_device(udev,
+		usb_free_device(udev,
 		    USB_UNCFG_FLAG_FREE_SUBDEV |
 		    USB_UNCFG_FLAG_FREE_EP0);
 		udev = NULL;
@@ -1796,7 +1796,7 @@ done:
 
 #if USB_HAVE_UGEN
 static struct cdev *
-usb2_make_dev(struct usb_device *udev, int ep, int mode)
+usb_make_dev(struct usb_device *udev, int ep, int mode)
 {
 	struct usb_fs_privdata* pd;
 	char devname[20];
@@ -1812,7 +1812,7 @@ usb2_make_dev(struct usb_device *udev, int ep, int mode)
 	/* Now, create the device itself */
 	snprintf(devname, sizeof(devname), "%u.%u.%u",
 	    pd->bus_index, pd->dev_index, pd->ep_addr);
-	pd->cdev = make_dev(&usb2_devsw, 0, UID_ROOT,
+	pd->cdev = make_dev(&usb_devsw, 0, UID_ROOT,
 	    GID_OPERATOR, 0600, USB_DEVICE_DIR "/%s", devname);
 	pd->cdev->si_drv1 = pd;
 
@@ -1820,7 +1820,7 @@ usb2_make_dev(struct usb_device *udev, int ep, int mode)
 }
 
 static void
-usb2_cdev_create(struct usb_device *udev)
+usb_cdev_create(struct usb_device *udev)
 {
 	struct usb_config_descriptor *cd;
 	struct usb_endpoint_descriptor *ed;
@@ -1834,7 +1834,7 @@ usb2_cdev_create(struct usb_device *udev)
 
 	DPRINTFN(2, "Creating device nodes\n");
 
-	if (usb2_get_mode(udev) == USB_MODE_DEVICE) {
+	if (usbd_get_mode(udev) == USB_MODE_DEVICE) {
 		inmode = FWRITE;
 		outmode = FREAD;
 	} else {		 /* USB_MODE_HOST */
@@ -1850,8 +1850,8 @@ usb2_cdev_create(struct usb_device *udev)
 	 * Collect all used endpoint numbers instead of just
 	 * generating 16 static endpoints.
 	 */
-	cd = usb2_get_config_descriptor(udev);
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	cd = usbd_get_config_descriptor(udev);
+	while ((desc = usb_desc_foreach(cd, desc))) {
 		/* filter out all endpoint descriptors */
 		if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
 		    (desc->bLength >= sizeof(*ed))) {
@@ -1873,14 +1873,14 @@ usb2_cdev_create(struct usb_device *udev)
 		if (mode == 0)
 			continue;	/* no IN or OUT endpoint */
 
-		dev = usb2_make_dev(udev, ep, mode);
+		dev = usb_make_dev(udev, ep, mode);
 		pd = dev->si_drv1;
 		LIST_INSERT_HEAD(&udev->pd_list, pd, pd_next);
 	}
 }
 
 static void
-usb2_cdev_free(struct usb_device *udev)
+usb_cdev_free(struct usb_device *udev)
 {
 	struct usb_fs_privdata* pd;
 
@@ -1889,28 +1889,28 @@ usb2_cdev_free(struct usb_device *udev)
 	while ((pd = LIST_FIRST(&udev->pd_list)) != NULL) {
 		KASSERT(pd->cdev->si_drv1 == pd, ("privdata corrupt"));
 
-		destroy_dev_sched_cb(pd->cdev, usb2_cdev_cleanup, pd);
+		destroy_dev_sched_cb(pd->cdev, usb_cdev_cleanup, pd);
 		pd->cdev = NULL;
 		LIST_REMOVE(pd, pd_next);
 	}
 }
 
 static void
-usb2_cdev_cleanup(void* arg)
+usb_cdev_cleanup(void* arg)
 {
 	free(arg, M_USBDEV);
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_free_device
+ *	usb_free_device
  *
  * This function is NULL safe and will free an USB device.
  *
  * Flag values, see "USB_UNCFG_FLAG_XXX".
  *------------------------------------------------------------------------*/
 void
-usb2_free_device(struct usb_device *udev, uint8_t flag)
+usb_free_device(struct usb_device *udev, uint8_t flag)
 {
 	struct usb_bus *bus;
 
@@ -1920,17 +1920,17 @@ usb2_free_device(struct usb_device *udev, uint8_t flag)
 	DPRINTFN(4, "udev=%p port=%d\n", udev, udev->port_no);
 
 	bus = udev->bus;
-	usb2_set_device_state(udev, USB_STATE_DETACHED);
+	usb_set_device_state(udev, USB_STATE_DETACHED);
 
 #if USB_HAVE_UGEN
-	usb2_notify_addq("-", udev);
+	usb_notify_addq("-", udev);
 
 	printf("%s: <%s> at %s (disconnected)\n", udev->ugen_name,
 	    udev->manufacturer, device_get_nameunit(bus->bdev));
 
 	/* Destroy UGEN symlink, if any */
 	if (udev->ugen_symlink) {
-		usb2_free_symlink(udev->ugen_symlink);
+		usb_free_symlink(udev->ugen_symlink);
 		udev->ugen_symlink = NULL;
 	}
 #endif
@@ -1938,43 +1938,43 @@ usb2_free_device(struct usb_device *udev, uint8_t flag)
 	 * Unregister our device first which will prevent any further
 	 * references:
 	 */
-	usb2_bus_port_set_device(bus, udev->parent_hub ?
+	usb_bus_port_set_device(bus, udev->parent_hub ?
 	    udev->parent_hub->hub->ports + udev->port_index : NULL,
 	    NULL, USB_ROOT_HUB_ADDR);
 
 #if USB_HAVE_UGEN
 	/* wait for all pending references to go away: */
-	mtx_lock(&usb2_ref_lock);
+	mtx_lock(&usb_ref_lock);
 	udev->refcount--;
 	while (udev->refcount != 0) {
-		cv_wait(udev->default_cv + 1, &usb2_ref_lock);
+		cv_wait(udev->default_cv + 1, &usb_ref_lock);
 	}
-	mtx_unlock(&usb2_ref_lock);
+	mtx_unlock(&usb_ref_lock);
 
-	destroy_dev_sched_cb(udev->default_dev, usb2_cdev_cleanup,
+	destroy_dev_sched_cb(udev->default_dev, usb_cdev_cleanup,
 	    udev->default_dev->si_drv1);
 #endif
 
 	if (udev->flags.usb_mode == USB_MODE_DEVICE) {
 		/* stop receiving any control transfers (Device Side Mode) */
-		usb2_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX);
+		usbd_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX);
 	}
 
 	/* the following will get the device unconfigured in software */
-	usb2_unconfigure(udev, flag);
+	usb_unconfigure(udev, flag);
 
 	/* unsetup any leftover default USB transfers */
-	usb2_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX);
+	usbd_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX);
 
 	/* template unsetup, if any */
-	(usb2_temp_unsetup_p) (udev);
+	(usb_temp_unsetup_p) (udev);
 
 	/* 
 	 * Make sure that our clear-stall messages are not queued
 	 * anywhere:
 	 */
 	USB_BUS_LOCK(udev->bus);
-	usb2_proc_mwait(&udev->bus->non_giant_callback_proc,
+	usb_proc_mwait(&udev->bus->non_giant_callback_proc,
 	    &udev->cs_msg[0], &udev->cs_msg[1]);
 	USB_BUS_UNLOCK(udev->bus);
 
@@ -1997,7 +1997,7 @@ usb2_free_device(struct usb_device *udev, uint8_t flag)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_get_iface
+ *	usbd_get_iface
  *
  * This function is the safe way to get the USB interface structure
  * pointer by interface index.
@@ -2007,7 +2007,7 @@ usb2_free_device(struct usb_device *udev, uint8_t flag)
  *   Else: Pointer to USB interface structure.
  *------------------------------------------------------------------------*/
 struct usb_interface *
-usb2_get_iface(struct usb_device *udev, uint8_t iface_index)
+usbd_get_iface(struct usb_device *udev, uint8_t iface_index)
 {
 	struct usb_interface *iface = udev->ifaces + iface_index;
 
@@ -2040,23 +2040,23 @@ usb2_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index,
 	struct usb_config_descriptor *cd;
 	struct usb_interface *iface;
 
-	cd = usb2_get_config_descriptor(udev);
+	cd = usbd_get_config_descriptor(udev);
 	if (cd == NULL) {
 		return (NULL);
 	}
 	if (id == NULL) {
-		iface = usb2_get_iface(udev, iface_index);
+		iface = usbd_get_iface(udev, iface_index);
 		if (iface == NULL) {
 			return (NULL);
 		}
-		id = usb2_get_interface_descriptor(iface);
+		id = usbd_get_interface_descriptor(iface);
 		if (id == NULL) {
 			return (NULL);
 		}
 	}
 	desc = (void *)id;
 
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 
 		if (desc->bDescriptorType == UDESC_INTERFACE) {
 			break;
@@ -2070,7 +2070,7 @@ usb2_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_devinfo
+ *	usb_devinfo
  *
  * This function will dump information from the device descriptor
  * belonging to the USB device pointed to by "udev", to the string
@@ -2078,7 +2078,7 @@ usb2_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index,
  * including the terminating zero.
  *------------------------------------------------------------------------*/
 void
-usb2_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len)
+usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len)
 {
 	struct usb_device_descriptor *udd = &udev->ddesc;
 	uint16_t bcdDevice;
@@ -2124,7 +2124,7 @@ struct usb_knowndev {
 #endif					/* USB_VERBOSE */
 
 static void
-usb2_set_device_strings(struct usb_device *udev)
+usbd_set_device_strings(struct usb_device *udev)
 {
 	struct usb_device_descriptor *udd = &udev->ddesc;
 #if USB_VERBOSE
@@ -2139,23 +2139,23 @@ usb2_set_device_strings(struct usb_device *udev)
 
 	/* get serial number string */
 	bzero(temp, sizeof(temp));
-	usb2_req_get_string_any(udev, NULL, temp, sizeof(temp),
+	usbd_req_get_string_any(udev, NULL, temp, sizeof(temp),
 	    udev->ddesc.iSerialNumber);
 	udev->serial = strdup(temp, M_USB);
 
 	/* get manufacturer string */
 	bzero(temp, sizeof(temp));
-	usb2_req_get_string_any(udev, NULL, temp, sizeof(temp),
+	usbd_req_get_string_any(udev, NULL, temp, sizeof(temp),
 	    udev->ddesc.iManufacturer);
-	usb2_trim_spaces(temp);
+	usb_trim_spaces(temp);
 	if (temp[0] != '\0')
 		udev->manufacturer = strdup(temp, M_USB);
 
 	/* get product string */
 	bzero(temp, sizeof(temp));
-	usb2_req_get_string_any(udev, NULL, temp, sizeof(temp),
+	usbd_req_get_string_any(udev, NULL, temp, sizeof(temp),
 	    udev->ddesc.iProduct);
-	usb2_trim_spaces(temp);
+	usb_trim_spaces(temp);
 	if (temp[0] != '\0')
 		udev->product = strdup(temp, M_USB);
 
@@ -2197,7 +2197,7 @@ usb2_set_device_strings(struct usb_device *udev)
  * See: USB_MODE_XXX
  */
 enum usb_hc_mode
-usb2_get_mode(struct usb_device *udev)
+usbd_get_mode(struct usb_device *udev)
 {
 	return (udev->flags.usb_mode);
 }
@@ -2207,13 +2207,13 @@ usb2_get_mode(struct usb_device *udev)
  * See: USB_SPEED_XXX
  */
 enum usb_dev_speed
-usb2_get_speed(struct usb_device *udev)
+usbd_get_speed(struct usb_device *udev)
 {
 	return (udev->speed);
 }
 
 uint32_t
-usb2_get_isoc_fps(struct usb_device *udev)
+usbd_get_isoc_fps(struct usb_device *udev)
 {
 	;				/* indent fix */
 	switch (udev->speed) {
@@ -2226,7 +2226,7 @@ usb2_get_isoc_fps(struct usb_device *udev)
 }
 
 struct usb_device_descriptor *
-usb2_get_device_descriptor(struct usb_device *udev)
+usbd_get_device_descriptor(struct usb_device *udev)
 {
 	if (udev == NULL)
 		return (NULL);		/* be NULL safe */
@@ -2234,7 +2234,7 @@ usb2_get_device_descriptor(struct usb_device *udev)
 }
 
 struct usb_config_descriptor *
-usb2_get_config_descriptor(struct usb_device *udev)
+usbd_get_config_descriptor(struct usb_device *udev)
 {
 	if (udev == NULL)
 		return (NULL);		/* be NULL safe */
@@ -2242,23 +2242,23 @@ usb2_get_config_descriptor(struct usb_device *udev)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_test_quirk - test a device for a given quirk
+ *	usb_test_quirk - test a device for a given quirk
  *
  * Return values:
  * 0: The USB device does not have the given quirk.
  * Else: The USB device has the given quirk.
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk)
+usb_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk)
 {
 	uint8_t found;
 
-	found = (usb2_test_quirk_p) (&uaa->info, quirk);
+	found = (usb_test_quirk_p) (&uaa->info, quirk);
 	return (found);
 }
 
 struct usb_interface_descriptor *
-usb2_get_interface_descriptor(struct usb_interface *iface)
+usbd_get_interface_descriptor(struct usb_interface *iface)
 {
 	if (iface == NULL)
 		return (NULL);		/* be NULL safe */
@@ -2266,31 +2266,31 @@ usb2_get_interface_descriptor(struct usb_interface *iface)
 }
 
 uint8_t
-usb2_get_interface_altindex(struct usb_interface *iface)
+usbd_get_interface_altindex(struct usb_interface *iface)
 {
 	return (iface->alt_index);
 }
 
 uint8_t
-usb2_get_bus_index(struct usb_device *udev)
+usbd_get_bus_index(struct usb_device *udev)
 {
 	return ((uint8_t)device_get_unit(udev->bus->bdev));
 }
 
 uint8_t
-usb2_get_device_index(struct usb_device *udev)
+usbd_get_device_index(struct usb_device *udev)
 {
 	return (udev->device_index);
 }
 
 #if USB_HAVE_UGEN
 /*------------------------------------------------------------------------*
- *	usb2_notify_addq
+ *	usb_notify_addq
  *
  * This function will generate events for dev.
  *------------------------------------------------------------------------*/
 static void
-usb2_notify_addq(const char *type, struct usb_device *udev)
+usb_notify_addq(const char *type, struct usb_device *udev)
 {
 	char *data = NULL;
 	struct malloc_type *mt;
@@ -2334,7 +2334,7 @@ usb2_notify_addq(const char *type, struct usb_device *udev)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fifo_free_wrap
+ *	usb_fifo_free_wrap
  *
  * This function will free the FIFOs.
  *
@@ -2346,7 +2346,7 @@ usb2_notify_addq(const char *type, struct usb_device *udev)
  * "USB_IFACE_INDEX_ANY" the flag has no effect.
  *------------------------------------------------------------------------*/
 static void
-usb2_fifo_free_wrap(struct usb_device *udev,
+usb_fifo_free_wrap(struct usb_device *udev,
     uint8_t iface_index, uint8_t flag)
 {
 	struct usb_fifo *f;
@@ -2362,7 +2362,7 @@ usb2_fifo_free_wrap(struct usb_device *udev,
 		}
 		/* Check if the interface index matches */
 		if (iface_index == f->iface_index) {
-			if (f->methods != &usb2_ugen_methods) {
+			if (f->methods != &usb_ugen_methods) {
 				/*
 				 * Don't free any non-generic FIFOs in
 				 * this case.
@@ -2375,7 +2375,7 @@ usb2_fifo_free_wrap(struct usb_device *udev,
 				continue;
 			}
 		} else if (iface_index == USB_IFACE_INDEX_ANY) {
-			if ((f->methods == &usb2_ugen_methods) &&
+			if ((f->methods == &usb_ugen_methods) &&
 			    (f->dev_ep_index == 0) &&
 			    (!(flag & USB_UNCFG_FLAG_FREE_EP0)) &&
 			    (f->fs_xfer == NULL)) {
@@ -2387,20 +2387,20 @@ usb2_fifo_free_wrap(struct usb_device *udev,
 			continue;
 		}
 		/* free this FIFO */
-		usb2_fifo_free(f);
+		usb_fifo_free(f);
 	}
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_peer_can_wakeup
+ *	usb_peer_can_wakeup
  *
  * Return values:
  * 0: Peer cannot do resume signalling.
  * Else: Peer can do resume signalling.
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_peer_can_wakeup(struct usb_device *udev)
+usb_peer_can_wakeup(struct usb_device *udev)
 {
 	const struct usb_config_descriptor *cdp;
 
@@ -2412,18 +2412,18 @@ usb2_peer_can_wakeup(struct usb_device *udev)
 }
 
 void
-usb2_set_device_state(struct usb_device *udev, enum usb_dev_state state)
+usb_set_device_state(struct usb_device *udev, enum usb_dev_state state)
 {
 
 	KASSERT(state < USB_STATE_MAX, ("invalid udev state"));
 
 	DPRINTF("udev %p state %s -> %s\n", udev,
-	    usb2_statestr(udev->state), usb2_statestr(state));
+	    usb_statestr(udev->state), usb_statestr(state));
 	udev->state = state;
 }
 
 uint8_t
-usb2_device_attached(struct usb_device *udev)
+usbd_device_attached(struct usb_device *udev)
 {
 	return (udev->state > USB_STATE_DETACHED);
 }
diff --git a/sys/dev/usb/usb_device.h b/sys/dev/usb/usb_device.h
index fc2925a..32af2e2 100644
--- a/sys/dev/usb/usb_device.h
+++ b/sys/dev/usb/usb_device.h
@@ -32,13 +32,13 @@ struct usb_device;		/* linux compat */
 
 #define	USB_DEFAULT_XFER_MAX 2
 
-/* "usb2_parse_config()" commands */
+/* "usb_parse_config()" commands */
 
 #define	USB_CFG_ALLOC 0
 #define	USB_CFG_FREE 1
 #define	USB_CFG_INIT 2
 
-/* "usb2_unconfigure()" flags */
+/* "usb_unconfigure()" flags */
 
 #define	USB_UNCFG_FLAG_NONE 0x00
 #define	USB_UNCFG_FLAG_FREE_SUBDEV 0x01		/* subdevices are freed */
@@ -166,7 +166,7 @@ struct usb_device {
 	struct usb_config_descriptor *cdesc;	/* full config descr */
 	struct usb_hub *hub;		/* only if this is a hub */
 	struct usb_xfer *default_xfer[USB_DEFAULT_XFER_MAX];
-	struct usb_temp_data *usb2_template_ptr;
+	struct usb_temp_data *usb_template_ptr;
 	struct usb_endpoint *ep_curr;	/* current clear stall endpoint */
 #if USB_HAVE_UGEN
 	struct usb_fifo *fifo[USB_FIFO_MAX];
@@ -224,36 +224,36 @@ struct usb_device {
 
 /* globals */
 
-extern int usb2_template;
+extern int usb_template;
 
 /* function prototypes */
 
-struct usb_device *usb2_alloc_device(device_t parent_dev, struct usb_bus *bus,
+struct usb_device *usb_alloc_device(device_t parent_dev, struct usb_bus *bus,
 		    struct usb_device *parent_hub, uint8_t depth,
 		    uint8_t port_index, uint8_t port_no,
 		    enum usb_dev_speed speed, enum usb_hc_mode mode);
-struct usb_endpoint *usb2_get_endpoint(struct usb_device *udev, uint8_t iface_index,
+struct usb_endpoint *usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index,
 		    const struct usb_config *setup);
-struct usb_endpoint *usb2_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val);
-usb_error_t	usb2_interface_count(struct usb_device *udev, uint8_t *count);
-usb_error_t	usb2_probe_and_attach(struct usb_device *udev,
+struct usb_endpoint *usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val);
+usb_error_t	usb_interface_count(struct usb_device *udev, uint8_t *count);
+usb_error_t	usb_probe_and_attach(struct usb_device *udev,
 		    uint8_t iface_index);
-usb_error_t	usb2_reset_iface_endpoints(struct usb_device *udev,
+usb_error_t	usb_reset_iface_endpoints(struct usb_device *udev,
 		    uint8_t iface_index);
-usb_error_t	usb2_set_config_index(struct usb_device *udev, uint8_t index);
-usb_error_t	usb2_set_endpoint_stall(struct usb_device *udev,
+usb_error_t	usbd_set_config_index(struct usb_device *udev, uint8_t index);
+usb_error_t	usbd_set_endpoint_stall(struct usb_device *udev,
 		    struct usb_endpoint *ep, uint8_t do_stall);
-usb_error_t	usb2_suspend_resume(struct usb_device *udev,
+usb_error_t	usb_suspend_resume(struct usb_device *udev,
 		    uint8_t do_suspend);
-void	usb2_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len);
-void	usb2_free_device(struct usb_device *, uint8_t);
+void	usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len);
+void	usb_free_device(struct usb_device *, uint8_t);
 void	*usb2_find_descriptor(struct usb_device *udev, void *id,
 	    uint8_t iface_index, uint8_t type, uint8_t type_mask,
 	    uint8_t subtype, uint8_t subtype_mask);
 void	usb_linux_free_device(struct usb_device *dev);
-uint8_t	usb2_peer_can_wakeup(struct usb_device *udev);
-struct usb_endpoint *usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep);
-void	usb2_set_device_state(struct usb_device *udev,
+uint8_t	usb_peer_can_wakeup(struct usb_device *udev);
+struct usb_endpoint *usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep);
+void	usb_set_device_state(struct usb_device *udev,
 	    enum usb_dev_state state);
 
 #endif					/* _USB2_DEVICE_H_ */
diff --git a/sys/dev/usb/usb_dynamic.c b/sys/dev/usb/usb_dynamic.c
index f60c930..eabb9df 100644
--- a/sys/dev/usb/usb_dynamic.c
+++ b/sys/dev/usb/usb_dynamic.c
@@ -34,72 +34,72 @@
 #include <dev/usb/usb_dynamic.h>
 
 /* function prototypes */
-static usb_handle_req_t usb2_temp_get_desc_w;
-static usb2_temp_setup_by_index_t usb2_temp_setup_by_index_w;
-static usb2_temp_unsetup_t usb2_temp_unsetup_w;
-static usb2_test_quirk_t usb2_test_quirk_w;
-static usb2_test_huawei_autoinst_t usb2_test_huawei_autoinst_w;
-static usb2_quirk_ioctl_t usb2_quirk_ioctl_w;
+static usb_handle_req_t usb_temp_get_desc_w;
+static usb_temp_setup_by_index_t usb_temp_setup_by_index_w;
+static usb_temp_unsetup_t usb_temp_unsetup_w;
+static usb_test_quirk_t usb_test_quirk_w;
+static usb_test_huawei_autoinst_t usb_test_huawei_autoinst_w;
+static usb_quirk_ioctl_t usb_quirk_ioctl_w;
 
 /* global variables */
-usb_handle_req_t *usb2_temp_get_desc_p = &usb2_temp_get_desc_w;
-usb2_temp_setup_by_index_t *usb2_temp_setup_by_index_p = &usb2_temp_setup_by_index_w;
-usb2_temp_unsetup_t *usb2_temp_unsetup_p = &usb2_temp_unsetup_w;
-usb2_test_quirk_t *usb2_test_quirk_p = &usb2_test_quirk_w;
-usb2_test_huawei_autoinst_t *usb2_test_huawei_autoinst_p = &usb2_test_huawei_autoinst_w;
-usb2_quirk_ioctl_t *usb2_quirk_ioctl_p = &usb2_quirk_ioctl_w;
-devclass_t usb2_devclass_ptr = NULL;
+usb_handle_req_t *usb_temp_get_desc_p = &usb_temp_get_desc_w;
+usb_temp_setup_by_index_t *usb_temp_setup_by_index_p = &usb_temp_setup_by_index_w;
+usb_temp_unsetup_t *usb_temp_unsetup_p = &usb_temp_unsetup_w;
+usb_test_quirk_t *usb_test_quirk_p = &usb_test_quirk_w;
+usb_test_huawei_autoinst_t *usb_test_huawei_autoinst_p = &usb_test_huawei_autoinst_w;
+usb_quirk_ioctl_t *usb_quirk_ioctl_p = &usb_quirk_ioctl_w;
+devclass_t usb_devclass_ptr = NULL;
 
 static usb_error_t
-usb2_temp_setup_by_index_w(struct usb_device *udev, uint16_t index)
+usb_temp_setup_by_index_w(struct usb_device *udev, uint16_t index)
 {
 	return (USB_ERR_INVAL);
 }
 
 static uint8_t
-usb2_test_quirk_w(const struct usb_lookup_info *info, uint16_t quirk)
+usb_test_quirk_w(const struct usbd_lookup_info *info, uint16_t quirk)
 {
 	return (0);			/* no match */
 }
 
 static int
-usb2_quirk_ioctl_w(unsigned long cmd, caddr_t data, int fflag, struct thread *td)
+usb_quirk_ioctl_w(unsigned long cmd, caddr_t data, int fflag, struct thread *td)
 {
 	return (ENOIOCTL);
 }
 
 static usb_error_t
-usb2_temp_get_desc_w(struct usb_device *udev, struct usb_device_request *req, const void **pPtr, uint16_t *pLength)
+usb_temp_get_desc_w(struct usb_device *udev, struct usb_device_request *req, const void **pPtr, uint16_t *pLength)
 {
 	/* stall */
 	return (USB_ERR_STALLED);
 }
 
 static void
-usb2_temp_unsetup_w(struct usb_device *udev)
+usb_temp_unsetup_w(struct usb_device *udev)
 {
-	if (udev->usb2_template_ptr) {
+	if (udev->usb_template_ptr) {
 
-		free(udev->usb2_template_ptr, M_USB);
+		free(udev->usb_template_ptr, M_USB);
 
-		udev->usb2_template_ptr = NULL;
+		udev->usb_template_ptr = NULL;
 	}
 }
 
 static uint8_t
-usb2_test_huawei_autoinst_w(struct usb_device *udev,
+usb_test_huawei_autoinst_w(struct usb_device *udev,
     struct usb_attach_arg *uaa)
 {
 	return (USB_ERR_INVAL);
 }
 
 void
-usb2_quirk_unload(void *arg)
+usb_quirk_unload(void *arg)
 {
 	/* reset function pointers */
 
-	usb2_test_quirk_p = &usb2_test_quirk_w;
-	usb2_quirk_ioctl_p = &usb2_quirk_ioctl_w;
+	usb_test_quirk_p = &usb_test_quirk_w;
+	usb_quirk_ioctl_p = &usb_quirk_ioctl_w;
 
 	/* wait for CPU to exit the loaded functions, if any */
 
@@ -109,13 +109,13 @@ usb2_quirk_unload(void *arg)
 }
 
 void
-usb2_temp_unload(void *arg)
+usb_temp_unload(void *arg)
 {
 	/* reset function pointers */
 
-	usb2_temp_get_desc_p = &usb2_temp_get_desc_w;
-	usb2_temp_setup_by_index_p = &usb2_temp_setup_by_index_w;
-	usb2_temp_unsetup_p = &usb2_temp_unsetup_w;
+	usb_temp_get_desc_p = &usb_temp_get_desc_w;
+	usb_temp_setup_by_index_p = &usb_temp_setup_by_index_w;
+	usb_temp_unsetup_p = &usb_temp_unsetup_w;
 
 	/* wait for CPU to exit the loaded functions, if any */
 
@@ -125,11 +125,11 @@ usb2_temp_unload(void *arg)
 }
 
 void
-usb2_bus_unload(void *arg)
+usb_bus_unload(void *arg)
 {
 	/* reset function pointers */
 
-	usb2_devclass_ptr = NULL;
+	usb_devclass_ptr = NULL;
 
 	/* wait for CPU to exit the loaded functions, if any */
 
@@ -139,11 +139,11 @@ usb2_bus_unload(void *arg)
 }
 
 void
-usb2_test_huawei_unload(void *arg)
+usb_test_huawei_unload(void *arg)
 {
 	/* reset function pointers */
 
-	usb2_test_huawei_autoinst_p = &usb2_test_huawei_autoinst_w;
+	usb_test_huawei_autoinst_p = &usb_test_huawei_autoinst_w;
 
 	/* wait for CPU to exit the loaded functions, if any */
 
diff --git a/sys/dev/usb/usb_dynamic.h b/sys/dev/usb/usb_dynamic.h
index ec1d783..1c47c52 100644
--- a/sys/dev/usb/usb_dynamic.h
+++ b/sys/dev/usb/usb_dynamic.h
@@ -30,38 +30,38 @@
 /* prototypes */
 
 struct usb_device;
-struct usb_lookup_info;
+struct usbd_lookup_info;
 struct usb_device_request;
 
 /* typedefs */
 
-typedef usb_error_t	(usb2_temp_setup_by_index_t)(struct usb_device *udev,
+typedef usb_error_t	(usb_temp_setup_by_index_t)(struct usb_device *udev,
 			    uint16_t index);
-typedef usb_error_t	(usb2_test_huawei_autoinst_t)(struct usb_device *udev, 
+typedef usb_error_t	(usb_test_huawei_autoinst_t)(struct usb_device *udev, 
 			    struct usb_attach_arg *uaa);
-typedef uint8_t		(usb2_test_quirk_t)(const struct usb_lookup_info *info,
+typedef uint8_t		(usb_test_quirk_t)(const struct usbd_lookup_info *info,
 			    uint16_t quirk);
-typedef int		(usb2_quirk_ioctl_t)(unsigned long cmd, caddr_t data,
+typedef int		(usb_quirk_ioctl_t)(unsigned long cmd, caddr_t data,
 			    int fflag, struct thread *td);
-typedef void		(usb2_temp_unsetup_t)(struct usb_device *udev);
+typedef void		(usb_temp_unsetup_t)(struct usb_device *udev);
 
 /* global function pointers */
 
-extern usb_handle_req_t *usb2_temp_get_desc_p;
-extern usb2_temp_setup_by_index_t *usb2_temp_setup_by_index_p;
-extern usb2_temp_unsetup_t *usb2_temp_unsetup_p;
-extern usb2_test_quirk_t *usb2_test_quirk_p;
-extern usb2_test_huawei_autoinst_t *usb2_test_huawei_autoinst_p;
-extern usb2_quirk_ioctl_t *usb2_quirk_ioctl_p;
-extern devclass_t usb2_devclass_ptr;
+extern usb_handle_req_t *usb_temp_get_desc_p;
+extern usb_temp_setup_by_index_t *usb_temp_setup_by_index_p;
+extern usb_temp_unsetup_t *usb_temp_unsetup_p;
+extern usb_test_quirk_t *usb_test_quirk_p;
+extern usb_test_huawei_autoinst_t *usb_test_huawei_autoinst_p;
+extern usb_quirk_ioctl_t *usb_quirk_ioctl_p;
+extern devclass_t usb_devclass_ptr;
 
 /* function prototypes */
 
-void	usb2_test_huawei_unload(void *);
-void	usb2_temp_unload(void *);
-void	usb2_quirk_unload(void *);
-void	usb2_bus_unload(void *);
+void	usb_test_huawei_unload(void *);
+void	usb_temp_unload(void *);
+void	usb_quirk_unload(void *);
+void	usb_bus_unload(void *);
 
-uint8_t	usb2_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk);
+uint8_t	usb_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk);
 
 #endif					/* _USB2_DYNAMIC_H_ */
diff --git a/sys/dev/usb/usb_error.c b/sys/dev/usb/usb_error.c
index c99652b..68a811f 100644
--- a/sys/dev/usb/usb_error.c
+++ b/sys/dev/usb/usb_error.c
@@ -62,12 +62,12 @@ static const char* usb_errstr_table[USB_ERR_MAX] = {
 };
 
 /*------------------------------------------------------------------------*
- *	usb2_errstr
+ *	usbd_errstr
  *
  * This function converts an USB error code into a string.
  *------------------------------------------------------------------------*/
 const char *
-usb2_errstr(usb_error_t err)
+usbd_errstr(usb_error_t err)
 {
 	return (err < USB_ERR_MAX ? usb_errstr_table[err] : "USB_ERR_UNKNOWN");
 }
diff --git a/sys/dev/usb/usb_generic.c b/sys/dev/usb/usb_generic.c
index 1a7939a..29a682a 100644
--- a/sys/dev/usb/usb_generic.c
+++ b/sys/dev/usb/usb_generic.c
@@ -82,7 +82,7 @@ static int	ugen_set_interface(struct usb_fifo *, uint8_t, uint8_t);
 static int	ugen_get_cdesc(struct usb_fifo *, struct usb_gen_descriptor *);
 static int	ugen_get_sdesc(struct usb_fifo *, struct usb_gen_descriptor *);
 static int	ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd);
-static int	usb2_gen_fill_deviceinfo(struct usb_fifo *,
+static int	usb_gen_fill_deviceinfo(struct usb_fifo *,
 		    struct usb_device_info *);
 static int	ugen_re_enumerate(struct usb_fifo *);
 static int	ugen_iface_ioctl(struct usb_fifo *, u_long, void *, int);
@@ -91,7 +91,7 @@ static int ugen_fs_uninit(struct usb_fifo *f);
 
 /* structures */
 
-struct usb_fifo_methods usb2_ugen_methods = {
+struct usb_fifo_methods usb_ugen_methods = {
 	.f_open = &ugen_open,
 	.f_close = &ugen_close,
 	.f_ioctl = &ugen_ioctl,
@@ -125,23 +125,23 @@ ugen_transfer_setup(struct usb_fifo *f,
 	mtx_unlock(f->priv_mtx);
 
 	/*
-	 * "usb2_transfer_setup()" can sleep so one needs to make a wrapper,
+	 * "usbd_transfer_setup()" can sleep so one needs to make a wrapper,
 	 * exiting the mutex and checking things
 	 */
-	error = usb2_transfer_setup(udev, &iface_index, f->xfer,
+	error = usbd_transfer_setup(udev, &iface_index, f->xfer,
 	    setup, n_setup, f, f->priv_mtx);
 	if (error == 0) {
 
 		if (f->xfer[0]->nframes == 1) {
-			error = usb2_fifo_alloc_buffer(f,
+			error = usb_fifo_alloc_buffer(f,
 			    f->xfer[0]->max_data_length, 2);
 		} else {
-			error = usb2_fifo_alloc_buffer(f,
+			error = usb_fifo_alloc_buffer(f,
 			    f->xfer[0]->max_frame_size,
 			    2 * f->xfer[0]->nframes);
 		}
 		if (error) {
-			usb2_transfer_unsetup(f->xfer, n_setup);
+			usbd_transfer_unsetup(f->xfer, n_setup);
 		}
 	}
 	mtx_lock(f->priv_mtx);
@@ -159,7 +159,7 @@ ugen_open(struct usb_fifo *f, int fflags)
 	DPRINTFN(6, "flag=0x%x\n", fflags);
 
 	mtx_lock(f->priv_mtx);
-	switch (usb2_get_speed(f->udev)) {
+	switch (usbd_get_speed(f->udev)) {
 	case USB_SPEED_LOW:
 	case USB_SPEED_FULL:
 		f->nframes = UGEN_HW_FRAMES;
@@ -191,12 +191,12 @@ ugen_close(struct usb_fifo *f, int fflags)
 	/* cleanup */
 
 	mtx_lock(f->priv_mtx);
-	usb2_transfer_stop(f->xfer[0]);
-	usb2_transfer_stop(f->xfer[1]);
+	usbd_transfer_stop(f->xfer[0]);
+	usbd_transfer_stop(f->xfer[1]);
 	mtx_unlock(f->priv_mtx);
 
-	usb2_transfer_unsetup(f->xfer, 2);
-	usb2_fifo_free_buffer(f);
+	usbd_transfer_unsetup(f->xfer, 2);
+	usb_fifo_free_buffer(f);
 
 	if (ugen_fs_uninit(f)) {
 		/* ignore any errors - we are closing */
@@ -348,11 +348,11 @@ ugen_start_read(struct usb_fifo *f)
 	/* check that pipes are open */
 	if (ugen_open_pipe_read(f)) {
 		/* signal error */
-		usb2_fifo_put_data_error(f);
+		usb_fifo_put_data_error(f);
 	}
 	/* start transfers */
-	usb2_transfer_start(f->xfer[0]);
-	usb2_transfer_start(f->xfer[1]);
+	usbd_transfer_start(f->xfer[0]);
+	usbd_transfer_start(f->xfer[1]);
 }
 
 static void
@@ -361,19 +361,19 @@ ugen_start_write(struct usb_fifo *f)
 	/* check that pipes are open */
 	if (ugen_open_pipe_write(f)) {
 		/* signal error */
-		usb2_fifo_get_data_error(f);
+		usb_fifo_get_data_error(f);
 	}
 	/* start transfers */
-	usb2_transfer_start(f->xfer[0]);
-	usb2_transfer_start(f->xfer[1]);
+	usbd_transfer_start(f->xfer[0]);
+	usbd_transfer_start(f->xfer[1]);
 }
 
 static void
 ugen_stop_io(struct usb_fifo *f)
 {
 	/* stop transfers */
-	usb2_transfer_stop(f->xfer[0]);
-	usb2_transfer_stop(f->xfer[1]);
+	usbd_transfer_stop(f->xfer[0]);
+	usbd_transfer_stop(f->xfer[1]);
 }
 
 static void
@@ -401,28 +401,28 @@ ugen_default_read_callback(struct usb_xfer *xfer)
 			xfer->interval = 0;
 			f->fifo_zlp = 0;
 		}
-		usb2_fifo_put_data(f, xfer->frbuffers, 0,
+		usb_fifo_put_data(f, xfer->frbuffers, 0,
 		    xfer->actlen, 1);
 
 	case USB_ST_SETUP:
 		if (f->flag_stall) {
-			usb2_transfer_start(f->xfer[1]);
+			usbd_transfer_start(f->xfer[1]);
 			break;
 		}
 		USB_IF_POLL(&f->free_q, m);
 		if (m) {
 			xfer->frlengths[0] = xfer->max_data_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
 	default:			/* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* send a zero length packet to userland */
-			usb2_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
+			usb_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
 			f->flag_stall = 1;
 			f->fifo_zlp = 0;
-			usb2_transfer_start(f->xfer[1]);
+			usbd_transfer_start(f->xfer[1]);
 		}
 		break;
 	}
@@ -444,23 +444,23 @@ ugen_default_write_callback(struct usb_xfer *xfer)
 		 * callback and solve the situation.
 		 */
 		if (f->flag_stall) {
-			usb2_transfer_start(f->xfer[1]);
+			usbd_transfer_start(f->xfer[1]);
 			break;
 		}
 		/*
 		 * Write data, setup and perform hardware transfer.
 		 */
-		if (usb2_fifo_get_data(f, xfer->frbuffers, 0,
+		if (usb_fifo_get_data(f, xfer->frbuffers, 0,
 		    xfer->max_data_length, &actlen, 0)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
 	default:			/* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			f->flag_stall = 1;
-			usb2_transfer_start(f->xfer[1]);
+			usbd_transfer_start(f->xfer[1]);
 		}
 		break;
 	}
@@ -476,10 +476,10 @@ ugen_read_clear_stall_callback(struct usb_xfer *xfer)
 		/* nothing to do */
 		return;
 	}
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTFN(5, "f=%p: stall cleared\n", f);
 		f->flag_stall = 0;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -493,10 +493,10 @@ ugen_write_clear_stall_callback(struct usb_xfer *xfer)
 		/* nothing to do */
 		return;
 	}
-	if (usb2_clear_stall_callback(xfer, xfer_other)) {
+	if (usbd_clear_stall_callback(xfer, xfer_other)) {
 		DPRINTFN(5, "f=%p: stall cleared\n", f);
 		f->flag_stall = 0;
-		usb2_transfer_start(xfer_other);
+		usbd_transfer_start(xfer_other);
 	}
 }
 
@@ -517,7 +517,7 @@ ugen_isoc_read_callback(struct usb_xfer *xfer)
 		offset = 0;
 
 		for (n = 0; n != xfer->aframes; n++) {
-			usb2_fifo_put_data(f, xfer->frbuffers, offset,
+			usb_fifo_put_data(f, xfer->frbuffers, offset,
 			    xfer->frlengths[n], 1);
 			offset += xfer->max_frame_size;
 		}
@@ -528,7 +528,7 @@ tr_setup:
 			/* setup size for next transfer */
 			xfer->frlengths[n] = xfer->max_frame_size;
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -555,7 +555,7 @@ ugen_isoc_write_callback(struct usb_xfer *xfer)
 tr_setup:
 		offset = 0;
 		for (n = 0; n != xfer->nframes; n++) {
-			if (usb2_fifo_get_data(f, xfer->frbuffers, offset,
+			if (usb_fifo_get_data(f, xfer->frbuffers, offset,
 			    xfer->max_frame_size, &actlen, 1)) {
 				xfer->frlengths[n] = actlen;
 				offset += actlen;
@@ -568,7 +568,7 @@ tr_setup:
 			/* fill in zero frames */
 			xfer->frlengths[n] = 0;
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -599,11 +599,11 @@ ugen_set_config(struct usb_fifo *f, uint8_t index)
 		DPRINTFN(6, "no FIFOs\n");
 	}
 	/* change setting - will free generic FIFOs, if any */
-	if (usb2_set_config_index(f->udev, index)) {
+	if (usbd_set_config_index(f->udev, index)) {
 		return (EIO);
 	}
 	/* probe and attach */
-	if (usb2_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) {
+	if (usb_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) {
 		return (EIO);
 	}
 	return (0);
@@ -626,11 +626,11 @@ ugen_set_interface(struct usb_fifo *f,
 		DPRINTFN(6, "no FIFOs\n");
 	}
 	/* change setting - will free generic FIFOs, if any */
-	if (usb2_set_alt_interface_index(f->udev, iface_index, alt_index)) {
+	if (usbd_set_alt_interface_index(f->udev, iface_index, alt_index)) {
 		return (EIO);
 	}
 	/* probe and attach */
-	if (usb2_probe_and_attach(f->udev, iface_index)) {
+	if (usb_probe_and_attach(f->udev, iface_index)) {
 		return (EIO);
 	}
 	return (0);
@@ -659,14 +659,14 @@ ugen_get_cdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
 	}
 	if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) ||
 	    (ugd->ugd_config_index == udev->curr_config_index)) {
-		cdesc = usb2_get_config_descriptor(udev);
+		cdesc = usbd_get_config_descriptor(udev);
 		if (cdesc == NULL) {
 			return (ENXIO);
 		}
 		free_data = 0;
 
 	} else {
-		if (usb2_req_get_config_desc_full(udev,
+		if (usbd_req_get_config_desc_full(udev,
 		    NULL, &cdesc, M_USBDEV,
 		    ugd->ugd_config_index)) {
 			return (ENXIO);
@@ -698,7 +698,7 @@ ugen_get_sdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
 	uint16_t size = sizeof(f->udev->bus->scratch[0].data);
 	int error;
 
-	if (usb2_req_get_string_desc(f->udev, NULL, ptr,
+	if (usbd_req_get_string_desc(f->udev, NULL, ptr,
 	    size, ugd->ugd_lang_id, ugd->ugd_string_index)) {
 		error = EINVAL;
 	} else {
@@ -745,7 +745,7 @@ ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
 		return (EINVAL);
 	}
 
-	iface = usb2_get_iface(udev, ugd->ugd_iface_index);
+	iface = usbd_get_iface(udev, ugd->ugd_iface_index);
 	if ((iface == NULL) || (iface->idesc == NULL)) {
 		/* invalid interface index */
 		return (EINVAL);
@@ -779,7 +779,7 @@ ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_gen_fill_deviceinfo
+ *	usb_gen_fill_deviceinfo
  *
  * This function dumps information about an USB device to the
  * structure pointed to by the "di" argument.
@@ -789,7 +789,7 @@ ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
  * Else: Failure
  *------------------------------------------------------------------------*/
 static int
-usb2_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di)
+usb_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di)
 {
 	struct usb_device *udev;
 	struct usb_device *hub;
@@ -804,7 +804,7 @@ usb2_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di)
 	strlcpy(di->udi_serial, udev->serial, sizeof(di->udi_serial));
 	strlcpy(di->udi_vendor, udev->manufacturer, sizeof(di->udi_vendor));
 	strlcpy(di->udi_product, udev->product, sizeof(di->udi_product));
-	usb2_printBCD(di->udi_release, sizeof(di->udi_release),
+	usb_printbcd(di->udi_release, sizeof(di->udi_release),
 	    UGETW(udev->ddesc.bcdDevice));
 	di->udi_vendorNo = UGETW(udev->ddesc.idVendor);
 	di->udi_productNo = UGETW(udev->ddesc.idProduct);
@@ -864,13 +864,13 @@ ugen_check_request(struct usb_device *udev, struct usb_device_request *req)
 	 */
 	if (req->bmRequestType == UT_WRITE_ENDPOINT) {
 
-		ep = usb2_get_ep_by_addr(udev, req->wIndex[0]);
+		ep = usbd_get_ep_by_addr(udev, req->wIndex[0]);
 		if (ep == NULL) {
 			return (EINVAL);
 		}
 		if ((req->bRequest == UR_CLEAR_FEATURE) &&
 		    (UGETW(req->wValue) == UF_ENDPOINT_HALT)) {
-			usb2_clear_data_toggle(udev, ep);
+			usbd_clear_data_toggle(udev, ep);
 		}
 	}
 	/* TODO: add more checks to verify the interface index */
@@ -897,7 +897,7 @@ ugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur)
 		}
 	}
 	/* do the USB request */
-	error = usb2_do_request_flags
+	error = usbd_do_request_flags
 	    (f->udev, NULL, &ur->ucr_request, ur->ucr_data,
 	    (ur->ucr_flags & USB_SHORT_XFER_OK) |
 	    USB_USER_DATA_PTR, &actlen,
@@ -934,7 +934,7 @@ ugen_re_enumerate(struct usb_fifo *f)
 	}
 	/* do a bus-reset */
 	mtx_lock(f->priv_mtx);
-	error = usb2_req_re_enumerate(udev, f->priv_mtx);
+	error = usbd_req_re_enumerate(udev, f->priv_mtx);
 	mtx_unlock(f->priv_mtx);
 
 	if (error) {
@@ -954,13 +954,13 @@ ugen_fs_uninit(struct usb_fifo *f)
 	if (f->fs_xfer == NULL) {
 		return (EINVAL);
 	}
-	usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max);
+	usbd_transfer_unsetup(f->fs_xfer, f->fs_ep_max);
 	free(f->fs_xfer, M_USB);
 	f->fs_xfer = NULL;
 	f->fs_ep_max = 0;
 	f->fs_ep_ptr = NULL;
 	f->flag_iscomplete = 0;
-	usb2_fifo_free_buffer(f);
+	usb_fifo_free_buffer(f);
 	return (0);
 }
 
@@ -1006,7 +1006,7 @@ ugen_fs_set_complete(struct usb_fifo *f, uint8_t index)
 
 	f->flag_iscomplete = 1;
 
-	usb2_fifo_wakeup(f);
+	usb_fifo_wakeup(f);
 }
 
 static int
@@ -1032,7 +1032,7 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
 		return (EINVAL);
 	}
 	mtx_lock(f->priv_mtx);
-	if (usb2_transfer_pending(xfer)) {
+	if (usbd_transfer_pending(xfer)) {
 		mtx_unlock(f->priv_mtx);
 		return (EBUSY);		/* should not happen */
 	}
@@ -1059,7 +1059,7 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
 		return (error);
 	}
 	/* reset first frame */
-	usb2_set_frame_offset(xfer, 0, 0);
+	usbd_set_frame_offset(xfer, 0, 0);
 
 	if (xfer->flags_int.control_xfr) {
 
@@ -1162,7 +1162,7 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
 				kaddr = USB_ADD_BYTES(kaddr, offset);
 			} else {
 				/* set current frame offset */
-				usb2_set_frame_offset(xfer, offset, n);
+				usbd_set_frame_offset(xfer, offset, n);
 
 				/* get kernel buffer address */
 				kaddr = xfer->frbuffers[n].buffer;
@@ -1210,7 +1210,7 @@ ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index)
 		return (EINVAL);
 
 	mtx_lock(f->priv_mtx);
-	if (usb2_transfer_pending(xfer)) {
+	if (usbd_transfer_pending(xfer)) {
 		mtx_unlock(f->priv_mtx);
 		return (EBUSY);		/* should not happen */
 	}
@@ -1403,7 +1403,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 			break;
 		}
 		mtx_lock(f->priv_mtx);
-		usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]);
+		usbd_transfer_start(f->fs_xfer[u.pstart->ep_index]);
 		mtx_unlock(f->priv_mtx);
 		break;
 
@@ -1413,7 +1413,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 			break;
 		}
 		mtx_lock(f->priv_mtx);
-		usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
+		usbd_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
 		mtx_unlock(f->priv_mtx);
 		break;
 
@@ -1437,7 +1437,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 			error = EINVAL;
 			break;
 		}
-		ep = usb2_get_ep_by_addr(f->udev, u.popen->ep_no);
+		ep = usbd_get_ep_by_addr(f->udev, u.popen->ep_no);
 		if (ep == NULL) {
 			error = EINVAL;
 			break;
@@ -1488,7 +1488,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 				}
 			}
 		}
-		error = usb2_transfer_setup(f->udev, &iface_index,
+		error = usbd_transfer_setup(f->udev, &iface_index,
 		    f->fs_xfer + u.popen->ep_index, usb_config, 1,
 		    f, f->priv_mtx);
 		if (error == 0) {
@@ -1513,7 +1513,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 			error = EINVAL;
 			break;
 		}
-		usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
+		usbd_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
 		break;
 
 	case USB_FS_CLEAR_STALL_SYNC:
@@ -1530,7 +1530,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 			break;
 		}
 		mtx_lock(f->priv_mtx);
-		error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
+		error = usbd_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
 		mtx_unlock(f->priv_mtx);
 
 		if (error) {
@@ -1546,9 +1546,9 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 		req.wIndex[1] = 0;
 		USETW(req.wLength, 0);
 
-		error = usb2_do_request(f->udev, NULL, &req, NULL);
+		error = usbd_do_request(f->udev, NULL, &req, NULL);
 		if (error == 0) {
-			usb2_clear_data_toggle(f->udev, ep);
+			usbd_clear_data_toggle(f->udev, ep);
 		} else {
 			error = ENXIO;
 		}
@@ -1645,7 +1645,7 @@ ugen_get_iface_desc(struct usb_fifo *f,
 {
 	struct usb_interface *iface;
 
-	iface = usb2_get_iface(f->udev, f->iface_index);
+	iface = usbd_get_iface(f->udev, f->iface_index);
 	if (iface && iface->idesc) {
 		*idesc = *(iface->idesc);
 	} else {
@@ -1702,7 +1702,7 @@ ugen_set_power_mode(struct usb_fifo *f, int mode)
 		}
 
 		/* clear port enable */
-		err = usb2_req_clear_port_feature(udev->parent_hub,
+		err = usbd_req_clear_port_feature(udev->parent_hub,
 		    NULL, udev->port_no, UHF_PORT_ENABLE);
 		break;
 
@@ -1711,13 +1711,13 @@ ugen_set_power_mode(struct usb_fifo *f, int mode)
 		break;
 
 	case USB_POWER_MODE_RESUME:
-		err = usb2_req_clear_port_feature(udev->parent_hub,
+		err = usbd_req_clear_port_feature(udev->parent_hub,
 		    NULL, udev->port_no, UHF_PORT_SUSPEND);
 		mode = USB_POWER_MODE_SAVE;
 		break;
 
 	case USB_POWER_MODE_SUSPEND:
-		err = usb2_req_set_port_feature(udev->parent_hub,
+		err = usbd_req_set_port_feature(udev->parent_hub,
 		    NULL, udev->port_no, UHF_PORT_SUSPEND);
 		mode = USB_POWER_MODE_SAVE;
 		break;
@@ -1737,7 +1737,7 @@ ugen_set_power_mode(struct usb_fifo *f, int mode)
 	}
 
 	/* set new power mode */
-	usb2_set_power_mode(udev, mode);
+	usbd_set_power_mode(udev, mode);
 
 	return (0);			/* success */
 }
@@ -1779,10 +1779,10 @@ ugen_do_port_feature(struct usb_fifo *f, uint8_t port_no,
 		return (EINVAL);
 	}
 	if (set)
-		err = usb2_req_set_port_feature(udev,
+		err = usbd_req_set_port_feature(udev,
 		    NULL, port_no, feature);
 	else
-		err = usb2_req_clear_port_feature(udev,
+		err = usbd_req_clear_port_feature(udev,
 		    NULL, port_no, feature);
 
 	if (err)
@@ -1960,7 +1960,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 
 	switch (cmd) {
 	case USB_DISCOVER:
-		usb2_needs_explore_all();
+		usb_needs_explore_all();
 		break;
 
 	case USB_SETDEBUG:
@@ -1968,7 +1968,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 			error = EPERM;
 			break;
 		}
-		usb2_debug = *(int *)addr;
+		usb_debug = *(int *)addr;
 		break;
 
 	case USB_GET_CONFIG:
@@ -1984,7 +1984,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 		break;
 
 	case USB_GET_ALTINTERFACE:
-		iface = usb2_get_iface(f->udev,
+		iface = usbd_get_iface(f->udev,
 		    u.ai->uai_interface_index);
 		if (iface && iface->idesc) {
 			u.ai->uai_alt_index = iface->alt_index;
@@ -2003,7 +2003,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 		break;
 
 	case USB_GET_DEVICE_DESC:
-		dtemp = usb2_get_device_descriptor(f->udev);
+		dtemp = usbd_get_device_descriptor(f->udev);
 		if (!dtemp) {
 			error = EIO;
 			break;
@@ -2012,7 +2012,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 		break;
 
 	case USB_GET_CONFIG_DESC:
-		ctemp = usb2_get_config_descriptor(f->udev);
+		ctemp = usbd_get_config_descriptor(f->udev);
 		if (!ctemp) {
 			error = EIO;
 			break;
@@ -2043,7 +2043,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 
 	case USB_DEVICEINFO:
 	case USB_GET_DEVICEINFO:
-		error = usb2_gen_fill_deviceinfo(f, addr);
+		error = usb_gen_fill_deviceinfo(f, addr);
 		break;
 
 	case USB_DEVICESTATS:
@@ -2128,14 +2128,14 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 			error = EBUSY;
 			break;
 		}
-		error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
+		error = usb_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
 		if (error) {
 			break;
 		}
 		f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) *
 		    u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO);
 		if (f->fs_xfer == NULL) {
-			usb2_fifo_free_buffer(f);
+			usb_fifo_free_buffer(f);
 			error = ENOMEM;
 			break;
 		}
@@ -2171,7 +2171,7 @@ ugen_default_fs_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_SETUP:
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 	default:
 		ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
diff --git a/sys/dev/usb/usb_generic.h b/sys/dev/usb/usb_generic.h
index 96b9d1d..1b6ea12 100644
--- a/sys/dev/usb/usb_generic.h
+++ b/sys/dev/usb/usb_generic.h
@@ -27,7 +27,7 @@
 #ifndef _USB2_GENERIC_H_
 #define	_USB2_GENERIC_H_
 
-extern struct usb_fifo_methods usb2_ugen_methods;
+extern struct usb_fifo_methods usb_ugen_methods;
 int	ugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur);
 
 #endif					/* _USB2_GENERIC_H_ */
diff --git a/sys/dev/usb/usb_handle_request.c b/sys/dev/usb/usb_handle_request.c
index 0f2f8c0..e6f89f6 100644
--- a/sys/dev/usb/usb_handle_request.c
+++ b/sys/dev/usb/usb_handle_request.c
@@ -28,7 +28,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_process.h>
@@ -44,24 +44,24 @@
 
 /* function prototypes */
 
-static uint8_t usb2_handle_get_stall(struct usb_device *, uint8_t);
-static usb_error_t	 usb2_handle_remote_wakeup(struct usb_xfer *, uint8_t);
-static usb_error_t	 usb2_handle_request(struct usb_xfer *);
-static usb_error_t	 usb2_handle_set_config(struct usb_xfer *, uint8_t);
-static usb_error_t	 usb2_handle_set_stall(struct usb_xfer *, uint8_t,
+static uint8_t usb_handle_get_stall(struct usb_device *, uint8_t);
+static usb_error_t	 usb_handle_remote_wakeup(struct usb_xfer *, uint8_t);
+static usb_error_t	 usb_handle_request(struct usb_xfer *);
+static usb_error_t	 usb_handle_set_config(struct usb_xfer *, uint8_t);
+static usb_error_t	 usb_handle_set_stall(struct usb_xfer *, uint8_t,
 			    uint8_t);
-static usb_error_t	 usb2_handle_iface_request(struct usb_xfer *, void **,
+static usb_error_t	 usb_handle_iface_request(struct usb_xfer *, void **,
 			    uint16_t *, struct usb_device_request, uint16_t,
 			    uint8_t);
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_request_callback
+ *	usb_handle_request_callback
  *
  * This function is the USB callback for generic USB Device control
  * transfers.
  *------------------------------------------------------------------------*/
 void
-usb2_handle_request_callback(struct usb_xfer *xfer)
+usb_handle_request_callback(struct usb_xfer *xfer)
 {
 	usb_error_t err;
 
@@ -72,25 +72,25 @@ usb2_handle_request_callback(struct usb_xfer *xfer)
 	case USB_ST_TRANSFERRED:
 
 		/* handle the request */
-		err = usb2_handle_request(xfer);
+		err = usb_handle_request(xfer);
 
 		if (err) {
 
 			if (err == USB_ERR_BAD_CONTEXT) {
 				/* we need to re-setup the control transfer */
-				usb2_needs_explore(xfer->xroot->bus, 0);
+				usb_needs_explore(xfer->xroot->bus, 0);
 				break;
 			}
 			goto tr_restart;
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:
 		/* check if a control transfer is active */
 		if (xfer->flags_int.control_rem != 0xFFFF) {
 			/* handle the request */
-			err = usb2_handle_request(xfer);
+			err = usb_handle_request(xfer);
 		}
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* should not happen - try stalling */
@@ -110,18 +110,18 @@ tr_restart:
 	xfer->flags.manual_status = 1;
 	xfer->flags.force_short_xfer = 0;
 	xfer->flags.stall_pipe = 1;	/* cancel previous transfer, if any */
-	usb2_start_hardware(xfer);
+	usbd_transfer_submit(xfer);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_set_config
+ *	usb_handle_set_config
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)
+usb_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)
 {
 	struct usb_device *udev = xfer->xroot->udev;
 	usb_error_t err = 0;
@@ -144,12 +144,12 @@ usb2_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)
 		conf_no--;
 	}
 
-	if (usb2_set_config_index(udev, conf_no)) {
+	if (usbd_set_config_index(udev, conf_no)) {
 		DPRINTF("set config %d failed\n", conf_no);
 		err = USB_ERR_STALLED;
 		goto done;
 	}
-	if (usb2_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) {
+	if (usb_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) {
 		DPRINTF("probe and attach failed\n");
 		err = USB_ERR_STALLED;
 		goto done;
@@ -162,14 +162,14 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_iface_request
+ *	usb_handle_iface_request
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_iface_request(struct usb_xfer *xfer,
+usb_handle_iface_request(struct usb_xfer *xfer,
     void **ppdata, uint16_t *plen,
     struct usb_device_request req, uint16_t off, uint8_t state)
 {
@@ -196,7 +196,7 @@ usb2_handle_iface_request(struct usb_xfer *xfer,
 	error = ENXIO;
 
 tr_repeat:
-	iface = usb2_get_iface(udev, iface_index);
+	iface = usbd_get_iface(udev, iface_index);
 	if ((iface == NULL) ||
 	    (iface->idesc == NULL)) {
 		/* end of interfaces non-existing interface */
@@ -215,7 +215,7 @@ tr_repeat:
 		    &req, ppdata, plen,
 		    off, state);
 	}
-	iface_parent = usb2_get_iface(udev, iface->parent_iface_index);
+	iface_parent = usbd_get_iface(udev, iface->parent_iface_index);
 
 	if ((iface_parent == NULL) ||
 	    (iface_parent->idesc == NULL)) {
@@ -265,11 +265,11 @@ tr_repeat:
 			 */
 			if ((iface_parent != NULL) ||
 			    (iface->alt_index == req.wValue[0])) {
-				error = usb2_reset_iface_endpoints(udev,
+				error = usb_reset_iface_endpoints(udev,
 				    iface_index);
 				if (error) {
 					DPRINTF("alt setting failed %s\n",
-					    usb2_errstr(error));
+					    usbd_errstr(error));
 					goto tr_stalled;
 				}
 				break;
@@ -278,14 +278,14 @@ tr_repeat:
 			 * Doing the alternate setting will detach the
 			 * interface aswell:
 			 */
-			error = usb2_set_alt_interface_index(udev,
+			error = usbd_set_alt_interface_index(udev,
 			    iface_index, req.wValue[0]);
 			if (error) {
 				DPRINTF("alt setting failed %s\n",
-				    usb2_errstr(error));
+				    usbd_errstr(error));
 				goto tr_stalled;
 			}
-			error = usb2_probe_and_attach(udev,
+			error = usb_probe_and_attach(udev,
 			    iface_index);
 			if (error) {
 				DPRINTF("alt setting probe failed\n");
@@ -325,39 +325,39 @@ tr_stalled:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_stall
+ *	usb_handle_stall
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall)
+usb_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall)
 {
 	struct usb_device *udev = xfer->xroot->udev;
 	usb_error_t err;
 
 	USB_XFER_UNLOCK(xfer);
-	err = usb2_set_endpoint_stall(udev,
-	    usb2_get_ep_by_addr(udev, ep), do_stall);
+	err = usbd_set_endpoint_stall(udev,
+	    usbd_get_ep_by_addr(udev, ep), do_stall);
 	USB_XFER_LOCK(xfer);
 	return (err);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_get_stall
+ *	usb_handle_get_stall
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_handle_get_stall(struct usb_device *udev, uint8_t ea_val)
+usb_handle_get_stall(struct usb_device *udev, uint8_t ea_val)
 {
 	struct usb_endpoint *ep;
 	uint8_t halted;
 
-	ep = usb2_get_ep_by_addr(udev, ea_val);
+	ep = usbd_get_ep_by_addr(udev, ea_val);
 	if (ep == NULL) {
 		/* nothing to do */
 		return (0);
@@ -370,14 +370,14 @@ usb2_handle_get_stall(struct usb_device *udev, uint8_t ea_val)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_remote_wakeup
+ *	usb_handle_remote_wakeup
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
+usb_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
 {
 	struct usb_device *udev;
 	struct usb_bus *bus;
@@ -396,12 +396,12 @@ usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
 	USB_BUS_UNLOCK(bus);
 
 	/* In case we are out of sync, update the power state. */
-	usb2_bus_power_update(udev->bus);
+	usb_bus_power_update(udev->bus);
 	return (0);			/* success */
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_request
+ *	usb_handle_request
  *
  * Internal state sequence:
  *
@@ -412,7 +412,7 @@ usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
  * Else: Stall current transfer, if any
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_request(struct usb_xfer *xfer)
+usb_handle_request(struct usb_xfer *xfer)
 {
 	struct usb_device_request req;
 	struct usb_device *udev;
@@ -460,12 +460,12 @@ usb2_handle_request(struct usb_xfer *xfer)
 
 	xfer->frlengths[0] = 0;
 
-	usb2_set_frame_offset(xfer, 0, 0);
-	usb2_set_frame_offset(xfer, sizeof(req), 1);
+	usbd_set_frame_offset(xfer, 0, 0);
+	usbd_set_frame_offset(xfer, sizeof(req), 1);
 
 	/* get the current request, if any */
 
-	usb2_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
+	usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
 
 	if (xfer->flags_int.control_rem == 0xFFFF) {
 		/* first time - not initialised */
@@ -572,7 +572,7 @@ usb2_handle_request(struct usb_xfer *xfer)
 		break;
 	default:
 		/* we use "USB_ADD_BYTES" to de-const the src_zcopy */
-		err = usb2_handle_iface_request(xfer,
+		err = usb_handle_iface_request(xfer,
 		    USB_ADD_BYTES(&src_zcopy, 0),
 		    &max_len, req, off, state);
 		if (err == 0) {
@@ -595,7 +595,7 @@ usb2_handle_request(struct usb_xfer *xfer)
 	goto tr_valid;
 
 tr_handle_get_descriptor:
-	err = (usb2_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len);
+	err = (usb_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len);
 	if (err)
 		goto tr_stalled;
 	if (src_zcopy == NULL)
@@ -643,7 +643,7 @@ tr_handle_set_address:
 
 tr_handle_set_config:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_set_config(xfer, req.wValue[0])) {
+		if (usb_handle_set_config(xfer, req.wValue[0])) {
 			goto tr_stalled;
 		}
 	}
@@ -651,7 +651,7 @@ tr_handle_set_config:
 
 tr_handle_clear_halt:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_set_stall(xfer, req.wIndex[0], 0)) {
+		if (usb_handle_set_stall(xfer, req.wIndex[0], 0)) {
 			goto tr_stalled;
 		}
 	}
@@ -659,7 +659,7 @@ tr_handle_clear_halt:
 
 tr_handle_clear_wakeup:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_remote_wakeup(xfer, 0)) {
+		if (usb_handle_remote_wakeup(xfer, 0)) {
 			goto tr_stalled;
 		}
 	}
@@ -667,7 +667,7 @@ tr_handle_clear_wakeup:
 
 tr_handle_set_halt:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_set_stall(xfer, req.wIndex[0], 1)) {
+		if (usb_handle_set_stall(xfer, req.wIndex[0], 1)) {
 			goto tr_stalled;
 		}
 	}
@@ -675,7 +675,7 @@ tr_handle_set_halt:
 
 tr_handle_set_wakeup:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_remote_wakeup(xfer, 1)) {
+		if (usb_handle_remote_wakeup(xfer, 1)) {
 			goto tr_stalled;
 		}
 	}
@@ -684,7 +684,7 @@ tr_handle_set_wakeup:
 tr_handle_get_ep_status:
 	if (state == USB_HR_NOT_COMPLETE) {
 		temp.wStatus[0] =
-		    usb2_handle_get_stall(udev, req.wIndex[0]);
+		    usb_handle_get_stall(udev, req.wIndex[0]);
 		temp.wStatus[1] = 0;
 		src_mcopy = temp.wStatus;
 		max_len = sizeof(temp.wStatus);
@@ -732,10 +732,10 @@ tr_valid:
 	if (max_len > 0) {
 		if (src_mcopy) {
 			src_mcopy = USB_ADD_BYTES(src_mcopy, off);
-			usb2_copy_in(xfer->frbuffers + 1, 0,
+			usbd_copy_in(xfer->frbuffers + 1, 0,
 			    src_mcopy, max_len);
 		} else {
-			usb2_set_frame_data(xfer,
+			usbd_set_frame_data(xfer,
 			    USB_ADD_BYTES(src_zcopy, off), 1);
 		}
 		xfer->frlengths[1] = max_len;
diff --git a/sys/dev/usb/usb_hid.c b/sys/dev/usb/usb_hid.c
index df71978..63c625c 100644
--- a/sys/dev/usb/usb_hid.c
+++ b/sys/dev/usb/usb_hid.c
@@ -45,7 +45,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usbhid.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -659,7 +659,7 @@ hid_get_descriptor_from_usb(struct usb_config_descriptor *cd,
 	if (desc == NULL) {
 		return (NULL);
 	}
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 		if ((desc->bDescriptorType == UDESC_HID) &&
 		    (desc->bLength >= USB_HID_DESCRIPTOR_SIZE(0))) {
 			return (void *)desc;
@@ -672,7 +672,7 @@ hid_get_descriptor_from_usb(struct usb_config_descriptor *cd,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_hid_desc
+ *	usbd_req_get_hid_desc
  *
  * This function will read out an USB report descriptor from the USB
  * device.
@@ -682,11 +682,11 @@ hid_get_descriptor_from_usb(struct usb_config_descriptor *cd,
  * Else: Success. The pointer should eventually be passed to free().
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,
     void **descp, uint16_t *sizep,
     struct malloc_type *mem, uint8_t iface_index)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_hid_descriptor *hid;
 	usb_error_t err;
 
@@ -694,7 +694,7 @@ usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,
 		return (USB_ERR_INVAL);
 	}
 	hid = hid_get_descriptor_from_usb
-	    (usb2_get_config_descriptor(udev), iface->idesc);
+	    (usbd_get_config_descriptor(udev), iface->idesc);
 
 	if (hid == NULL) {
 		return (USB_ERR_IOERROR);
@@ -714,7 +714,7 @@ usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,
 	if (*descp == NULL) {
 		return (USB_ERR_NOMEM);
 	}
-	err = usb2_req_get_report_descriptor
+	err = usbd_req_get_report_descriptor
 	    (udev, mtx, *descp, *sizep, iface_index);
 
 	if (err) {
diff --git a/sys/dev/usb/usb_hid.h b/sys/dev/usb/usb_hid.h
index 4613d02..a0f4cfc 100644
--- a/sys/dev/usb/usb_hid.h
+++ b/sys/dev/usb/usb_hid.h
@@ -72,7 +72,7 @@ struct hid_item {
 	struct hid_location loc;
 };
 
-/* prototypes from "usb2_hid.c" */
+/* prototypes from "usb_hid.c" */
 
 struct hid_data *hid_start_parse(const void *d, usb_size_t len, int kindset);
 void	hid_end_parse(struct hid_data *s);
@@ -88,7 +88,7 @@ int	hid_is_collection(const void *desc, usb_size_t size, uint32_t usage);
 struct usb_hid_descriptor *hid_get_descriptor_from_usb(
 	    struct usb_config_descriptor *cd,
 	    struct usb_interface_descriptor *id);
-usb_error_t usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,
 	    void **descp, uint16_t *sizep, struct malloc_type *mem,
 	    uint8_t iface_index);
 
diff --git a/sys/dev/usb/usb_hub.c b/sys/dev/usb/usb_hub.c
index 595e7cd..2b48752 100644
--- a/sys/dev/usb/usb_hub.c
+++ b/sys/dev/usb/usb_hub.c
@@ -63,10 +63,10 @@ SYSCTL_INT(_hw_usb_uhub, OID_AUTO, debug, CTLFLAG_RW, &uhub_debug, 0,
 #endif
 
 #if USB_HAVE_POWERD
-static int usb2_power_timeout = 30;	/* seconds */
+static int usb_power_timeout = 30;	/* seconds */
 
 SYSCTL_INT(_hw_usb, OID_AUTO, power_timeout, CTLFLAG_RW,
-    &usb2_power_timeout, 0, "USB power timeout");
+    &usb_power_timeout, 0, "USB power timeout");
 #endif
 
 struct uhub_current_state {
@@ -102,8 +102,8 @@ static bus_child_pnpinfo_str_t uhub_child_pnpinfo_string;
 
 static usb_callback_t uhub_intr_callback;
 
-static void usb2_dev_resume_peer(struct usb_device *udev);
-static void usb2_dev_suspend_peer(struct usb_device *udev);
+static void usb_dev_resume_peer(struct usb_device *udev);
+static void usb_dev_suspend_peer(struct usb_device *udev);
 
 static const struct usb_config uhub_config[UHUB_N_TRANSFER] = {
 
@@ -162,11 +162,11 @@ uhub_intr_callback(struct usb_xfer *xfer)
 		 * event handler thread that we need
 		 * to be explored again:
 		 */
-		usb2_needs_explore(sc->sc_udev->bus, 0);
+		usb_needs_explore(sc->sc_udev->bus, 0);
 
 	case USB_ST_SETUP:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -178,7 +178,7 @@ uhub_intr_callback(struct usb_xfer *xfer)
 			 */
 			xfer->flags.stall_pipe = 1;
 			xfer->frlengths[0] = xfer->max_data_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 	}
@@ -206,7 +206,7 @@ uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up)
 	refcount = bus->driver_added_refcount;
 
 	/* get device assosiated with the given port */
-	child = usb2_bus_port_get_device(bus, up);
+	child = usb_bus_port_get_device(bus, up);
 	if (child == NULL) {
 		/* nothing to do */
 		goto done;
@@ -215,7 +215,7 @@ uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up)
 
 	if (child->driver_added_refcount != refcount) {
 		child->driver_added_refcount = refcount;
-		err = usb2_probe_and_attach(child,
+		err = usb_probe_and_attach(child,
 		    USB_IFACE_INDEX_ANY);
 		if (err) {
 			goto done;
@@ -224,7 +224,7 @@ uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up)
 	/* start control transfer, if device mode */
 
 	if (child->flags.usb_mode == USB_MODE_DEVICE) {
-		usb2_default_transfer_setup(child);
+		usbd_default_transfer_setup(child);
 	}
 	/* if a HUB becomes present, do a recursive HUB explore */
 
@@ -244,7 +244,7 @@ uhub_read_port_status(struct uhub_softc *sc, uint8_t portno)
 	struct usb_port_status ps;
 	usb_error_t err;
 
-	err = usb2_req_get_port_status(
+	err = usbd_req_get_port_status(
 	    sc->sc_udev, NULL, &ps, portno);
 
 	/* update status regardless of error */
@@ -257,7 +257,7 @@ uhub_read_port_status(struct uhub_softc *sc, uint8_t portno)
 	DPRINTFN(4, "port %d, wPortStatus=0x%04x, "
 	    "wPortChange=0x%04x, err=%s\n",
 	    portno, sc->sc_st.port_status,
-	    sc->sc_st.port_change, usb2_errstr(err));
+	    sc->sc_st.port_change, usbd_errstr(err));
 	return (err);
 }
 
@@ -283,14 +283,14 @@ uhub_reattach_port(struct uhub_softc *sc, uint8_t portno)
 	err = 0;
 	timeout = 0;
 	udev = sc->sc_udev;
-	child = usb2_bus_port_get_device(udev->bus,
+	child = usb_bus_port_get_device(udev->bus,
 	    udev->hub->ports + portno - 1);
 
 repeat:
 
 	/* first clear the port connection change bit */
 
-	err = usb2_req_clear_port_feature(udev, NULL,
+	err = usbd_req_clear_port_feature(udev, NULL,
 	    portno, UHF_C_PORT_CONNECTION);
 
 	if (err) {
@@ -299,7 +299,7 @@ repeat:
 	/* detach any existing devices */
 
 	if (child) {
-		usb2_free_device(child,
+		usb_free_device(child,
 		    USB_UNCFG_FLAG_FREE_SUBDEV |
 		    USB_UNCFG_FLAG_FREE_EP0);
 		child = NULL;
@@ -330,24 +330,24 @@ repeat:
 		if (sc->sc_st.port_status & UPS_SUSPEND) {
 			DPRINTF("Port %d was still "
 			    "suspended, clearing.\n", portno);
-			err = usb2_req_clear_port_feature(sc->sc_udev,
+			err = usbd_req_clear_port_feature(sc->sc_udev,
 			    NULL, portno, UHF_PORT_SUSPEND);
 		}
 		/* USB Host Mode */
 
 		/* wait for maximum device power up time */
 
-		usb2_pause_mtx(NULL, 
+		usb_pause_mtx(NULL, 
 		    USB_MS_TO_TICKS(USB_PORT_POWERUP_DELAY));
 
 		/* reset port, which implies enabling it */
 
-		err = usb2_req_reset_port(udev, NULL, portno);
+		err = usbd_req_reset_port(udev, NULL, portno);
 
 		if (err) {
 			DPRINTFN(0, "port %d reset "
 			    "failed, error=%s\n",
-			    portno, usb2_errstr(err));
+			    portno, usbd_errstr(err));
 			goto error;
 		}
 		/* get port status again, it might have changed during reset */
@@ -410,7 +410,7 @@ repeat:
 
 	/* need to create a new child */
 
-	child = usb2_alloc_device(sc->sc_dev, udev->bus, udev,
+	child = usb_alloc_device(sc->sc_dev, udev->bus, udev,
 	    udev->depth + 1, portno - 1, portno, speed, mode);
 	if (child == NULL) {
 		DPRINTFN(0, "could not allocate new device!\n");
@@ -420,21 +420,21 @@ repeat:
 
 error:
 	if (child) {
-		usb2_free_device(child,
+		usb_free_device(child,
 		    USB_UNCFG_FLAG_FREE_SUBDEV |
 		    USB_UNCFG_FLAG_FREE_EP0);
 		child = NULL;
 	}
 	if (err == 0) {
 		if (sc->sc_st.port_status & UPS_PORT_ENABLED) {
-			err = usb2_req_clear_port_feature(
+			err = usbd_req_clear_port_feature(
 			    sc->sc_udev, NULL,
 			    portno, UHF_PORT_ENABLE);
 		}
 	}
 	if (err) {
 		DPRINTFN(0, "device problem (%s), "
-		    "disabling port %d\n", usb2_errstr(err), portno);
+		    "disabling port %d\n", usbd_errstr(err), portno);
 	}
 	return (err);
 }
@@ -457,12 +457,12 @@ uhub_suspend_resume_port(struct uhub_softc *sc, uint8_t portno)
 	DPRINTF("port %d\n", portno);
 
 	udev = sc->sc_udev;
-	child = usb2_bus_port_get_device(udev->bus,
+	child = usb_bus_port_get_device(udev->bus,
 	    udev->hub->ports + portno - 1);
 
 	/* first clear the port suspend change bit */
 
-	err = usb2_req_clear_port_feature(udev, NULL,
+	err = usbd_req_clear_port_feature(udev, NULL,
 	    portno, UHF_C_PORT_SUSPEND);
 	if (err) {
 		DPRINTF("clearing suspend failed.\n");
@@ -494,9 +494,9 @@ uhub_suspend_resume_port(struct uhub_softc *sc, uint8_t portno)
 		 * suspend and resume here
 		 */
 		if (is_suspend == 0)
-			usb2_dev_resume_peer(child);
+			usb_dev_resume_peer(child);
 		else if (child->flags.usb_mode == USB_MODE_DEVICE)
-			usb2_dev_suspend_peer(child);
+			usb_dev_suspend_peer(child);
 	}
 done:
 	return (err);
@@ -514,7 +514,7 @@ uhub_root_intr(struct usb_bus *bus, const uint8_t *ptr, uint8_t len)
 {
 	USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
 
-	usb2_needs_explore(bus, 0);
+	usb_needs_explore(bus, 0);
 }
 
 /*------------------------------------------------------------------------*
@@ -560,7 +560,7 @@ uhub_explore(struct usb_device *udev)
 		}
 		if (sc->sc_st.port_change & UPS_C_OVERCURRENT_INDICATOR) {
 			DPRINTF("Overcurrent on port %u.\n", portno);
-			err = usb2_req_clear_port_feature(
+			err = usbd_req_clear_port_feature(
 			    udev, NULL, portno, UHF_C_PORT_OVER_CURRENT);
 			if (err) {
 				/* most likely the HUB is gone */
@@ -576,7 +576,7 @@ uhub_explore(struct usb_device *udev)
 			    UPS_C_CONNECT_STATUS;
 		}
 		if (sc->sc_st.port_change & UPS_C_PORT_ENABLED) {
-			err = usb2_req_clear_port_feature(
+			err = usbd_req_clear_port_feature(
 			    udev, NULL, portno, UHF_C_PORT_ENABLE);
 			if (err) {
 				/* most likely the HUB is gone */
@@ -675,7 +675,7 @@ uhub_attach(device_t dev)
 	snprintf(sc->sc_name, sizeof(sc->sc_name), "%s",
 	    device_get_nameunit(dev));
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	DPRINTFN(2, "depth=%d selfpowered=%d, parent=%p, "
 	    "parent->selfpowered=%d\n",
@@ -701,17 +701,17 @@ uhub_attach(device_t dev)
 	DPRINTFN(2, "getting HUB descriptor\n");
 
 	/* assuming that there is one port */
-	err = usb2_req_get_hub_descriptor(udev, NULL, &hubdesc, 1);
+	err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc, 1);
 
 	nports = hubdesc.bNbrPorts;
 
 	if (!err && (nports >= 8)) {
 		/* get complete HUB descriptor */
-		err = usb2_req_get_hub_descriptor(udev, NULL, &hubdesc, nports);
+		err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc, nports);
 	}
 	if (err) {
 		DPRINTFN(0, "getting hub descriptor failed,"
-		    "error=%s\n", usb2_errstr(err));
+		    "error=%s\n", usbd_errstr(err));
 		goto error;
 	}
 	if (hubdesc.bNbrPorts != nports) {
@@ -732,7 +732,7 @@ uhub_attach(device_t dev)
 
 #if USB_HAVE_TT_SUPPORT
 	/* init FULL-speed ISOCHRONOUS schedule */
-	usb2_fs_isoc_schedule_init_all(hub->fs_isoc_schedule);
+	usbd_fs_isoc_schedule_init_all(hub->fs_isoc_schedule);
 #endif
 	/* initialize HUB structure */
 	hub->hubsoftc = sc;
@@ -754,16 +754,16 @@ uhub_attach(device_t dev)
 		err = 0;
 	} else {
 		/* normal HUB */
-		err = usb2_transfer_setup(udev, &iface_index, sc->sc_xfer,
+		err = usbd_transfer_setup(udev, &iface_index, sc->sc_xfer,
 		    uhub_config, UHUB_N_TRANSFER, sc, &Giant);
 	}
 	if (err) {
 		DPRINTFN(0, "cannot setup interrupt transfer, "
-		    "errstr=%s!\n", usb2_errstr(err));
+		    "errstr=%s!\n", usbd_errstr(err));
 		goto error;
 	}
 	/* wait with power off for a while */
-	usb2_pause_mtx(NULL, USB_MS_TO_TICKS(USB_POWER_DOWN_TIME));
+	usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_POWER_DOWN_TIME));
 
 	/*
 	 * To have the best chance of success we do things in the exact same
@@ -810,18 +810,18 @@ uhub_attach(device_t dev)
 		}
 		if (!err) {
 			/* turn the power on */
-			err = usb2_req_set_port_feature(udev, NULL,
+			err = usbd_req_set_port_feature(udev, NULL,
 			    portno, UHF_PORT_POWER);
 		}
 		if (err) {
 			DPRINTFN(0, "port %d power on failed, %s\n",
-			    portno, usb2_errstr(err));
+			    portno, usbd_errstr(err));
 		}
 		DPRINTF("turn on port %d power\n",
 		    portno);
 
 		/* wait for stable power */
-		usb2_pause_mtx(NULL, USB_MS_TO_TICKS(pwrdly));
+		usb_pause_mtx(NULL, USB_MS_TO_TICKS(pwrdly));
 	}
 
 	device_printf(dev, "%d port%s with %d "
@@ -832,18 +832,18 @@ uhub_attach(device_t dev)
 
 	if (sc->sc_xfer[0] != NULL) {
 		USB_XFER_LOCK(sc->sc_xfer[0]);
-		usb2_transfer_start(sc->sc_xfer[0]);
+		usbd_transfer_start(sc->sc_xfer[0]);
 		USB_XFER_UNLOCK(sc->sc_xfer[0]);
 	}
 
 	/* Enable automatic power save on all USB HUBs */
 
-	usb2_set_power_mode(udev, USB_POWER_MODE_SAVE);
+	usbd_set_power_mode(udev, USB_POWER_MODE_SAVE);
 
 	return (0);
 
 error:
-	usb2_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER);
 
 	if (udev->hub) {
 		free(udev->hub, M_USBDEV);
@@ -872,7 +872,7 @@ uhub_detach(device_t dev)
 	}
 	for (x = 0; x != hub->nports; x++) {
 
-		child = usb2_bus_port_get_device(sc->sc_udev->bus, hub->ports + x);
+		child = usb_bus_port_get_device(sc->sc_udev->bus, hub->ports + x);
 
 		if (child == NULL) {
 			continue;
@@ -881,11 +881,11 @@ uhub_detach(device_t dev)
 		 * Subdevices are not freed, because the caller of
 		 * uhub_detach() will do that.
 		 */
-		usb2_free_device(child,
+		usb_free_device(child,
 		    USB_UNCFG_FLAG_FREE_EP0);
 	}
 
-	usb2_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER);
 
 	free(hub, M_USBDEV);
 	sc->sc_udev->hub = NULL;
@@ -911,7 +911,7 @@ uhub_resume(device_t dev)
 static void
 uhub_driver_added(device_t dev, driver_t *driver)
 {
-	usb2_needs_explore_all();
+	usb_needs_explore_all();
 }
 
 struct hub_result {
@@ -932,13 +932,13 @@ uhub_find_iface_index(struct usb_hub *hub, device_t child,
 
 	nports = hub->nports;
 	for (x = 0; x != nports; x++) {
-		udev = usb2_bus_port_get_device(hub->hubudev->bus,
+		udev = usb_bus_port_get_device(hub->hubudev->bus,
 		    hub->ports + x);
 		if (!udev) {
 			continue;
 		}
 		for (i = 0; i != USB_IFACE_MAX; i++) {
-			iface = usb2_get_iface(udev, i);
+			iface = usbd_get_iface(udev, i);
 			if (iface &&
 			    (iface->subdev == child)) {
 				res->iface_index = i;
@@ -996,7 +996,7 @@ uhub_child_pnpinfo_string(device_t parent, device_t child,
 		}
 		goto done;
 	}
-	iface = usb2_get_iface(res.udev, res.iface_index);
+	iface = usbd_get_iface(res.udev, res.iface_index);
 	if (iface && iface->idesc) {
 		snprintf(buf, buflen, "vendor=0x%04x product=0x%04x "
 		    "devclass=0x%02x devsubclass=0x%02x "
@@ -1052,13 +1052,13 @@ done:
  */
 
 /*------------------------------------------------------------------------*
- *	usb2_intr_find_best_slot
+ *	usb_intr_find_best_slot
  *
  * Return value:
  *   The best Transaction Translation slot for an interrupt endpoint.
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end)
+usb_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end)
 {
 	usb_size_t max = 0 - 1;
 	uint8_t x;
@@ -1078,7 +1078,7 @@ usb2_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_intr_schedule_adjust
+ *	usb_intr_schedule_adjust
  *
  * This function will update the bandwith usage for the microframe
  * having index "slot" by "len" bytes. "len" can be negative.  If the
@@ -1090,7 +1090,7 @@ usb2_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end)
  *   The slot on which the bandwidth update was done.
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot)
+usb_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot)
 {
 	struct usb_bus *bus = udev->bus;
 	struct usb_hub *hub;
@@ -1098,7 +1098,7 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot)
 
 	USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
 
-	speed = usb2_get_speed(udev);
+	speed = usbd_get_speed(udev);
 
 	switch (speed) {
 	case USB_SPEED_LOW:
@@ -1115,7 +1115,7 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot)
 
 		hub = udev->parent_hs_hub->hub;
 		if (slot >= USB_HS_MICRO_FRAMES_MAX) {
-			slot = usb2_intr_find_best_slot(hub->uframe_usage,
+			slot = usb_intr_find_best_slot(hub->uframe_usage,
 			    USB_FS_ISOC_UFRAME_MAX, 6);
 		}
 		hub->uframe_usage[slot] += len;
@@ -1123,7 +1123,7 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot)
 		break;
 	default:
 		if (slot >= USB_HS_MICRO_FRAMES_MAX) {
-			slot = usb2_intr_find_best_slot(bus->uframe_usage, 0,
+			slot = usb_intr_find_best_slot(bus->uframe_usage, 0,
 			    USB_HS_MICRO_FRAMES_MAX);
 		}
 		bus->uframe_usage[slot] += len;
@@ -1133,14 +1133,14 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fs_isoc_schedule_init_sub
+ *	usbd_fs_isoc_schedule_init_sub
  *
  * This function initialises an USB FULL speed isochronous schedule
  * entry.
  *------------------------------------------------------------------------*/
 #if USB_HAVE_TT_SUPPORT
 static void
-usb2_fs_isoc_schedule_init_sub(struct usb_fs_isoc_schedule *fss)
+usbd_fs_isoc_schedule_init_sub(struct usb_fs_isoc_schedule *fss)
 {
 	fss->total_bytes = (USB_FS_ISOC_UFRAME_MAX *
 	    USB_FS_BYTES_PER_HS_UFRAME);
@@ -1150,26 +1150,26 @@ usb2_fs_isoc_schedule_init_sub(struct usb_fs_isoc_schedule *fss)
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_fs_isoc_schedule_init_all
+ *	usbd_fs_isoc_schedule_init_all
  *
  * This function will reset the complete USB FULL speed isochronous
  * bandwidth schedule.
  *------------------------------------------------------------------------*/
 #if USB_HAVE_TT_SUPPORT
 void
-usb2_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss)
+usbd_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss)
 {
 	struct usb_fs_isoc_schedule *fss_end = fss + USB_ISOC_TIME_MAX;
 
 	while (fss != fss_end) {
-		usb2_fs_isoc_schedule_init_sub(fss);
+		usbd_fs_isoc_schedule_init_sub(fss);
 		fss++;
 	}
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_isoc_time_expand
+ *	usb_isoc_time_expand
  *
  * This function will expand the time counter from 7-bit to 16-bit.
  *
@@ -1177,7 +1177,7 @@ usb2_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss)
  *   16-bit isochronous time counter.
  *------------------------------------------------------------------------*/
 uint16_t
-usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr)
+usb_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr)
 {
 	uint16_t rem;
 
@@ -1200,7 +1200,7 @@ usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_fs_isoc_schedule_isoc_time_expand
+ *	usbd_fs_isoc_schedule_isoc_time_expand
  *
  * This function does multiple things. First of all it will expand the
  * passed isochronous time, which is the return value. Then it will
@@ -1216,7 +1216,7 @@ usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr)
  *------------------------------------------------------------------------*/
 #if USB_HAVE_TT_SUPPORT
 uint16_t
-usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev,
+usbd_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev,
     struct usb_fs_isoc_schedule **pp_start,
     struct usb_fs_isoc_schedule **pp_end,
     uint16_t isoc_time)
@@ -1226,7 +1226,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev,
 	struct usb_fs_isoc_schedule *fss_b;
 	struct usb_hub *hs_hub;
 
-	isoc_time = usb2_isoc_time_expand(udev->bus, isoc_time);
+	isoc_time = usb_isoc_time_expand(udev->bus, isoc_time);
 
 	hs_hub = udev->parent_hs_hub->hub;
 
@@ -1250,7 +1250,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev,
 				fss_a = hs_hub->fs_isoc_schedule;
 				continue;
 			}
-			usb2_fs_isoc_schedule_init_sub(fss_a);
+			usbd_fs_isoc_schedule_init_sub(fss_a);
 			fss_a++;
 		}
 
@@ -1264,7 +1264,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev,
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_fs_isoc_schedule_alloc
+ *	usbd_fs_isoc_schedule_alloc
  *
  * This function will allocate bandwidth for an isochronous FULL speed
  * transaction in the FULL speed schedule. The microframe slot where
@@ -1278,7 +1278,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev,
  *------------------------------------------------------------------------*/
 #if USB_HAVE_TT_SUPPORT
 uint8_t
-usb2_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss,
+usbd_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss,
     uint8_t *pstart, uint16_t len)
 {
 	uint8_t slot = fss->frame_slot;
@@ -1312,12 +1312,12 @@ usb2_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss,
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_port_get_device
+ *	usb_bus_port_get_device
  *
  * This function is NULL safe.
  *------------------------------------------------------------------------*/
 struct usb_device *
-usb2_bus_port_get_device(struct usb_bus *bus, struct usb_port *up)
+usb_bus_port_get_device(struct usb_bus *bus, struct usb_port *up)
 {
 	if ((bus == NULL) || (up == NULL)) {
 		/* be NULL safe */
@@ -1331,12 +1331,12 @@ usb2_bus_port_get_device(struct usb_bus *bus, struct usb_port *up)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_port_set_device
+ *	usb_bus_port_set_device
  *
  * This function is NULL safe.
  *------------------------------------------------------------------------*/
 void
-usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up,
+usb_bus_port_set_device(struct usb_bus *bus, struct usb_port *up,
     struct usb_device *udev, uint8_t device_index)
 {
 	if (bus == NULL) {
@@ -1360,11 +1360,11 @@ usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up,
 	 */
 	if (device_index != 0) {
 #if USB_HAVE_UGEN
-		mtx_lock(&usb2_ref_lock);
+		mtx_lock(&usb_ref_lock);
 #endif
 		bus->devices[device_index] = udev;
 #if USB_HAVE_UGEN
-		mtx_unlock(&usb2_ref_lock);
+		mtx_unlock(&usb_ref_lock);
 #endif
 	}
 	/*
@@ -1374,12 +1374,12 @@ usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_needs_explore
+ *	usb_needs_explore
  *
  * This functions is called when the USB event thread needs to run.
  *------------------------------------------------------------------------*/
 void
-usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe)
+usb_needs_explore(struct usb_bus *bus, uint8_t do_probe)
 {
 	uint8_t do_unlock;
 
@@ -1403,7 +1403,7 @@ usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe)
 	if (do_probe) {
 		bus->do_probe = 1;
 	}
-	if (usb2_proc_msignal(&bus->explore_proc,
+	if (usb_proc_msignal(&bus->explore_proc,
 	    &bus->explore_msg[0], &bus->explore_msg[1])) {
 		/* ignore */
 	}
@@ -1413,13 +1413,13 @@ usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_needs_explore_all
+ *	usb_needs_explore_all
  *
  * This function is called whenever a new driver is loaded and will
  * cause that all USB busses are re-explored.
  *------------------------------------------------------------------------*/
 void
-usb2_needs_explore_all(void)
+usb_needs_explore_all(void)
 {
 	struct usb_bus *bus;
 	devclass_t dc;
@@ -1428,7 +1428,7 @@ usb2_needs_explore_all(void)
 
 	DPRINTFN(3, "\n");
 
-	dc = usb2_devclass_ptr;
+	dc = usb_devclass_ptr;
 	if (dc == NULL) {
 		DPRINTFN(0, "no devclass\n");
 		return;
@@ -1442,7 +1442,7 @@ usb2_needs_explore_all(void)
 		if (dev) {
 			bus = device_get_softc(dev);
 			if (bus) {
-				usb2_needs_explore(bus, 1);
+				usb_needs_explore(bus, 1);
 			}
 		}
 		max--;
@@ -1450,7 +1450,7 @@ usb2_needs_explore_all(void)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_power_update
+ *	usb_bus_power_update
  *
  * This function will ensure that all USB devices on the given bus are
  * properly suspended or resumed according to the device transfer
@@ -1458,14 +1458,14 @@ usb2_needs_explore_all(void)
  *------------------------------------------------------------------------*/
 #if USB_HAVE_POWERD
 void
-usb2_bus_power_update(struct usb_bus *bus)
+usb_bus_power_update(struct usb_bus *bus)
 {
-	usb2_needs_explore(bus, 0 /* no probe */ );
+	usb_needs_explore(bus, 0 /* no probe */ );
 }
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_power_ref
+ *	usbd_transfer_power_ref
  *
  * This function will modify the power save reference counts and
  * wakeup the USB device associated with the given USB transfer, if
@@ -1473,7 +1473,7 @@ usb2_bus_power_update(struct usb_bus *bus)
  *------------------------------------------------------------------------*/
 #if USB_HAVE_POWERD
 void
-usb2_transfer_power_ref(struct usb_xfer *xfer, int val)
+usbd_transfer_power_ref(struct usb_xfer *xfer, int val)
 {
 	static const usb_power_mask_t power_mask[4] = {
 		[UE_CONTROL] = USB_HW_POWER_CONTROL,
@@ -1518,7 +1518,7 @@ usb2_transfer_power_ref(struct usb_xfer *xfer, int val)
 		needs_explore =
 		    (udev->pwr_save.write_refs != 0) ||
 		    ((udev->pwr_save.read_refs != 0) &&
-		    (usb2_peer_can_wakeup(udev) == 0));
+		    (usb_peer_can_wakeup(udev) == 0));
 	else
 		needs_explore = 0;
 
@@ -1534,7 +1534,7 @@ usb2_transfer_power_ref(struct usb_xfer *xfer, int val)
 
 	if (needs_explore) {
 		DPRINTF("update\n");
-		usb2_bus_power_update(udev->bus);
+		usb_bus_power_update(udev->bus);
 	} else if (needs_hw_power) {
 		DPRINTF("needs power\n");
 		if (udev->bus->methods->set_hw_power != NULL) {
@@ -1545,14 +1545,14 @@ usb2_transfer_power_ref(struct usb_xfer *xfer, int val)
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_bus_powerd
+ *	usb_bus_powerd
  *
  * This function implements the USB power daemon and is called
  * regularly from the USB explore thread.
  *------------------------------------------------------------------------*/
 #if USB_HAVE_POWERD
 void
-usb2_bus_powerd(struct usb_bus *bus)
+usb_bus_powerd(struct usb_bus *bus)
 {
 	struct usb_device *udev;
 	usb_ticks_t temp;
@@ -1562,7 +1562,7 @@ usb2_bus_powerd(struct usb_bus *bus)
 	uint8_t x;
 	uint8_t rem_wakeup;
 
-	limit = usb2_power_timeout;
+	limit = usb_power_timeout;
 	if (limit == 0)
 		limit = hz;
 	else if (limit > 255)
@@ -1585,7 +1585,7 @@ usb2_bus_powerd(struct usb_bus *bus)
 		if (udev == NULL)
 			continue;
 
-		rem_wakeup = usb2_peer_can_wakeup(udev);
+		rem_wakeup = usb_peer_can_wakeup(udev);
 
 		temp = ticks - udev->pwr_save.last_xfer_time;
 
@@ -1598,7 +1598,7 @@ usb2_bus_powerd(struct usb_bus *bus)
 			/* check if we are suspended */
 			if (udev->flags.self_suspended != 0) {
 				USB_BUS_UNLOCK(bus);
-				usb2_dev_resume_peer(udev);
+				usb_dev_resume_peer(udev);
 				USB_BUS_LOCK(bus);
 			}
 		} else if (temp >= limit) {
@@ -1606,7 +1606,7 @@ usb2_bus_powerd(struct usb_bus *bus)
 			/* check if we are not suspended */
 			if (udev->flags.self_suspended == 0) {
 				USB_BUS_UNLOCK(bus);
-				usb2_dev_suspend_peer(udev);
+				usb_dev_suspend_peer(udev);
 				USB_BUS_LOCK(bus);
 			}
 		}
@@ -1677,13 +1677,13 @@ usb2_bus_powerd(struct usb_bus *bus)
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_dev_resume_peer
+ *	usb_dev_resume_peer
  *
  * This function will resume an USB peer and do the required USB
  * signalling to get an USB device out of the suspended state.
  *------------------------------------------------------------------------*/
 static void
-usb2_dev_resume_peer(struct usb_device *udev)
+usb_dev_resume_peer(struct usb_device *udev)
 {
 	struct usb_bus *bus;
 	int err;
@@ -1715,17 +1715,17 @@ usb2_dev_resume_peer(struct usb_device *udev)
 	bus = udev->bus;
 
 	/* resume parent hub first */
-	usb2_dev_resume_peer(udev->parent_hub);
+	usb_dev_resume_peer(udev->parent_hub);
 
 	/* resume current port (Valid in Host and Device Mode) */
-	err = usb2_req_clear_port_feature(udev->parent_hub,
+	err = usbd_req_clear_port_feature(udev->parent_hub,
 	    NULL, udev->port_no, UHF_PORT_SUSPEND);
 	if (err) {
 		DPRINTFN(0, "Resuming port failed!\n");
 		return;
 	}
 	/* resume settle time */
-	usb2_pause_mtx(NULL, USB_MS_TO_TICKS(USB_PORT_RESUME_DELAY));
+	usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_PORT_RESUME_DELAY));
 
 	if (bus->methods->device_resume != NULL) {
 		/* resume USB device on the USB controller */
@@ -1756,31 +1756,31 @@ usb2_dev_resume_peer(struct usb_device *udev)
 	}
 	sx_xlock(udev->default_sx + 1);
 	/* notify all sub-devices about resume */
-	err = usb2_suspend_resume(udev, 0);
+	err = usb_suspend_resume(udev, 0);
 	sx_unlock(udev->default_sx + 1);
 
 	/* check if peer has wakeup capability */
-	if (usb2_peer_can_wakeup(udev)) {
+	if (usb_peer_can_wakeup(udev)) {
 		/* clear remote wakeup */
-		err = usb2_req_clear_device_feature(udev,
+		err = usbd_req_clear_device_feature(udev,
 		    NULL, UF_DEVICE_REMOTE_WAKEUP);
 		if (err) {
 			DPRINTFN(0, "Clearing device "
 			    "remote wakeup failed: %s!\n",
-			    usb2_errstr(err));
+			    usbd_errstr(err));
 		}
 	}
 	return;
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dev_suspend_peer
+ *	usb_dev_suspend_peer
  *
  * This function will suspend an USB peer and do the required USB
  * signalling to get an USB device into the suspended state.
  *------------------------------------------------------------------------*/
 static void
-usb2_dev_suspend_peer(struct usb_device *udev)
+usb_dev_suspend_peer(struct usb_device *udev)
 {
 	struct usb_device *child;
 	int err;
@@ -1809,7 +1809,7 @@ repeat:
 		/* check if all devices on the HUB are suspended */
 		for (x = 0; x != nports; x++) {
 
-			child = usb2_bus_port_get_device(udev->bus,
+			child = usb_bus_port_get_device(udev->bus,
 			    udev->hub->ports + x);
 
 			if (child == NULL)
@@ -1825,12 +1825,12 @@ repeat:
 
 	sx_xlock(udev->default_sx + 1);
 	/* notify all sub-devices about suspend */
-	err = usb2_suspend_resume(udev, 1);
+	err = usb_suspend_resume(udev, 1);
 	sx_unlock(udev->default_sx + 1);
 
-	if (usb2_peer_can_wakeup(udev)) {
+	if (usb_peer_can_wakeup(udev)) {
 		/* allow device to do remote wakeup */
-		err = usb2_req_set_device_feature(udev,
+		err = usbd_req_set_device_feature(udev,
 		    NULL, UF_DEVICE_REMOTE_WAKEUP);
 		if (err) {
 			DPRINTFN(0, "Setting device "
@@ -1852,12 +1852,12 @@ repeat:
 		(udev->bus->methods->device_suspend) (udev);
 
 		/* do DMA delay */
-		temp = usb2_get_dma_delay(udev->bus);
-		usb2_pause_mtx(NULL, USB_MS_TO_TICKS(temp));
+		temp = usbd_get_dma_delay(udev->bus);
+		usb_pause_mtx(NULL, USB_MS_TO_TICKS(temp));
 
 	}
 	/* suspend current port */
-	err = usb2_req_set_port_feature(udev->parent_hub,
+	err = usbd_req_set_port_feature(udev->parent_hub,
 	    NULL, udev->port_no, UHF_PORT_SUSPEND);
 	if (err) {
 		DPRINTFN(0, "Suspending port failed\n");
@@ -1869,13 +1869,13 @@ repeat:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_set_power_mode
+ *	usbd_set_power_mode
  *
  * This function will set the power mode, see USB_POWER_MODE_XXX for a
  * USB device.
  *------------------------------------------------------------------------*/
 void
-usb2_set_power_mode(struct usb_device *udev, uint8_t power_mode)
+usbd_set_power_mode(struct usb_device *udev, uint8_t power_mode)
 {
 	/* filter input argument */
 	if ((power_mode != USB_POWER_MODE_ON) &&
@@ -1885,6 +1885,6 @@ usb2_set_power_mode(struct usb_device *udev, uint8_t power_mode)
 	udev->power_mode = power_mode;	/* update copy of power mode */
 
 #if USB_HAVE_POWERD
-	usb2_bus_power_update(udev->bus);
+	usb_bus_power_update(udev->bus);
 #endif
 }
diff --git a/sys/dev/usb/usb_hub.h b/sys/dev/usb/usb_hub.h
index 23db90c..0d69ba6 100644
--- a/sys/dev/usb/usb_hub.h
+++ b/sys/dev/usb/usb_hub.h
@@ -66,17 +66,17 @@ struct usb_hub {
 
 /* function prototypes */
 
-uint8_t	usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len,
+uint8_t	usb_intr_schedule_adjust(struct usb_device *udev, int16_t len,
 	    uint8_t slot);
-void	usb2_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss);
-void	usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up,
+void	usbd_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss);
+void	usb_bus_port_set_device(struct usb_bus *bus, struct usb_port *up,
 	    struct usb_device *udev, uint8_t device_index);
-struct usb_device *usb2_bus_port_get_device(struct usb_bus *bus,
+struct usb_device *usb_bus_port_get_device(struct usb_bus *bus,
 	    struct usb_port *up);
-void	usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe);
-void	usb2_needs_explore_all(void);
-void	usb2_bus_power_update(struct usb_bus *bus);
-void	usb2_bus_powerd(struct usb_bus *bus);
+void	usb_needs_explore(struct usb_bus *bus, uint8_t do_probe);
+void	usb_needs_explore_all(void);
+void	usb_bus_power_update(struct usb_bus *bus);
+void	usb_bus_powerd(struct usb_bus *bus);
 void	uhub_root_intr(struct usb_bus *, const uint8_t *, uint8_t);
 
 #endif					/* _USB2_HUB_H_ */
diff --git a/sys/dev/usb/usb_lookup.c b/sys/dev/usb/usb_lookup.c
index 8cd887d..4950eaf 100644
--- a/sys/dev/usb/usb_lookup.c
+++ b/sys/dev/usb/usb_lookup.c
@@ -28,10 +28,10 @@
 #include <dev/usb/usb_lookup.h>
 
 /*------------------------------------------------------------------------*
- *	usb2_lookup_id_by_info
+ *	usbd_lookup_id_by_info
  *
  * This functions takes an array of "struct usb_device_id" and tries
- * to match the entries with the information in "struct usb_lookup_info".
+ * to match the entries with the information in "struct usbd_lookup_info".
  *
  * NOTE: The "sizeof_id" parameter must be a multiple of the
  * usb_device_id structure size. Else the behaviour of this function
@@ -42,8 +42,8 @@
  * Else: Pointer to matching entry.
  *------------------------------------------------------------------------*/
 const struct usb_device_id *
-usb2_lookup_id_by_info(const struct usb_device_id *id, usb_size_t sizeof_id,
-    const struct usb_lookup_info *info)
+usbd_lookup_id_by_info(const struct usb_device_id *id, usb_size_t sizeof_id,
+    const struct usbd_lookup_info *info)
 {
 	const struct usb_device_id *id_end;
 
@@ -114,17 +114,17 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_lookup_id_by_uaa - factored out code
+ *	usbd_lookup_id_by_uaa - factored out code
  *
  * Return values:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 int
-usb2_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id,
+usbd_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id,
     struct usb_attach_arg *uaa)
 {
-	id = usb2_lookup_id_by_info(id, sizeof_id, &uaa->info);
+	id = usbd_lookup_id_by_info(id, sizeof_id, &uaa->info);
 	if (id) {
 		/* copy driver info */
 		uaa->driver_info = id->driver_info;
diff --git a/sys/dev/usb/usb_lookup.h b/sys/dev/usb/usb_lookup.h
index 759d0b9..63c3fbd 100644
--- a/sys/dev/usb/usb_lookup.h
+++ b/sys/dev/usb/usb_lookup.h
@@ -113,10 +113,10 @@ struct usb_device_id {
 #define	USB_GET_DRIVER_INFO(did)		\
   (did)->driver_info
 
-const struct usb_device_id *usb2_lookup_id_by_info(
+const struct usb_device_id *usbd_lookup_id_by_info(
 	    const struct usb_device_id *id, usb_size_t sizeof_id,
-	    const struct usb_lookup_info *info);
-int	usb2_lookup_id_by_uaa(const struct usb_device_id *id,
+	    const struct usbd_lookup_info *info);
+int	usbd_lookup_id_by_uaa(const struct usb_device_id *id,
 	    usb_size_t sizeof_id, struct usb_attach_arg *uaa);
 
 #endif					/* _USB2_LOOKUP_H_ */
diff --git a/sys/dev/usb/usb_mbuf.c b/sys/dev/usb/usb_mbuf.c
index f57d274..f8ce154 100644
--- a/sys/dev/usb/usb_mbuf.c
+++ b/sys/dev/usb/usb_mbuf.c
@@ -28,14 +28,14 @@
 #include <dev/usb/usb_mbuf.h>
 
 /*------------------------------------------------------------------------*
- *      usb2_alloc_mbufs - allocate mbufs to an usbd interface queue
+ *      usb_alloc_mbufs - allocate mbufs to an usbd interface queue
  *
  * Returns:
  *   A pointer that should be passed to "free()" when the buffer(s)
  *   should be released.
  *------------------------------------------------------------------------*/
 void   *
-usb2_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq,
+usb_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq,
     usb_size_t block_size, uint16_t nblocks)
 {
 	struct usb_mbuf *m_ptr;
diff --git a/sys/dev/usb/usb_mbuf.h b/sys/dev/usb/usb_mbuf.h
index 998f581..8b44519 100644
--- a/sys/dev/usb/usb_mbuf.h
+++ b/sys/dev/usb/usb_mbuf.h
@@ -34,8 +34,8 @@
 struct usb_mbuf {
 	uint8_t *cur_data_ptr;
 	uint8_t *min_data_ptr;
-	struct usb_mbuf *usb2_nextpkt;
-	struct usb_mbuf *usb2_next;
+	struct usb_mbuf *usb_nextpkt;
+	struct usb_mbuf *usb_next;
 
 	usb_size_t cur_data_len;
 	usb_size_t max_data_len;
@@ -56,11 +56,11 @@ struct usb_ifqueue {
 };
 
 #define	USB_IF_ENQUEUE(ifq, m) do {		\
-    (m)->usb2_nextpkt = NULL;			\
+    (m)->usb_nextpkt = NULL;			\
     if ((ifq)->ifq_tail == NULL)		\
         (ifq)->ifq_head = (m);			\
     else					\
-        (ifq)->ifq_tail->usb2_nextpkt = (m);	\
+        (ifq)->ifq_tail->usb_nextpkt = (m);	\
     (ifq)->ifq_tail = (m);			\
     (ifq)->ifq_len++;				\
   } while (0)
@@ -68,16 +68,16 @@ struct usb_ifqueue {
 #define	USB_IF_DEQUEUE(ifq, m) do {				\
     (m) = (ifq)->ifq_head;					\
     if (m) {							\
-        if (((ifq)->ifq_head = (m)->usb2_nextpkt) == NULL) {	\
+        if (((ifq)->ifq_head = (m)->usb_nextpkt) == NULL) {	\
 	     (ifq)->ifq_tail = NULL;				\
 	}							\
-	(m)->usb2_nextpkt = NULL;				\
+	(m)->usb_nextpkt = NULL;				\
 	(ifq)->ifq_len--;					\
     }								\
   } while (0)
 
 #define	USB_IF_PREPEND(ifq, m) do {		\
-      (m)->usb2_nextpkt = (ifq)->ifq_head;	\
+      (m)->usb_nextpkt = (ifq)->ifq_head;	\
       if ((ifq)->ifq_tail == NULL) {		\
 	  (ifq)->ifq_tail = (m);		\
       }						\
@@ -96,7 +96,7 @@ struct usb_ifqueue {
   } while (0)
 
 /* prototypes */
-void   *usb2_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq,
+void   *usb_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq,
 	    usb_size_t block_size, uint16_t nblocks);
 
 #endif					/* _USB2_MBUF_H_ */
diff --git a/sys/dev/usb/usb_msctest.c b/sys/dev/usb/usb_msctest.c
index f8981ac..e813bcc 100644
--- a/sys/dev/usb/usb_msctest.c
+++ b/sys/dev/usb/usb_msctest.c
@@ -36,7 +36,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_busdma.h>
@@ -221,7 +221,7 @@ static void
 bbb_transfer_start(struct bbb_transfer *sc, uint8_t xfer_index)
 {
 	sc->state = xfer_index;
-	usb2_transfer_start(sc->xfer[xfer_index]);
+	usbd_transfer_start(sc->xfer[xfer_index]);
 }
 
 static void
@@ -230,7 +230,7 @@ bbb_data_clear_stall_callback(struct usb_xfer *xfer,
 {
 	struct bbb_transfer *sc = xfer->priv_sc;
 
-	if (usb2_clear_stall_callback(xfer, sc->xfer[stall_xfer])) {
+	if (usbd_clear_stall_callback(xfer, sc->xfer[stall_xfer])) {
 		switch (USB_GET_STATE(xfer)) {
 		case USB_ST_SETUP:
 		case USB_ST_TRANSFERRED:
@@ -272,8 +272,8 @@ bbb_command_callback(struct usb_xfer *xfer)
 		}
 		xfer->frlengths[0] = sizeof(sc->cbw);
 
-		usb2_set_frame_data(xfer, &sc->cbw, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, &sc->cbw, 0);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -312,8 +312,8 @@ bbb_data_read_callback(struct usb_xfer *xfer)
 		xfer->timeout = sc->data_timeout;
 		xfer->frlengths[0] = max_bulk;
 
-		usb2_set_frame_data(xfer, sc->data_ptr, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, sc->data_ptr, 0);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:			/* Error */
@@ -363,8 +363,8 @@ bbb_data_write_callback(struct usb_xfer *xfer)
 		xfer->timeout = sc->data_timeout;
 		xfer->frlengths[0] = max_bulk;
 
-		usb2_set_frame_data(xfer, sc->data_ptr, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, sc->data_ptr, 0);
+		usbd_transfer_submit(xfer);
 		return;
 
 	default:			/* Error */
@@ -407,13 +407,13 @@ bbb_status_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 		xfer->frlengths[0] = sizeof(sc->csw);
 
-		usb2_set_frame_data(xfer, &sc->csw, 0);
-		usb2_start_hardware(xfer);
+		usbd_set_frame_data(xfer, &sc->csw, 0);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:
 		DPRINTFN(0, "Failed to read CSW: %s, try %d\n",
-		    usb2_errstr(xfer->error), sc->status_try);
+		    usbd_errstr(xfer->error), sc->status_try);
 
 		if ((xfer->error == USB_ERR_CANCELLED) ||
 		    (sc->status_try)) {
@@ -447,23 +447,23 @@ bbb_command_start(struct bbb_transfer *sc, uint8_t dir, uint8_t lun,
 	sc->actlen = 0;
 	sc->cmd_len = cmd_len;
 
-	usb2_transfer_start(sc->xfer[sc->state]);
+	usbd_transfer_start(sc->xfer[sc->state]);
 
-	while (usb2_transfer_pending(sc->xfer[sc->state])) {
+	while (usbd_transfer_pending(sc->xfer[sc->state])) {
 		cv_wait(&sc->cv, &sc->mtx);
 	}
 	return (sc->error);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_test_autoinstall
+ *	usb_test_autoinstall
  *
  * Return values:
  * 0: This interface is an auto install disk (CD-ROM)
  * Else: Not an auto install disk.
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_test_autoinstall(struct usb_device *udev, uint8_t iface_index,
+usb_test_autoinstall(struct usb_device *udev, uint8_t iface_index,
     uint8_t do_eject)
 {
 	struct usb_interface *iface;
@@ -476,7 +476,7 @@ usb2_test_autoinstall(struct usb_device *udev, uint8_t iface_index,
 	if (udev == NULL) {
 		return (USB_ERR_INVAL);
 	}
-	iface = usb2_get_iface(udev, iface_index);
+	iface = usbd_get_iface(udev, iface_index);
 	if (iface == NULL) {
 		return (USB_ERR_INVAL);
 	}
@@ -510,7 +510,7 @@ usb2_test_autoinstall(struct usb_device *udev, uint8_t iface_index,
 	mtx_init(&sc->mtx, "USB autoinstall", NULL, MTX_DEF);
 	cv_init(&sc->cv, "WBBB");
 
-	err = usb2_transfer_setup(udev,
+	err = usbd_transfer_setup(udev,
 	    &iface_index, sc->xfer, bbb_config,
 	    ST_MAX, sc, &sc->mtx);
 
@@ -552,13 +552,13 @@ repeat_inquiry:
 				    NULL, 0, 6, USB_MS_HZ);
 
 				DPRINTFN(0, "Eject CD command "
-				    "status: %s\n", usb2_errstr(err));
+				    "status: %s\n", usbd_errstr(err));
 			}
 			err = 0;
 			goto done;
 		}
 	} else if ((err != 2) && --timeout) {
-		usb2_pause_mtx(&sc->mtx, hz);
+		usb_pause_mtx(&sc->mtx, hz);
 		goto repeat_inquiry;
 	}
 	err = USB_ERR_INVAL;
@@ -566,7 +566,7 @@ repeat_inquiry:
 
 done:
 	mtx_unlock(&sc->mtx);
-	usb2_transfer_unsetup(sc->xfer, ST_MAX);
+	usbd_transfer_unsetup(sc->xfer, ST_MAX);
 	mtx_destroy(&sc->mtx);
 	cv_destroy(&sc->cv);
 	free(sc, M_USB);
diff --git a/sys/dev/usb/usb_msctest.h b/sys/dev/usb/usb_msctest.h
index b7ce205..9fca458 100644
--- a/sys/dev/usb/usb_msctest.h
+++ b/sys/dev/usb/usb_msctest.h
@@ -27,7 +27,7 @@
 #ifndef _USB2_MSCTEST_H_
 #define	_USB2_MSCTEST_H_
 
-usb_error_t usb2_test_autoinstall(struct usb_device *udev,
+usb_error_t usb_test_autoinstall(struct usb_device *udev,
 	    uint8_t iface_index, uint8_t do_eject);
 
 #endif					/* _USB2_MSCTEST_H_ */
diff --git a/sys/dev/usb/usb_parse.c b/sys/dev/usb/usb_parse.c
index c6b3cca..aef7b14 100644
--- a/sys/dev/usb/usb_parse.c
+++ b/sys/dev/usb/usb_parse.c
@@ -31,7 +31,7 @@
 #include <dev/usb/usb_parse.h>
 
 /*------------------------------------------------------------------------*
- *	usb2_desc_foreach
+ *	usb_desc_foreach
  *
  * This function is the safe way to iterate across the USB config
  * descriptor. It contains several checks against invalid
@@ -43,7 +43,7 @@
  *   Else: Next descriptor after "desc"
  *------------------------------------------------------------------------*/
 struct usb_descriptor *
-usb2_desc_foreach(struct usb_config_descriptor *cd, 
+usb_desc_foreach(struct usb_config_descriptor *cd, 
     struct usb_descriptor *_desc)
 {
 	uint8_t *desc_next;
@@ -84,7 +84,7 @@ usb2_desc_foreach(struct usb_config_descriptor *cd,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_idesc_foreach
+ *	usb_idesc_foreach
  *
  * This function will iterate the interface descriptors in the config
  * descriptor. The parse state structure should be zeroed before
@@ -95,7 +95,7 @@ usb2_desc_foreach(struct usb_config_descriptor *cd,
  *   Else: A valid interface descriptor
  *------------------------------------------------------------------------*/
 struct usb_interface_descriptor *
-usb2_idesc_foreach(struct usb_config_descriptor *cd,
+usb_idesc_foreach(struct usb_config_descriptor *cd,
     struct usb_idesc_parse_state *ps)
 {
 	struct usb_interface_descriptor *id;
@@ -108,7 +108,7 @@ usb2_idesc_foreach(struct usb_config_descriptor *cd,
 
 	while (1) {
 		id = (struct usb_interface_descriptor *)
-		    usb2_desc_foreach(cd, (struct usb_descriptor *)id);
+		    usb_desc_foreach(cd, (struct usb_descriptor *)id);
 		if (id == NULL)
 			break;
 		if ((id->bDescriptorType == UDESC_INTERFACE) &&
@@ -137,7 +137,7 @@ usb2_idesc_foreach(struct usb_config_descriptor *cd,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_edesc_foreach
+ *	usb_edesc_foreach
  *
  * This function will iterate all the endpoint descriptors within an
  * interface descriptor. Starting value for the "ped" argument should
@@ -148,14 +148,14 @@ usb2_idesc_foreach(struct usb_config_descriptor *cd,
  *   Else: A valid endpoint descriptor
  *------------------------------------------------------------------------*/
 struct usb_endpoint_descriptor *
-usb2_edesc_foreach(struct usb_config_descriptor *cd,
+usb_edesc_foreach(struct usb_config_descriptor *cd,
     struct usb_endpoint_descriptor *ped)
 {
 	struct usb_descriptor *desc;
 
 	desc = ((struct usb_descriptor *)ped);
 
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 		if (desc->bDescriptorType == UDESC_INTERFACE) {
 			break;
 		}
@@ -171,18 +171,18 @@ usb2_edesc_foreach(struct usb_config_descriptor *cd,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_get_no_descriptors
+ *	usbd_get_no_descriptors
  *
  * This function will count the total number of descriptors in the
  * configuration descriptor of type "type".
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_get_no_descriptors(struct usb_config_descriptor *cd, uint8_t type)
+usbd_get_no_descriptors(struct usb_config_descriptor *cd, uint8_t type)
 {
 	struct usb_descriptor *desc = NULL;
 	uint8_t count = 0;
 
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 		if (desc->bDescriptorType == type) {
 			count++;
 			if (count == 0xFF)
@@ -193,13 +193,13 @@ usb2_get_no_descriptors(struct usb_config_descriptor *cd, uint8_t type)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_get_no_alts
+ *	usbd_get_no_alts
  *
  * Return value:
  *   Number of alternate settings for the given interface descriptor pointer.
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_get_no_alts(struct usb_config_descriptor *cd,
+usbd_get_no_alts(struct usb_config_descriptor *cd,
     struct usb_interface_descriptor *id)
 {
 	struct usb_descriptor *desc;
@@ -210,7 +210,7 @@ usb2_get_no_alts(struct usb_config_descriptor *cd,
 
 	desc = (struct usb_descriptor *)id;
 
-	while ((desc = usb2_desc_foreach(cd, desc))) {
+	while ((desc = usb_desc_foreach(cd, desc))) {
 		if ((desc->bDescriptorType == UDESC_INTERFACE) &&
 		    (desc->bLength >= sizeof(*id))) {
 			id = (struct usb_interface_descriptor *)desc;
diff --git a/sys/dev/usb/usb_parse.h b/sys/dev/usb/usb_parse.h
index 4f36618..fc5f683 100644
--- a/sys/dev/usb/usb_parse.h
+++ b/sys/dev/usb/usb_parse.h
@@ -38,17 +38,17 @@ struct usb_idesc_parse_state {
 
 /* prototypes */
 
-struct usb_descriptor *usb2_desc_foreach(struct usb_config_descriptor *cd,
+struct usb_descriptor *usb_desc_foreach(struct usb_config_descriptor *cd,
 	    struct usb_descriptor *desc);
-struct usb_interface_descriptor *usb2_idesc_foreach(
+struct usb_interface_descriptor *usb_idesc_foreach(
 	    struct usb_config_descriptor *cd,
 	    struct usb_idesc_parse_state *ps);
-struct usb_endpoint_descriptor *usb2_edesc_foreach(
+struct usb_endpoint_descriptor *usb_edesc_foreach(
 	    struct usb_config_descriptor *cd,
 	    struct usb_endpoint_descriptor *ped);
-uint8_t usb2_get_no_descriptors(struct usb_config_descriptor *cd,
+uint8_t usbd_get_no_descriptors(struct usb_config_descriptor *cd,
 	    uint8_t type);
-uint8_t usb2_get_no_alts(struct usb_config_descriptor *cd,
+uint8_t usbd_get_no_alts(struct usb_config_descriptor *cd,
 	    struct usb_interface_descriptor *id);
 
 #endif					/* _USB2_PARSE_H_ */
diff --git a/sys/dev/usb/usb_process.c b/sys/dev/usb/usb_process.c
index f36d57c..0732ee05 100644
--- a/sys/dev/usb/usb_process.c
+++ b/sys/dev/usb/usb_process.c
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  */
 
-#define	USB_DEBUG_VAR usb2_proc_debug
+#define	USB_DEBUG_VAR usb_proc_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_process.h>
@@ -53,10 +53,10 @@
 #endif
 
 #if USB_DEBUG
-static int usb2_proc_debug;
+static int usb_proc_debug;
 
 SYSCTL_NODE(_hw_usb, OID_AUTO, proc, CTLFLAG_RW, 0, "USB process");
-SYSCTL_INT(_hw_usb_proc, OID_AUTO, debug, CTLFLAG_RW, &usb2_proc_debug, 0,
+SYSCTL_INT(_hw_usb_proc, OID_AUTO, debug, CTLFLAG_RW, &usb_proc_debug, 0,
     "Debug level");
 #endif
 
@@ -164,7 +164,7 @@ usb_process(void *arg)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_proc_create
+ *	usb_proc_create
  *
  * This function will create a process using the given "prio" that can
  * execute callbacks. The mutex pointed to by "p_mtx" will be applied
@@ -177,7 +177,7 @@ usb_process(void *arg)
  * Else: failure
  *------------------------------------------------------------------------*/
 int
-usb2_proc_create(struct usb_process *up, struct mtx *p_mtx,
+usb_proc_create(struct usb_process *up, struct mtx *p_mtx,
     const char *pmesg, uint8_t prio)
 {
 	up->up_mtx = p_mtx;
@@ -197,12 +197,12 @@ usb2_proc_create(struct usb_process *up, struct mtx *p_mtx,
 	return (0);
 
 error:
-	usb2_proc_free(up);
+	usb_proc_free(up);
 	return (ENOMEM);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_proc_free
+ *	usb_proc_free
  *
  * NOTE: If the structure pointed to by "up" is all zero, this
  * function does nothing.
@@ -211,13 +211,13 @@ error:
  * removed nor called.
  *------------------------------------------------------------------------*/
 void
-usb2_proc_free(struct usb_process *up)
+usb_proc_free(struct usb_process *up)
 {
 	/* check if not initialised */
 	if (up->up_mtx == NULL)
 		return;
 
-	usb2_proc_drain(up);
+	usb_proc_drain(up);
 
 	cv_destroy(&up->up_cv);
 	cv_destroy(&up->up_drain);
@@ -227,7 +227,7 @@ usb2_proc_free(struct usb_process *up)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_proc_msignal
+ *	usb_proc_msignal
  *
  * This function will queue one of the passed USB process messages on
  * the USB process queue. The first message that is not already queued
@@ -238,7 +238,7 @@ usb2_proc_free(struct usb_process *up)
  * at a time. The message that was queued is returned.
  *------------------------------------------------------------------------*/
 void   *
-usb2_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1)
+usb_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1)
 {
 	struct usb_proc_msg *pm0 = _pm0;
 	struct usb_proc_msg *pm1 = _pm1;
@@ -314,14 +314,14 @@ usb2_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_proc_is_gone
+ *	usb_proc_is_gone
  *
  * Return values:
  *    0: USB process is running
  * Else: USB process is tearing down
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_proc_is_gone(struct usb_process *up)
+usb_proc_is_gone(struct usb_process *up)
 {
 	if (up->up_gone)
 		return (1);
@@ -331,14 +331,14 @@ usb2_proc_is_gone(struct usb_process *up)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_proc_mwait
+ *	usb_proc_mwait
  *
  * This function will return when the USB process message pointed to
  * by "pm" is no longer on a queue. This function must be called
  * having "up->up_mtx" locked.
  *------------------------------------------------------------------------*/
 void
-usb2_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1)
+usb_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1)
 {
 	struct usb_proc_msg *pm0 = _pm0;
 	struct usb_proc_msg *pm1 = _pm1;
@@ -371,7 +371,7 @@ usb2_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_proc_drain
+ *	usb_proc_drain
  *
  * This function will tear down an USB process, waiting for the
  * currently executing command to return.
@@ -380,7 +380,7 @@ usb2_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1)
  * this function does nothing.
  *------------------------------------------------------------------------*/
 void
-usb2_proc_drain(struct usb_process *up)
+usb_proc_drain(struct usb_process *up)
 {
 	/* check if not initialised */
 	if (up->up_mtx == NULL)
diff --git a/sys/dev/usb/usb_process.h b/sys/dev/usb/usb_process.h
index b248e9e..86f1536 100644
--- a/sys/dev/usb/usb_process.h
+++ b/sys/dev/usb/usb_process.h
@@ -77,12 +77,12 @@ struct usb_process {
 
 /* prototypes */
 
-uint8_t	usb2_proc_is_gone(struct usb_process *up);
-int	usb2_proc_create(struct usb_process *up, struct mtx *p_mtx,
+uint8_t	usb_proc_is_gone(struct usb_process *up);
+int	usb_proc_create(struct usb_process *up, struct mtx *p_mtx,
 	    const char *pmesg, uint8_t prio);
-void	usb2_proc_drain(struct usb_process *up);
-void	usb2_proc_mwait(struct usb_process *up, void *pm0, void *pm1);
-void	usb2_proc_free(struct usb_process *up);
-void   *usb2_proc_msignal(struct usb_process *up, void *pm0, void *pm1);
+void	usb_proc_drain(struct usb_process *up);
+void	usb_proc_mwait(struct usb_process *up, void *pm0, void *pm1);
+void	usb_proc_free(struct usb_process *up);
+void   *usb_proc_msignal(struct usb_process *up, void *pm0, void *pm1);
 
 #endif					/* _USB2_PROCESS_H_ */
diff --git a/sys/dev/usb/usb_request.c b/sys/dev/usb/usb_request.c
index da694c5..da93b7b 100644
--- a/sys/dev/usb/usb_request.c
+++ b/sys/dev/usb/usb_request.c
@@ -32,7 +32,7 @@
 #include <dev/usb/usb_ioctl.h>
 #include <dev/usb/usbhid.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_busdma.h>
@@ -49,26 +49,26 @@
 #include <sys/ctype.h>
 
 #if USB_DEBUG
-static int usb2_pr_poll_delay = USB_PORT_RESET_DELAY;
-static int usb2_pr_recovery_delay = USB_PORT_RESET_RECOVERY;
-static int usb2_ss_delay = 0;
+static int usb_pr_poll_delay = USB_PORT_RESET_DELAY;
+static int usb_pr_recovery_delay = USB_PORT_RESET_RECOVERY;
+static int usb_ss_delay = 0;
 
 SYSCTL_INT(_hw_usb, OID_AUTO, pr_poll_delay, CTLFLAG_RW,
-    &usb2_pr_poll_delay, 0, "USB port reset poll delay in ms");
+    &usb_pr_poll_delay, 0, "USB port reset poll delay in ms");
 SYSCTL_INT(_hw_usb, OID_AUTO, pr_recovery_delay, CTLFLAG_RW,
-    &usb2_pr_recovery_delay, 0, "USB port reset recovery delay in ms");
+    &usb_pr_recovery_delay, 0, "USB port reset recovery delay in ms");
 SYSCTL_INT(_hw_usb, OID_AUTO, ss_delay, CTLFLAG_RW,
-    &usb2_ss_delay, 0, "USB status stage delay in ms");
+    &usb_ss_delay, 0, "USB status stage delay in ms");
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_do_request_callback
+ *	usbd_do_request_callback
  *
  * This function is the USB callback for generic USB Host control
  * transfers.
  *------------------------------------------------------------------------*/
 void
-usb2_do_request_callback(struct usb_xfer *xfer)
+usbd_do_request_callback(struct usb_xfer *xfer)
 {
 	;				/* workaround for a bug in "indent" */
 
@@ -76,7 +76,7 @@ usb2_do_request_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_SETUP:
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 	default:
 		cv_signal(xfer->xroot->udev->default_cv);
@@ -85,12 +85,12 @@ usb2_do_request_callback(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_do_clear_stall_callback
+ *	usb_do_clear_stall_callback
  *
  * This function is the USB callback for generic clear stall requests.
  *------------------------------------------------------------------------*/
 void
-usb2_do_clear_stall_callback(struct usb_xfer *xfer)
+usb_do_clear_stall_callback(struct usb_xfer *xfer)
 {
 	struct usb_device_request req;
 	struct usb_device *udev;
@@ -119,7 +119,7 @@ usb2_do_clear_stall_callback(struct usb_xfer *xfer)
 			ep->toggle_next = 0;
 			ep->is_stalled = 0;
 			/* start up the current or next transfer, if any */
-			usb2_command_wrapper(&ep->endpoint_q,
+			usb_command_wrapper(&ep->endpoint_q,
 			    ep->endpoint_q.curr);
 		}
 		ep++;
@@ -144,14 +144,14 @@ tr_setup:
 
 			/* copy in the transfer */
 
-			usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+			usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
 
 			/* set length */
 			xfer->frlengths[0] = sizeof(req);
 			xfer->nframes = 1;
 			USB_BUS_UNLOCK(udev->bus);
 
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 
 			USB_BUS_LOCK(udev->bus);
 			break;
@@ -173,11 +173,11 @@ tr_setup:
 }
 
 static usb_handle_req_t *
-usb2_get_hr_func(struct usb_device *udev)
+usbd_get_hr_func(struct usb_device *udev)
 {
 	/* figure out if there is a Handle Request function */
 	if (udev->flags.usb_mode == USB_MODE_DEVICE)
-		return (usb2_temp_get_desc_p);
+		return (usb_temp_get_desc_p);
 	else if (udev->parent_hub == NULL)
 		return (udev->bus->methods->roothub_exec);
 	else
@@ -185,7 +185,7 @@ usb2_get_hr_func(struct usb_device *udev)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_do_request_flags and usb2_do_request
+ *	usbd_do_request_flags and usbd_do_request
  *
  * Description of arguments passed to these functions:
  *
@@ -232,7 +232,7 @@ usb2_get_hr_func(struct usb_device *udev)
  * does not allow control requests without a timeout.
  *
  * NOTE: This function is thread safe. All calls to
- * "usb2_do_request_flags" will be serialised by the use of an
+ * "usbd_do_request_flags" will be serialised by the use of an
  * internal "sx_lock".
  *
  * Returns:
@@ -240,7 +240,7 @@ usb2_get_hr_func(struct usb_device *udev)
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
+usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx,
     struct usb_device_request *req, void *data, uint16_t flags,
     uint16_t *actlen, usb_timeout_t timeout)
 {
@@ -301,7 +301,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 
 	sx_xlock(udev->default_sx);
 
-	hr_func = usb2_get_hr_func(udev);
+	hr_func = usbd_get_hr_func(udev);
 
 	if (hr_func != NULL) {
 		DPRINTF("Handle Request function is set\n");
@@ -354,7 +354,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 	/*
 	 * Setup a new USB transfer or use the existing one, if any:
 	 */
-	usb2_default_transfer_setup(udev);
+	usbd_default_transfer_setup(udev);
 
 	xfer = udev->default_xfer[0];
 	if (xfer == NULL) {
@@ -380,7 +380,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 
 	max_ticks = USB_MS_TO_TICKS(timeout);
 
-	usb2_copy_in(xfer->frbuffers, 0, req, sizeof(*req));
+	usbd_copy_in(xfer->frbuffers, 0, req, sizeof(*req));
 
 	xfer->frlengths[0] = sizeof(*req);
 	xfer->nframes = 2;
@@ -397,7 +397,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 #if USB_HAVE_USER_IO
 				if (flags & USB_USER_DATA_PTR) {
 					USB_XFER_UNLOCK(xfer);
-					err = usb2_copy_in_user(xfer->frbuffers + 1,
+					err = usbd_copy_in_user(xfer->frbuffers + 1,
 					    0, data, temp);
 					USB_XFER_LOCK(xfer);
 					if (err) {
@@ -406,7 +406,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 					}
 				} else
 #endif
-					usb2_copy_in(xfer->frbuffers + 1,
+					usbd_copy_in(xfer->frbuffers + 1,
 					    0, data, temp);
 			}
 			xfer->nframes = 2;
@@ -416,12 +416,12 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 #if USB_DEBUG
 					int temp;
 
-					temp = usb2_ss_delay;
+					temp = usb_ss_delay;
 					if (temp > 5000) {
 						temp = 5000;
 					}
 					if (temp > 0) {
-						usb2_pause_mtx(
+						usb_pause_mtx(
 						    xfer->xroot->xfer_mtx,
 						    USB_MS_TO_TICKS(temp));
 					}
@@ -434,9 +434,9 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 			xfer->nframes = 1;
 		}
 
-		usb2_transfer_start(xfer);
+		usbd_transfer_start(xfer);
 
-		while (usb2_transfer_pending(xfer)) {
+		while (usbd_transfer_pending(xfer)) {
 			cv_wait(udev->default_cv,
 			    xfer->xroot->xfer_mtx);
 		}
@@ -465,7 +465,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 #if USB_HAVE_USER_IO
 				if (flags & USB_USER_DATA_PTR) {
 					USB_XFER_UNLOCK(xfer);
-					err = usb2_copy_out_user(xfer->frbuffers + 1,
+					err = usbd_copy_out_user(xfer->frbuffers + 1,
 					    0, data, temp);
 					USB_XFER_LOCK(xfer);
 					if (err) {
@@ -474,7 +474,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 					}
 				} else
 #endif
-					usb2_copy_out(xfer->frbuffers + 1,
+					usbd_copy_out(xfer->frbuffers + 1,
 					    0, data, temp);
 			}
 		}
@@ -509,7 +509,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 		 * Make sure that the control endpoint is no longer
 		 * blocked in case of a non-transfer related error:
 		 */
-		usb2_transfer_stop(xfer);
+		usbd_transfer_stop(xfer);
 	}
 	USB_XFER_UNLOCK(xfer);
 
@@ -523,17 +523,17 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_do_request_proc - factored out code
+ *	usbd_do_request_proc - factored out code
  *
  * This function is factored out code. It does basically the same like
- * usb2_do_request_flags, except it will check the status of the
+ * usbd_do_request_flags, except it will check the status of the
  * passed process argument before doing the USB request. If the
  * process is draining the USB_ERR_IOERROR code will be returned. It
  * is assumed that the mutex associated with the process is locked
  * when calling this function.
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_do_request_proc(struct usb_device *udev, struct usb_process *pproc,
+usbd_do_request_proc(struct usb_device *udev, struct usb_process *pproc,
     struct usb_device_request *req, void *data, uint16_t flags,
     uint16_t *actlen, usb_timeout_t timeout)
 {
@@ -544,13 +544,13 @@ usb2_do_request_proc(struct usb_device *udev, struct usb_process *pproc,
 	len = UGETW(req->wLength);
 
 	/* check if the device is being detached */
-	if (usb2_proc_is_gone(pproc)) {
+	if (usb_proc_is_gone(pproc)) {
 		err = USB_ERR_IOERROR;
 		goto done;
 	}
 
 	/* forward the USB request */
-	err = usb2_do_request_flags(udev, pproc->up_mtx,
+	err = usbd_do_request_flags(udev, pproc->up_mtx,
 	    req, data, flags, actlen, timeout);
 
 done:
@@ -566,7 +566,7 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_reset_port
+ *	usbd_req_reset_port
  *
  * This function will instruct an USB HUB to perform a reset sequence
  * on the specified port number.
@@ -577,7 +577,7 @@ done:
  *       disabled.
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port)
+usbd_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port)
 {
 	struct usb_port_status ps;
 	usb_error_t err;
@@ -588,19 +588,19 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port)
 	uint16_t pr_recovery_delay;
 
 #endif
-	err = usb2_req_set_port_feature(udev, mtx, port, UHF_PORT_RESET);
+	err = usbd_req_set_port_feature(udev, mtx, port, UHF_PORT_RESET);
 	if (err) {
 		goto done;
 	}
 #if USB_DEBUG
 	/* range check input parameters */
-	pr_poll_delay = usb2_pr_poll_delay;
+	pr_poll_delay = usb_pr_poll_delay;
 	if (pr_poll_delay < 1) {
 		pr_poll_delay = 1;
 	} else if (pr_poll_delay > 1000) {
 		pr_poll_delay = 1000;
 	}
-	pr_recovery_delay = usb2_pr_recovery_delay;
+	pr_recovery_delay = usb_pr_recovery_delay;
 	if (pr_recovery_delay > 1000) {
 		pr_recovery_delay = 1000;
 	}
@@ -609,14 +609,14 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port)
 	while (1) {
 #if USB_DEBUG
 		/* wait for the device to recover from reset */
-		usb2_pause_mtx(mtx, USB_MS_TO_TICKS(pr_poll_delay));
+		usb_pause_mtx(mtx, USB_MS_TO_TICKS(pr_poll_delay));
 		n += pr_poll_delay;
 #else
 		/* wait for the device to recover from reset */
-		usb2_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY));
+		usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY));
 		n += USB_PORT_RESET_DELAY;
 #endif
-		err = usb2_req_get_port_status(udev, mtx, &ps, port);
+		err = usbd_req_get_port_status(udev, mtx, &ps, port);
 		if (err) {
 			goto done;
 		}
@@ -636,7 +636,7 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port)
 	}
 
 	/* clear port reset first */
-	err = usb2_req_clear_port_feature(
+	err = usbd_req_clear_port_feature(
 	    udev, mtx, port, UHF_C_PORT_RESET);
 	if (err) {
 		goto done;
@@ -648,20 +648,20 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port)
 	}
 #if USB_DEBUG
 	/* wait for the device to recover from reset */
-	usb2_pause_mtx(mtx, USB_MS_TO_TICKS(pr_recovery_delay));
+	usb_pause_mtx(mtx, USB_MS_TO_TICKS(pr_recovery_delay));
 #else
 	/* wait for the device to recover from reset */
-	usb2_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_RECOVERY));
+	usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_RECOVERY));
 #endif
 
 done:
 	DPRINTFN(2, "port %d reset returning error=%s\n",
-	    port, usb2_errstr(err));
+	    port, usbd_errstr(err));
 	return (err);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_desc
+ *	usbd_req_get_desc
  *
  * This function can be used to retrieve USB descriptors. It contains
  * some additional logic like zeroing of missing descriptor bytes and
@@ -685,7 +685,7 @@ done:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_desc(struct usb_device *udev,
+usbd_req_get_desc(struct usb_device *udev,
     struct mtx *mtx, uint16_t *actlen, void *desc,
     uint16_t min_len, uint16_t max_len,
     uint16_t id, uint8_t type, uint8_t index,
@@ -711,7 +711,7 @@ usb2_req_get_desc(struct usb_device *udev,
 		}
 		USETW(req.wLength, min_len);
 
-		err = usb2_do_request_flags(udev, mtx, &req,
+		err = usbd_do_request_flags(udev, mtx, &req,
 		    desc, 0, NULL, 1000);
 
 		if (err) {
@@ -720,7 +720,7 @@ usb2_req_get_desc(struct usb_device *udev,
 			}
 			retries--;
 
-			usb2_pause_mtx(mtx, hz / 5);
+			usb_pause_mtx(mtx, hz / 5);
 
 			continue;
 		}
@@ -764,7 +764,7 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_string_any
+ *	usbd_req_get_string_any
  *
  * This function will return the string given by "string_index"
  * using the first language ID. The maximum length "len" includes
@@ -776,7 +776,7 @@ done:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf,
+usbd_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf,
     uint16_t len, uint8_t string_index)
 {
 	char *s;
@@ -800,7 +800,7 @@ usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf,
 		buf[0] = 0;
 		return (USB_ERR_STALLED);
 	}
-	err = usb2_req_get_string_desc
+	err = usbd_req_get_string_desc
 	    (udev, mtx, buf, len, udev->langid, string_index);
 	if (err) {
 		buf[0] = 0;
@@ -861,26 +861,26 @@ usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_string_desc
+ *	usbd_req_get_string_desc
  *
  * If you don't know the language ID, consider using
- * "usb2_req_get_string_any()".
+ * "usbd_req_get_string_any()".
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_string_desc(struct usb_device *udev, struct mtx *mtx, void *sdesc,
+usbd_req_get_string_desc(struct usb_device *udev, struct mtx *mtx, void *sdesc,
     uint16_t max_len, uint16_t lang_id,
     uint8_t string_index)
 {
-	return (usb2_req_get_desc(udev, mtx, NULL, sdesc, 2, max_len, lang_id,
+	return (usbd_req_get_desc(udev, mtx, NULL, sdesc, 2, max_len, lang_id,
 	    UDESC_STRING, string_index, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_config_desc_ptr
+ *	usbd_req_get_config_desc_ptr
  *
  * This function is used in device side mode to retrieve the pointer
  * to the generated config descriptor. This saves allocating space for
@@ -891,7 +891,7 @@ usb2_req_get_string_desc(struct usb_device *udev, struct mtx *mtx, void *sdesc,
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_descriptor_ptr(struct usb_device *udev,
+usbd_req_get_descriptor_ptr(struct usb_device *udev,
     struct usb_config_descriptor **ppcd, uint16_t wValue)
 {
 	struct usb_device_request req;
@@ -909,7 +909,7 @@ usb2_req_get_descriptor_ptr(struct usb_device *udev,
 	ptr = NULL;
 	len = 0;
 
-	hr_func = usb2_get_hr_func(udev);
+	hr_func = usbd_get_hr_func(udev);
 
 	if (hr_func == NULL)
 		err = USB_ERR_INVAL;
@@ -930,21 +930,21 @@ usb2_req_get_descriptor_ptr(struct usb_device *udev,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_config_desc
+ *	usbd_req_get_config_desc
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_config_desc(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_config_desc(struct usb_device *udev, struct mtx *mtx,
     struct usb_config_descriptor *d, uint8_t conf_index)
 {
 	usb_error_t err;
 
 	DPRINTFN(4, "confidx=%d\n", conf_index);
 
-	err = usb2_req_get_desc(udev, mtx, NULL, d, sizeof(*d),
+	err = usbd_req_get_desc(udev, mtx, NULL, d, sizeof(*d),
 	    sizeof(*d), 0, UDESC_CONFIG, conf_index, 0);
 	if (err) {
 		goto done;
@@ -958,7 +958,7 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_config_desc_full
+ *	usbd_req_get_config_desc_full
  *
  * This function gets the complete USB configuration descriptor and
  * ensures that "wTotalLength" is correct.
@@ -968,7 +968,7 @@ done:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx,
     struct usb_config_descriptor **ppcd, struct malloc_type *mtype,
     uint8_t index)
 {
@@ -981,7 +981,7 @@ usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx,
 
 	*ppcd = NULL;
 
-	err = usb2_req_get_config_desc(udev, mtx, &cd, index);
+	err = usbd_req_get_config_desc(udev, mtx, &cd, index);
 	if (err) {
 		return (err);
 	}
@@ -995,7 +995,7 @@ usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx,
 	if (cdesc == NULL) {
 		return (USB_ERR_NOMEM);
 	}
-	err = usb2_req_get_desc(udev, mtx, NULL, cdesc, len, len, 0,
+	err = usbd_req_get_desc(udev, mtx, NULL, cdesc, len, len, 0,
 	    UDESC_CONFIG, index, 3);
 	if (err) {
 		free(cdesc, mtype);
@@ -1010,33 +1010,33 @@ usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_device_desc
+ *	usbd_req_get_device_desc
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_device_desc(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_device_desc(struct usb_device *udev, struct mtx *mtx,
     struct usb_device_descriptor *d)
 {
 	DPRINTFN(4, "\n");
-	return (usb2_req_get_desc(udev, mtx, NULL, d, sizeof(*d),
+	return (usbd_req_get_desc(udev, mtx, NULL, d, sizeof(*d),
 	    sizeof(*d), 0, UDESC_DEVICE, 0, 3));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_alt_interface_no
+ *	usbd_req_get_alt_interface_no
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx,
     uint8_t *alt_iface_no, uint8_t iface_index)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_device_request req;
 
 	if ((iface == NULL) || (iface->idesc == NULL)) {
@@ -1048,21 +1048,21 @@ usb2_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = iface->idesc->bInterfaceNumber;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 1);
-	return (usb2_do_request(udev, mtx, &req, alt_iface_no));
+	return (usbd_do_request(udev, mtx, &req, alt_iface_no));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_alt_interface_no
+ *	usbd_req_set_alt_interface_no
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx,
+usbd_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx,
     uint8_t iface_index, uint8_t alt_no)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_device_request req;
 
 	if ((iface == NULL) || (iface->idesc == NULL)) {
@@ -1075,18 +1075,18 @@ usb2_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = iface->idesc->bInterfaceNumber;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_device_status
+ *	usbd_req_get_device_status
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_device_status(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_device_status(struct usb_device *udev, struct mtx *mtx,
     struct usb_status *st)
 {
 	struct usb_device_request req;
@@ -1096,18 +1096,18 @@ usb2_req_get_device_status(struct usb_device *udev, struct mtx *mtx,
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, sizeof(*st));
-	return (usb2_do_request(udev, mtx, &req, st));
+	return (usbd_do_request(udev, mtx, &req, st));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_hub_descriptor
+ *	usbd_req_get_hub_descriptor
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx,
     struct usb_hub_descriptor *hd, uint8_t nports)
 {
 	struct usb_device_request req;
@@ -1118,18 +1118,18 @@ usb2_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx,
 	USETW2(req.wValue, UDESC_HUB, 0);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, len);
-	return (usb2_do_request(udev, mtx, &req, hd));
+	return (usbd_do_request(udev, mtx, &req, hd));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_hub_status
+ *	usbd_req_get_hub_status
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_hub_status(struct usb_device *udev, struct mtx *mtx,
     struct usb_hub_status *st)
 {
 	struct usb_device_request req;
@@ -1139,11 +1139,11 @@ usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx,
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, sizeof(struct usb_hub_status));
-	return (usb2_do_request(udev, mtx, &req, st));
+	return (usbd_do_request(udev, mtx, &req, st));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_address
+ *	usbd_req_set_address
  *
  * This function is used to set the address for an USB device. After
  * port reset the USB device will respond at address zero.
@@ -1153,7 +1153,7 @@ usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx,
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr)
+usbd_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr)
 {
 	struct usb_device_request req;
 
@@ -1166,19 +1166,19 @@ usb2_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr)
 	USETW(req.wLength, 0);
 
 	/* Setting the address should not take more than 1 second ! */
-	return (usb2_do_request_flags(udev, mtx, &req, NULL,
+	return (usbd_do_request_flags(udev, mtx, &req, NULL,
 	    USB_DELAY_STATUS_STAGE, NULL, 1000));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_port_status
+ *	usbd_req_get_port_status
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_port_status(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_port_status(struct usb_device *udev, struct mtx *mtx,
     struct usb_port_status *ps, uint8_t port)
 {
 	struct usb_device_request req;
@@ -1189,18 +1189,18 @@ usb2_req_get_port_status(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = port;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, sizeof *ps);
-	return (usb2_do_request(udev, mtx, &req, ps));
+	return (usbd_do_request(udev, mtx, &req, ps));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_clear_hub_feature
+ *	usbd_req_clear_hub_feature
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx,
+usbd_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx,
     uint16_t sel)
 {
 	struct usb_device_request req;
@@ -1210,18 +1210,18 @@ usb2_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx,
 	USETW(req.wValue, sel);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_hub_feature
+ *	usbd_req_set_hub_feature
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx,
+usbd_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx,
     uint16_t sel)
 {
 	struct usb_device_request req;
@@ -1231,18 +1231,18 @@ usb2_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx,
 	USETW(req.wValue, sel);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_clear_port_feature
+ *	usbd_req_clear_port_feature
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx,
+usbd_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx,
     uint8_t port, uint16_t sel)
 {
 	struct usb_device_request req;
@@ -1253,18 +1253,18 @@ usb2_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = port;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_port_feature
+ *	usbd_req_set_port_feature
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_port_feature(struct usb_device *udev, struct mtx *mtx,
+usbd_req_set_port_feature(struct usb_device *udev, struct mtx *mtx,
     uint8_t port, uint16_t sel)
 {
 	struct usb_device_request req;
@@ -1275,21 +1275,21 @@ usb2_req_set_port_feature(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = port;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_protocol
+ *	usbd_req_set_protocol
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_protocol(struct usb_device *udev, struct mtx *mtx,
+usbd_req_set_protocol(struct usb_device *udev, struct mtx *mtx,
     uint8_t iface_index, uint16_t report)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_device_request req;
 
 	if ((iface == NULL) || (iface->idesc == NULL)) {
@@ -1304,21 +1304,21 @@ usb2_req_set_protocol(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = iface->idesc->bInterfaceNumber;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_report
+ *	usbd_req_set_report
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_report(struct usb_device *udev, struct mtx *mtx, void *data, uint16_t len,
+usbd_req_set_report(struct usb_device *udev, struct mtx *mtx, void *data, uint16_t len,
     uint8_t iface_index, uint8_t type, uint8_t id)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_device_request req;
 
 	if ((iface == NULL) || (iface->idesc == NULL)) {
@@ -1332,21 +1332,21 @@ usb2_req_set_report(struct usb_device *udev, struct mtx *mtx, void *data, uint16
 	req.wIndex[0] = iface->idesc->bInterfaceNumber;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, len);
-	return (usb2_do_request(udev, mtx, &req, data));
+	return (usbd_do_request(udev, mtx, &req, data));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_report
+ *	usbd_req_get_report
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_report(struct usb_device *udev, struct mtx *mtx, void *data,
+usbd_req_get_report(struct usb_device *udev, struct mtx *mtx, void *data,
     uint16_t len, uint8_t iface_index, uint8_t type, uint8_t id)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_device_request req;
 
 	if ((iface == NULL) || (iface->idesc == NULL) || (id == 0)) {
@@ -1360,21 +1360,21 @@ usb2_req_get_report(struct usb_device *udev, struct mtx *mtx, void *data,
 	req.wIndex[0] = iface->idesc->bInterfaceNumber;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, len);
-	return (usb2_do_request(udev, mtx, &req, data));
+	return (usbd_do_request(udev, mtx, &req, data));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_idle
+ *	usbd_req_set_idle
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_idle(struct usb_device *udev, struct mtx *mtx,
+usbd_req_set_idle(struct usb_device *udev, struct mtx *mtx,
     uint8_t iface_index, uint8_t duration, uint8_t id)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_device_request req;
 
 	if ((iface == NULL) || (iface->idesc == NULL)) {
@@ -1388,21 +1388,21 @@ usb2_req_set_idle(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = iface->idesc->bInterfaceNumber;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_report_descriptor
+ *	usbd_req_get_report_descriptor
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx,
+usbd_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx,
     void *d, uint16_t size, uint8_t iface_index)
 {
-	struct usb_interface *iface = usb2_get_iface(udev, iface_index);
+	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
 	struct usb_device_request req;
 
 	if ((iface == NULL) || (iface->idesc == NULL)) {
@@ -1414,11 +1414,11 @@ usb2_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx,
 	req.wIndex[0] = iface->idesc->bInterfaceNumber;
 	req.wIndex[1] = 0;
 	USETW(req.wLength, size);
-	return (usb2_do_request(udev, mtx, &req, d));
+	return (usbd_do_request(udev, mtx, &req, d));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_config
+ *	usbd_req_set_config
  *
  * This function is used to select the current configuration number in
  * both USB device side mode and USB host side mode. When setting the
@@ -1429,7 +1429,7 @@ usb2_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx,
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf)
+usbd_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf)
 {
 	struct usb_device_request req;
 
@@ -1443,18 +1443,18 @@ usb2_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf)
 	req.wValue[1] = 0;
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_get_config
+ *	usbd_req_get_config
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf)
+usbd_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf)
 {
 	struct usb_device_request req;
 
@@ -1463,11 +1463,11 @@ usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf)
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 1);
-	return (usb2_do_request(udev, mtx, &req, pconf));
+	return (usbd_do_request(udev, mtx, &req, pconf));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_re_enumerate
+ *	usbd_req_re_enumerate
  *
  * NOTE: After this function returns the hardware is in the
  * unconfigured state! The application is responsible for setting a
@@ -1478,7 +1478,7 @@ usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf)
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_re_enumerate(struct usb_device *udev, struct mtx *mtx)
+usbd_req_re_enumerate(struct usb_device *udev, struct mtx *mtx)
 {
 	struct usb_device *parent_hub;
 	usb_error_t err;
@@ -1494,10 +1494,10 @@ usb2_req_re_enumerate(struct usb_device *udev, struct mtx *mtx)
 		return (USB_ERR_INVAL);
 	}
 retry:
-	err = usb2_req_reset_port(parent_hub, mtx, udev->port_no);
+	err = usbd_req_reset_port(parent_hub, mtx, udev->port_no);
 	if (err) {
 		DPRINTFN(0, "addr=%d, port reset failed, %s\n", 
-		    old_addr, usb2_errstr(err));
+		    old_addr, usbd_errstr(err));
 		goto done;
 	}
 	/*
@@ -1512,39 +1512,39 @@ retry:
 	/*
 	 * Restore device address:
 	 */
-	err = usb2_req_set_address(udev, mtx, old_addr);
+	err = usbd_req_set_address(udev, mtx, old_addr);
 	if (err) {
 		/* XXX ignore any errors! */
 		DPRINTFN(0, "addr=%d, set address failed! (%s, ignored)\n",
-		    old_addr, usb2_errstr(err));
+		    old_addr, usbd_errstr(err));
 	}
 	/* restore device address */
 	udev->address = old_addr;
 
 	/* allow device time to set new address */
-	usb2_pause_mtx(mtx, USB_MS_TO_TICKS(USB_SET_ADDRESS_SETTLE));
+	usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_SET_ADDRESS_SETTLE));
 
 	/* get the device descriptor */
-	err = usb2_req_get_desc(udev, mtx, NULL, &udev->ddesc,
+	err = usbd_req_get_desc(udev, mtx, NULL, &udev->ddesc,
 	    USB_MAX_IPACKET, USB_MAX_IPACKET, 0, UDESC_DEVICE, 0, 0);
 	if (err) {
 		DPRINTFN(0, "getting device descriptor "
 		    "at addr %d failed, %s!\n", udev->address,
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		goto done;
 	}
 	/* get the full device descriptor */
-	err = usb2_req_get_device_desc(udev, mtx, &udev->ddesc);
+	err = usbd_req_get_device_desc(udev, mtx, &udev->ddesc);
 	if (err) {
 		DPRINTFN(0, "addr=%d, getting device "
 		    "descriptor failed, %s!\n", old_addr, 
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		goto done;
 	}
 done:
 	if (err && do_retry) {
 		/* give the USB firmware some time to load */
-		usb2_pause_mtx(mtx, hz / 2);
+		usb_pause_mtx(mtx, hz / 2);
 		/* no more retries after this retry */
 		do_retry = 0;
 		/* try again */
@@ -1556,14 +1556,14 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_clear_device_feature
+ *	usbd_req_clear_device_feature
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx,
+usbd_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx,
     uint16_t sel)
 {
 	struct usb_device_request req;
@@ -1573,18 +1573,18 @@ usb2_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx,
 	USETW(req.wValue, sel);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_req_set_device_feature
+ *	usbd_req_set_device_feature
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_req_set_device_feature(struct usb_device *udev, struct mtx *mtx,
+usbd_req_set_device_feature(struct usb_device *udev, struct mtx *mtx,
     uint16_t sel)
 {
 	struct usb_device_request req;
@@ -1594,5 +1594,5 @@ usb2_req_set_device_feature(struct usb_device *udev, struct mtx *mtx,
 	USETW(req.wValue, sel);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, 0);
-	return (usb2_do_request(udev, mtx, &req, 0));
+	return (usbd_do_request(udev, mtx, &req, 0));
 }
diff --git a/sys/dev/usb/usb_request.h b/sys/dev/usb/usb_request.h
index f6e6416..b02f345 100644
--- a/sys/dev/usb/usb_request.h
+++ b/sys/dev/usb/usb_request.h
@@ -29,78 +29,78 @@
 
 struct usb_process;
 
-usb_error_t usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx,
 		    struct usb_device_request *req, void *data, uint16_t flags,
 		    uint16_t *actlen, usb_timeout_t timeout);
-usb_error_t usb2_do_request_proc(struct usb_device *udev, struct usb_process *pproc,
+usb_error_t usbd_do_request_proc(struct usb_device *udev, struct usb_process *pproc,
 		    struct usb_device_request *req, void *data, uint16_t flags,
 		    uint16_t *actlen, usb_timeout_t timeout);
-usb_error_t usb2_req_clear_hub_feature(struct usb_device *udev,
+usb_error_t usbd_req_clear_hub_feature(struct usb_device *udev,
 		    struct mtx *mtx, uint16_t sel);
-usb_error_t usb2_req_clear_port_feature(struct usb_device *udev,
+usb_error_t usbd_req_clear_port_feature(struct usb_device *udev,
 		    struct mtx *mtx, uint8_t port, uint16_t sel);
-usb_error_t usb2_req_get_alt_interface_no(struct usb_device *udev,
+usb_error_t usbd_req_get_alt_interface_no(struct usb_device *udev,
 		    struct mtx *mtx, uint8_t *alt_iface_no,
 		    uint8_t iface_index);
-usb_error_t usb2_req_get_config(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_config(struct usb_device *udev, struct mtx *mtx,
 		    uint8_t *pconf);
-usb_error_t usb2_req_get_descriptor_ptr(struct usb_device *udev,
+usb_error_t usbd_req_get_descriptor_ptr(struct usb_device *udev,
 		    struct usb_config_descriptor **ppcd, uint16_t wValue);
-usb_error_t usb2_req_get_config_desc(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_config_desc(struct usb_device *udev, struct mtx *mtx,
 		    struct usb_config_descriptor *d, uint8_t conf_index);
-usb_error_t usb2_req_get_config_desc_full(struct usb_device *udev,
+usb_error_t usbd_req_get_config_desc_full(struct usb_device *udev,
 		    struct mtx *mtx, struct usb_config_descriptor **ppcd,
 		    struct malloc_type *mtype, uint8_t conf_index);
-usb_error_t usb2_req_get_desc(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_desc(struct usb_device *udev, struct mtx *mtx,
 		    uint16_t *actlen, void *desc, uint16_t min_len,
 		    uint16_t max_len, uint16_t id, uint8_t type,
 		    uint8_t index, uint8_t retries);
-usb_error_t usb2_req_get_device_desc(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_device_desc(struct usb_device *udev, struct mtx *mtx,
 		    struct usb_device_descriptor *d);
-usb_error_t usb2_req_get_device_status(struct usb_device *udev,
+usb_error_t usbd_req_get_device_status(struct usb_device *udev,
 		    struct mtx *mtx, struct usb_status *st);
-usb_error_t usb2_req_get_hub_descriptor(struct usb_device *udev,
+usb_error_t usbd_req_get_hub_descriptor(struct usb_device *udev,
 		    struct mtx *mtx, struct usb_hub_descriptor *hd,
 		    uint8_t nports);
-usb_error_t usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_hub_status(struct usb_device *udev, struct mtx *mtx,
 		    struct usb_hub_status *st);
-usb_error_t usb2_req_get_port_status(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_port_status(struct usb_device *udev, struct mtx *mtx,
 		    struct usb_port_status *ps, uint8_t port);
-usb_error_t usb2_req_get_report(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_report(struct usb_device *udev, struct mtx *mtx,
 		    void *data, uint16_t len, uint8_t iface_index, uint8_t type,
 		    uint8_t id);
-usb_error_t usb2_req_get_report_descriptor(struct usb_device *udev,
+usb_error_t usbd_req_get_report_descriptor(struct usb_device *udev,
 		    struct mtx *mtx, void *d, uint16_t size,
 		    uint8_t iface_index);
-usb_error_t usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_string_any(struct usb_device *udev, struct mtx *mtx,
 		    char *buf, uint16_t len, uint8_t string_index);
-usb_error_t usb2_req_get_string_desc(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_get_string_desc(struct usb_device *udev, struct mtx *mtx,
 		    void *sdesc, uint16_t max_len, uint16_t lang_id,
 		    uint8_t string_index);
-usb_error_t usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_reset_port(struct usb_device *udev, struct mtx *mtx,
 		    uint8_t port);
-usb_error_t usb2_req_set_address(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_set_address(struct usb_device *udev, struct mtx *mtx,
 		    uint16_t addr);
-usb_error_t usb2_req_set_alt_interface_no(struct usb_device *udev,
+usb_error_t usbd_req_set_alt_interface_no(struct usb_device *udev,
 		    struct mtx *mtx, uint8_t iface_index, uint8_t alt_no);
-usb_error_t usb2_req_set_config(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_set_config(struct usb_device *udev, struct mtx *mtx,
 		    uint8_t conf);
-usb_error_t usb2_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx,
 		    uint16_t sel);
-usb_error_t usb2_req_set_idle(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_set_idle(struct usb_device *udev, struct mtx *mtx,
 		    uint8_t iface_index, uint8_t duration, uint8_t id);
-usb_error_t usb2_req_set_port_feature(struct usb_device *udev,
+usb_error_t usbd_req_set_port_feature(struct usb_device *udev,
 		    struct mtx *mtx, uint8_t port, uint16_t sel);
-usb_error_t usb2_req_set_protocol(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_set_protocol(struct usb_device *udev, struct mtx *mtx,
 		    uint8_t iface_index, uint16_t report);
-usb_error_t usb2_req_set_report(struct usb_device *udev, struct mtx *mtx,
+usb_error_t usbd_req_set_report(struct usb_device *udev, struct mtx *mtx,
 		    void *data, uint16_t len, uint8_t iface_index,
 		    uint8_t type, uint8_t id);
-usb_error_t usb2_req_re_enumerate(struct usb_device *udev, struct mtx *mtx);
-usb_error_t usb2_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel);
-usb_error_t usb2_req_set_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel);
+usb_error_t usbd_req_re_enumerate(struct usb_device *udev, struct mtx *mtx);
+usb_error_t usbd_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel);
+usb_error_t usbd_req_set_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel);
 
-#define	usb2_do_request(u,m,r,d) \
-  usb2_do_request_flags(u,m,r,d,0,NULL,USB_DEFAULT_TIMEOUT)
+#define	usbd_do_request(u,m,r,d) \
+  usbd_do_request_flags(u,m,r,d,0,NULL,USB_DEFAULT_TIMEOUT)
 
 #endif					/* _USB2_REQUEST_H_ */
diff --git a/sys/dev/usb/usb_transfer.c b/sys/dev/usb/usb_transfer.c
index f258314..bad72d4 100644
--- a/sys/dev/usb/usb_transfer.c
+++ b/sys/dev/usb/usb_transfer.c
@@ -28,7 +28,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_busdma.h>
@@ -41,7 +41,7 @@
 #include <dev/usb/usb_controller.h>
 #include <dev/usb/usb_bus.h>
 
-struct usb2_std_packet_size {
+struct usb_std_packet_size {
 	struct {
 		uint16_t min;		/* inclusive */
 		uint16_t max;		/* inclusive */
@@ -50,9 +50,9 @@ struct usb2_std_packet_size {
 	uint16_t fixed[4];
 };
 
-static usb_callback_t usb2_request_callback;
+static usb_callback_t usb_request_callback;
 
-static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
+static const struct usb_config usb_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
 
 	/* This transfer is used for generic control endpoint transfers */
 
@@ -62,7 +62,7 @@ static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
 		.direction = UE_DIR_ANY,
 		.bufsize = USB_EP0_BUFSIZE,	/* bytes */
 		.flags = {.proxy_buffer = 1,},
-		.callback = &usb2_request_callback,
+		.callback = &usb_request_callback,
 		.usb_mode = USB_MODE_DUAL,	/* both modes */
 	},
 
@@ -73,7 +73,7 @@ static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
 		.bufsize = sizeof(struct usb_device_request),
-		.callback = &usb2_do_clear_stall_callback,
+		.callback = &usb_do_clear_stall_callback,
 		.timeout = 1000,	/* 1 second */
 		.interval = 50,	/* 50ms */
 		.usb_mode = USB_MODE_HOST,
@@ -82,39 +82,39 @@ static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
 
 /* function prototypes */
 
-static void	usb2_update_max_frame_size(struct usb_xfer *);
-static void	usb2_transfer_unsetup_sub(struct usb_xfer_root *, uint8_t);
-static void	usb2_control_transfer_init(struct usb_xfer *);
-static uint8_t	usb2_start_hardware_sub(struct usb_xfer *);
-static void	usb2_callback_proc(struct usb_proc_msg *);
-static void	usb2_callback_ss_done_defer(struct usb_xfer *);
-static void	usb2_callback_wrapper(struct usb_xfer_queue *);
-static void	usb2_dma_delay_done_cb(void *);
-static void	usb2_transfer_start_cb(void *);
-static uint8_t	usb2_callback_wrapper_sub(struct usb_xfer *);
-static void	usb2_get_std_packet_size(struct usb2_std_packet_size *ptr, 
+static void	usbd_update_max_frame_size(struct usb_xfer *);
+static void	usbd_transfer_unsetup_sub(struct usb_xfer_root *, uint8_t);
+static void	usbd_control_transfer_init(struct usb_xfer *);
+static uint8_t	usbd_start_hardware_sub(struct usb_xfer *);
+static void	usb_callback_proc(struct usb_proc_msg *);
+static void	usbd_callback_ss_done_defer(struct usb_xfer *);
+static void	usbd_callback_wrapper(struct usb_xfer_queue *);
+static void	usb_dma_delay_done_cb(void *);
+static void	usbd_transfer_start_cb(void *);
+static uint8_t	usbd_callback_wrapper_sub(struct usb_xfer *);
+static void	usbd_get_std_packet_size(struct usb_std_packet_size *ptr, 
 		    uint8_t type, enum usb_dev_speed speed);
 
 /*------------------------------------------------------------------------*
- *	usb2_request_callback
+ *	usb_request_callback
  *------------------------------------------------------------------------*/
 static void
-usb2_request_callback(struct usb_xfer *xfer)
+usb_request_callback(struct usb_xfer *xfer)
 {
 	if (xfer->flags_int.usb_mode == USB_MODE_DEVICE)
-		usb2_handle_request_callback(xfer);
+		usb_handle_request_callback(xfer);
 	else
-		usb2_do_request_callback(xfer);
+		usbd_do_request_callback(xfer);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_update_max_frame_size
+ *	usbd_update_max_frame_size
  *
  * This function updates the maximum frame size, hence high speed USB
  * can transfer multiple consecutive packets.
  *------------------------------------------------------------------------*/
 static void
-usb2_update_max_frame_size(struct usb_xfer *xfer)
+usbd_update_max_frame_size(struct usb_xfer *xfer)
 {
 	/* compute maximum frame size */
 
@@ -128,7 +128,7 @@ usb2_update_max_frame_size(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_get_dma_delay
+ *	usbd_get_dma_delay
  *
  * The following function is called when we need to
  * synchronize with DMA hardware.
@@ -138,7 +138,7 @@ usb2_update_max_frame_size(struct usb_xfer *xfer)
  * Else: milliseconds of DMA delay
  *------------------------------------------------------------------------*/
 usb_timeout_t
-usb2_get_dma_delay(struct usb_bus *bus)
+usbd_get_dma_delay(struct usb_bus *bus)
 {
 	uint32_t temp = 0;
 
@@ -155,7 +155,7 @@ usb2_get_dma_delay(struct usb_bus *bus)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_setup_sub_malloc
+ *	usbd_transfer_setup_sub_malloc
  *
  * This function will allocate one or more DMA'able memory chunks
  * according to "size", "align" and "count" arguments. "ppc" is
@@ -167,7 +167,7 @@ usb2_get_dma_delay(struct usb_bus *bus)
  *------------------------------------------------------------------------*/
 #if USB_HAVE_BUSDMA
 uint8_t
-usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,
+usbd_transfer_setup_sub_malloc(struct usb_setup_params *parm,
     struct usb_page_cache **ppc, usb_size_t size, usb_size_t align,
     usb_size_t count)
 {
@@ -244,7 +244,7 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,
 			z = r * size;
 			n_obj = r;
 		}
-		if (usb2_pc_alloc_mem(parm->dma_page_cache_ptr,
+		if (usb_pc_alloc_mem(parm->dma_page_cache_ptr,
 		    pg, z, align)) {
 			return (1);	/* failure */
 		}
@@ -257,14 +257,14 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,
 		for (y = 0; (y != n_obj); y++, r--, pc++, pg++) {
 
 			/* Load sub-chunk into DMA */
-			if (usb2_pc_dmamap_create(pc, size)) {
+			if (usb_pc_dmamap_create(pc, size)) {
 				return (1);	/* failure */
 			}
 			pc->buffer = USB_ADD_BYTES(buf, y * size);
 			pc->page_start = pg;
 
 			mtx_lock(pc->tag_parent->mtx);
-			if (usb2_pc_load_mem(pc, size, 1 /* synchronous */ )) {
+			if (usb_pc_load_mem(pc, size, 1 /* synchronous */ )) {
 				mtx_unlock(pc->tag_parent->mtx);
 				return (1);	/* failure */
 			}
@@ -279,7 +279,7 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,
 #endif
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_setup_sub - transfer setup subroutine
+ *	usbd_transfer_setup_sub - transfer setup subroutine
  *
  * This function must be called from the "xfer_setup" callback of the
  * USB Host or Device controller driver when setting up an USB
@@ -288,7 +288,7 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,
  * structure.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_setup_sub(struct usb_setup_params *parm)
+usbd_transfer_setup_sub(struct usb_setup_params *parm)
 {
 	enum {
 		REQ_SIZE = 8,
@@ -297,7 +297,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm)
 	struct usb_xfer *xfer = parm->curr_xfer;
 	const struct usb_config *setup = parm->curr_setup;
 	struct usb_endpoint_descriptor *edesc;
-	struct usb2_std_packet_size std_size;
+	struct usb_std_packet_size std_size;
 	usb_frcount_t n_frlengths;
 	usb_frcount_t n_frbuffers;
 	usb_frcount_t x;
@@ -348,7 +348,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm)
 	}
 	/* filter "wMaxPacketSize" according to standard sizes */
 
-	usb2_get_std_packet_size(&std_size, type, parm->speed);
+	usbd_get_std_packet_size(&std_size, type, parm->speed);
 
 	if (std_size.range.min || std_size.range.max) {
 
@@ -374,7 +374,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm)
 
 	/* compute "max_frame_size" */
 
-	usb2_update_max_frame_size(xfer);
+	usbd_update_max_frame_size(xfer);
 
 	/* check interrupt interval and transfer pre-delay */
 
@@ -478,7 +478,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm)
 			xfer->max_packet_size = MIN_PKT;
 			xfer->max_packet_count = 1;
 			parm->bufsize = 0;	/* automatic setup length */
-			usb2_update_max_frame_size(xfer);
+			usbd_update_max_frame_size(xfer);
 
 		} else {
 			parm->err = USB_ERR_ZERO_MAXP;
@@ -601,10 +601,10 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm)
 			xfer->local_buffer =
 			    USB_ADD_BYTES(parm->buf, parm->size[0]);
 
-			usb2_set_frame_offset(xfer, 0, 0);
+			usbd_set_frame_offset(xfer, 0, 0);
 
 			if ((type == UE_CONTROL) && (n_frbuffers > 1)) {
-				usb2_set_frame_offset(xfer, REQ_SIZE, 1);
+				usbd_set_frame_offset(xfer, REQ_SIZE, 1);
 			}
 		}
 		parm->size[0] += parm->bufsize;
@@ -676,7 +676,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm)
 			if (xfer->flags_int.bdma_enable &&
 			    (parm->bufsize_max > 0)) {
 
-				if (usb2_pc_dmamap_create(
+				if (usb_pc_dmamap_create(
 				    xfer->frbuffers + x,
 				    parm->bufsize_max)) {
 					parm->err = USB_ERR_NOMEM;
@@ -701,10 +701,10 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_setup - setup an array of USB transfers
+ *	usbd_transfer_setup - setup an array of USB transfers
  *
- * NOTE: You must always call "usb2_transfer_unsetup" after calling
- * "usb2_transfer_setup" if success was returned.
+ * NOTE: You must always call "usbd_transfer_unsetup" after calling
+ * "usbd_transfer_setup" if success was returned.
  *
  * The idea is that the USB device driver should pre-allocate all its
  * transfers by one call to this function.
@@ -714,7 +714,7 @@ done:
  * Else: Failure
  *------------------------------------------------------------------------*/
 usb_error_t
-usb2_transfer_setup(struct usb_device *udev,
+usbd_transfer_setup(struct usb_device *udev,
     const uint8_t *ifaces, struct usb_xfer **ppxfer,
     const struct usb_config *setup_start, uint16_t n_setup,
     void *priv_sc, struct mtx *xfer_mtx)
@@ -735,7 +735,7 @@ usb2_transfer_setup(struct usb_device *udev,
 	info = NULL;
 
 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
-	    "usb2_transfer_setup can sleep!");
+	    "usbd_transfer_setup can sleep!");
 
 	/* do some checking first */
 
@@ -771,7 +771,7 @@ usb2_transfer_setup(struct usb_device *udev,
 	bzero(&parm, sizeof(parm));
 
 	parm.udev = udev;
-	parm.speed = usb2_get_speed(udev);
+	parm.speed = usbd_get_speed(udev);
 	parm.hc_max_packet_count = 1;
 
 	if (parm.speed >= USB_SPEED_MAX) {
@@ -803,23 +803,23 @@ usb2_transfer_setup(struct usb_device *udev,
 
 			info->xfer_mtx = xfer_mtx;
 #if USB_HAVE_BUSDMA
-			usb2_dma_tag_setup(&info->dma_parent_tag,
+			usb_dma_tag_setup(&info->dma_parent_tag,
 			    parm.dma_tag_p, udev->bus->dma_parent_tag[0].tag,
-			    xfer_mtx, &usb2_bdma_done_event, 32, parm.dma_tag_max);
+			    xfer_mtx, &usb_bdma_done_event, 32, parm.dma_tag_max);
 #endif
 
 			info->bus = udev->bus;
 			info->udev = udev;
 
 			TAILQ_INIT(&info->done_q.head);
-			info->done_q.command = &usb2_callback_wrapper;
+			info->done_q.command = &usbd_callback_wrapper;
 #if USB_HAVE_BUSDMA
 			TAILQ_INIT(&info->dma_q.head);
-			info->dma_q.command = &usb2_bdma_work_loop;
+			info->dma_q.command = &usb_bdma_work_loop;
 #endif
-			info->done_m[0].hdr.pm_callback = &usb2_callback_proc;
+			info->done_m[0].hdr.pm_callback = &usb_callback_proc;
 			info->done_m[0].xroot = info;
-			info->done_m[1].hdr.pm_callback = &usb2_callback_proc;
+			info->done_m[1].hdr.pm_callback = &usb_callback_proc;
 			info->done_m[1].xroot = info;
 
 			/* 
@@ -828,7 +828,7 @@ usb2_transfer_setup(struct usb_device *udev,
 			 * context, else there is a chance of
 			 * deadlock!
 			 */
-			if (setup_start == usb2_control_ep_cfg)
+			if (setup_start == usb_control_ep_cfg)
 				info->done_p = 
 				    &udev->bus->control_xfer_proc;
 			else if (xfer_mtx == &Giant)
@@ -852,7 +852,7 @@ usb2_transfer_setup(struct usb_device *udev,
 				continue;
 			}
 			/* see if there is a matching endpoint */
-			ep = usb2_get_endpoint(udev,
+			ep = usbd_get_endpoint(udev,
 			    ifaces[setup->if_index], setup);
 
 			if ((ep == NULL) || (ep->methods == NULL)) {
@@ -881,7 +881,7 @@ usb2_transfer_setup(struct usb_device *udev,
 				xfer->priv_sc = priv_sc;
 				xfer->xroot = info;
 
-				usb2_callout_init_mtx(&xfer->timeout_handle,
+				usb_callout_init_mtx(&xfer->timeout_handle,
 				    &udev->bus->bus_mtx, 0);
 			} else {
 				/*
@@ -1031,26 +1031,26 @@ done:
 	if (buf) {
 		if (info->setup_refcount == 0) {
 			/*
-			 * "usb2_transfer_unsetup_sub" will unlock
+			 * "usbd_transfer_unsetup_sub" will unlock
 			 * the bus mutex before returning !
 			 */
 			USB_BUS_LOCK(info->bus);
 
 			/* something went wrong */
-			usb2_transfer_unsetup_sub(info, 0);
+			usbd_transfer_unsetup_sub(info, 0);
 		}
 	}
 	if (parm.err) {
-		usb2_transfer_unsetup(ppxfer, n_setup);
+		usbd_transfer_unsetup(ppxfer, n_setup);
 	}
 	return (parm.err);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_unsetup_sub - factored out code
+ *	usbd_transfer_unsetup_sub - factored out code
  *------------------------------------------------------------------------*/
 static void
-usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay)
+usbd_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay)
 {
 	struct usb_page_cache *pc;
 
@@ -1060,13 +1060,13 @@ usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay)
 
 	if (needs_delay) {
 		usb_timeout_t temp;
-		temp = usb2_get_dma_delay(info->bus);
-		usb2_pause_mtx(&info->bus->bus_mtx,
+		temp = usbd_get_dma_delay(info->bus);
+		usb_pause_mtx(&info->bus->bus_mtx,
 		    USB_MS_TO_TICKS(temp));
 	}
 
 	/* make sure that our done messages are not queued anywhere */
-	usb2_proc_mwait(info->done_p, &info->done_m[0], &info->done_m[1]);
+	usb_proc_mwait(info->done_p, &info->done_m[0], &info->done_m[1]);
 
 	USB_BUS_UNLOCK(info->bus);
 
@@ -1074,19 +1074,19 @@ usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay)
 	/* free DMA'able memory, if any */
 	pc = info->dma_page_cache_start;
 	while (pc != info->dma_page_cache_end) {
-		usb2_pc_free_mem(pc);
+		usb_pc_free_mem(pc);
 		pc++;
 	}
 
 	/* free DMA maps in all "xfer->frbuffers" */
 	pc = info->xfer_page_cache_start;
 	while (pc != info->xfer_page_cache_end) {
-		usb2_pc_dmamap_destroy(pc);
+		usb_pc_dmamap_destroy(pc);
 		pc++;
 	}
 
 	/* free all DMA tags */
-	usb2_dma_tag_unsetup(&info->dma_parent_tag);
+	usb_dma_tag_unsetup(&info->dma_parent_tag);
 #endif
 
 	cv_destroy(&info->cv_drain);
@@ -1099,21 +1099,21 @@ usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_unsetup - unsetup/free an array of USB transfers
+ *	usbd_transfer_unsetup - unsetup/free an array of USB transfers
  *
  * NOTE: All USB transfers in progress will get called back passing
  * the error code "USB_ERR_CANCELLED" before this function
  * returns.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
+usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
 {
 	struct usb_xfer *xfer;
 	struct usb_xfer_root *info;
 	uint8_t needs_delay = 0;
 
 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
-	    "usb2_transfer_unsetup can sleep!");
+	    "usbd_transfer_unsetup can sleep!");
 
 	while (n_setup--) {
 		xfer = pxfer[n_setup];
@@ -1130,13 +1130,13 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
 		 * HINT: when you start/stop a transfer, it might be a
 		 * good idea to directly use the "pxfer[]" structure:
 		 *
-		 * usb2_transfer_start(sc->pxfer[0]);
-		 * usb2_transfer_stop(sc->pxfer[0]);
+		 * usbd_transfer_start(sc->pxfer[0]);
+		 * usbd_transfer_stop(sc->pxfer[0]);
 		 *
 		 * That way, if your code has many parts that will not
 		 * stop running under the same lock, in other words
-		 * "xfer_mtx", the usb2_transfer_start and
-		 * usb2_transfer_stop functions will simply return
+		 * "xfer_mtx", the usbd_transfer_start and
+		 * usbd_transfer_stop functions will simply return
 		 * when they detect a NULL pointer argument.
 		 *
 		 * To avoid any races we clear the "pxfer[]" pointer
@@ -1147,7 +1147,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
 		USB_BUS_UNLOCK(info->bus);
 		USB_XFER_UNLOCK(xfer);
 
-		usb2_transfer_drain(xfer);
+		usbd_transfer_drain(xfer);
 
 #if USB_HAVE_BUSDMA
 		if (xfer->flags_int.bdma_enable)
@@ -1159,7 +1159,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
 		 */
 		xfer->endpoint->refcount--;
 
-		usb2_callout_drain(&xfer->timeout_handle);
+		usb_callout_drain(&xfer->timeout_handle);
 
 		USB_BUS_LOCK(info->bus);
 
@@ -1169,7 +1169,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
 		info->setup_refcount--;
 
 		if (info->setup_refcount == 0) {
-			usb2_transfer_unsetup_sub(info,
+			usbd_transfer_unsetup_sub(info,
 			    needs_delay);
 		} else {
 			USB_BUS_UNLOCK(info->bus);
@@ -1178,7 +1178,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_control_transfer_init - factored out code
+ *	usbd_control_transfer_init - factored out code
  *
  * In USB Device Mode we have to wait for the SETUP packet which
  * containst the "struct usb_device_request" structure, before we can
@@ -1189,13 +1189,13 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
  * initialisation code, so that we don't duplicate the code.
  *------------------------------------------------------------------------*/
 static void
-usb2_control_transfer_init(struct usb_xfer *xfer)
+usbd_control_transfer_init(struct usb_xfer *xfer)
 {
 	struct usb_device_request req;
 
 	/* copy out the USB request header */
 
-	usb2_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
+	usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
 
 	/* setup remainder */
 
@@ -1209,7 +1209,7 @@ usb2_control_transfer_init(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_start_hardware_sub
+ *	usbd_start_hardware_sub
  *
  * This function handles initialisation of control transfers. Control
  * transfers are special in that regard that they can both transmit
@@ -1220,7 +1220,7 @@ usb2_control_transfer_init(struct usb_xfer *xfer)
  * Else: Failure
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_start_hardware_sub(struct usb_xfer *xfer)
+usbd_start_hardware_sub(struct usb_xfer *xfer)
 {
 	usb_frlength_t len;
 
@@ -1261,7 +1261,7 @@ usb2_start_hardware_sub(struct usb_xfer *xfer)
 
 			/* setup control transfer */
 			if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
-				usb2_control_transfer_init(xfer);
+				usbd_control_transfer_init(xfer);
 			}
 		}
 		/* get data length */
@@ -1294,14 +1294,14 @@ usb2_start_hardware_sub(struct usb_xfer *xfer)
 			/*
 			 * Set a dummy "control_rem" value.  This
 			 * variable will be overwritten later by a
-			 * call to "usb2_control_transfer_init()" !
+			 * call to "usbd_control_transfer_init()" !
 			 */
 			xfer->flags_int.control_rem = 0xFFFF;
 		} else {
 
 			/* setup "endpoint" and "control_rem" */
 
-			usb2_control_transfer_init(xfer);
+			usbd_control_transfer_init(xfer);
 		}
 
 		/* set transfer-header flag */
@@ -1362,12 +1362,12 @@ error:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_start_hardware - start USB hardware for the given transfer
+ *	usbd_transfer_submit - start USB hardware for the given transfer
  *
  * This function should only be called from the USB callback.
  *------------------------------------------------------------------------*/
 void
-usb2_start_hardware(struct usb_xfer *xfer)
+usbd_transfer_submit(struct usb_xfer *xfer)
 {
 	struct usb_xfer_root *info;
 	struct usb_bus *bus;
@@ -1384,7 +1384,7 @@ usb2_start_hardware(struct usb_xfer *xfer)
 	if (USB_DEBUG_VAR > 0) {
 		USB_BUS_LOCK(bus);
 
-		usb2_dump_endpoint(xfer->endpoint);
+		usb_dump_endpoint(xfer->endpoint);
 
 		USB_BUS_UNLOCK(bus);
 	}
@@ -1408,7 +1408,7 @@ usb2_start_hardware(struct usb_xfer *xfer)
 
 #if USB_HAVE_POWERD
 	/* increment power reference */
-	usb2_transfer_power_ref(xfer, 1);
+	usbd_transfer_power_ref(xfer, 1);
 #endif
 	/*
 	 * Check if the transfer is waiting on a queue, most
@@ -1416,7 +1416,7 @@ usb2_start_hardware(struct usb_xfer *xfer)
 	 */
 	if (xfer->wait_queue) {
 		USB_BUS_LOCK(bus);
-		usb2_transfer_dequeue(xfer);
+		usbd_transfer_dequeue(xfer);
 		USB_BUS_UNLOCK(bus);
 	}
 	/* clear "did_dma_delay" flag */
@@ -1447,7 +1447,7 @@ usb2_start_hardware(struct usb_xfer *xfer)
 		 * Must return cancelled error code else
 		 * device drivers can hang.
 		 */
-		usb2_transfer_done(xfer, USB_ERR_CANCELLED);
+		usbd_transfer_done(xfer, USB_ERR_CANCELLED);
 		USB_BUS_UNLOCK(bus);
 		return;
 	}
@@ -1464,12 +1464,12 @@ usb2_start_hardware(struct usb_xfer *xfer)
 			USB_BUS_LOCK(bus);
 			xfer->flags_int.can_cancel_immed = 1;
 			/* start the transfer */
-			usb2_command_wrapper(&xfer->endpoint->endpoint_q, xfer);
+			usb_command_wrapper(&xfer->endpoint->endpoint_q, xfer);
 			USB_BUS_UNLOCK(bus);
 			return;
 		}
 		USB_BUS_LOCK(bus);
-		usb2_transfer_done(xfer, USB_ERR_INVAL);
+		usbd_transfer_done(xfer, USB_ERR_INVAL);
 		USB_BUS_UNLOCK(bus);
 		return;
 	}
@@ -1480,7 +1480,7 @@ usb2_start_hardware(struct usb_xfer *xfer)
 		if (xfer->sumlen < xfer->frlengths[x]) {
 			/* length wrapped around */
 			USB_BUS_LOCK(bus);
-			usb2_transfer_done(xfer, USB_ERR_INVAL);
+			usbd_transfer_done(xfer, USB_ERR_INVAL);
 			USB_BUS_UNLOCK(bus);
 			return;
 		}
@@ -1495,9 +1495,9 @@ usb2_start_hardware(struct usb_xfer *xfer)
 
 	if (xfer->flags_int.control_xfr) {
 
-		if (usb2_start_hardware_sub(xfer)) {
+		if (usbd_start_hardware_sub(xfer)) {
 			USB_BUS_LOCK(bus);
-			usb2_transfer_done(xfer, USB_ERR_STALLED);
+			usbd_transfer_done(xfer, USB_ERR_STALLED);
 			USB_BUS_UNLOCK(bus);
 			return;
 		}
@@ -1540,7 +1540,7 @@ usb2_start_hardware(struct usb_xfer *xfer)
 #if USB_HAVE_BUSDMA
 	if (xfer->flags_int.bdma_enable) {
 		/* insert the USB transfer last in the BUS-DMA queue */
-		usb2_command_wrapper(&xfer->xroot->dma_q, xfer);
+		usb_command_wrapper(&xfer->xroot->dma_q, xfer);
 		return;
 	}
 #endif
@@ -1548,14 +1548,14 @@ usb2_start_hardware(struct usb_xfer *xfer)
 	 * Enter the USB transfer into the Host Controller or
 	 * Device Controller schedule:
 	 */
-	usb2_pipe_enter(xfer);
+	usbd_pipe_enter(xfer);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pipe_enter - factored out code
+ *	usbd_pipe_enter - factored out code
  *------------------------------------------------------------------------*/
 void
-usb2_pipe_enter(struct usb_xfer *xfer)
+usbd_pipe_enter(struct usb_xfer *xfer)
 {
 	struct usb_endpoint *ep;
 
@@ -1575,25 +1575,25 @@ usb2_pipe_enter(struct usb_xfer *xfer)
 	/* check for transfer error */
 	if (xfer->error) {
 		/* some error has happened */
-		usb2_transfer_done(xfer, 0);
+		usbd_transfer_done(xfer, 0);
 		USB_BUS_UNLOCK(xfer->xroot->bus);
 		return;
 	}
 
 	/* start the transfer */
-	usb2_command_wrapper(&ep->endpoint_q, xfer);
+	usb_command_wrapper(&ep->endpoint_q, xfer);
 	USB_BUS_UNLOCK(xfer->xroot->bus);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_start - start an USB transfer
+ *	usbd_transfer_start - start an USB transfer
  *
  * NOTE: Calling this function more than one time will only
  *       result in a single transfer start, until the USB transfer
  *       completes.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_start(struct usb_xfer *xfer)
+usbd_transfer_start(struct usb_xfer *xfer)
 {
 	if (xfer == NULL) {
 		/* transfer is gone */
@@ -1613,20 +1613,20 @@ usb2_transfer_start(struct usb_xfer *xfer)
 	}
 	USB_BUS_LOCK(xfer->xroot->bus);
 	/* call the USB transfer callback */
-	usb2_callback_ss_done_defer(xfer);
+	usbd_callback_ss_done_defer(xfer);
 	USB_BUS_UNLOCK(xfer->xroot->bus);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_stop - stop an USB transfer
+ *	usbd_transfer_stop - stop an USB transfer
  *
  * NOTE: Calling this function more than one time will only
  *       result in a single transfer stop.
  * NOTE: When this function returns it is not safe to free nor
- *       reuse any DMA buffers. See "usb2_transfer_drain()".
+ *       reuse any DMA buffers. See "usbd_transfer_drain()".
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_stop(struct usb_xfer *xfer)
+usbd_transfer_stop(struct usb_xfer *xfer)
 {
 	struct usb_endpoint *ep;
 
@@ -1679,7 +1679,7 @@ usb2_transfer_stop(struct usb_xfer *xfer)
 
 		/*
 		 * Any additional DMA delay is done by
-		 * "usb2_transfer_unsetup()".
+		 * "usbd_transfer_unsetup()".
 		 */
 
 		/*
@@ -1693,7 +1693,7 @@ usb2_transfer_stop(struct usb_xfer *xfer)
 		 * to start the next one:
 		 */
 		if (ep->endpoint_q.curr == xfer) {
-			usb2_command_wrapper(&ep->endpoint_q, NULL);
+			usb_command_wrapper(&ep->endpoint_q, NULL);
 		}
 	}
 
@@ -1701,7 +1701,7 @@ usb2_transfer_stop(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_pending
+ *	usbd_transfer_pending
  *
  * This function will check if an USB transfer is pending which is a
  * little bit complicated!
@@ -1710,7 +1710,7 @@ usb2_transfer_stop(struct usb_xfer *xfer)
  * 1: Pending: The USB transfer will receive a callback in the future.
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_transfer_pending(struct usb_xfer *xfer)
+usbd_transfer_pending(struct usb_xfer *xfer)
 {
 	struct usb_xfer_root *info;
 	struct usb_xfer_queue *pq;
@@ -1745,7 +1745,7 @@ usb2_transfer_pending(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_drain
+ *	usbd_transfer_drain
  *
  * This function will stop the USB transfer and wait for any
  * additional BUS-DMA and HW-DMA operations to complete. Buffers that
@@ -1753,10 +1753,10 @@ usb2_transfer_pending(struct usb_xfer *xfer)
  * function has returned.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_drain(struct usb_xfer *xfer)
+usbd_transfer_drain(struct usb_xfer *xfer)
 {
 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
-	    "usb2_transfer_drain can sleep!");
+	    "usbd_transfer_drain can sleep!");
 
 	if (xfer == NULL) {
 		/* transfer is gone */
@@ -1767,9 +1767,9 @@ usb2_transfer_drain(struct usb_xfer *xfer)
 	}
 	USB_XFER_LOCK(xfer);
 
-	usb2_transfer_stop(xfer);
+	usbd_transfer_stop(xfer);
 
-	while (usb2_transfer_pending(xfer)) {
+	while (usbd_transfer_pending(xfer)) {
 		xfer->flags_int.draining = 1;
 		/*
 		 * Wait until the current outstanding USB
@@ -1781,7 +1781,7 @@ usb2_transfer_drain(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_set_frame_data
+ *	usbd_set_frame_data
  *
  * This function sets the pointer of the buffer that should
  * loaded directly into DMA for the given USB frame. Passing "ptr"
@@ -1789,20 +1789,20 @@ usb2_transfer_drain(struct usb_xfer *xfer)
  * than zero gives undefined results!
  *------------------------------------------------------------------------*/
 void
-usb2_set_frame_data(struct usb_xfer *xfer, void *ptr, usb_frcount_t frindex)
+usbd_set_frame_data(struct usb_xfer *xfer, void *ptr, usb_frcount_t frindex)
 {
 	/* set virtual address to load and length */
 	xfer->frbuffers[frindex].buffer = ptr;
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_set_frame_offset
+ *	usbd_set_frame_offset
  *
  * This function sets the frame data buffer offset relative to the beginning
  * of the USB DMA buffer allocated for this USB transfer.
  *------------------------------------------------------------------------*/
 void
-usb2_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
+usbd_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
     usb_frcount_t frindex)
 {
 	USB_ASSERT(!xfer->flags.ext_buffer, ("Cannot offset data frame "
@@ -1814,12 +1814,12 @@ usb2_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_callback_proc - factored out code
+ *	usb_callback_proc - factored out code
  *
  * This function performs USB callbacks.
  *------------------------------------------------------------------------*/
 static void
-usb2_callback_proc(struct usb_proc_msg *_pm)
+usb_callback_proc(struct usb_proc_msg *_pm)
 {
 	struct usb_done_msg *pm = (void *)_pm;
 	struct usb_xfer_root *info = pm->xroot;
@@ -1835,20 +1835,20 @@ usb2_callback_proc(struct usb_proc_msg *_pm)
 	USB_BUS_LOCK(info->bus);
 
 	/* Continue where we lost track */
-	usb2_command_wrapper(&info->done_q,
+	usb_command_wrapper(&info->done_q,
 	    info->done_q.curr);
 
 	mtx_unlock(info->xfer_mtx);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_callback_ss_done_defer
+ *	usbd_callback_ss_done_defer
  *
  * This function will defer the start, stop and done callback to the
  * correct thread.
  *------------------------------------------------------------------------*/
 static void
-usb2_callback_ss_done_defer(struct usb_xfer *xfer)
+usbd_callback_ss_done_defer(struct usb_xfer *xfer)
 {
 	struct usb_xfer_root *info = xfer->xroot;
 	struct usb_xfer_queue *pq = &info->done_q;
@@ -1856,7 +1856,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer)
 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
 
 	if (pq->curr != xfer) {
-		usb2_transfer_enqueue(pq, xfer);
+		usbd_transfer_enqueue(pq, xfer);
 	}
 	if (!pq->recurse_1) {
 
@@ -1865,7 +1865,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer)
 	         * will have a Lock Order Reversal, LOR, if we try to
 	         * proceed !
 	         */
-		if (usb2_proc_msignal(info->done_p,
+		if (usb_proc_msignal(info->done_p,
 		    &info->done_m[0], &info->done_m[1])) {
 			/* ignore */
 		}
@@ -1878,7 +1878,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_callback_wrapper
+ *	usbd_callback_wrapper
  *
  * This is a wrapper for USB callbacks. This wrapper does some
  * auto-magic things like figuring out if we can call the callback
@@ -1886,7 +1886,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer)
  * interrupt process.
  *------------------------------------------------------------------------*/
 static void
-usb2_callback_wrapper(struct usb_xfer_queue *pq)
+usbd_callback_wrapper(struct usb_xfer_queue *pq)
 {
 	struct usb_xfer *xfer = pq->curr;
 	struct usb_xfer_root *info = xfer->xroot;
@@ -1905,7 +1905,7 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq)
 	         * will have a Lock Order Reversal, LOR, if we try to
 	         * proceed !
 	         */
-		if (usb2_proc_msignal(info->done_p,
+		if (usb_proc_msignal(info->done_p,
 		    &info->done_m[0], &info->done_m[1])) {
 			/* ignore */
 		}
@@ -1928,7 +1928,7 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq)
 
 	/* set correct USB state for callback */
 	if (!xfer->flags_int.transferring) {
-		xfer->usb2_state = USB_ST_SETUP;
+		xfer->usb_state = USB_ST_SETUP;
 		if (!xfer->flags_int.started) {
 			/* we got stopped before we even got started */
 			USB_BUS_LOCK(info->bus);
@@ -1936,27 +1936,27 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq)
 		}
 	} else {
 
-		if (usb2_callback_wrapper_sub(xfer)) {
+		if (usbd_callback_wrapper_sub(xfer)) {
 			/* the callback has been deferred */
 			USB_BUS_LOCK(info->bus);
 			goto done;
 		}
 #if USB_HAVE_POWERD
 		/* decrement power reference */
-		usb2_transfer_power_ref(xfer, -1);
+		usbd_transfer_power_ref(xfer, -1);
 #endif
 		xfer->flags_int.transferring = 0;
 
 		if (xfer->error) {
-			xfer->usb2_state = USB_ST_ERROR;
+			xfer->usb_state = USB_ST_ERROR;
 		} else {
 			/* set transferred state */
-			xfer->usb2_state = USB_ST_TRANSFERRED;
+			xfer->usb_state = USB_ST_TRANSFERRED;
 #if USB_HAVE_BUSDMA
 			/* sync DMA memory, if any */
 			if (xfer->flags_int.bdma_enable &&
 			    (!xfer->flags_int.bdma_no_post_sync)) {
-				usb2_bdma_post_sync(xfer);
+				usb_bdma_post_sync(xfer);
 			}
 #endif
 		}
@@ -1974,9 +1974,9 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq)
 	 */
 	if ((!xfer->flags_int.open) &&
 	    (xfer->flags_int.started) &&
-	    (xfer->usb2_state == USB_ST_ERROR)) {
+	    (xfer->usb_state == USB_ST_ERROR)) {
 		/* try to loop, but not recursivly */
-		usb2_command_wrapper(&info->done_q, xfer);
+		usb_command_wrapper(&info->done_q, xfer);
 		return;
 	}
 
@@ -1986,18 +1986,18 @@ done:
 	 */
 	if (xfer->flags_int.draining &&
 	    (!xfer->flags_int.transferring)) {
-		/* "usb2_transfer_drain()" is waiting for end of transfer */
+		/* "usbd_transfer_drain()" is waiting for end of transfer */
 		xfer->flags_int.draining = 0;
 		cv_broadcast(&info->cv_drain);
 	}
 
 	/* do the next callback, if any */
-	usb2_command_wrapper(&info->done_q,
+	usb_command_wrapper(&info->done_q,
 	    info->done_q.curr);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_dma_delay_done_cb
+ *	usb_dma_delay_done_cb
  *
  * This function is called when the DMA delay has been exectuded, and
  * will make sure that the callback is called to complete the USB
@@ -2005,7 +2005,7 @@ done:
  * error like USB_ERR_CANCELLED.
  *------------------------------------------------------------------------*/
 static void
-usb2_dma_delay_done_cb(void *arg)
+usb_dma_delay_done_cb(void *arg)
 {
 	struct usb_xfer *xfer = arg;
 
@@ -2014,11 +2014,11 @@ usb2_dma_delay_done_cb(void *arg)
 	DPRINTFN(3, "Completed %p\n", xfer);
 
 	/* queue callback for execution, again */
-	usb2_transfer_done(xfer, 0);
+	usbd_transfer_done(xfer, 0);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_dequeue
+ *	usbd_transfer_dequeue
  *
  *  - This function is used to remove an USB transfer from a USB
  *  transfer queue.
@@ -2026,7 +2026,7 @@ usb2_dma_delay_done_cb(void *arg)
  *  - This function can be called multiple times in a row.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_dequeue(struct usb_xfer *xfer)
+usbd_transfer_dequeue(struct usb_xfer *xfer)
 {
 	struct usb_xfer_queue *pq;
 
@@ -2038,7 +2038,7 @@ usb2_transfer_dequeue(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_enqueue
+ *	usbd_transfer_enqueue
  *
  *  - This function is used to insert an USB transfer into a USB *
  *  transfer queue.
@@ -2046,7 +2046,7 @@ usb2_transfer_dequeue(struct usb_xfer *xfer)
  *  - This function can be called multiple times in a row.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
+usbd_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
 {
 	/*
 	 * Insert the USB transfer into the queue, if it is not
@@ -2059,7 +2059,7 @@ usb2_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_done
+ *	usbd_transfer_done
  *
  *  - This function is used to remove an USB transfer from the busdma,
  *  pipe or interrupt queue.
@@ -2070,11 +2070,11 @@ usb2_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
  *  - This function is used to stop any USB transfer timeouts.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error)
+usbd_transfer_done(struct usb_xfer *xfer, usb_error_t error)
 {
 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
 
-	DPRINTF("err=%s\n", usb2_errstr(error));
+	DPRINTF("err=%s\n", usbd_errstr(error));
 
 	/*
 	 * If we are not transferring then just return.
@@ -2089,14 +2089,14 @@ usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error)
 		xfer->error = error;
 	}
 	/* stop any callouts */
-	usb2_callout_stop(&xfer->timeout_handle);
+	usb_callout_stop(&xfer->timeout_handle);
 
 	/*
 	 * If we are waiting on a queue, just remove the USB transfer
 	 * from the queue, if any. We should have the required locks
 	 * locked to do the remove when this function is called.
 	 */
-	usb2_transfer_dequeue(xfer);
+	usbd_transfer_dequeue(xfer);
 
 #if USB_HAVE_BUSDMA
 	if (mtx_owned(xfer->xroot->xfer_mtx)) {
@@ -2110,7 +2110,7 @@ usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error)
 
 		if (pq->curr == xfer) {
 			/* start the next BUS-DMA load, if any */
-			usb2_command_wrapper(pq, NULL);
+			usb_command_wrapper(pq, NULL);
 		}
 	}
 #endif
@@ -2124,18 +2124,18 @@ usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error)
 	}
 
 	/* call the USB transfer callback */
-	usb2_callback_ss_done_defer(xfer);
+	usbd_callback_ss_done_defer(xfer);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_start_cb
+ *	usbd_transfer_start_cb
  *
  * This function is called to start the USB transfer when
  * "xfer->interval" is greater than zero, and and the endpoint type is
  * BULK or CONTROL.
  *------------------------------------------------------------------------*/
 static void
-usb2_transfer_start_cb(void *arg)
+usbd_transfer_start_cb(void *arg)
 {
 	struct usb_xfer *xfer = arg;
 	struct usb_endpoint *ep = xfer->endpoint;
@@ -2152,18 +2152,18 @@ usb2_transfer_start_cb(void *arg)
 	/* check for error */
 	if (xfer->error) {
 		/* some error has happened */
-		usb2_transfer_done(xfer, 0);
+		usbd_transfer_done(xfer, 0);
 	}
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_set_stall
+ *	usbd_transfer_set_stall
  *
  * This function is used to set the stall flag outside the
  * callback. This function is NULL safe.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_set_stall(struct usb_xfer *xfer)
+usbd_transfer_set_stall(struct usb_xfer *xfer)
 {
 	if (xfer == NULL) {
 		/* tearing down */
@@ -2180,13 +2180,13 @@ usb2_transfer_set_stall(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_clear_stall
+ *	usbd_transfer_clear_stall
  *
  * This function is used to clear the stall flag outside the
  * callback. This function is NULL safe.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_clear_stall(struct usb_xfer *xfer)
+usbd_transfer_clear_stall(struct usb_xfer *xfer)
 {
 	if (xfer == NULL) {
 		/* tearing down */
@@ -2203,12 +2203,12 @@ usb2_transfer_clear_stall(struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_pipe_start
+ *	usbd_pipe_start
  *
  * This function is used to add an USB transfer to the pipe transfer list.
  *------------------------------------------------------------------------*/
 void
-usb2_pipe_start(struct usb_xfer_queue *pq)
+usbd_pipe_start(struct usb_xfer_queue *pq)
 {
 	struct usb_endpoint *ep;
 	struct usb_xfer *xfer;
@@ -2250,7 +2250,7 @@ usb2_pipe_start(struct usb_xfer_queue *pq)
 				    udev, NULL, ep);
 			} else if (udev->default_xfer[1]) {
 				info = udev->default_xfer[1]->xroot;
-				if (usb2_proc_msignal(
+				if (usb_proc_msignal(
 				    &info->bus->non_giant_callback_proc,
 				    &udev->cs_msg[0], &udev->cs_msg[1])) {
 					/* ignore */
@@ -2269,7 +2269,7 @@ usb2_pipe_start(struct usb_xfer_queue *pq)
 	if (xfer->nframes == 0) {
 		/* we are complete */
 		xfer->aframes = 0;
-		usb2_transfer_done(xfer, 0);
+		usbd_transfer_done(xfer, 0);
 		return;
 	}
 	/*
@@ -2287,8 +2287,8 @@ usb2_pipe_start(struct usb_xfer_queue *pq)
 		type = (ep->edesc->bmAttributes & UE_XFERTYPE);
 		if ((type == UE_BULK) ||
 		    (type == UE_CONTROL)) {
-			usb2_transfer_timeout_ms(xfer,
-			    &usb2_transfer_start_cb,
+			usbd_transfer_timeout_ms(xfer,
+			    &usbd_transfer_start_cb,
 			    xfer->interval);
 			return;
 		}
@@ -2303,30 +2303,30 @@ usb2_pipe_start(struct usb_xfer_queue *pq)
 	/* check for error */
 	if (xfer->error) {
 		/* some error has happened */
-		usb2_transfer_done(xfer, 0);
+		usbd_transfer_done(xfer, 0);
 	}
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_transfer_timeout_ms
+ *	usbd_transfer_timeout_ms
  *
  * This function is used to setup a timeout on the given USB
  * transfer. If the timeout has been deferred the callback given by
  * "cb" will get called after "ms" milliseconds.
  *------------------------------------------------------------------------*/
 void
-usb2_transfer_timeout_ms(struct usb_xfer *xfer,
+usbd_transfer_timeout_ms(struct usb_xfer *xfer,
     void (*cb) (void *arg), usb_timeout_t ms)
 {
 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
 
 	/* defer delay */
-	usb2_callout_reset(&xfer->timeout_handle,
+	usb_callout_reset(&xfer->timeout_handle,
 	    USB_MS_TO_TICKS(ms), cb, xfer);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_callback_wrapper_sub
+ *	usbd_callback_wrapper_sub
  *
  *  - This function will update variables in an USB transfer after
  *  that the USB transfer is complete.
@@ -2343,7 +2343,7 @@ usb2_transfer_timeout_ms(struct usb_xfer *xfer,
  * Else: The callback has been deferred.
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_callback_wrapper_sub(struct usb_xfer *xfer)
+usbd_callback_wrapper_sub(struct usb_xfer *xfer)
 {
 	struct usb_endpoint *ep;
 	usb_frcount_t x;
@@ -2374,15 +2374,15 @@ usb2_callback_wrapper_sub(struct usb_xfer *xfer)
 		/* we can not cancel this delay */
 		xfer->flags_int.can_cancel_immed = 0;
 
-		temp = usb2_get_dma_delay(xfer->xroot->bus);
+		temp = usbd_get_dma_delay(xfer->xroot->bus);
 
 		DPRINTFN(3, "DMA delay, %u ms, "
 		    "on %p\n", temp, xfer);
 
 		if (temp != 0) {
 			USB_BUS_LOCK(xfer->xroot->bus);
-			usb2_transfer_timeout_ms(xfer,
-			    &usb2_dma_delay_done_cb, temp);
+			usbd_transfer_timeout_ms(xfer,
+			    &usb_dma_delay_done_cb, temp);
 			USB_BUS_UNLOCK(xfer->xroot->bus);
 			return (1);	/* wait for new callback */
 		}
@@ -2477,7 +2477,7 @@ usb2_callback_wrapper_sub(struct usb_xfer *xfer)
 	 */
 	USB_BUS_LOCK(xfer->xroot->bus);
 	if (ep->endpoint_q.curr == xfer) {
-		usb2_command_wrapper(&ep->endpoint_q, NULL);
+		usb_command_wrapper(&ep->endpoint_q, NULL);
 
 		if (ep->endpoint_q.curr || TAILQ_FIRST(&ep->endpoint_q.head)) {
 			/* there is another USB transfer waiting */
@@ -2493,13 +2493,13 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_command_wrapper
+ *	usb_command_wrapper
  *
  * This function is used to execute commands non-recursivly on an USB
  * transfer.
  *------------------------------------------------------------------------*/
 void
-usb2_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
+usb_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
 {
 	if (xfer) {
 		/*
@@ -2507,7 +2507,7 @@ usb2_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
 		 * queue it!
 		 */
 		if (pq->curr != xfer) {
-			usb2_transfer_enqueue(pq, xfer);
+			usbd_transfer_enqueue(pq, xfer);
 			if (pq->curr != NULL) {
 				/* something is already processing */
 				DPRINTFN(6, "busy %p\n", pq->curr);
@@ -2554,13 +2554,13 @@ usb2_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_default_transfer_setup
+ *	usbd_default_transfer_setup
  *
  * This function is used to setup the default USB control endpoint
  * transfer.
  *------------------------------------------------------------------------*/
 void
-usb2_default_transfer_setup(struct usb_device *udev)
+usbd_default_transfer_setup(struct usb_device *udev)
 {
 	struct usb_xfer *xfer;
 	uint8_t no_resetup;
@@ -2585,7 +2585,7 @@ repeat:
 				 * starting the USB transfer must be
 				 * atomic!
 				 */
-				usb2_transfer_start(xfer);
+				usbd_transfer_start(xfer);
 			}
 		}
 		USB_XFER_UNLOCK(xfer);
@@ -2609,15 +2609,15 @@ repeat:
 	/*
 	 * Unsetup any existing USB transfer:
 	 */
-	usb2_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX);
+	usbd_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX);
 
 	/*
 	 * Try to setup a new USB transfer for the
 	 * default control endpoint:
 	 */
 	iface_index = 0;
-	if (usb2_transfer_setup(udev, &iface_index,
-	    udev->default_xfer, usb2_control_ep_cfg, USB_DEFAULT_XFER_MAX, NULL,
+	if (usbd_transfer_setup(udev, &iface_index,
+	    udev->default_xfer, usb_control_ep_cfg, USB_DEFAULT_XFER_MAX, NULL,
 	    udev->default_mtx)) {
 		DPRINTFN(0, "could not setup default "
 		    "USB transfer!\n");
@@ -2627,13 +2627,13 @@ repeat:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_clear_data_toggle - factored out code
+ *	usbd_clear_data_toggle - factored out code
  *
  * NOTE: the intention of this function is not to reset the hardware
  * data toggle.
  *------------------------------------------------------------------------*/
 void
-usb2_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep)
+usbd_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep)
 {
 	DPRINTFN(5, "udev=%p endpoint=%p\n", udev, ep);
 
@@ -2643,7 +2643,7 @@ usb2_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_clear_stall_callback - factored out clear stall callback
+ *	usbd_clear_stall_callback - factored out clear stall callback
  *
  * Input parameters:
  *  xfer1: Clear Stall Control Transfer
@@ -2668,11 +2668,11 @@ usb2_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep)
  *	.usb_mode = USB_MODE_HOST,
  * };
  *
- * ** "my_clear_stall_callback" calls "usb2_clear_stall_callback"
+ * ** "my_clear_stall_callback" calls "usbd_clear_stall_callback"
  * passing the correct parameters.
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_clear_stall_callback(struct usb_xfer *xfer1,
+usbd_clear_stall_callback(struct usb_xfer *xfer1,
     struct usb_xfer *xfer2)
 {
 	struct usb_device_request req;
@@ -2693,7 +2693,7 @@ usb2_clear_stall_callback(struct usb_xfer *xfer1,
 		 * "ata-usb.c" depends on this)
 		 */
 
-		usb2_clear_data_toggle(xfer2->xroot->udev, xfer2->endpoint);
+		usbd_clear_data_toggle(xfer2->xroot->udev, xfer2->endpoint);
 
 		/* setup a clear-stall packet */
 
@@ -2705,20 +2705,20 @@ usb2_clear_stall_callback(struct usb_xfer *xfer1,
 		USETW(req.wLength, 0);
 
 		/*
-		 * "usb2_transfer_setup_sub()" will ensure that
+		 * "usbd_transfer_setup_sub()" will ensure that
 		 * we have sufficient room in the buffer for
 		 * the request structure!
 		 */
 
 		/* copy in the transfer */
 
-		usb2_copy_in(xfer1->frbuffers, 0, &req, sizeof(req));
+		usbd_copy_in(xfer1->frbuffers, 0, &req, sizeof(req));
 
 		/* set length */
 		xfer1->frlengths[0] = sizeof(req);
 		xfer1->nframes = 1;
 
-		usb2_start_hardware(xfer1);
+		usbd_transfer_submit(xfer1);
 		return (0);
 
 	case USB_ST_TRANSFERRED:
@@ -2734,19 +2734,19 @@ usb2_clear_stall_callback(struct usb_xfer *xfer1,
 }
 
 void
-usb2_do_poll(struct usb_xfer **ppxfer, uint16_t max)
+usbd_do_poll(struct usb_xfer **ppxfer, uint16_t max)
 {
 	static uint8_t once = 0;
 	/* polling is currently not supported */
 	if (!once) {
 		once = 1;
-		printf("usb2_do_poll: USB polling is "
+		printf("usbd_do_poll: USB polling is "
 		    "not supported!\n");
 	}
 }
 
 static void
-usb2_get_std_packet_size(struct usb2_std_packet_size *ptr,
+usbd_get_std_packet_size(struct usb_std_packet_size *ptr,
     uint8_t type, enum usb_dev_speed speed)
 {
 	static const uint16_t intr_range_max[USB_SPEED_MAX] = {
diff --git a/sys/dev/usb/usb_transfer.h b/sys/dev/usb/usb_transfer.h
index 68cf393..9b5a33c 100644
--- a/sys/dev/usb/usb_transfer.h
+++ b/sys/dev/usb/usb_transfer.h
@@ -111,28 +111,28 @@ struct usb_setup_params {
 
 /* function prototypes */
 
-uint8_t	usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,
+uint8_t	usbd_transfer_setup_sub_malloc(struct usb_setup_params *parm,
 	    struct usb_page_cache **ppc, usb_size_t size, usb_size_t align,
 	    usb_size_t count);
-void	usb2_command_wrapper(struct usb_xfer_queue *pq,
+void	usb_command_wrapper(struct usb_xfer_queue *pq,
 	    struct usb_xfer *xfer);
-void	usb2_pipe_enter(struct usb_xfer *xfer);
-void	usb2_pipe_start(struct usb_xfer_queue *pq);
-void	usb2_transfer_dequeue(struct usb_xfer *xfer);
-void	usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error);
-void	usb2_transfer_enqueue(struct usb_xfer_queue *pq,
+void	usbd_pipe_enter(struct usb_xfer *xfer);
+void	usbd_pipe_start(struct usb_xfer_queue *pq);
+void	usbd_transfer_dequeue(struct usb_xfer *xfer);
+void	usbd_transfer_done(struct usb_xfer *xfer, usb_error_t error);
+void	usbd_transfer_enqueue(struct usb_xfer_queue *pq,
 	    struct usb_xfer *xfer);
-void	usb2_transfer_setup_sub(struct usb_setup_params *parm);
-void	usb2_default_transfer_setup(struct usb_device *udev);
-void	usb2_clear_data_toggle(struct usb_device *udev,
+void	usbd_transfer_setup_sub(struct usb_setup_params *parm);
+void	usbd_default_transfer_setup(struct usb_device *udev);
+void	usbd_clear_data_toggle(struct usb_device *udev,
 	    struct usb_endpoint *ep);
-void	usb2_do_poll(struct usb_xfer **ppxfer, uint16_t max);
-usb_callback_t usb2_do_request_callback;
-usb_callback_t usb2_handle_request_callback;
-usb_callback_t usb2_do_clear_stall_callback;
-void	usb2_transfer_timeout_ms(struct usb_xfer *xfer,
+void	usbd_do_poll(struct usb_xfer **ppxfer, uint16_t max);
+usb_callback_t usbd_do_request_callback;
+usb_callback_t usb_handle_request_callback;
+usb_callback_t usb_do_clear_stall_callback;
+void	usbd_transfer_timeout_ms(struct usb_xfer *xfer,
 	    void (*cb) (void *arg), usb_timeout_t ms);
-usb_timeout_t usb2_get_dma_delay(struct usb_bus *bus);
-void	usb2_transfer_power_ref(struct usb_xfer *xfer, int val);
+usb_timeout_t usbd_get_dma_delay(struct usb_bus *bus);
+void	usbd_transfer_power_ref(struct usb_xfer *xfer, int val);
 
 #endif					/* _USB2_TRANSFER_H_ */
diff --git a/sys/dev/usb/usb_util.c b/sys/dev/usb/usb_util.c
index ab0c987..8b16531 100644
--- a/sys/dev/usb/usb_util.c
+++ b/sys/dev/usb/usb_util.c
@@ -65,13 +65,13 @@ device_delete_all_children(device_t dev)
 #endif
 
 /*------------------------------------------------------------------------*
- *	device_set_usb2_desc
+ *	device_set_usb_desc
  *
  * This function can be called at probe or attach to set the USB
  * device supplied textual description for the given device.
  *------------------------------------------------------------------------*/
 void
-device_set_usb2_desc(device_t dev)
+device_set_usb_desc(device_t dev)
 {
 	struct usb_attach_arg *uaa;
 	struct usb_device *udev;
@@ -103,13 +103,13 @@ device_set_usb2_desc(device_t dev)
 
 	if (!err) {
 		/* try to get the interface string ! */
-		err = usb2_req_get_string_any
+		err = usbd_req_get_string_any
 		    (udev, NULL, temp_p,
 		    sizeof(udev->bus->scratch), iface->idesc->iInterface);
 	}
 	if (err) {
 		/* use default description */
-		usb2_devinfo(udev, temp_p,
+		usb_devinfo(udev, temp_p,
 		    sizeof(udev->bus->scratch));
 	}
 	device_set_desc_copy(dev, temp_p);
@@ -118,14 +118,14 @@ device_set_usb2_desc(device_t dev)
 }
 
 /*------------------------------------------------------------------------*
- *	 usb2_pause_mtx - factored out code
+ *	 usb_pause_mtx - factored out code
  *
  * This function will delay the code by the passed number of system
  * ticks. The passed mutex "mtx" will be dropped while waiting, if
  * "mtx" is not NULL.
  *------------------------------------------------------------------------*/
 void
-usb2_pause_mtx(struct mtx *mtx, int _ticks)
+usb_pause_mtx(struct mtx *mtx, int _ticks)
 {
 	if (mtx != NULL)
 		mtx_unlock(mtx);
@@ -154,14 +154,14 @@ usb2_pause_mtx(struct mtx *mtx, int _ticks)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_printBCD
+ *	usb_printbcd
  *
  * This function will print the version number "bcd" to the string
  * pointed to by "p" having a maximum length of "p_len" bytes
  * including the terminating zero.
  *------------------------------------------------------------------------*/
 void
-usb2_printBCD(char *p, uint16_t p_len, uint16_t bcd)
+usb_printbcd(char *p, uint16_t p_len, uint16_t bcd)
 {
 	if (snprintf(p, p_len, "%x.%02x", bcd >> 8, bcd & 0xff)) {
 		/* ignore any errors */
@@ -169,13 +169,13 @@ usb2_printBCD(char *p, uint16_t p_len, uint16_t bcd)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_trim_spaces
+ *	usb_trim_spaces
  *
  * This function removes spaces at the beginning and the end of the string
  * pointed to by the "p" argument.
  *------------------------------------------------------------------------*/
 void
-usb2_trim_spaces(char *p)
+usb_trim_spaces(char *p)
 {
 	char *q;
 	char *e;
@@ -192,10 +192,10 @@ usb2_trim_spaces(char *p)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_make_str_desc - convert an ASCII string into a UNICODE string
+ *	usb_make_str_desc - convert an ASCII string into a UNICODE string
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_make_str_desc(void *ptr, uint16_t max_len, const char *s)
+usb_make_str_desc(void *ptr, uint16_t max_len, const char *s)
 {
 	struct usb_string_descriptor *p = ptr;
 	uint8_t totlen;
diff --git a/sys/dev/usb/usb_util.h b/sys/dev/usb/usb_util.h
index 4273306..6b8f027 100644
--- a/sys/dev/usb/usb_util.h
+++ b/sys/dev/usb/usb_util.h
@@ -28,10 +28,10 @@
 #define	_USB2_UTIL_H_
 
 int	device_delete_all_children(device_t dev);
-uint8_t	usb2_make_str_desc(void *ptr, uint16_t max_len, const char *s);
-void	device_set_usb2_desc(device_t dev);
-void	usb2_pause_mtx(struct mtx *mtx, int _ticks);
-void	usb2_printBCD(char *p, uint16_t p_len, uint16_t bcd);
-void	usb2_trim_spaces(char *p);
+uint8_t	usb_make_str_desc(void *ptr, uint16_t max_len, const char *s);
+void	device_set_usb_desc(device_t dev);
+void	usb_pause_mtx(struct mtx *mtx, int _ticks);
+void	usb_printbcd(char *p, uint16_t p_len, uint16_t bcd);
+void	usb_trim_spaces(char *p);
 
 #endif					/* _USB2_UTIL_H_ */
diff --git a/sys/dev/usb/wlan/if_rum.c b/sys/dev/usb/wlan/if_rum.c
index fe86ac7..799abeb 100644
--- a/sys/dev/usb/wlan/if_rum.c
+++ b/sys/dev/usb/wlan/if_rum.c
@@ -418,7 +418,7 @@ rum_match(device_t self)
 	if (uaa->info.bIfaceIndex != RT2573_IFACE_INDEX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(rum_devs, sizeof(rum_devs), uaa));
+	return (usbd_lookup_id_by_uaa(rum_devs, sizeof(rum_devs), uaa));
 }
 
 static int
@@ -432,7 +432,7 @@ rum_attach(device_t self)
 	uint32_t tmp;
 	int error, ntries;
 
-	device_set_usb2_desc(self);
+	device_set_usb_desc(self);
 	sc->sc_udev = uaa->device;
 	sc->sc_dev = self;
 
@@ -440,11 +440,11 @@ rum_attach(device_t self)
 	    MTX_NETWORK_LOCK, MTX_DEF);
 
 	iface_index = RT2573_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device, &iface_index,
+	error = usbd_transfer_setup(uaa->device, &iface_index,
 	    sc->sc_xfer, rum_config, RUM_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(self, "could not allocate USB transfers, "
-		    "err=%s\n", usb2_errstr(error));
+		    "err=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 
@@ -547,7 +547,7 @@ rum_detach(device_t self)
 	struct ieee80211com *ic;
 
 	/* stop all USB transfers */
-	usb2_transfer_unsetup(sc->sc_xfer, RUM_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, RUM_N_TRANSFER);
 
 	/* free TX list, if any */
 	RUM_LOCK(sc);
@@ -572,13 +572,13 @@ rum_do_request(struct rum_softc *sc,
 	int ntries = 10;
 
 	while (ntries--) {
-		err = usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx,
+		err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
 		    req, data, 0, NULL, 250 /* ms */);
 		if (err == 0)
 			break;
 
 		DPRINTFN(1, "Control request failed, %s (retrying)\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		if (rum_pause(sc, hz / 100))
 			break;
 	}
@@ -610,7 +610,7 @@ rum_vap_create(struct ieee80211com *ic,
 	rvp->newstate = vap->iv_newstate;
 	vap->iv_newstate = rum_newstate;
 
-	usb2_callout_init_mtx(&rvp->amrr_ch, &sc->sc_mtx, 0);
+	usb_callout_init_mtx(&rvp->amrr_ch, &sc->sc_mtx, 0);
 	TASK_INIT(&rvp->amrr_task, 0, rum_amrr_task, rvp);
 	ieee80211_amrr_init(&rvp->amrr, vap,
 	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
@@ -629,7 +629,7 @@ rum_vap_delete(struct ieee80211vap *vap)
 	struct rum_vap *rvp = RUM_VAP(vap);
 	struct ieee80211com *ic = vap->iv_ic;
 
-	usb2_callout_drain(&rvp->amrr_ch);
+	usb_callout_drain(&rvp->amrr_ch);
 	ieee80211_draintask(ic, &rvp->amrr_task);
 	ieee80211_amrr_cleanup(&rvp->amrr);
 	ieee80211_vap_detach(vap);
@@ -718,7 +718,7 @@ rum_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 
 	IEEE80211_UNLOCK(ic);
 	RUM_LOCK(sc);
-	usb2_callout_stop(&rvp->amrr_ch);
+	usb_callout_stop(&rvp->amrr_ch);
 
 	switch (nstate) {
 	case IEEE80211_S_INIT:
@@ -798,9 +798,9 @@ tr_setup:
 				    m->m_pkthdr.len);
 				m->m_pkthdr.len = (MCLBYTES + RT2573_TX_DESC_SIZE);
 			}
-			usb2_copy_in(xfer->frbuffers, 0, &data->desc,
+			usbd_copy_in(xfer->frbuffers, 0, &data->desc,
 			    RT2573_TX_DESC_SIZE);
-			usb2_m_copy_in(xfer->frbuffers, RT2573_TX_DESC_SIZE, m,
+			usbd_m_copy_in(xfer->frbuffers, RT2573_TX_DESC_SIZE, m,
 			    0, m->m_pkthdr.len);
 
 			vap = data->ni->ni_vap;
@@ -825,13 +825,13 @@ tr_setup:
 			xfer->frlengths[0] = len;
 			xfer->priv_fifo = data;
 
-			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));
 
 		ifp->if_oerrors++;
 		data = xfer->priv_fifo;
@@ -877,7 +877,7 @@ rum_bulk_read_callback(struct usb_xfer *xfer)
 		}
 
 		len -= RT2573_RX_DESC_SIZE;
-		usb2_copy_out(xfer->frbuffers, 0, &sc->sc_rx_desc,
+		usbd_copy_out(xfer->frbuffers, 0, &sc->sc_rx_desc,
 		    RT2573_RX_DESC_SIZE);
 
 		rssi = rum_get_rssi(sc, sc->sc_rx_desc.rssi);
@@ -899,7 +899,7 @@ rum_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, RT2573_RX_DESC_SIZE,
+		usbd_copy_out(xfer->frbuffers, RT2573_RX_DESC_SIZE,
 		    mtod(m, uint8_t *), len);
 
 		/* finalize mbuf */
@@ -922,7 +922,7 @@ rum_bulk_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);
 
 		/*
 		 * At the end of a USB callback it is always safe to unlock
@@ -1068,7 +1068,7 @@ rum_sendprot(struct rum_softc *sc,
 	rum_setup_tx_desc(sc, &data->desc, flags, 0, mprot->m_pkthdr.len, protrate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
 
 	return 0;
 }
@@ -1128,7 +1128,7 @@ rum_tx_mgt(struct rum_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
 	    m0->m_pkthdr.len + (int)RT2573_TX_DESC_SIZE, tp->mgmtrate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
 
 	return (0);
 }
@@ -1180,7 +1180,7 @@ rum_tx_raw(struct rum_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
 	    m0->m_pkthdr.len, rate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
 
 	return 0;
 }
@@ -1262,7 +1262,7 @@ rum_tx_data(struct rum_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
 	    m0->m_pkthdr.len + (int)RT2573_TX_DESC_SIZE, rate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
 
 	return 0;
 }
@@ -1351,7 +1351,7 @@ rum_eeprom_read(struct rum_softc *sc, uint16_t addr, void *buf, int len)
 	error = rum_do_request(sc, &req, buf);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 }
 
@@ -1381,7 +1381,7 @@ rum_read_multi(struct rum_softc *sc, uint16_t reg, void *buf, int len)
 	if (error != 0) {
 		device_printf(sc->sc_dev,
 		    "could not multi read MAC register: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 }
 
@@ -1409,7 +1409,7 @@ rum_write_multi(struct rum_softc *sc, uint16_t reg, void *buf, size_t len)
 	if (error != 0) {
 		device_printf(sc->sc_dev,
 		    "could not multi write MAC register: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 	return (error);
 }
@@ -2011,8 +2011,8 @@ rum_init_locked(struct rum_softc *sc)
 
 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
-	usb2_transfer_set_stall(sc->sc_xfer[RUM_BULK_WR]);
-	usb2_transfer_start(sc->sc_xfer[RUM_BULK_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[RUM_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[RUM_BULK_RD]);
 	return;
 
 fail:	rum_stop(sc);
@@ -2049,8 +2049,8 @@ rum_stop(struct rum_softc *sc)
 	/*
 	 * Drain the USB transfers, if not already drained:
 	 */
-	usb2_transfer_drain(sc->sc_xfer[RUM_BULK_WR]);
-	usb2_transfer_drain(sc->sc_xfer[RUM_BULK_RD]);
+	usbd_transfer_drain(sc->sc_xfer[RUM_BULK_WR]);
+	usbd_transfer_drain(sc->sc_xfer[RUM_BULK_RD]);
 
 	RUM_LOCK(sc);
 
@@ -2092,7 +2092,7 @@ rum_load_microcode(struct rum_softc *sc, const uint8_t *ucode, size_t size)
 	err = rum_do_request(sc, &req, NULL);
 	if (err != 0) {
 		device_printf(sc->sc_dev, "could not run firmware: %s\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 	}
 
 	/* give the chip some time to boot */
@@ -2189,7 +2189,7 @@ rum_amrr_start(struct rum_softc *sc, struct ieee80211_node *ni)
 
 	ieee80211_amrr_node_init(&rvp->amrr, &RUM_NODE(ni)->amn, ni);
 
-	usb2_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp);
+	usb_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp);
 }
 
 static void
@@ -2227,7 +2227,7 @@ rum_amrr_task(void *arg, int pending)
 
 	ifp->if_oerrors += fail;	/* count TX retry-fail as Tx errors */
 
-	usb2_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp);
+	usb_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp);
 	RUM_UNLOCK(sc);
 }
 
@@ -2339,7 +2339,7 @@ static int
 rum_pause(struct rum_softc *sc, int timeout)
 {
 
-	usb2_pause_mtx(&sc->sc_mtx, timeout);
+	usb_pause_mtx(&sc->sc_mtx, timeout);
 	return (0);
 }
 
diff --git a/sys/dev/usb/wlan/if_uath.c b/sys/dev/usb/wlan/if_uath.c
index 1c12a9c..29f2398 100644
--- a/sys/dev/usb/wlan/if_uath.c
+++ b/sys/dev/usb/wlan/if_uath.c
@@ -338,7 +338,7 @@ uath_match(device_t dev)
 	if (uaa->info.bIfaceIndex != UATH_IFACE_INDEX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(uath_devs, sizeof(uath_devs), uaa));
+	return (usbd_lookup_id_by_uaa(uath_devs, sizeof(uath_devs), uaa));
 }
 
 static int
@@ -357,7 +357,7 @@ uath_attach(device_t dev)
 #ifdef UATH_DEBUG
 	sc->sc_debug = uath_debug;
 #endif
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	/*
 	 * Only post-firmware devices here.
@@ -378,11 +378,11 @@ uath_attach(device_t dev)
 		goto fail;
 	}
 
-	error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
+	error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
 	    uath_usbconfig, UATH_N_XFERS, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "could not allocate USB transfers, "
-		    "err=%s\n", usb2_errstr(error));
+		    "err=%s\n", usbd_errstr(error));
 		goto fail1;
 	}
 
@@ -497,7 +497,7 @@ uath_attach(device_t dev)
 
 fail4:	if_free(ifp);
 fail3:	UATH_UNLOCK(sc);
-fail2:	usb2_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS);
+fail2:	usbd_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS);
 fail1:	uath_free_cmd_list(sc, sc->sc_cmd, UATH_CMD_LIST_COUNT);
 fail:
 	return (error);
@@ -519,7 +519,7 @@ uath_detach(device_t dev)
 	callout_drain(&sc->stat_ch);
 	callout_drain(&sc->watchdog_ch);
 
-	usb2_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS);
+	usbd_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS);
 	ieee80211_ifdetach(ic);
 
 	/* free buffers */
@@ -735,10 +735,10 @@ uath_cmdsend(struct uath_softc *sc, uint32_t code, const void *idata, int ilen,
 
 	STAILQ_INSERT_TAIL(&sc->sc_cmd_pending, cmd, next);
 	UATH_STAT_INC(sc, st_cmd_pending);
-	usb2_transfer_start(sc->sc_xfer[UATH_INTR_TX]);
+	usbd_transfer_start(sc->sc_xfer[UATH_INTR_TX]);
 
 	if (cmd->flags & UATH_CMD_FLAG_READ) {
-		usb2_transfer_start(sc->sc_xfer[UATH_INTR_RX]);
+		usbd_transfer_start(sc->sc_xfer[UATH_INTR_RX]);
 
 		/* wait at most two seconds for command reply */
 		error = mtx_sleep(cmd, &sc->sc_mtx, 0, "uathcmd", 2 * hz);
@@ -1168,7 +1168,7 @@ uath_init_locked(void *arg)
 	/* XXX? check */
 	uath_cmd_write(sc, WDCMSG_RESET_KEY_CACHE, NULL, 0, 0);
 
-	usb2_transfer_start(sc->sc_xfer[UATH_BULK_RX]);
+	usbd_transfer_start(sc->sc_xfer[UATH_BULK_RX]);
 	/* enable Rx */
 	uath_set_rxfilter(sc, 0x0, UATH_FILTER_OP_INIT);
 	uath_set_rxfilter(sc,
@@ -1355,7 +1355,7 @@ uath_abort_xfers(struct uath_softc *sc)
 	UATH_ASSERT_LOCKED(sc);
 	/* abort any pending transfers */
 	for (i = 0; i < UATH_N_XFERS; i++)
-		usb2_transfer_stop(sc->sc_xfer[i]);
+		usbd_transfer_stop(sc->sc_xfer[i]);
 }
 
 static int
@@ -1425,7 +1425,7 @@ uath_dataflush(struct uath_softc *sc)
 	STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next);
 	UATH_STAT_INC(sc, st_tx_pending);
 	sc->sc_tx_timer = 5;
-	usb2_transfer_start(sc->sc_xfer[UATH_BULK_TX]);
+	usbd_transfer_start(sc->sc_xfer[UATH_BULK_TX]);
 
 	return (0);
 }
@@ -1692,7 +1692,7 @@ uath_tx_start(struct uath_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
 
 	STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next);
 	UATH_STAT_INC(sc, st_tx_pending);
-	usb2_transfer_start(sc->sc_xfer[UATH_BULK_TX]);
+	usbd_transfer_start(sc->sc_xfer[UATH_BULK_TX]);
 
 	return (0);
 }
@@ -2401,12 +2401,12 @@ uath_intr_rx_callback(struct usb_xfer *xfer)
 
 		KASSERT(xfer->actlen >= sizeof(struct uath_cmd_hdr),
 		    ("short xfer error"));
-		usb2_copy_out(xfer->frbuffers, 0, cmd->buf, xfer->actlen);
+		usbd_copy_out(xfer->frbuffers, 0, cmd->buf, xfer->actlen);
 		uath_cmdeof(sc, cmd);
 	case USB_ST_SETUP:
 setup:
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 	default:
 		if (xfer->error != USB_ERR_CANCELLED) {
@@ -2456,9 +2456,9 @@ setup:
 		else
 			UATH_STAT_INC(sc, st_cmd_active);
 
-		usb2_set_frame_data(xfer, cmd->buf, 0);
+		usbd_set_frame_data(xfer, cmd->buf, 0);
 		xfer->frlengths[0] = cmd->buflen;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 	default:
 		if (xfer->error != USB_ERR_CANCELLED) {
@@ -2708,9 +2708,9 @@ setup:
 		UATH_STAT_DEC(sc, st_rx_inactive);
 		STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next);
 		UATH_STAT_INC(sc, st_rx_active);
-		usb2_set_frame_data(xfer, data->buf, 0);
+		usbd_set_frame_data(xfer, data->buf, 0);
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		/*
 		 * To avoid LOR we should unlock our private mutex here to call
@@ -2818,9 +2818,9 @@ setup:
 		STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next);
 		UATH_STAT_INC(sc, st_tx_active);
 
-		usb2_set_frame_data(xfer, data->buf, 0);
+		usbd_set_frame_data(xfer, data->buf, 0);
 		xfer->frlengths[0] = data->buflen;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		UATH_UNLOCK(sc);
 		uath_start(ifp);
diff --git a/sys/dev/usb/wlan/if_upgt.c b/sys/dev/usb/wlan/if_upgt.c
index c1e5b12..b7e697c 100644
--- a/sys/dev/usb/wlan/if_upgt.c
+++ b/sys/dev/usb/wlan/if_upgt.c
@@ -239,7 +239,7 @@ upgt_match(device_t dev)
 	if (uaa->info.bIfaceIndex != UPGT_IFACE_INDEX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(upgt_devs_2, sizeof(upgt_devs_2), uaa));
+	return (usbd_lookup_id_by_uaa(upgt_devs_2, sizeof(upgt_devs_2), uaa));
 }
 
 static int
@@ -257,7 +257,7 @@ upgt_attach(device_t dev)
 #ifdef UPGT_DEBUG
 	sc->sc_debug = upgt_debug;
 #endif
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, device_get_nameunit(sc->sc_dev), MTX_NETWORK_LOCK,
 	    MTX_DEF);
@@ -272,11 +272,11 @@ upgt_attach(device_t dev)
 	if (error)
 		goto fail2;
 
-	error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
+	error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
 	    upgt_config, UPGT_N_XFERS, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "could not allocate USB transfers, "
-		    "err=%s\n", usb2_errstr(error));
+		    "err=%s\n", usbd_errstr(error));
 		goto fail3;
 	}
 
@@ -382,7 +382,7 @@ upgt_attach(device_t dev)
 	return (0);
 
 fail5:	if_free(ifp);
-fail4:	usb2_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS);
+fail4:	usbd_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS);
 fail3:	upgt_free_rx(sc);
 fail2:	upgt_free_tx(sc);
 fail1:	mtx_destroy(&sc->sc_mtx);
@@ -641,7 +641,7 @@ upgt_init_locked(struct upgt_softc *sc)
 	if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 		upgt_stop_locked(sc);
 
-	usb2_transfer_start(sc->sc_xfer[UPGT_BULK_RX]);
+	usbd_transfer_start(sc->sc_xfer[UPGT_BULK_RX]);
 
 	(void)upgt_set_macfilter(sc, IEEE80211_S_SCAN);
 
@@ -1319,7 +1319,7 @@ upgt_eeprom_read(struct upgt_softc *sc)
 	int block, error, offset;
 
 	UPGT_LOCK(sc);
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	offset = 0;
 	block = UPGT_EEPROM_BLOCK_SIZE;
@@ -1679,7 +1679,7 @@ upgt_fw_load(struct upgt_softc *sc)
 	upgt_bulk_tx(sc, data_cmd);
 
 	/* waiting 'OK' response.  */
-	usb2_transfer_start(sc->sc_xfer[UPGT_BULK_RX]);
+	usbd_transfer_start(sc->sc_xfer[UPGT_BULK_RX]);
 	error = mtx_sleep(sc, &sc->sc_mtx, 0, "upgtfw", 2 * hz);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "firmware load failed!\n");
@@ -1911,7 +1911,7 @@ upgt_bulk_tx(struct upgt_softc *sc, struct upgt_data *data)
 
 	STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next);
 	UPGT_STAT_INC(sc, st_tx_pending);
-	usb2_transfer_start(sc->sc_xfer[UPGT_BULK_TX]);
+	usbd_transfer_start(sc->sc_xfer[UPGT_BULK_TX]);
 }
 
 static int
@@ -1930,7 +1930,7 @@ upgt_device_reset(struct upgt_softc *sc)
 	bcopy(init_cmd, data->buf, sizeof(init_cmd));
 	data->buflen = sizeof(init_cmd);
 	upgt_bulk_tx(sc, data);
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	UPGT_UNLOCK(sc);
 	DPRINTF(sc, UPGT_DEBUG_FW, "%s: device initialized\n", __func__);
@@ -2000,7 +2000,7 @@ upgt_detach(device_t dev)
 	callout_drain(&sc->sc_led_ch);
 	callout_drain(&sc->sc_watchdog_ch);
 
-	usb2_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS);
+	usbd_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS);
 	ieee80211_ifdetach(ic);
 	upgt_free_rx(sc);
 	upgt_free_tx(sc);
@@ -2045,7 +2045,7 @@ upgt_abort_xfers_locked(struct upgt_softc *sc)
 	UPGT_ASSERT_LOCKED(sc);
 	/* abort any pending transfers */
 	for (i = 0; i < UPGT_N_XFERS; i++)
-		usb2_transfer_stop(sc->sc_xfer[i]);
+		usbd_transfer_stop(sc->sc_xfer[i]);
 }
 
 static void
@@ -2274,9 +2274,9 @@ setup:
 			return;
 		STAILQ_REMOVE_HEAD(&sc->sc_rx_inactive, next);
 		STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next);
-		usb2_set_frame_data(xfer, data->buf, 0);
+		usbd_set_frame_data(xfer, data->buf, 0);
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		/*
 		 * To avoid LOR we should unlock our private mutex here to call
@@ -2347,9 +2347,9 @@ setup:
 		STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next);
 		UPGT_STAT_INC(sc, st_tx_active);
 
-		usb2_set_frame_data(xfer, data->buf, 0);
+		usbd_set_frame_data(xfer, data->buf, 0);
 		xfer->frlengths[0] = data->buflen;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		UPGT_UNLOCK(sc);
 		upgt_start(ifp);
 		UPGT_LOCK(sc);
diff --git a/sys/dev/usb/wlan/if_ural.c b/sys/dev/usb/wlan/if_ural.c
index 83e279ce..f450e31 100644
--- a/sys/dev/usb/wlan/if_ural.c
+++ b/sys/dev/usb/wlan/if_ural.c
@@ -421,7 +421,7 @@ ural_match(device_t self)
 	if (uaa->info.bIfaceIndex != RAL_IFACE_INDEX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(ural_devs, sizeof(ural_devs), uaa));
+	return (usbd_lookup_id_by_uaa(ural_devs, sizeof(ural_devs), uaa));
 }
 
 static int
@@ -434,7 +434,7 @@ ural_attach(device_t self)
 	uint8_t iface_index, bands;
 	int error;
 
-	device_set_usb2_desc(self);
+	device_set_usb_desc(self);
 	sc->sc_udev = uaa->device;
 	sc->sc_dev = self;
 
@@ -442,12 +442,12 @@ ural_attach(device_t self)
 	    MTX_NETWORK_LOCK, MTX_DEF);
 
 	iface_index = RAL_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &iface_index, sc->sc_xfer, ural_config,
 	    URAL_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(self, "could not allocate USB transfers, "
-		    "err=%s\n", usb2_errstr(error));
+		    "err=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 
@@ -538,7 +538,7 @@ ural_detach(device_t self)
 	struct ieee80211com *ic;
 
 	/* stop all USB transfers */
-	usb2_transfer_unsetup(sc->sc_xfer, URAL_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, URAL_N_TRANSFER);
 
 	/* free TX list, if any */
 	RAL_LOCK(sc);
@@ -563,13 +563,13 @@ ural_do_request(struct ural_softc *sc,
 	int ntries = 10;
 
 	while (ntries--) {
-		err = usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx,
+		err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
 		    req, data, 0, NULL, 250 /* ms */);
 		if (err == 0)
 			break;
 
 		DPRINTFN(1, "Control request failed, %s (retrying)\n",
-		    usb2_errstr(err));
+		    usbd_errstr(err));
 		if (ural_pause(sc, hz / 100))
 			break;
 	}
@@ -601,7 +601,7 @@ ural_vap_create(struct ieee80211com *ic,
 	uvp->newstate = vap->iv_newstate;
 	vap->iv_newstate = ural_newstate;
 
-	usb2_callout_init_mtx(&uvp->amrr_ch, &sc->sc_mtx, 0);
+	usb_callout_init_mtx(&uvp->amrr_ch, &sc->sc_mtx, 0);
 	TASK_INIT(&uvp->amrr_task, 0, ural_amrr_task, uvp);
 	ieee80211_amrr_init(&uvp->amrr, vap,
 	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
@@ -620,7 +620,7 @@ ural_vap_delete(struct ieee80211vap *vap)
 	struct ural_vap *uvp = URAL_VAP(vap);
 	struct ieee80211com *ic = vap->iv_ic;
 
-	usb2_callout_drain(&uvp->amrr_ch);
+	usb_callout_drain(&uvp->amrr_ch);
 	ieee80211_draintask(ic, &uvp->amrr_task);
 	ieee80211_amrr_cleanup(&uvp->amrr);
 	ieee80211_vap_detach(vap);
@@ -707,7 +707,7 @@ ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 
 	IEEE80211_UNLOCK(ic);
 	RAL_LOCK(sc);
-	usb2_callout_stop(&uvp->amrr_ch);
+	usb_callout_stop(&uvp->amrr_ch);
 
 	switch (nstate) {
 	case IEEE80211_S_INIT:
@@ -811,9 +811,9 @@ tr_setup:
 				    m->m_pkthdr.len);
 				m->m_pkthdr.len = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE);
 			}
-			usb2_copy_in(xfer->frbuffers, 0, &data->desc,
+			usbd_copy_in(xfer->frbuffers, 0, &data->desc,
 			    RAL_TX_DESC_SIZE);
-			usb2_m_copy_in(xfer->frbuffers, RAL_TX_DESC_SIZE, m, 0,
+			usbd_m_copy_in(xfer->frbuffers, RAL_TX_DESC_SIZE, m, 0,
 			    m->m_pkthdr.len);
 
 			vap = data->ni->ni_vap;
@@ -838,13 +838,13 @@ tr_setup:
 			xfer->frlengths[0] = len;
 			xfer->priv_fifo = data;
 
-			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));
 
 		ifp->if_oerrors++;
 		data = xfer->priv_fifo;
@@ -891,7 +891,7 @@ ural_bulk_read_callback(struct usb_xfer *xfer)
 
 		len -= RAL_RX_DESC_SIZE;
 		/* rx descriptor is located at the end */
-		usb2_copy_out(xfer->frbuffers, len, &sc->sc_rx_desc,
+		usbd_copy_out(xfer->frbuffers, len, &sc->sc_rx_desc,
 		    RAL_RX_DESC_SIZE);
 
 		rssi = URAL_RSSI(sc->sc_rx_desc.rssi);
@@ -914,7 +914,7 @@ ural_bulk_read_callback(struct usb_xfer *xfer)
 			ifp->if_ierrors++;
 			goto tr_setup;
 		}
-		usb2_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *), len);
+		usbd_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *), len);
 
 		/* finalize mbuf */
 		m->m_pkthdr.rcvif = ifp;
@@ -939,7 +939,7 @@ ural_bulk_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);
 
 		/*
 		 * At the end of a USB callback it is always safe to unlock
@@ -1071,7 +1071,7 @@ ural_tx_bcn(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
 	    m0->m_pkthdr.len, tp->mgmtrate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
 
 	return (0);
 }
@@ -1132,7 +1132,7 @@ ural_tx_mgt(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
 	    m0->m_pkthdr.len, tp->mgmtrate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
 
 	return 0;
 }
@@ -1183,7 +1183,7 @@ ural_sendprot(struct ural_softc *sc,
 	ural_setup_tx_desc(sc, &data->desc, flags, mprot->m_pkthdr.len, protrate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
 
 	return 0;
 }
@@ -1236,7 +1236,7 @@ ural_tx_raw(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
 	    m0->m_pkthdr.len, rate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
 
 	return 0;
 }
@@ -1316,7 +1316,7 @@ ural_tx_data(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
 	    m0->m_pkthdr.len, rate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
 
 	return 0;
 }
@@ -1403,7 +1403,7 @@ ural_set_testmode(struct ural_softc *sc)
 	error = ural_do_request(sc, &req, NULL);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not set test mode: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 }
 
@@ -1422,7 +1422,7 @@ ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len)
 	error = ural_do_request(sc, &req, buf);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 }
 
@@ -1442,7 +1442,7 @@ ural_read(struct ural_softc *sc, uint16_t reg)
 	error = ural_do_request(sc, &req, &val);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 		return 0;
 	}
 
@@ -1464,7 +1464,7 @@ ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
 	error = ural_do_request(sc, &req, buf);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 }
 
@@ -1483,7 +1483,7 @@ ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val)
 	error = ural_do_request(sc, &req, NULL);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 }
 
@@ -1502,7 +1502,7 @@ ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
 	error = ural_do_request(sc, &req, buf);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 }
 
@@ -2120,8 +2120,8 @@ ural_init_locked(struct ural_softc *sc)
 
 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
-	usb2_transfer_set_stall(sc->sc_xfer[URAL_BULK_WR]);
-	usb2_transfer_start(sc->sc_xfer[URAL_BULK_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[URAL_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[URAL_BULK_RD]);
 	return;
 
 fail:	ural_stop(sc);
@@ -2156,8 +2156,8 @@ ural_stop(struct ural_softc *sc)
 	 * Drain all the transfers, if not already drained:
 	 */
 	RAL_UNLOCK(sc);
-	usb2_transfer_drain(sc->sc_xfer[URAL_BULK_WR]);
-	usb2_transfer_drain(sc->sc_xfer[URAL_BULK_RD]);
+	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_WR]);
+	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_RD]);
 	RAL_LOCK(sc);
 
 	ural_unsetup_tx_list(sc);
@@ -2234,7 +2234,7 @@ ural_amrr_start(struct ural_softc *sc, struct ieee80211_node *ni)
 
 	ieee80211_amrr_node_init(&uvp->amrr, &URAL_NODE(ni)->amn, ni);
 
-	usb2_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp);
+	usb_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp);
 }
 
 static void
@@ -2272,7 +2272,7 @@ ural_amrr_task(void *arg, int pending)
 
 	ifp->if_oerrors += fail;	/* count TX retry-fail as Tx errors */
 
-	usb2_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp);
+	usb_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp);
 	RAL_UNLOCK(sc);
 }
 
@@ -2280,6 +2280,6 @@ static int
 ural_pause(struct ural_softc *sc, int timeout)
 {
 
-	usb2_pause_mtx(&sc->sc_mtx, timeout);
+	usb_pause_mtx(&sc->sc_mtx, timeout);
 	return (0);
 }
diff --git a/sys/dev/usb/wlan/if_urtw.c b/sys/dev/usb/wlan/if_urtw.c
index 883c1d9..30b14d3 100644
--- a/sys/dev/usb/wlan/if_urtw.c
+++ b/sys/dev/usb/wlan/if_urtw.c
@@ -730,7 +730,7 @@ urtw_match(device_t dev)
 	if (uaa->info.bIfaceIndex != URTW_IFACE_INDEX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(urtw_devs, sizeof(urtw_devs), uaa));
+	return (usbd_lookup_id_by_uaa(urtw_devs, sizeof(urtw_devs), uaa));
 }
 
 static int
@@ -747,7 +747,7 @@ urtw_attach(device_t dev)
 	uint32_t data;
 	usb_error_t error;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	sc->sc_dev = dev;
 	sc->sc_udev = uaa->device;
@@ -759,7 +759,7 @@ urtw_attach(device_t dev)
 
 	mtx_init(&sc->sc_mtx, device_get_nameunit(sc->sc_dev), MTX_NETWORK_LOCK,
 	    MTX_DEF);
-	usb2_callout_init_mtx(&sc->sc_led_ch, &sc->sc_mtx, 0);
+	usb_callout_init_mtx(&sc->sc_led_ch, &sc->sc_mtx, 0);
 	TASK_INIT(&sc->sc_led_task, 0, urtw_ledtask, sc);
 	callout_init(&sc->sc_watchdog_ch, 0);
 
@@ -771,11 +771,11 @@ urtw_attach(device_t dev)
 		n_setup = URTW_8187L_N_XFERS;
 	}
 
-	error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
+	error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
 	    setup_start, n_setup, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "could not allocate USB transfers, "
-		    "err=%s\n", usb2_errstr(error));
+		    "err=%s\n", usbd_errstr(error));
 		ret = ENXIO;
 		goto fail0;
 	}
@@ -865,7 +865,7 @@ urtw_attach(device_t dev)
 	return (0);
 
 fail:	URTW_UNLOCK(sc);
-fail1:	usb2_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ?
+fail1:	usbd_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ?
 	    URTW_8187B_N_XFERS : URTW_8187L_N_XFERS);
 fail0:
 	return (ret);
@@ -884,10 +884,10 @@ urtw_detach(device_t dev)
 	urtw_stop(ifp, 1);
 	ieee80211_draintask(ic, &sc->sc_led_task);
 
-	usb2_callout_drain(&sc->sc_led_ch);
+	usb_callout_drain(&sc->sc_led_ch);
 	callout_drain(&sc->sc_watchdog_ch);
 
-	usb2_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ?
+	usbd_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ?
 	    URTW_8187B_N_XFERS : URTW_8187L_N_XFERS);
 	ieee80211_ifdetach(ic);
 
@@ -1141,7 +1141,7 @@ urtw_adapter_start_b(struct urtw_softc *sc)
 	urtw_write16_m(sc, URTW_RF_PINS_OUTPUT, 0x0480);
 	urtw_write16_m(sc, URTW_RF_PINS_SELECT, 0x2488);
 	urtw_write16_m(sc, URTW_RF_PINS_ENABLE, 0x1fff);
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	error = sc->sc_rf_init(sc);
 	if (error != 0)
@@ -1305,7 +1305,7 @@ urtw_8187b_cmd_reset(struct urtw_softc *sc)
 	urtw_write8_m(sc, URTW_CMD, data8);
 
 	for (i = 0; i < 20; i++) {
-		usb2_pause_mtx(&sc->sc_mtx, 2);
+		usb_pause_mtx(&sc->sc_mtx, 2);
 		urtw_read8_m(sc, URTW_CMD, &data8);
 		if (!(data8 & URTW_CMD_RST))
 			break;
@@ -1320,7 +1320,7 @@ urtw_8187b_cmd_reset(struct urtw_softc *sc)
 		goto fail;
 
 	for (i = 0; i < 20; i++) {
-		usb2_pause_mtx(&sc->sc_mtx, 4);
+		usb_pause_mtx(&sc->sc_mtx, 4);
 		urtw_read8_m(sc, URTW_EPROM_CMD, &data8);
 		if (!(data8 & URTW_EPROM_CMD_CONFIG))
 			break;
@@ -1358,15 +1358,15 @@ urtw_do_request(struct urtw_softc *sc,
 	URTW_ASSERT_LOCKED(sc);
 
 	while (ntries--) {
-		err = usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx,
+		err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
 		    req, data, 0, NULL, 250 /* ms */);
 		if (err == 0)
 			break;
 
 		DPRINTF(sc, URTW_DEBUG_INIT,
 		    "Control request failed, %s (retrying)\n",
-		    usb2_errstr(err));
-		usb2_pause_mtx(&sc->sc_mtx, hz / 100);
+		    usbd_errstr(err));
+		usb_pause_mtx(&sc->sc_mtx, hz / 100);
 	}
 	return (err);
 }
@@ -1431,9 +1431,9 @@ urtw_stop_locked(struct ifnet *ifp, int disable)
 fail:
 	if (error)
 		device_printf(sc->sc_dev, "failed to stop (%s)\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 
-	usb2_callout_stop(&sc->sc_led_ch);
+	usb_callout_stop(&sc->sc_led_ch);
 	callout_stop(&sc->sc_watchdog_ch);
 
 	urtw_abort_xfers(sc);
@@ -1461,7 +1461,7 @@ urtw_abort_xfers(struct urtw_softc *sc)
 
 	/* abort any pending transfers */
 	for (i = 0; i < max; i++)
-		usb2_transfer_stop(sc->sc_xfer[i]);
+		usbd_transfer_stop(sc->sc_xfer[i]);
 }
 
 static int
@@ -1709,7 +1709,7 @@ urtw_set_channel(struct ieee80211com *ic)
 	error = sc->sc_rf_set_chan(sc, ieee80211_chan2ieee(ic, ic->ic_curchan));
 	if (error != 0)
 		goto fail;
-	usb2_pause_mtx(&sc->sc_mtx, 10);
+	usb_pause_mtx(&sc->sc_mtx, 10);
 	urtw_write32_m(sc, URTW_TX_CONF, orig);
 
 	urtw_write16_m(sc, URTW_ATIM_WND, 2);
@@ -1862,7 +1862,7 @@ urtw_tx_start(struct urtw_softc *sc, struct ieee80211_node *ni, struct mbuf *m0,
 		    sc->sc_xfer[URTW_8187L_BULK_TX_NORMAL];
 
 	STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next);
-	usb2_transfer_start(xfer);
+	usbd_transfer_start(xfer);
 
 	error = urtw_led_ctl(sc, URTW_LED_CTL_TX);
 	if (error != 0)
@@ -1888,7 +1888,7 @@ urtw_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 
 	IEEE80211_UNLOCK(ic);
 	URTW_LOCK(sc);
-	usb2_callout_stop(&sc->sc_led_ch);
+	usb_callout_stop(&sc->sc_led_ch);
 	callout_stop(&sc->sc_watchdog_ch);
 
 	switch (nstate) {
@@ -2528,20 +2528,20 @@ urtw_8225_rf_init(struct urtw_softc *sc)
 	error = urtw_8185_rf_pins_enable(sc);
 	if (error)
 		goto fail;
-	usb2_pause_mtx(&sc->sc_mtx, 1000);
+	usb_pause_mtx(&sc->sc_mtx, 1000);
 
 	for (i = 0; i < N(urtw_8225_rf_part1); i++) {
 		urtw_8225_write(sc, urtw_8225_rf_part1[i].reg,
 		    urtw_8225_rf_part1[i].val);
-		usb2_pause_mtx(&sc->sc_mtx, 1);
+		usb_pause_mtx(&sc->sc_mtx, 1);
 	}
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 	urtw_8225_write(sc,
 	    URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC1);
-	usb2_pause_mtx(&sc->sc_mtx, 200);
+	usb_pause_mtx(&sc->sc_mtx, 200);
 	urtw_8225_write(sc,
 	    URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC2);
-	usb2_pause_mtx(&sc->sc_mtx, 200);
+	usb_pause_mtx(&sc->sc_mtx, 200);
 	urtw_8225_write(sc,
 	    URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC3);
 
@@ -2557,15 +2557,15 @@ urtw_8225_rf_init(struct urtw_softc *sc)
 
 	for (i = 0; i < 128; i++) {
 		urtw_8187_write_phy_ofdm(sc, 0xb, urtw_8225_agc[i]);
-		usb2_pause_mtx(&sc->sc_mtx, 1);
+		usb_pause_mtx(&sc->sc_mtx, 1);
 		urtw_8187_write_phy_ofdm(sc, 0xa, (uint8_t)i + 0x80);
-		usb2_pause_mtx(&sc->sc_mtx, 1);
+		usb_pause_mtx(&sc->sc_mtx, 1);
 	}
 
 	for (i = 0; i < N(urtw_8225_rf_part2); i++) {
 		urtw_8187_write_phy_ofdm(sc, urtw_8225_rf_part2[i].reg,
 		    urtw_8225_rf_part2[i].val);
-		usb2_pause_mtx(&sc->sc_mtx, 1);
+		usb_pause_mtx(&sc->sc_mtx, 1);
 	}
 
 	error = urtw_8225_setgain(sc, 4);
@@ -2575,7 +2575,7 @@ urtw_8225_rf_init(struct urtw_softc *sc)
 	for (i = 0; i < N(urtw_8225_rf_part3); i++) {
 		urtw_8187_write_phy_cck(sc, urtw_8225_rf_part3[i].reg,
 		    urtw_8225_rf_part3[i].val);
-		usb2_pause_mtx(&sc->sc_mtx, 1);
+		usb_pause_mtx(&sc->sc_mtx, 1);
 	}
 
 	urtw_write8_m(sc, URTW_TESTR, 0x0d);
@@ -2585,9 +2585,9 @@ urtw_8225_rf_init(struct urtw_softc *sc)
 		goto fail;
 
 	urtw_8187_write_phy_cck(sc, 0x10, 0x9b);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 	urtw_8187_write_phy_ofdm(sc, 0x26, 0x90);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 
 	/* TX ant A, 0x0 for B */
 	error = urtw_8185_tx_antenna(sc, 0x3);
@@ -2617,7 +2617,7 @@ urtw_8185_tx_antenna(struct urtw_softc *sc, uint8_t ant)
 	usb_error_t error;
 
 	urtw_write8_m(sc, URTW_TX_ANTENNA, ant);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 fail:
 	return (error);
 }
@@ -2649,7 +2649,7 @@ urtw_8187_write_phy(struct urtw_softc *sc, uint8_t addr, uint32_t data)
 	urtw_write8_m(sc, URTW_PHY_MAGIC3, ((phyw & 0x00ff0000) >> 16));
 	urtw_write8_m(sc, URTW_PHY_MAGIC2, ((phyw & 0x0000ff00) >> 8));
 	urtw_write8_m(sc, URTW_PHY_MAGIC1, ((phyw & 0x000000ff)));
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 fail:
 	return (error);
 }
@@ -2689,7 +2689,7 @@ urtw_8225_usb_init(struct urtw_softc *sc)
 	urtw_write16_m(sc, URTW_RF_PINS_SELECT, 0x80);
 	urtw_write16_m(sc, URTW_RF_PINS_ENABLE, 0x80);
 
-	usb2_pause_mtx(&sc->sc_mtx, 500);
+	usb_pause_mtx(&sc->sc_mtx, 500);
 fail:
 	return (error);
 }
@@ -2722,7 +2722,7 @@ urtw_8225_write_c(struct urtw_softc *sc, uint8_t addr, uint16_t data)
 	DELAY(10);
 	urtw_write16_m(sc, URTW_RF_PINS_OUTPUT, d80 | URTW_BB_HOST_BANG_EN);
 	urtw_write16_m(sc, URTW_RF_PINS_SELECT, d84);
-	usb2_pause_mtx(&sc->sc_mtx, 2);
+	usb_pause_mtx(&sc->sc_mtx, 2);
 fail:
 	return (error);
 }
@@ -2776,7 +2776,7 @@ urtw_8225_rf_set_chan(struct urtw_softc *sc, int chan)
 	if (error)
 		goto fail;
 	urtw_8225_write(sc, URTW_8225_ADDR_7_MAGIC, urtw_8225_channel[chan]);
-	usb2_pause_mtx(&sc->sc_mtx, 10);
+	usb_pause_mtx(&sc->sc_mtx, 10);
 
 	urtw_write8_m(sc, URTW_SIFS, 0x22);
 
@@ -2855,7 +2855,7 @@ urtw_8225_set_txpwrlvl(struct urtw_softc *sc, int chan)
 		urtw_8187_write_phy_cck(sc, 0x44 + i,
 		    cck_pwltable[idx * 8 + i]);
 	}
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 
 	/* OFDM power setting */
 	ofdm_pwrlvl = (ofdm_pwrlvl > (ofdm_pwrlvl_max - ofdm_pwrlvl_min)) ?
@@ -2876,7 +2876,7 @@ urtw_8225_set_txpwrlvl(struct urtw_softc *sc, int chan)
 	    urtw_8225_tx_gain_cck_ofdm[set] >> 1);
 	urtw_8187_write_phy_ofdm(sc, 0x5, urtw_8225_txpwr_ofdm[idx]);
 	urtw_8187_write_phy_ofdm(sc, 0x7, urtw_8225_txpwr_ofdm[idx]);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 fail:
 	return (error);
 }
@@ -2950,13 +2950,13 @@ urtw_8225v2_rf_init(struct urtw_softc *sc)
 	if (error)
 		goto fail;
 
-	usb2_pause_mtx(&sc->sc_mtx, 500);
+	usb_pause_mtx(&sc->sc_mtx, 500);
 
 	for (i = 0; i < N(urtw_8225v2_rf_part1); i++) {
 		urtw_8225_write(sc, urtw_8225v2_rf_part1[i].reg,
 		    urtw_8225v2_rf_part1[i].val);
 	}
-	usb2_pause_mtx(&sc->sc_mtx, 50);
+	usb_pause_mtx(&sc->sc_mtx, 50);
 
 	urtw_8225_write(sc,
 	    URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC1);
@@ -2975,10 +2975,10 @@ urtw_8225v2_rf_init(struct urtw_softc *sc)
 	    URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC2);
 	urtw_8225_write(sc,
 	    URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC1);
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 	urtw_8225_write(sc,
 	    URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC2);
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	error = urtw_8225_read(sc, URTW_8225_ADDR_6_MAGIC, &data32);
 	if (error != 0)
@@ -2988,17 +2988,17 @@ urtw_8225v2_rf_init(struct urtw_softc *sc)
 	if (!(data32 & URTW_8225_ADDR_6_DATA_MAGIC2)) {
 		urtw_8225_write(sc,
 		    URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC1);
-		usb2_pause_mtx(&sc->sc_mtx, 100);
+		usb_pause_mtx(&sc->sc_mtx, 100);
 		urtw_8225_write(sc,
 		    URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC2);
-		usb2_pause_mtx(&sc->sc_mtx, 50);
+		usb_pause_mtx(&sc->sc_mtx, 50);
 		error = urtw_8225_read(sc, URTW_8225_ADDR_6_MAGIC, &data32);
 		if (error != 0)
 			goto fail;
 		if (!(data32 & URTW_8225_ADDR_6_DATA_MAGIC2))
 			device_printf(sc->sc_dev, "RF calibration failed\n");
 	}
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	urtw_8225_write(sc,
 	    URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC6);
@@ -3054,7 +3054,7 @@ urtw_8225v2_rf_set_chan(struct urtw_softc *sc, int chan)
 		goto fail;
 
 	urtw_8225_write(sc, URTW_8225_ADDR_7_MAGIC, urtw_8225_channel[chan]);
-	usb2_pause_mtx(&sc->sc_mtx, 10);
+	usb_pause_mtx(&sc->sc_mtx, 10);
 
 	urtw_write8_m(sc, URTW_SIFS, 0x22);
 
@@ -3193,7 +3193,7 @@ urtw_8225v2_set_txpwrlvl(struct urtw_softc *sc, int chan)
 
 	urtw_write8_m(sc, URTW_TX_GAIN_CCK,
 	    urtw_8225v2_tx_gain_cck_ofdm[cck_pwrlvl]);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 
 	/* OFDM power setting */
 	ofdm_pwrlvl = (ofdm_pwrlvl > (ofdm_pwrlvl_max - ofdm_pwrlvl_min)) ?
@@ -3213,7 +3213,7 @@ urtw_8225v2_set_txpwrlvl(struct urtw_softc *sc, int chan)
 
 	urtw_write8_m(sc, URTW_TX_GAIN_OFDM,
 	    urtw_8225v2_tx_gain_cck_ofdm[ofdm_pwrlvl]);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 fail:
 	return (error);
 }
@@ -3227,13 +3227,13 @@ urtw_8225v2_setgain(struct urtw_softc *sc, int16_t gain)
 	/* XXX for A?  */
 	gainp = urtw_8225v2_gain_bg;
 	urtw_8187_write_phy_ofdm(sc, 0x0d, gainp[gain * 3]);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 	urtw_8187_write_phy_ofdm(sc, 0x1b, gainp[gain * 3 + 1]);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 	urtw_8187_write_phy_ofdm(sc, 0x1d, gainp[gain * 3 + 2]);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 	urtw_8187_write_phy_ofdm(sc, 0x21, 0x17);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 fail:
 	return (error);
 }
@@ -3249,7 +3249,7 @@ urtw_8225_isv2(struct urtw_softc *sc, int *ret)
 	urtw_write16_m(sc, URTW_RF_PINS_OUTPUT, URTW_RF_PINS_MAGIC5);
 	urtw_write16_m(sc, URTW_RF_PINS_SELECT, URTW_RF_PINS_MAGIC5);
 	urtw_write16_m(sc, URTW_RF_PINS_ENABLE, URTW_RF_PINS_MAGIC5);
-	usb2_pause_mtx(&sc->sc_mtx, 500);
+	usb_pause_mtx(&sc->sc_mtx, 500);
 
 	urtw_8225_write(sc, URTW_8225_ADDR_0_MAGIC,
 	    URTW_8225_ADDR_0_DATA_MAGIC1);
@@ -3342,7 +3342,7 @@ urtw_8225v2b_rf_set_chan(struct urtw_softc *sc, int chan)
 		goto fail;
 
 	urtw_8225_write(sc, URTW_8225_ADDR_7_MAGIC, urtw_8225_channel[chan]);
-	usb2_pause_mtx(&sc->sc_mtx, 10);
+	usb_pause_mtx(&sc->sc_mtx, 10);
 
 	urtw_write8_m(sc, URTW_SIFS, 0xa);
 	if (ic->ic_flags & IEEE80211_F_SHSLOT) {
@@ -3405,7 +3405,7 @@ urtw_8225v2b_set_txpwrlvl(struct urtw_softc *sc, int chan)
 
 	urtw_write8_m(sc, URTW_TX_GAIN_CCK,
 	    urtw_8225v2_tx_gain_cck_ofdm[cck_pwrlvl] << 1);
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 
 	/* OFDM power setting */
 	ofdm_pwrlvl = (ofdm_pwrlvl > 15) ?
@@ -3437,7 +3437,7 @@ urtw_8225v2b_set_txpwrlvl(struct urtw_softc *sc, int chan)
 			urtw_8187_write_phy_ofdm(sc, 0x89, 0x50);
 		}
 	}
-	usb2_pause_mtx(&sc->sc_mtx, 1);
+	usb_pause_mtx(&sc->sc_mtx, 1);
 fail:
 	return (error);
 }
@@ -3554,7 +3554,7 @@ urtw_reset(struct urtw_softc *sc)
 	error = urtw_intr_disable(sc);
 	if (error)
 		goto fail;
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	error = urtw_write8e(sc, 0x18, 0x10);
 	if (error != 0)
@@ -3565,12 +3565,12 @@ urtw_reset(struct urtw_softc *sc)
 	error = urtw_write8e(sc, 0x18, 0x00);
 	if (error != 0)
 		goto fail;
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	urtw_read8_m(sc, URTW_CMD, &data);
 	data = (data & 0x2) | URTW_CMD_RST;
 	urtw_write8_m(sc, URTW_CMD, data);
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	urtw_read8_m(sc, URTW_CMD, &data);
 	if (data & URTW_CMD_RST) {
@@ -3581,7 +3581,7 @@ urtw_reset(struct urtw_softc *sc)
 	error = urtw_set_mode(sc, URTW_EPROM_CMD_LOAD);
 	if (error)
 		goto fail;
-	usb2_pause_mtx(&sc->sc_mtx, 100);
+	usb_pause_mtx(&sc->sc_mtx, 100);
 
 	error = urtw_8180_set_anaparam(sc, URTW_8225_ANAPARAM_ON);
 	if (error)
@@ -3654,11 +3654,11 @@ urtw_led_mode0(struct urtw_softc *sc, int mode)
 		sc->sc_gpio_ledinprogress = 1;
 		sc->sc_gpio_blinkstate = (sc->sc_gpio_ledon != 0) ?
 			URTW_LED_OFF : URTW_LED_ON;
-		usb2_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc);
+		usb_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc);
 		break;
 	case URTW_LED_POWER_ON_BLINK:
 		urtw_led_on(sc, URTW_LED_GPIO);
-		usb2_pause_mtx(&sc->sc_mtx, 100);
+		usb_pause_mtx(&sc->sc_mtx, 100);
 		urtw_led_off(sc, URTW_LED_GPIO);
 		break;
 	default:
@@ -3803,7 +3803,7 @@ urtw_led_blink(struct urtw_softc *sc)
 
 	switch (sc->sc_gpio_ledstate) {
 	case URTW_LED_BLINK_NORMAL:
-		usb2_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc);
+		usb_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc);
 		break;
 	default:
 		panic("unknown LED status 0x%x", sc->sc_gpio_ledstate);
@@ -3818,7 +3818,7 @@ urtw_rx_enable(struct urtw_softc *sc)
 	uint8_t data;
 	usb_error_t error;
 
-	usb2_transfer_start((sc->sc_flags & URTW_RTL8187B) ?
+	usbd_transfer_start((sc->sc_flags & URTW_RTL8187B) ?
 	    sc->sc_xfer[URTW_8187B_BULK_RX] : sc->sc_xfer[URTW_8187L_BULK_RX]);
 
 	error = urtw_rx_setconf(sc);
@@ -4055,9 +4055,9 @@ setup:
 		}
 		STAILQ_REMOVE_HEAD(&sc->sc_rx_inactive, next);
 		STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next);
-		usb2_set_frame_data(xfer, data->buf, 0);
+		usbd_set_frame_data(xfer, data->buf, 0);
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		/*
 		 * To avoid LOR we should unlock our private mutex here to call
@@ -4155,9 +4155,9 @@ setup:
 		STAILQ_REMOVE_HEAD(&sc->sc_tx_pending, next);
 		STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next);
 
-		usb2_set_frame_data(xfer, data->buf, 0);
+		usbd_set_frame_data(xfer, data->buf, 0);
 		xfer->frlengths[0] = data->buflen;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 
 		URTW_UNLOCK(sc);
 		urtw_start(ifp);
diff --git a/sys/dev/usb/wlan/if_zyd.c b/sys/dev/usb/wlan/if_zyd.c
index a0079eb7..8627d81 100644
--- a/sys/dev/usb/wlan/if_zyd.c
+++ b/sys/dev/usb/wlan/if_zyd.c
@@ -110,7 +110,7 @@ enum {
 #endif
 
 #define	zyd_do_request(sc,req,data) \
-    usb2_do_request_flags((sc)->sc_udev, &(sc)->sc_mtx, req, data, 0, NULL, 5000)
+    usbd_do_request_flags((sc)->sc_udev, &(sc)->sc_mtx, req, data, 0, NULL, 5000)
 
 static device_probe_t zyd_match;
 static device_attach_t zyd_attach;
@@ -330,7 +330,7 @@ zyd_match(device_t dev)
 	if (uaa->info.bIfaceIndex != ZYD_IFACE_INDEX)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(zyd_devs, sizeof(zyd_devs), uaa));
+	return (usbd_lookup_id_by_uaa(zyd_devs, sizeof(zyd_devs), uaa));
 }
 
 static int
@@ -350,7 +350,7 @@ zyd_attach(device_t dev)
 		return (EINVAL);
 	}
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 	sc->sc_dev = dev;
 	sc->sc_udev = uaa->device;
 	sc->sc_macrev = USB_GET_DRIVER_INFO(uaa);
@@ -360,12 +360,12 @@ zyd_attach(device_t dev)
 	STAILQ_INIT(&sc->sc_rqh);
 
 	iface_index = ZYD_IFACE_INDEX;
-	error = usb2_transfer_setup(uaa->device,
+	error = usbd_transfer_setup(uaa->device,
 	    &iface_index, sc->sc_xfer, zyd_config,
 	    ZYD_N_TRANSFER, sc, &sc->sc_mtx);
 	if (error) {
 		device_printf(dev, "could not allocate USB transfers, "
-		    "err=%s\n", usb2_errstr(error));
+		    "err=%s\n", usbd_errstr(error));
 		goto detach;
 	}
 
@@ -448,7 +448,7 @@ zyd_detach(device_t dev)
 	struct ieee80211com *ic;
 
 	/* stop all USB transfers */
-	usb2_transfer_unsetup(sc->sc_xfer, ZYD_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, ZYD_N_TRANSFER);
 
 	/* free TX list, if any */
 	zyd_unsetup_tx_list(sc);
@@ -644,7 +644,7 @@ zyd_intr_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_copy_out(xfer->frbuffers, 0, cmd, sizeof(*cmd));
+		usbd_copy_out(xfer->frbuffers, 0, cmd, sizeof(*cmd));
 
 		switch (le16toh(cmd->code)) {
 		case ZYD_NOTIF_RETRYSTATUS:
@@ -720,12 +720,12 @@ zyd_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 */
 		DPRINTF(sc, ZYD_DEBUG_CMD, "error = %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -760,19 +760,19 @@ tr_setup:
 			if (rqp->flags & ZYD_CMD_FLAG_SENT)
 				continue;
 
-			usb2_copy_in(xfer->frbuffers, 0, rqp->cmd, rqp->ilen);
+			usbd_copy_in(xfer->frbuffers, 0, rqp->cmd, rqp->ilen);
 
 			xfer->frlengths[0] = rqp->ilen;
 			xfer->priv_fifo = rqp;
 			rqp->flags |= ZYD_CMD_FLAG_SENT;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 			break;
 		}
 		break;
 
 	default:			/* Error */
 		DPRINTF(sc, ZYD_DEBUG_ANY, "error = %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -806,8 +806,8 @@ zyd_cmd(struct zyd_softc *sc, uint16_t code, const void *idata, int ilen,
 	rq.olen = olen;
 	rq.flags = flags;
 	STAILQ_INSERT_TAIL(&sc->sc_rqh, &rq, rq);
-	usb2_transfer_start(sc->sc_xfer[ZYD_INTR_RD]);
-	usb2_transfer_start(sc->sc_xfer[ZYD_INTR_WR]);
+	usbd_transfer_start(sc->sc_xfer[ZYD_INTR_RD]);
+	usbd_transfer_start(sc->sc_xfer[ZYD_INTR_WR]);
 
 	/* wait at most one second for command reply */
 	error = mtx_sleep(&rq, &sc->sc_mtx, 0 , "zydcmd", hz);
@@ -1922,7 +1922,7 @@ zyd_get_macaddr(struct zyd_softc *sc)
 	error = zyd_do_request(sc, &req, sc->sc_bssid);
 	if (error != 0) {
 		device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
-		    usb2_errstr(error));
+		    usbd_errstr(error));
 	}
 
 	return (error);
@@ -2179,8 +2179,8 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len)
 		ifp->if_ierrors++;
 		return;
 	}
-	usb2_copy_out(xfer->frbuffers, offset, &plcp, sizeof(plcp));
-	usb2_copy_out(xfer->frbuffers, offset + len - sizeof(stat),
+	usbd_copy_out(xfer->frbuffers, offset, &plcp, sizeof(plcp));
+	usbd_copy_out(xfer->frbuffers, offset + len - sizeof(stat),
 	    &stat, sizeof(stat));
 
 	if (stat.flags & ZYD_RX_ERROR) {
@@ -2213,7 +2213,7 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len)
 	}
 	m->m_pkthdr.rcvif = ifp;
 	m->m_pkthdr.len = m->m_len = rlen;
-	usb2_copy_out(xfer->frbuffers, offset + sizeof(plcp),
+	usbd_copy_out(xfer->frbuffers, offset + sizeof(plcp),
 	    mtod(m, uint8_t *), rlen);
 
 	if (ieee80211_radiotap_active(ic)) {
@@ -2255,7 +2255,7 @@ zyd_bulk_read_callback(struct usb_xfer *xfer)
 	sc->sc_rx_count = 0;
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_copy_out(xfer->frbuffers, xfer->actlen - sizeof(desc),
+		usbd_copy_out(xfer->frbuffers, xfer->actlen - sizeof(desc),
 		    &desc, sizeof(desc));
 
 		offset = 0;
@@ -2288,7 +2288,7 @@ zyd_bulk_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);
 
 		/*
 		 * At the end of a USB callback it is always safe to unlock
@@ -2315,7 +2315,7 @@ tr_setup:
 		break;
 
 	default:			/* Error */
-		DPRINTF(sc, ZYD_DEBUG_ANY, "frame error: %s\n", usb2_errstr(xfer->error));
+		DPRINTF(sc, ZYD_DEBUG_ANY, "frame error: %s\n", usbd_errstr(xfer->error));
 
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* try to clear stall first */
@@ -2397,9 +2397,9 @@ tr_setup:
 				    m->m_pkthdr.len);
 				m->m_pkthdr.len = ZYD_MAX_TXBUFSZ;
 			}
-			usb2_copy_in(xfer->frbuffers, 0, &data->desc,
+			usbd_copy_in(xfer->frbuffers, 0, &data->desc,
 			    ZYD_TX_DESC_SIZE);
-			usb2_m_copy_in(xfer->frbuffers, ZYD_TX_DESC_SIZE, m, 0,
+			usbd_m_copy_in(xfer->frbuffers, ZYD_TX_DESC_SIZE, m, 0,
 			    m->m_pkthdr.len);
 
 			vap = data->ni->ni_vap;
@@ -2414,13 +2414,13 @@ tr_setup:
 
 			xfer->frlengths[0] = ZYD_TX_DESC_SIZE + m->m_pkthdr.len;
 			xfer->priv_fifo = data;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
 	default:			/* Error */
 		DPRINTF(sc, ZYD_DEBUG_ANY, "transfer error, %s\n",
-		    usb2_errstr(xfer->error));
+		    usbd_errstr(xfer->error));
 
 		ifp->if_oerrors++;
 		data = xfer->priv_fifo;
@@ -2553,7 +2553,7 @@ zyd_tx_start(struct zyd_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
 		rate);
 
 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
-	usb2_transfer_start(sc->sc_xfer[ZYD_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[ZYD_BULK_WR]);
 
 	return (0);
 }
@@ -2682,8 +2682,8 @@ zyd_init_locked(struct zyd_softc *sc)
 		}
 
 		/* reset device */
-		cd = usb2_get_config_descriptor(sc->sc_udev);
-		error = usb2_req_set_config(sc->sc_udev, &sc->sc_mtx,
+		cd = usbd_get_config_descriptor(sc->sc_udev);
+		error = usbd_req_set_config(sc->sc_udev, &sc->sc_mtx,
 		    cd->bConfigurationValue);
 		if (error)
 			device_printf(sc->sc_dev, "reset failed, continuing\n");
@@ -2761,9 +2761,9 @@ zyd_init_locked(struct zyd_softc *sc)
 
 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
-	usb2_transfer_set_stall(sc->sc_xfer[ZYD_BULK_WR]);
-	usb2_transfer_start(sc->sc_xfer[ZYD_BULK_RD]);
-	usb2_transfer_start(sc->sc_xfer[ZYD_INTR_RD]);
+	usbd_transfer_set_stall(sc->sc_xfer[ZYD_BULK_WR]);
+	usbd_transfer_start(sc->sc_xfer[ZYD_BULK_RD]);
+	usbd_transfer_start(sc->sc_xfer[ZYD_INTR_RD]);
 
 	return;
 
@@ -2800,8 +2800,8 @@ zyd_stop(struct zyd_softc *sc)
 	 * Drain all the transfers, if not already drained:
 	 */
 	ZYD_UNLOCK(sc);
-	usb2_transfer_drain(sc->sc_xfer[ZYD_BULK_WR]);
-	usb2_transfer_drain(sc->sc_xfer[ZYD_BULK_RD]);
+	usbd_transfer_drain(sc->sc_xfer[ZYD_BULK_WR]);
+	usbd_transfer_drain(sc->sc_xfer[ZYD_BULK_RD]);
 	ZYD_LOCK(sc);
 
 	zyd_unsetup_tx_list(sc);
diff --git a/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c
index b802d42..8299100 100644
--- a/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c
+++ b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c
@@ -97,7 +97,7 @@
 #include <dev/usb/usb_mfunc.h>
 #include <dev/usb/usb_error.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -127,7 +127,7 @@ static device_detach_t	ubt_detach;
 static void		ubt_task_schedule(ubt_softc_p, int);
 static task_fn_t	ubt_task;
 
-#define	ubt_xfer_start(sc, i)	usb2_transfer_start((sc)->sc_xfer[(i)])
+#define	ubt_xfer_start(sc, i)	usbd_transfer_start((sc)->sc_xfer[(i)])
 
 /* Netgraph methods */
 static ng_constructor_t	ng_ubt_constructor;
@@ -407,11 +407,11 @@ ubt_probe(device_t dev)
 	if (uaa->use_generic == 0)
 		return (ENXIO);
 
-	if (usb2_lookup_id_by_uaa(ubt_ignore_devs,
+	if (usbd_lookup_id_by_uaa(ubt_ignore_devs,
 			sizeof(ubt_ignore_devs), uaa) == 0)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(ubt_devs, sizeof(ubt_devs), uaa));
+	return (usbd_lookup_id_by_uaa(ubt_devs, sizeof(ubt_devs), uaa));
 } /* ubt_probe */
 
 /*
@@ -430,7 +430,7 @@ ubt_attach(device_t dev)
 	uint8_t				alt_index, i, j;
 	uint8_t				iface_index[2] = { 0, 1 };
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	sc->sc_dev = dev;
 	sc->sc_debug = NG_UBT_WARN_LEVEL;
@@ -502,8 +502,8 @@ ubt_attach(device_t dev)
 	 * Search through all the descriptors looking for the largest
 	 * packet size:
 	 */
-	while ((ed = (struct usb_endpoint_descriptor *)usb2_desc_foreach(
-	    usb2_get_config_descriptor(uaa->device), 
+	while ((ed = (struct usb_endpoint_descriptor *)usb_desc_foreach(
+	    usbd_get_config_descriptor(uaa->device), 
 	    (struct usb_descriptor *)ed))) {
 
 		if ((ed->bDescriptorType == UDESC_INTERFACE) &&
@@ -528,22 +528,22 @@ ubt_attach(device_t dev)
 
 	/* Set alt configuration on interface #1 only if we found it */
 	if (wMaxPacketSize > 0 &&
-	    usb2_set_alt_interface_index(uaa->device, 1, alt_index)) {
+	    usbd_set_alt_interface_index(uaa->device, 1, alt_index)) {
 		UBT_ALERT(sc, "could not set alternate setting %d " \
 			"for interface 1!\n", alt_index);
 		goto detach;
 	}
 
 	/* Setup transfers for both interfaces */
-	if (usb2_transfer_setup(uaa->device, iface_index, sc->sc_xfer,
+	if (usbd_transfer_setup(uaa->device, iface_index, sc->sc_xfer,
 			ubt_config, UBT_N_TRANSFER, sc, &sc->sc_if_mtx)) {
 		UBT_ALERT(sc, "could not allocate transfers\n");
 		goto detach;
 	}
 
 	/* Claim all interfaces on the device */
-	for (i = 1; usb2_get_iface(uaa->device, i) != NULL; i ++)
-		usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
+	for (i = 1; usbd_get_iface(uaa->device, i) != NULL; i ++)
+		usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
 
 	return (0); /* success */
 
@@ -575,7 +575,7 @@ ubt_detach(device_t dev)
 	taskqueue_drain(taskqueue_swi, &sc->sc_task);
 
 	/* Free USB transfers, if any */
-	usb2_transfer_unsetup(sc->sc_xfer, UBT_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, UBT_N_TRANSFER);
 
 	/* Destroy queues */
 	UBT_NG_LOCK(sc);
@@ -631,8 +631,8 @@ send_next:
 			"bmRequestType=0x%02x, wLength=%d\n",
 			req.bmRequestType, UGETW(req.wLength));
 
-		usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
-		usb2_m_copy_in(xfer->frbuffers + 1, 0, m, 0, m->m_pkthdr.len);
+		usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+		usbd_m_copy_in(xfer->frbuffers + 1, 0, m, 0, m->m_pkthdr.len);
 
 		xfer->frlengths[0] = sizeof(req);
 		xfer->frlengths[1] = m->m_pkthdr.len;
@@ -640,13 +640,13 @@ send_next:
 
 		NG_FREE_M(m);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default: /* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			UBT_WARN(sc, "control transfer failed: %s\n",
-				usb2_errstr(xfer->error));
+				usbd_errstr(xfer->error));
 
 			UBT_STAT_OERROR(sc);
 			goto send_next;
@@ -694,7 +694,7 @@ ubt_intr_read_callback(struct usb_xfer *xfer)
 		if (xfer->actlen > MCLBYTES - 1)
 			xfer->actlen = MCLBYTES - 1;
 
-		usb2_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1,
+		usbd_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1,
 			xfer->actlen);
 		m->m_pkthdr.len += xfer->actlen;
 		m->m_len += xfer->actlen;
@@ -735,13 +735,13 @@ submit_next:
 		NG_FREE_M(m); /* checks for m != NULL */
 
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default: /* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			UBT_WARN(sc, "interrupt transfer failed: %s\n",
-				usb2_errstr(xfer->error));
+				usbd_errstr(xfer->error));
 
 			/* Try to clear stall first */
 			xfer->flags.stall_pipe = 1;
@@ -790,7 +790,7 @@ ubt_bulk_read_callback(struct usb_xfer *xfer)
 		if (xfer->actlen > MCLBYTES - 1)
 			xfer->actlen = MCLBYTES - 1;
 
-		usb2_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1,
+		usbd_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1,
 			xfer->actlen);
 		m->m_pkthdr.len += xfer->actlen;
 		m->m_len += xfer->actlen;
@@ -831,13 +831,13 @@ submit_next:
 		NG_FREE_M(m); /* checks for m != NULL */
 
 		xfer->frlengths[0] = xfer->max_data_length;
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default: /* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			UBT_WARN(sc, "bulk-in transfer failed: %s\n",
-				usb2_errstr(xfer->error));
+				usbd_errstr(xfer->error));
 
 			/* Try to clear stall first */
 			xfer->flags.stall_pipe = 1;
@@ -884,7 +884,7 @@ send_next:
 		 * and schedule transfer
 		 */
 
-		usb2_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len);
+		usbd_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len);
 		xfer->frlengths[0] = m->m_pkthdr.len;
 
 		UBT_INFO(sc, "bulk-out transfer has been started, len=%d\n",
@@ -892,13 +892,13 @@ send_next:
 
 		NG_FREE_M(m);
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default: /* Error */
 		if (xfer->error != USB_ERR_CANCELLED) {
 			UBT_WARN(sc, "bulk-out transfer failed: %s\n",
-				usb2_errstr(xfer->error));
+				usbd_errstr(xfer->error));
 
 			UBT_STAT_OERROR(sc);
 
@@ -935,7 +935,7 @@ read_next:
 		for (n = 0; n < xfer->nframes; n ++)
 			xfer->frlengths[n] = xfer->max_frame_size;
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default: /* Error */
@@ -1003,7 +1003,7 @@ ubt_isoc_read_one_frame(struct usb_xfer *xfer, int frame_no)
 		if (got + len > want)
 			len = want - got;
 
-		usb2_copy_out(xfer->frbuffers, frame_no * xfer->max_frame_size,
+		usbd_copy_out(xfer->frbuffers, frame_no * xfer->max_frame_size,
 			mtod(m, uint8_t *) + m->m_pkthdr.len, len);
 
 		m->m_pkthdr.len += len;
@@ -1070,7 +1070,7 @@ send_next:
 
 			n = min(space, m->m_pkthdr.len);
 			if (n > 0) {
-				usb2_m_copy_in(xfer->frbuffers, offset, m,0, n);
+				usbd_m_copy_in(xfer->frbuffers, offset, m,0, n);
 				m_adj(m, n);
 
 				offset += n;
@@ -1101,7 +1101,7 @@ send_next:
 			offset -= xfer->frlengths[n];
 		}
 
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default: /* Error */
@@ -1233,12 +1233,12 @@ ubt_task(void *context, int pending)
 	/*
 	 * Stop all USB transfers synchronously.
 	 * Stop interface #0 and #1 transfers at the same time and in the
-	 * same loop. usb2_transfer_drain() will do appropriate locking.
+	 * same loop. usbd_transfer_drain() will do appropriate locking.
 	 */
 
 	if (task_flags & UBT_FLAG_T_STOP_ALL)
 		for (i = 0; i < UBT_N_TRANSFER; i ++)
-			usb2_transfer_drain(sc->sc_xfer[i]);
+			usbd_transfer_drain(sc->sc_xfer[i]);
 
 	/* Start incoming interrupt and bulk, and all isoc. USB transfers */
 	if (task_flags & UBT_FLAG_T_START_ALL) {
diff --git a/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c b/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c
index 35b8233..00f364b 100644
--- a/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c
+++ b/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c
@@ -37,7 +37,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb_ioctl.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_debug.h>
@@ -180,7 +180,7 @@ ubtbcmfw_probe(device_t dev)
 	if (uaa->info.bIfaceIndex != 0)
 		return (ENXIO);
 
-	return (usb2_lookup_id_by_uaa(devs, sizeof(devs), uaa));
+	return (usbd_lookup_id_by_uaa(devs, sizeof(devs), uaa));
 } /* ubtbcmfw_probe */
 
 /*
@@ -197,27 +197,27 @@ ubtbcmfw_attach(device_t dev)
 
 	sc->sc_udev = uaa->device;
 
-	device_set_usb2_desc(dev);
+	device_set_usb_desc(dev);
 
 	mtx_init(&sc->sc_mtx, "ubtbcmfw lock", NULL, MTX_DEF | MTX_RECURSE);
 
 	iface_index = UBTBCMFW_IFACE_IDX;
-	error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
+	error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
 				ubtbcmfw_config, UBTBCMFW_N_TRANSFER,
 				sc, &sc->sc_mtx);
 	if (error != 0) {
 		device_printf(dev, "allocating USB transfers failed. %s\n",
-			usb2_errstr(error));
+			usbd_errstr(error));
 		goto detach;
 	}
 
-	error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx,
+	error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 			&ubtbcmfw_fifo_methods, &sc->sc_fifo,
 			device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex,
 			UID_ROOT, GID_OPERATOR, 0644);
 	if (error != 0) {
 		device_printf(dev, "could not attach fifo. %s\n",
-			usb2_errstr(error));
+			usbd_errstr(error));
 		goto detach;
 	}
 
@@ -238,9 +238,9 @@ ubtbcmfw_detach(device_t dev)
 {
 	struct ubtbcmfw_softc	*sc = device_get_softc(dev);
 
-	usb2_fifo_detach(&sc->sc_fifo);
+	usb_fifo_detach(&sc->sc_fifo);
 
-	usb2_transfer_unsetup(sc->sc_xfer, UBTBCMFW_N_TRANSFER);
+	usbd_transfer_unsetup(sc->sc_xfer, UBTBCMFW_N_TRANSFER);
 
 	mtx_destroy(&sc->sc_mtx);
 
@@ -262,10 +262,10 @@ ubtbcmfw_write_callback(struct usb_xfer *xfer)
 	case USB_ST_SETUP:
 	case USB_ST_TRANSFERRED:
 setup_next:
-		if (usb2_fifo_get_data(f, xfer->frbuffers, 0,
+		if (usb_fifo_get_data(f, xfer->frbuffers, 0,
 				xfer->max_data_length, &actlen, 0)) {
 			xfer->frlengths[0] = actlen;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
@@ -291,14 +291,14 @@ ubtbcmfw_read_callback(struct usb_xfer *xfer)
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
-		usb2_fifo_put_data(fifo, xfer->frbuffers, 0, xfer->actlen, 1);
+		usb_fifo_put_data(fifo, xfer->frbuffers, 0, xfer->actlen, 1);
 		/* FALLTHROUGH */
 
 	case USB_ST_SETUP:
 setup_next:
-		if (usb2_fifo_put_bytes_max(fifo) > 0) {
+		if (usb_fifo_put_bytes_max(fifo) > 0) {
 			xfer->frlengths[0] = xfer->max_data_length;
-			usb2_start_hardware(xfer);
+			usbd_transfer_submit(xfer);
 		}
 		break;
 
@@ -321,7 +321,7 @@ ubtbcmfw_start_read(struct usb_fifo *fifo)
 {
 	struct ubtbcmfw_softc	*sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]);
+	usbd_transfer_start(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]);
 } /* ubtbcmfw_start_read */
 
 /*
@@ -333,7 +333,7 @@ ubtbcmfw_stop_read(struct usb_fifo *fifo)
 {
 	struct ubtbcmfw_softc	*sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]);
+	usbd_transfer_stop(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]);
 } /* ubtbcmfw_stop_read */
 
 /*
@@ -346,7 +346,7 @@ ubtbcmfw_start_write(struct usb_fifo *fifo)
 {
 	struct ubtbcmfw_softc	*sc = fifo->priv_sc0;
 
-	usb2_transfer_start(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]);
+	usbd_transfer_start(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]);
 } /* ubtbcmfw_start_write */
 
 /*
@@ -358,7 +358,7 @@ ubtbcmfw_stop_write(struct usb_fifo *fifo)
 {
 	struct ubtbcmfw_softc	*sc = fifo->priv_sc0;
 
-	usb2_transfer_stop(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]);
+	usbd_transfer_stop(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]);
 } /* ubtbcmfw_stop_write */
 
 /*
@@ -383,7 +383,7 @@ ubtbcmfw_open(struct usb_fifo *fifo, int fflags)
 	else
 		return (EINVAL);	/* should not happen */
 
-	if (usb2_fifo_alloc_buffer(fifo, xfer->max_data_length,
+	if (usb_fifo_alloc_buffer(fifo, xfer->max_data_length,
 			UBTBCMFW_IFQ_MAXLEN) != 0)
 		return (ENOMEM);
 
@@ -398,7 +398,7 @@ static void
 ubtbcmfw_close(struct usb_fifo *fifo, int fflags)
 {
 	if (fflags & (FREAD | FWRITE))
-		usb2_fifo_free_buffer(fifo);
+		usb_fifo_free_buffer(fifo);
 } /* ubtbcmfw_close */
 
 /*
@@ -414,7 +414,7 @@ ubtbcmfw_ioctl(struct usb_fifo *fifo, u_long cmd, void *data,
 
 	switch (cmd) {
 	case USB_GET_DEVICE_DESC:
-		memcpy(data, usb2_get_device_descriptor(sc->sc_udev),
+		memcpy(data, usbd_get_device_descriptor(sc->sc_udev),
 			sizeof(struct usb_device_descriptor));
 		break;