MFp4 //depot/projects/usb@159909

- make usb2_power_mask_t 16-bit
- remove "usb2_config_sub" structure from "usb2_config". To compensate for this
  "usb2_config" has a new field called "usb_mode" which select for which mode
  the current xfer entry is active. Options are: a) Device mode only b) Host
  mode only (default-by-zero) c) Both modes.  This change was scripted using
  the following sed script: "s/\.mh\././g".
- the standard packet size table in "usb_transfer.c" is now a function, hence
  the code for the function uses less memory than the table itself.

Submitted by:	Hans Petter Selasky

51 files changed, 744 insertions, 657 deletions

diff --git a/sys/dev/sound/usb/uaudio.c b/sys/dev/sound/usb/uaudio.c
index 50728ee5dc80..50866dabec9b 100644
--- a/sys/dev/sound/usb/uaudio.c
+++ b/sys/dev/sound/usb/uaudio.c
@@ -400,20 +400,20 @@ static const struct usb2_config
 		.type = UE_ISOCHRONOUS,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = 0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames = UAUDIO_MINFRAMES,
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.callback = &uaudio_chan_record_callback,
+		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
+		.frames = UAUDIO_MINFRAMES,
+		.flags = {.short_xfer_ok = 1,},
+		.callback = &uaudio_chan_record_callback,
 	},
 
 	[1] = {
 		.type = UE_ISOCHRONOUS,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = 0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames = UAUDIO_MINFRAMES,
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.callback = &uaudio_chan_record_callback,
+		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
+		.frames = UAUDIO_MINFRAMES,
+		.flags = {.short_xfer_ok = 1,},
+		.callback = &uaudio_chan_record_callback,
 	},
 };
 
@@ -423,20 +423,20 @@ static const struct usb2_config
 		.type = UE_ISOCHRONOUS,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = 0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames = UAUDIO_MINFRAMES,
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.callback = &uaudio_chan_play_callback,
+		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
+		.frames = UAUDIO_MINFRAMES,
+		.flags = {.short_xfer_ok = 1,},
+		.callback = &uaudio_chan_play_callback,
 	},
 
 	[1] = {
 		.type = UE_ISOCHRONOUS,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = 0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames = UAUDIO_MINFRAMES,
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.callback = &uaudio_chan_play_callback,
+		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
+		.frames = UAUDIO_MINFRAMES,
+		.flags = {.short_xfer_ok = 1,},
+		.callback = &uaudio_chan_play_callback,
 	},
 };
 
@@ -446,9 +446,9 @@ static const struct usb2_config
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = (sizeof(struct usb2_device_request) + 4),
-		.mh.callback = &uaudio_mixer_write_cfg_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = (sizeof(struct usb2_device_request) + 4),
+		.callback = &uaudio_mixer_write_cfg_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 };
 
@@ -478,40 +478,40 @@ static const struct usb2_config
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UMIDI_BULK_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &umidi_bulk_write_callback,
+		.bufsize = UMIDI_BULK_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &umidi_bulk_write_callback,
 	},
 
 	[1] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UMIDI_BULK_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &umidi_bulk_read_callback,
+		.bufsize = UMIDI_BULK_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &umidi_bulk_read_callback,
 	},
 
 	[2] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.flags = {},
-		.mh.callback = &umidi_write_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.flags = {},
+		.callback = &umidi_write_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
 	},
 
 	[3] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.flags = {},
-		.mh.callback = &umidi_read_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.flags = {},
+		.callback = &umidi_read_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
 	},
 };
 
diff --git a/sys/dev/usb/bluetooth/ng_ubt.c b/sys/dev/usb/bluetooth/ng_ubt.c
index 149e1cf120de..a5a19ded53dd 100644
--- a/sys/dev/usb/bluetooth/ng_ubt.c
+++ b/sys/dev/usb/bluetooth/ng_ubt.c
@@ -276,9 +276,9 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	UE_ADDR_ANY,
 		.direction =	UE_DIR_OUT,
 		.if_index = 	0,
-		.mh.bufsize =	UBT_BULK_WRITE_BUFFER_SIZE,
-		.mh.flags =	{ .pipe_bof = 1, .force_short_xfer = 1, },
-		.mh.callback =	&ubt_bulk_write_callback,
+		.bufsize =	UBT_BULK_WRITE_BUFFER_SIZE,
+		.flags =	{ .pipe_bof = 1, .force_short_xfer = 1, },
+		.callback =	&ubt_bulk_write_callback,
 	},
 	/* Incoming bulk transfer - ACL packets */
 	[UBT_IF_0_BULK_DT_RD] = {
@@ -286,9 +286,9 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	UE_ADDR_ANY,
 		.direction =	UE_DIR_IN,
 		.if_index = 	0,
-		.mh.bufsize =	UBT_BULK_READ_BUFFER_SIZE,
-		.mh.flags =	{ .pipe_bof = 1, .short_xfer_ok = 1, },
-		.mh.callback =	&ubt_bulk_read_callback,
+		.bufsize =	UBT_BULK_READ_BUFFER_SIZE,
+		.flags =	{ .pipe_bof = 1, .short_xfer_ok = 1, },
+		.callback =	&ubt_bulk_read_callback,
 	},
 	/* Incoming interrupt transfer - HCI events */
 	[UBT_IF_0_INTR_DT_RD] = {
@@ -296,9 +296,9 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	UE_ADDR_ANY,
 		.direction =	UE_DIR_IN,
 		.if_index = 	0,
-		.mh.flags =	{ .pipe_bof = 1, .short_xfer_ok = 1, },
-		.mh.bufsize =	UBT_INTR_BUFFER_SIZE,
-		.mh.callback =	&ubt_intr_read_callback,
+		.flags =	{ .pipe_bof = 1, .short_xfer_ok = 1, },
+		.bufsize =	UBT_INTR_BUFFER_SIZE,
+		.callback =	&ubt_intr_read_callback,
 	},
 	/* Outgoing control transfer - HCI commands */
 	[UBT_IF_0_CTRL_DT_WR] = {
@@ -306,9 +306,9 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	0x00,	/* control pipe */
 		.direction =	UE_DIR_ANY,
 		.if_index = 	0,
-		.mh.bufsize =	UBT_CTRL_BUFFER_SIZE,
-		.mh.callback =	&ubt_ctrl_write_callback,
-		.mh.timeout =	5000,	/* 5 seconds */
+		.bufsize =	UBT_CTRL_BUFFER_SIZE,
+		.callback =	&ubt_ctrl_write_callback,
+		.timeout =	5000,	/* 5 seconds */
 	},
 
 	/*
@@ -321,10 +321,10 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	UE_ADDR_ANY,
 		.direction =	UE_DIR_IN,
 		.if_index = 	1,
-		.mh.bufsize =	0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames =	UBT_ISOC_NFRAMES,
-		.mh.flags =	{ .short_xfer_ok = 1, },
-		.mh.callback =	&ubt_isoc_read_callback,
+		.bufsize =	0,	/* use "wMaxPacketSize * frames" */
+		.frames =	UBT_ISOC_NFRAMES,
+		.flags =	{ .short_xfer_ok = 1, },
+		.callback =	&ubt_isoc_read_callback,
 	},
 	/* Incoming isochronous transfer #2 - SCO packets */
 	[UBT_IF_1_ISOC_DT_RD2] = {
@@ -332,10 +332,10 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	UE_ADDR_ANY,
 		.direction =	UE_DIR_IN,
 		.if_index = 	1,
-		.mh.bufsize =	0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames =	UBT_ISOC_NFRAMES,
-		.mh.flags =	{ .short_xfer_ok = 1, },
-		.mh.callback =	&ubt_isoc_read_callback,
+		.bufsize =	0,	/* use "wMaxPacketSize * frames" */
+		.frames =	UBT_ISOC_NFRAMES,
+		.flags =	{ .short_xfer_ok = 1, },
+		.callback =	&ubt_isoc_read_callback,
 	},
 	/* Outgoing isochronous transfer #1 - SCO packets */
 	[UBT_IF_1_ISOC_DT_WR1] = {
@@ -343,10 +343,10 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	UE_ADDR_ANY,
 		.direction =	UE_DIR_OUT,
 		.if_index = 	1,
-		.mh.bufsize =	0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames =	UBT_ISOC_NFRAMES,
-		.mh.flags =	{ .short_xfer_ok = 1, },
-		.mh.callback =	&ubt_isoc_write_callback,
+		.bufsize =	0,	/* use "wMaxPacketSize * frames" */
+		.frames =	UBT_ISOC_NFRAMES,
+		.flags =	{ .short_xfer_ok = 1, },
+		.callback =	&ubt_isoc_write_callback,
 	},
 	/* Outgoing isochronous transfer #2 - SCO packets */
 	[UBT_IF_1_ISOC_DT_WR2] = {
@@ -354,10 +354,10 @@ static const struct usb2_config		ubt_config[UBT_N_TRANSFER] =
 		.endpoint =	UE_ADDR_ANY,
 		.direction =	UE_DIR_OUT,
 		.if_index = 	1,
-		.mh.bufsize =	0,	/* use "wMaxPacketSize * frames" */
-		.mh.frames =	UBT_ISOC_NFRAMES,
-		.mh.flags =	{ .short_xfer_ok = 1, },
-		.mh.callback =	&ubt_isoc_write_callback,
+		.bufsize =	0,	/* use "wMaxPacketSize * frames" */
+		.frames =	UBT_ISOC_NFRAMES,
+		.flags =	{ .short_xfer_ok = 1, },
+		.callback =	&ubt_isoc_write_callback,
 	},
 };
 
diff --git a/sys/dev/usb/bluetooth/ubtbcmfw.c b/sys/dev/usb/bluetooth/ubtbcmfw.c
index bfa390f1a2ea..1932a3971a95 100644
--- a/sys/dev/usb/bluetooth/ubtbcmfw.c
+++ b/sys/dev/usb/bluetooth/ubtbcmfw.c
@@ -118,10 +118,10 @@ static const struct usb2_config	ubtbcmfw_config[UBTBCMFW_N_TRANSFER] =
 		.endpoint =	0x02,	/* fixed */
 		.direction =	UE_DIR_OUT,
 		.if_index =	UBTBCMFW_IFACE_IDX,
-		.mh.bufsize =	UBTBCMFW_BSIZE,
-		.mh.flags =	{ .pipe_bof = 1, .force_short_xfer = 1,
+		.bufsize =	UBTBCMFW_BSIZE,
+		.flags =	{ .pipe_bof = 1, .force_short_xfer = 1,
 				  .proxy_buffer = 1, },
-		.mh.callback =	&ubtbcmfw_write_callback,
+		.callback =	&ubtbcmfw_write_callback,
 	},
 
 	[UBTBCMFW_INTR_DT_RD] = {
@@ -129,10 +129,10 @@ static const struct usb2_config	ubtbcmfw_config[UBTBCMFW_N_TRANSFER] =
 		.endpoint =	0x01,	/* fixed */
 		.direction =	UE_DIR_IN,
 		.if_index =	UBTBCMFW_IFACE_IDX,
-		.mh.bufsize =	UBTBCMFW_BSIZE,
-		.mh.flags =	{ .pipe_bof = 1, .short_xfer_ok = 1,
+		.bufsize =	UBTBCMFW_BSIZE,
+		.flags =	{ .pipe_bof = 1, .short_xfer_ok = 1,
 				  .proxy_buffer = 1, },
-		.mh.callback =	&ubtbcmfw_read_callback,
+		.callback =	&ubtbcmfw_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/controller/usb_controller.c b/sys/dev/usb/controller/usb_controller.c
index 28b99d367951..7ae0ce83605e 100644
--- a/sys/dev/usb/controller/usb_controller.c
+++ b/sys/dev/usb/controller/usb_controller.c
@@ -209,7 +209,6 @@ usb2_bus_explore(struct usb2_proc_msg *pm)
 		 * First update the USB power state!
 		 */
 		usb2_bus_powerd(bus);
-
 		/*
 		 * Explore the Root USB HUB. This call can sleep,
 		 * exiting Giant, which is actually Giant.
@@ -328,6 +327,20 @@ usb2_bus_attach(struct usb2_proc_msg *pm)
 	USB_BUS_UNLOCK(bus);
 	mtx_lock(&Giant);		/* XXX not required by USB */
 
+	/* default power_mask value */
+	bus->hw_power_state =
+	  USB_HW_POWER_CONTROL |
+	  USB_HW_POWER_BULK |
+	  USB_HW_POWER_INTERRUPT |
+	  USB_HW_POWER_ISOC |
+	  USB_HW_POWER_NON_ROOT_HUB;
+
+	/* make sure power is set at least once */
+
+	if (bus->methods->set_hw_power != NULL) {
+		(bus->methods->set_hw_power) (bus);
+	}
+
 	/* Allocate the Root USB device */
 
 	child = usb2_alloc_device(bus->bdev, bus, NULL, 0, 0, 1,
diff --git a/sys/dev/usb/input/uhid.c b/sys/dev/usb/input/uhid.c
index b6fa631fd31c..78931bdb7c48 100644
--- a/sys/dev/usb/input/uhid.c
+++ b/sys/dev/usb/input/uhid.c
@@ -316,27 +316,27 @@ static const struct usb2_config uhid_config[UHID_N_TRANSFER] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = UHID_BSIZE,
-		.mh.callback = &uhid_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = UHID_BSIZE,
+		.callback = &uhid_intr_callback,
 	},
 
 	[UHID_CTRL_DT_WR] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE,
-		.mh.callback = &uhid_write_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE,
+		.callback = &uhid_write_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 
 	[UHID_CTRL_DT_RD] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE,
-		.mh.callback = &uhid_read_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE,
+		.callback = &uhid_read_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 };
 
diff --git a/sys/dev/usb/input/ukbd.c b/sys/dev/usb/input/ukbd.c
index df81ad9b799d..58e815169a73 100644
--- a/sys/dev/usb/input/ukbd.c
+++ b/sys/dev/usb/input/ukbd.c
@@ -562,28 +562,28 @@ static const struct usb2_config ukbd_config[UKBD_N_TRANSFER] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &ukbd_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &ukbd_intr_callback,
 	},
 
 	[UKBD_INTR_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &ukbd_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &ukbd_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
 	},
 
 	[UKBD_CTRL_LED] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request) + 1,
-		.mh.callback = &ukbd_set_leds_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = sizeof(struct usb2_device_request) + 1,
+		.callback = &ukbd_set_leds_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 };
 
diff --git a/sys/dev/usb/input/ums.c b/sys/dev/usb/input/ums.c
index 9539e20905d2..04c0a0bb1054 100644
--- a/sys/dev/usb/input/ums.c
+++ b/sys/dev/usb/input/ums.c
@@ -312,9 +312,9 @@ static const struct usb2_config ums_config[UMS_N_TRANSFER] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &ums_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &ums_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/misc/udbp.c b/sys/dev/usb/misc/udbp.c
index cba9780a7d44..e8acba81cfe8 100644
--- a/sys/dev/usb/misc/udbp.c
+++ b/sys/dev/usb/misc/udbp.c
@@ -192,39 +192,39 @@ static const struct usb2_config udbp_config[UDBP_T_MAX] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UDBP_BUFFERSIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &udbp_bulk_write_callback,
-		.mh.timeout = UDBP_TIMEOUT,
+		.bufsize = UDBP_BUFFERSIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &udbp_bulk_write_callback,
+		.timeout = UDBP_TIMEOUT,
 	},
 
 	[UDBP_T_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UDBP_BUFFERSIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &udbp_bulk_read_callback,
+		.bufsize = UDBP_BUFFERSIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &udbp_bulk_read_callback,
 	},
 
 	[UDBP_T_WR_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &udbp_bulk_write_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &udbp_bulk_write_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
 	},
 
 	[UDBP_T_RD_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &udbp_bulk_read_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &udbp_bulk_read_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
 	},
 };
 
diff --git a/sys/dev/usb/net/if_aue.c b/sys/dev/usb/net/if_aue.c
index b014b01a0ace..ca72948f1507 100644
--- a/sys/dev/usb/net/if_aue.c
+++ b/sys/dev/usb/net/if_aue.c
@@ -209,28 +209,28 @@ static const struct usb2_config aue_config[AUE_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = (MCLBYTES + 2),
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = aue_bulk_write_callback,
-		.mh.timeout = 10000,	/* 10 seconds */
+		.bufsize = (MCLBYTES + 2),
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = aue_bulk_write_callback,
+		.timeout = 10000,	/* 10 seconds */
 	},
 
 	[AUE_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = (MCLBYTES + 4 + ETHER_CRC_LEN),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = aue_bulk_read_callback,
+		.bufsize = (MCLBYTES + 4 + ETHER_CRC_LEN),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = aue_bulk_read_callback,
 	},
 
 	[AUE_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = aue_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = aue_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/net/if_axe.c b/sys/dev/usb/net/if_axe.c
index 43ac676b79be..c0db84b0995a 100644
--- a/sys/dev/usb/net/if_axe.c
+++ b/sys/dev/usb/net/if_axe.c
@@ -182,10 +182,10 @@ static const struct usb2_config axe_config[AXE_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = AXE_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = axe_bulk_write_callback,
-		.mh.timeout = 10000,	/* 10 seconds */
+		.bufsize = AXE_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = axe_bulk_write_callback,
+		.timeout = 10000,	/* 10 seconds */
 	},
 
 	[AXE_BULK_DT_RD] = {
@@ -195,19 +195,19 @@ static const struct usb2_config axe_config[AXE_N_TRANSFER] = {
 #if (MCLBYTES < 2048)
 #error "(MCLBYTES < 2048)"
 #endif
-		.mh.bufsize = MCLBYTES,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = axe_bulk_read_callback,
-		.mh.timeout = 0,	/* no timeout */
+		.bufsize = MCLBYTES,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = axe_bulk_read_callback,
+		.timeout = 0,	/* no timeout */
 	},
 
 	[AXE_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = axe_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = axe_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/net/if_cdce.c b/sys/dev/usb/net/if_cdce.c
index 8e7aae44e127..9a9cb37da56f 100644
--- a/sys/dev/usb/net/if_cdce.c
+++ b/sys/dev/usb/net/if_cdce.c
@@ -96,59 +96,54 @@ SYSCTL_INT(_hw_usb2_cdce, OID_AUTO, debug, CTLFLAG_RW, &cdce_debug, 0,
 
 static const struct usb2_config cdce_config[CDCE_N_TRANSFER] = {
 
-	[CDCE_BULK_A] = {
+	[CDCE_BULK_RX] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
-		.direction = UE_DIR_OUT,
+		.direction = UE_DIR_RX,
 		.if_index = 0,
-		/* Host Mode */
-		.mh.frames = CDCE_FRAMES_MAX,
-		.mh.bufsize = (CDCE_FRAMES_MAX * MCLBYTES),
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,},
-		.mh.callback = cdce_bulk_write_callback,
-		.mh.timeout = 10000,	/* 10 seconds */
-		/* Device Mode */
-		.md.frames = CDCE_FRAMES_MAX,
-		.md.bufsize = (CDCE_FRAMES_MAX * MCLBYTES),
-		.md.flags = {.pipe_bof = 1,.short_frames_ok = 1,.short_xfer_ok = 1,.ext_buffer = 1,},
-		.md.callback = cdce_bulk_read_callback,
-		.md.timeout = 0,	/* no timeout */
+		.frames = CDCE_FRAMES_MAX,
+		.bufsize = (CDCE_FRAMES_MAX * MCLBYTES),
+		.flags = {.pipe_bof = 1,.short_frames_ok = 1,.short_xfer_ok = 1,.ext_buffer = 1,},
+		.callback = cdce_bulk_read_callback,
+		.timeout = 0,	/* no timeout */
+		.usb_mode = USB_MODE_MAX,	/* both modes */
 	},
 
-	[CDCE_BULK_B] = {
+	[CDCE_BULK_TX] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
-		.direction = UE_DIR_IN,
+		.direction = UE_DIR_TX,
 		.if_index = 0,
-		/* Host Mode */
-		.mh.frames = CDCE_FRAMES_MAX,
-		.mh.bufsize = (CDCE_FRAMES_MAX * MCLBYTES),
-		.mh.flags = {.pipe_bof = 1,.short_frames_ok = 1,.short_xfer_ok = 1,.ext_buffer = 1,},
-		.mh.callback = cdce_bulk_read_callback,
-		.mh.timeout = 0,	/* no timeout */
-		/* Device Mode */
-		.md.frames = CDCE_FRAMES_MAX,
-		.md.bufsize = (CDCE_FRAMES_MAX * MCLBYTES),
-		.md.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,},
-		.md.callback = cdce_bulk_write_callback,
-		.md.timeout = 10000,	/* 10 seconds */
+		.frames = CDCE_FRAMES_MAX,
+		.bufsize = (CDCE_FRAMES_MAX * MCLBYTES),
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,},
+		.callback = cdce_bulk_write_callback,
+		.timeout = 10000,	/* 10 seconds */
+		.usb_mode = USB_MODE_MAX,	/* both modes */
 	},
 
-	[CDCE_INTR] = {
+	[CDCE_INTR_RX] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
-		.direction = UE_DIR_IN,
+		.direction = UE_DIR_RX,
 		.if_index = 1,
-		/* Host Mode */
-		.mh.bufsize = CDCE_IND_SIZE_MAX,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,},
-		.mh.callback = cdce_intr_read_callback,
-		.mh.timeout = 0,
-		/* Device Mode */
-		.md.bufsize = CDCE_IND_SIZE_MAX,
-		.md.flags = {.pipe_bof = 1,.force_short_xfer = 1,.no_pipe_ok = 1,},
-		.md.callback = cdce_intr_write_callback,
-		.md.timeout = 10000,	/* 10 seconds */
+		.bufsize = CDCE_IND_SIZE_MAX,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,},
+		.callback = cdce_intr_read_callback,
+		.timeout = 0,
+		.usb_mode = USB_MODE_HOST,
+	},
+
+	[CDCE_INTR_TX] = {
+		.type = UE_INTERRUPT,
+		.endpoint = UE_ADDR_ANY,
+		.direction = UE_DIR_TX,
+		.if_index = 1,
+		.bufsize = CDCE_IND_SIZE_MAX,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,.no_pipe_ok = 1,},
+		.callback = cdce_intr_write_callback,
+		.timeout = 10000,	/* 10 seconds */
+		.usb_mode = USB_MODE_DEVICE,
 	},
 };
 
@@ -416,8 +411,8 @@ cdce_start(struct usb2_ether *ue)
 	/*
 	 * Start the USB transfers, if not already started:
 	 */
-	usb2_transfer_start(sc->sc_xfer[CDCE_BULK_B]);
-	usb2_transfer_start(sc->sc_xfer[CDCE_BULK_A]);
+	usb2_transfer_start(sc->sc_xfer[CDCE_BULK_TX]);
+	usb2_transfer_start(sc->sc_xfer[CDCE_BULK_RX]);
 }
 
 static void
@@ -557,13 +552,11 @@ cdce_init(struct usb2_ether *ue)
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 
 	/* start interrupt transfer */
-	usb2_transfer_start(sc->sc_xfer[CDCE_INTR]);
+	usb2_transfer_start(sc->sc_xfer[CDCE_INTR_RX]);
+	usb2_transfer_start(sc->sc_xfer[CDCE_INTR_TX]);
 
 	/* stall data write direction, which depends on USB mode */
-	if (usb2_get_mode(sc->sc_ue.ue_udev) == USB_MODE_HOST)
-		usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_A]);
-	else
-		usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_B]);
+	usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]);
 
 	/* start data transfers */
 	cdce_start(ue);
@@ -582,9 +575,10 @@ cdce_stop(struct usb2_ether *ue)
 	/*
 	 * stop all the transfers, if not already stopped:
 	 */
-	usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_A]);
-	usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_B]);
-	usb2_transfer_stop(sc->sc_xfer[CDCE_INTR]);
+	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]);
 }
 
 static void
diff --git a/sys/dev/usb/net/if_cdcereg.h b/sys/dev/usb/net/if_cdcereg.h
index dac512196fdd..0bcdde77352e 100644
--- a/sys/dev/usb/net/if_cdcereg.h
+++ b/sys/dev/usb/net/if_cdcereg.h
@@ -39,9 +39,10 @@
 #define	CDCE_IND_SIZE_MAX 32            /* bytes */
 
 enum {
-	CDCE_BULK_A,
-	CDCE_BULK_B,
-	CDCE_INTR,
+	CDCE_BULK_RX,
+	CDCE_BULK_TX,
+	CDCE_INTR_RX,
+	CDCE_INTR_TX,
 	CDCE_N_TRANSFER,
 };
 
diff --git a/sys/dev/usb/net/if_cue.c b/sys/dev/usb/net/if_cue.c
index 54bff1de79e9..10fd03884a77 100644
--- a/sys/dev/usb/net/if_cue.c
+++ b/sys/dev/usb/net/if_cue.c
@@ -121,19 +121,19 @@ static const struct usb2_config cue_config[CUE_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = (MCLBYTES + 2),
-		.mh.flags = {.pipe_bof = 1,},
-		.mh.callback = cue_bulk_write_callback,
-		.mh.timeout = 10000,	/* 10 seconds */
+		.bufsize = (MCLBYTES + 2),
+		.flags = {.pipe_bof = 1,},
+		.callback = cue_bulk_write_callback,
+		.timeout = 10000,	/* 10 seconds */
 	},
 
 	[CUE_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = (MCLBYTES + 2),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = cue_bulk_read_callback,
+		.bufsize = (MCLBYTES + 2),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = cue_bulk_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/net/if_kue.c b/sys/dev/usb/net/if_kue.c
index 8a648a4a978f..3056692c0d9f 100644
--- a/sys/dev/usb/net/if_kue.c
+++ b/sys/dev/usb/net/if_kue.c
@@ -163,20 +163,20 @@ static const struct usb2_config kue_config[KUE_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = (MCLBYTES + 2 + 64),
-		.mh.flags = {.pipe_bof = 1,},
-		.mh.callback = kue_bulk_write_callback,
-		.mh.timeout = 10000,	/* 10 seconds */
+		.bufsize = (MCLBYTES + 2 + 64),
+		.flags = {.pipe_bof = 1,},
+		.callback = kue_bulk_write_callback,
+		.timeout = 10000,	/* 10 seconds */
 	},
 
 	[KUE_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = (MCLBYTES + 2),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = kue_bulk_read_callback,
-		.mh.timeout = 0,	/* no timeout */
+		.bufsize = (MCLBYTES + 2),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = kue_bulk_read_callback,
+		.timeout = 0,	/* no timeout */
 	},
 };
 
diff --git a/sys/dev/usb/net/if_rue.c b/sys/dev/usb/net/if_rue.c
index 73958d178cfe..dc7a31fdae58 100644
--- a/sys/dev/usb/net/if_rue.c
+++ b/sys/dev/usb/net/if_rue.c
@@ -141,29 +141,29 @@ static const struct usb2_config rue_config[RUE_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = MCLBYTES,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = rue_bulk_write_callback,
-		.mh.timeout = 10000,	/* 10 seconds */
+		.bufsize = MCLBYTES,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = rue_bulk_write_callback,
+		.timeout = 10000,	/* 10 seconds */
 	},
 
 	[RUE_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = (MCLBYTES + 4),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = rue_bulk_read_callback,
-		.mh.timeout = 0,	/* no timeout */
+		.bufsize = (MCLBYTES + 4),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = rue_bulk_read_callback,
+		.timeout = 0,	/* no timeout */
 	},
 
 	[RUE_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = rue_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = rue_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/net/if_udav.c b/sys/dev/usb/net/if_udav.c
index 76cdef45eb7f..5962d1915131 100644
--- a/sys/dev/usb/net/if_udav.c
+++ b/sys/dev/usb/net/if_udav.c
@@ -101,29 +101,29 @@ static const struct usb2_config udav_config[UDAV_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = (MCLBYTES + 2),
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = udav_bulk_write_callback,
-		.mh.timeout = 10000,	/* 10 seconds */
+		.bufsize = (MCLBYTES + 2),
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = udav_bulk_write_callback,
+		.timeout = 10000,	/* 10 seconds */
 	},
 
 	[UDAV_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = (MCLBYTES + 3),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = udav_bulk_read_callback,
-		.mh.timeout = 0,	/* no timeout */
+		.bufsize = (MCLBYTES + 3),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = udav_bulk_read_callback,
+		.timeout = 0,	/* no timeout */
 	},
 
 	[UDAV_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = udav_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = udav_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/u3g.c b/sys/dev/usb/serial/u3g.c
index 19d3d506a98d..19009c6eea9b 100644
--- a/sys/dev/usb/serial/u3g.c
+++ b/sys/dev/usb/serial/u3g.c
@@ -116,18 +116,18 @@ static const struct usb2_config u3g_config[U3G_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = U3G_BSIZE,/* bytes */
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &u3g_write_callback,
+		.bufsize = U3G_BSIZE,/* bytes */
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &u3g_write_callback,
 	},
 
 	[U3G_BULK_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = U3G_BSIZE,/* bytes */
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &u3g_read_callback,
+		.bufsize = U3G_BSIZE,/* bytes */
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &u3g_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/uark.c b/sys/dev/usb/serial/uark.c
index e0f9db7a5fee..bc0bace12188 100644
--- a/sys/dev/usb/serial/uark.c
+++ b/sys/dev/usb/serial/uark.c
@@ -106,18 +106,18 @@ static const struct usb2_config
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UARK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uark_bulk_write_callback,
+		.bufsize = UARK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uark_bulk_write_callback,
 	},
 
 	[UARK_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UARK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uark_bulk_read_callback,
+		.bufsize = UARK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uark_bulk_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/ubsa.c b/sys/dev/usb/serial/ubsa.c
index 244ca653e9e0..a52c828b5152 100644
--- a/sys/dev/usb/serial/ubsa.c
+++ b/sys/dev/usb/serial/ubsa.c
@@ -188,27 +188,27 @@ static const struct usb2_config ubsa_config[UBSA_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UBSA_BSIZE,	/* bytes */
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &ubsa_write_callback,
+		.bufsize = UBSA_BSIZE,	/* bytes */
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &ubsa_write_callback,
 	},
 
 	[UBSA_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UBSA_BSIZE,	/* bytes */
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &ubsa_read_callback,
+		.bufsize = UBSA_BSIZE,	/* bytes */
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &ubsa_read_callback,
 	},
 
 	[UBSA_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &ubsa_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &ubsa_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/ubser.c b/sys/dev/usb/serial/ubser.c
index 08d5e14e8840..6ec67ae1e9f1 100644
--- a/sys/dev/usb/serial/ubser.c
+++ b/sys/dev/usb/serial/ubser.c
@@ -156,18 +156,18 @@ static const struct usb2_config ubser_config[UBSER_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &ubser_write_callback,
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &ubser_write_callback,
 	},
 
 	[UBSER_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &ubser_read_callback,
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &ubser_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/uchcom.c b/sys/dev/usb/serial/uchcom.c
index b99f0488ed03..413fb125cd4a 100644
--- a/sys/dev/usb/serial/uchcom.c
+++ b/sys/dev/usb/serial/uchcom.c
@@ -233,27 +233,27 @@ static const struct usb2_config uchcom_config_data[UCHCOM_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UCHCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uchcom_write_callback,
+		.bufsize = UCHCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uchcom_write_callback,
 	},
 
 	[UCHCOM_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UCHCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uchcom_read_callback,
+		.bufsize = UCHCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uchcom_read_callback,
 	},
 
 	[UCHCOM_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &uchcom_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &uchcom_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/ucycom.c b/sys/dev/usb/serial/ucycom.c
index f3f99a25a888..a044c007286b 100644
--- a/sys/dev/usb/serial/ucycom.c
+++ b/sys/dev/usb/serial/ucycom.c
@@ -120,18 +120,18 @@ static const struct usb2_config ucycom_config[UCYCOM_N_TRANSFER] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = (sizeof(struct usb2_device_request) + UCYCOM_MAX_IOLEN),
-		.mh.callback = &ucycom_ctrl_write_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = (sizeof(struct usb2_device_request) + UCYCOM_MAX_IOLEN),
+		.callback = &ucycom_ctrl_write_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 
 	[UCYCOM_INTR_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = UCYCOM_MAX_IOLEN,
-		.mh.callback = &ucycom_intr_read_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = UCYCOM_MAX_IOLEN,
+		.callback = &ucycom_intr_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/ufoma.c b/sys/dev/usb/serial/ufoma.c
index e84ab1da1d6d..62471e724ef8 100644
--- a/sys/dev/usb/serial/ufoma.c
+++ b/sys/dev/usb/serial/ufoma.c
@@ -232,28 +232,28 @@ static const struct usb2_config
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = sizeof(struct usb2_cdc_notification),
-		.mh.callback = &ufoma_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = sizeof(struct usb2_cdc_notification),
+		.callback = &ufoma_intr_callback,
 	},
 
 	[UFOMA_CTRL_ENDPT_READ] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = (sizeof(struct usb2_device_request) + UFOMA_CMD_BUF_SIZE),
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.callback = &ufoma_ctrl_read_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = (sizeof(struct usb2_device_request) + UFOMA_CMD_BUF_SIZE),
+		.flags = {.short_xfer_ok = 1,},
+		.callback = &ufoma_ctrl_read_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 
 	[UFOMA_CTRL_ENDPT_WRITE] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = (sizeof(struct usb2_device_request) + 1),
-		.mh.callback = &ufoma_ctrl_write_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = (sizeof(struct usb2_device_request) + 1),
+		.callback = &ufoma_ctrl_write_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 };
 
@@ -264,18 +264,18 @@ static const struct usb2_config
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UFOMA_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &ufoma_bulk_write_callback,
+		.bufsize = UFOMA_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &ufoma_bulk_write_callback,
 	},
 
 	[UFOMA_BULK_ENDPT_READ] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UFOMA_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &ufoma_bulk_read_callback,
+		.bufsize = UFOMA_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &ufoma_bulk_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/uftdi.c b/sys/dev/usb/serial/uftdi.c
index d03638f5cd33..c075b06f4037 100644
--- a/sys/dev/usb/serial/uftdi.c
+++ b/sys/dev/usb/serial/uftdi.c
@@ -150,18 +150,18 @@ static const struct usb2_config uftdi_config[UFTDI_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UFTDI_OBUFSIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uftdi_write_callback,
+		.bufsize = UFTDI_OBUFSIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uftdi_write_callback,
 	},
 
 	[UFTDI_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UFTDI_IBUFSIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uftdi_read_callback,
+		.bufsize = UFTDI_IBUFSIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uftdi_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/ugensa.c b/sys/dev/usb/serial/ugensa.c
index 6174f1762892..f370e1b310fd 100644
--- a/sys/dev/usb/serial/ugensa.c
+++ b/sys/dev/usb/serial/ugensa.c
@@ -106,18 +106,18 @@ static const struct usb2_config
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UGENSA_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &ugensa_bulk_write_callback,
+		.bufsize = UGENSA_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &ugensa_bulk_write_callback,
 	},
 
 	[UGENSA_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UGENSA_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &ugensa_bulk_read_callback,
+		.bufsize = UGENSA_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &ugensa_bulk_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/uipaq.c b/sys/dev/usb/serial/uipaq.c
index daebe8bf960a..24dbd25618bf 100644
--- a/sys/dev/usb/serial/uipaq.c
+++ b/sys/dev/usb/serial/uipaq.c
@@ -115,18 +115,18 @@ static const struct usb2_config uipaq_config_data[UIPAQ_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UIPAQ_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uipaq_write_callback,
+		.bufsize = UIPAQ_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uipaq_write_callback,
 	},
 
 	[UIPAQ_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UIPAQ_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uipaq_read_callback,
+		.bufsize = UIPAQ_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uipaq_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/ulpt.c b/sys/dev/usb/serial/ulpt.c
index 56ff9fcc1a62..024325ee7433 100644
--- a/sys/dev/usb/serial/ulpt.c
+++ b/sys/dev/usb/serial/ulpt.c
@@ -338,27 +338,27 @@ static const struct usb2_config ulpt_config[ULPT_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = ULPT_BSIZE,
-		.mh.flags = {.pipe_bof = 1,.proxy_buffer = 1},
-		.mh.callback = &ulpt_write_callback,
+		.bufsize = ULPT_BSIZE,
+		.flags = {.pipe_bof = 1,.proxy_buffer = 1},
+		.callback = &ulpt_write_callback,
 	},
 
 	[ULPT_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = ULPT_BSIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1},
-		.mh.callback = &ulpt_read_callback,
+		.bufsize = ULPT_BSIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1},
+		.callback = &ulpt_read_callback,
 	},
 
 	[ULPT_INTR_DT_RD] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request) + 1,
-		.mh.callback = &ulpt_status_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = sizeof(struct usb2_device_request) + 1,
+		.callback = &ulpt_status_callback,
+		.timeout = 1000,	/* 1 second */
 	},
 };
 
diff --git a/sys/dev/usb/serial/umct.c b/sys/dev/usb/serial/umct.c
index 9e49440d9312..db3ddb46ce59 100644
--- a/sys/dev/usb/serial/umct.c
+++ b/sys/dev/usb/serial/umct.c
@@ -137,18 +137,18 @@ static const struct usb2_config umct_config[UMCT_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &umct_write_callback,
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &umct_write_callback,
 	},
 
 	[UMCT_BULK_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &umct_read_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &umct_read_callback,
 		.ep_index = 0,		/* first interrupt endpoint */
 	},
 
@@ -156,9 +156,9 @@ static const struct usb2_config umct_config[UMCT_N_TRANSFER] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &umct_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &umct_intr_callback,
 		.ep_index = 1,		/* second interrupt endpoint */
 	},
 };
diff --git a/sys/dev/usb/serial/umodem.c b/sys/dev/usb/serial/umodem.c
index dedea151da9d..35186fd93a10 100644
--- a/sys/dev/usb/serial/umodem.c
+++ b/sys/dev/usb/serial/umodem.c
@@ -189,9 +189,9 @@ static const struct usb2_config umodem_config[UMODEM_N_TRANSFER] = {
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
 		.if_index = 0,
-		.mh.bufsize = UMODEM_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &umodem_write_callback,
+		.bufsize = UMODEM_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &umodem_write_callback,
 	},
 
 	[UMODEM_BULK_RD] = {
@@ -199,9 +199,9 @@ static const struct usb2_config umodem_config[UMODEM_N_TRANSFER] = {
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
 		.if_index = 0,
-		.mh.bufsize = UMODEM_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &umodem_read_callback,
+		.bufsize = UMODEM_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &umodem_read_callback,
 	},
 
 	[UMODEM_INTR_RD] = {
@@ -209,9 +209,9 @@ static const struct usb2_config umodem_config[UMODEM_N_TRANSFER] = {
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
 		.if_index = 1,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &umodem_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &umodem_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/umoscom.c b/sys/dev/usb/serial/umoscom.c
index 8ced0c8cb9e6..f2820aec0d4c 100644
--- a/sys/dev/usb/serial/umoscom.c
+++ b/sys/dev/usb/serial/umoscom.c
@@ -204,27 +204,27 @@ static const struct usb2_config umoscom_config_data[UMOSCOM_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UMOSCOM_BUFSIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &umoscom_write_callback,
+		.bufsize = UMOSCOM_BUFSIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &umoscom_write_callback,
 	},
 
 	[UMOSCOM_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UMOSCOM_BUFSIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &umoscom_read_callback,
+		.bufsize = UMOSCOM_BUFSIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &umoscom_read_callback,
 	},
 
 	[UMOSCOM_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &umoscom_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &umoscom_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/uplcom.c b/sys/dev/usb/serial/uplcom.c
index a915160240ba..24a4b36eb049 100644
--- a/sys/dev/usb/serial/uplcom.c
+++ b/sys/dev/usb/serial/uplcom.c
@@ -187,9 +187,9 @@ static const struct usb2_config uplcom_config_data[UPLCOM_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UPLCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uplcom_write_callback,
+		.bufsize = UPLCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uplcom_write_callback,
 		.if_index = 0,
 	},
 
@@ -197,9 +197,9 @@ static const struct usb2_config uplcom_config_data[UPLCOM_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UPLCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uplcom_read_callback,
+		.bufsize = UPLCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uplcom_read_callback,
 		.if_index = 0,
 	},
 
@@ -207,9 +207,9 @@ static const struct usb2_config uplcom_config_data[UPLCOM_N_TRANSFER] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &uplcom_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &uplcom_intr_callback,
 		.if_index = 1,
 	},
 };
diff --git a/sys/dev/usb/serial/uslcom.c b/sys/dev/usb/serial/uslcom.c
index d1351aa40a6c..5df0abb0867c 100644
--- a/sys/dev/usb/serial/uslcom.c
+++ b/sys/dev/usb/serial/uslcom.c
@@ -128,18 +128,18 @@ static const struct usb2_config uslcom_config[USLCOM_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = USLCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uslcom_write_callback,
+		.bufsize = USLCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uslcom_write_callback,
 	},
 
 	[USLCOM_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = USLCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uslcom_read_callback,
+		.bufsize = USLCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uslcom_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/uvisor.c b/sys/dev/usb/serial/uvisor.c
index bff317bef44a..54de2e29b8ee 100644
--- a/sys/dev/usb/serial/uvisor.c
+++ b/sys/dev/usb/serial/uvisor.c
@@ -196,18 +196,18 @@ static const struct usb2_config uvisor_config[UVISOR_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UVISOR_BUFSIZE,	/* bytes */
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uvisor_write_callback,
+		.bufsize = UVISOR_BUFSIZE,	/* bytes */
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uvisor_write_callback,
 	},
 
 	[UVISOR_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UVISOR_BUFSIZE,	/* bytes */
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uvisor_read_callback,
+		.bufsize = UVISOR_BUFSIZE,	/* bytes */
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uvisor_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/serial/uvscom.c b/sys/dev/usb/serial/uvscom.c
index 6de4f5b98489..cfda9f8cca0a 100644
--- a/sys/dev/usb/serial/uvscom.c
+++ b/sys/dev/usb/serial/uvscom.c
@@ -179,27 +179,27 @@ static const struct usb2_config uvscom_config[UVSCOM_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UVSCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = &uvscom_write_callback,
+		.bufsize = UVSCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = &uvscom_write_callback,
 	},
 
 	[UVSCOM_BULK_DT_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UVSCOM_BULK_BUF_SIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = &uvscom_read_callback,
+		.bufsize = UVSCOM_BULK_BUF_SIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = &uvscom_read_callback,
 	},
 
 	[UVSCOM_INTR_DT_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &uvscom_intr_callback,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &uvscom_intr_callback,
 	},
 };
 
diff --git a/sys/dev/usb/storage/umass.c b/sys/dev/usb/storage/umass.c
index 6ee17bfc63b2..2f2a163523fc 100644
--- a/sys/dev/usb/storage/umass.c
+++ b/sys/dev/usb/storage/umass.c
@@ -1063,87 +1063,87 @@ struct usb2_config umass_bbb_config[UMASS_T_BBB_MAX] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_bbb_reset1_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
-		.mh.interval = 500,	/* 500 milliseconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_bbb_reset1_callback,
+		.timeout = 5000,	/* 5 seconds */
+		.interval = 500,	/* 500 milliseconds */
 	},
 
 	[UMASS_T_BBB_RESET2] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_bbb_reset2_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
-		.mh.interval = 50,	/* 50 milliseconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_bbb_reset2_callback,
+		.timeout = 5000,	/* 5 seconds */
+		.interval = 50,	/* 50 milliseconds */
 	},
 
 	[UMASS_T_BBB_RESET3] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_bbb_reset3_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
-		.mh.interval = 50,	/* 50 milliseconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_bbb_reset3_callback,
+		.timeout = 5000,	/* 5 seconds */
+		.interval = 50,	/* 50 milliseconds */
 	},
 
 	[UMASS_T_BBB_COMMAND] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = sizeof(umass_bbb_cbw_t),
-		.mh.callback = &umass_t_bbb_command_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
+		.bufsize = sizeof(umass_bbb_cbw_t),
+		.callback = &umass_t_bbb_command_callback,
+		.timeout = 5000,	/* 5 seconds */
 	},
 
 	[UMASS_T_BBB_DATA_READ] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UMASS_BULK_SIZE,
-		.mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
-		.mh.callback = &umass_t_bbb_data_read_callback,
-		.mh.timeout = 0,	/* overwritten later */
+		.bufsize = UMASS_BULK_SIZE,
+		.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
+		.callback = &umass_t_bbb_data_read_callback,
+		.timeout = 0,	/* overwritten later */
 	},
 
 	[UMASS_T_BBB_DATA_RD_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_bbb_data_rd_cs_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_bbb_data_rd_cs_callback,
+		.timeout = 5000,	/* 5 seconds */
 	},
 
 	[UMASS_T_BBB_DATA_WRITE] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UMASS_BULK_SIZE,
-		.mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
-		.mh.callback = &umass_t_bbb_data_write_callback,
-		.mh.timeout = 0,	/* overwritten later */
+		.bufsize = UMASS_BULK_SIZE,
+		.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
+		.callback = &umass_t_bbb_data_write_callback,
+		.timeout = 0,	/* overwritten later */
 	},
 
 	[UMASS_T_BBB_DATA_WR_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_bbb_data_wr_cs_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_bbb_data_wr_cs_callback,
+		.timeout = 5000,	/* 5 seconds */
 	},
 
 	[UMASS_T_BBB_STATUS] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = sizeof(umass_bbb_csw_t),
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.callback = &umass_t_bbb_status_callback,
-		.mh.timeout = 5000,	/* ms */
+		.bufsize = sizeof(umass_bbb_csw_t),
+		.flags = {.short_xfer_ok = 1,},
+		.callback = &umass_t_bbb_status_callback,
+		.timeout = 5000,	/* ms */
 	},
 };
 
@@ -1153,98 +1153,98 @@ struct usb2_config umass_cbi_config[UMASS_T_CBI_MAX] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = (sizeof(struct usb2_device_request) +
+		.bufsize = (sizeof(struct usb2_device_request) +
 		    UMASS_CBI_DIAGNOSTIC_CMDLEN),
-		.mh.callback = &umass_t_cbi_reset1_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
-		.mh.interval = 500,	/* 500 milliseconds */
+		.callback = &umass_t_cbi_reset1_callback,
+		.timeout = 5000,	/* 5 seconds */
+		.interval = 500,	/* 500 milliseconds */
 	},
 
 	[UMASS_T_CBI_RESET2] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_cbi_reset2_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
-		.mh.interval = 50,	/* 50 milliseconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_cbi_reset2_callback,
+		.timeout = 5000,	/* 5 seconds */
+		.interval = 50,	/* 50 milliseconds */
 	},
 
 	[UMASS_T_CBI_RESET3] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_cbi_reset3_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
-		.mh.interval = 50,	/* 50 milliseconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_cbi_reset3_callback,
+		.timeout = 5000,	/* 5 seconds */
+		.interval = 50,	/* 50 milliseconds */
 	},
 
 	[UMASS_T_CBI_COMMAND] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = (sizeof(struct usb2_device_request) +
+		.bufsize = (sizeof(struct usb2_device_request) +
 		    UMASS_MAX_CMDLEN),
-		.mh.callback = &umass_t_cbi_command_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
+		.callback = &umass_t_cbi_command_callback,
+		.timeout = 5000,	/* 5 seconds */
 	},
 
 	[UMASS_T_CBI_DATA_READ] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = UMASS_BULK_SIZE,
-		.mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
-		.mh.callback = &umass_t_cbi_data_read_callback,
-		.mh.timeout = 0,	/* overwritten later */
+		.bufsize = UMASS_BULK_SIZE,
+		.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
+		.callback = &umass_t_cbi_data_read_callback,
+		.timeout = 0,	/* overwritten later */
 	},
 
 	[UMASS_T_CBI_DATA_RD_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_cbi_data_rd_cs_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_cbi_data_rd_cs_callback,
+		.timeout = 5000,	/* 5 seconds */
 	},
 
 	[UMASS_T_CBI_DATA_WRITE] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = UMASS_BULK_SIZE,
-		.mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
-		.mh.callback = &umass_t_cbi_data_write_callback,
-		.mh.timeout = 0,	/* overwritten later */
+		.bufsize = UMASS_BULK_SIZE,
+		.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS},
+		.callback = &umass_t_cbi_data_write_callback,
+		.timeout = 0,	/* overwritten later */
 	},
 
 	[UMASS_T_CBI_DATA_WR_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_cbi_data_wr_cs_callback,
-		.mh.timeout = 5000,	/* 5 seconds */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_cbi_data_wr_cs_callback,
+		.timeout = 5000,	/* 5 seconds */
 	},
 
 	[UMASS_T_CBI_STATUS] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.bufsize = sizeof(umass_cbi_sbl_t),
-		.mh.callback = &umass_t_cbi_status_callback,
-		.mh.timeout = 5000,	/* ms */
+		.flags = {.short_xfer_ok = 1,},
+		.bufsize = sizeof(umass_cbi_sbl_t),
+		.callback = &umass_t_cbi_status_callback,
+		.timeout = 5000,	/* ms */
 	},
 
 	[UMASS_T_CBI_RESET4] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &umass_t_cbi_reset4_callback,
-		.mh.timeout = 5000,	/* ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &umass_t_cbi_reset4_callback,
+		.timeout = 5000,	/* ms */
 	},
 };
 
diff --git a/sys/dev/usb/storage/urio.c b/sys/dev/usb/storage/urio.c
index ea80b4e5556c..0c27aa04d6cc 100644
--- a/sys/dev/usb/storage/urio.c
+++ b/sys/dev/usb/storage/urio.c
@@ -130,38 +130,38 @@ static const struct usb2_config urio_config[URIO_T_MAX] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = URIO_BSIZE,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,.proxy_buffer = 1,},
-		.mh.callback = &urio_write_callback,
+		.bufsize = URIO_BSIZE,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,.proxy_buffer = 1,},
+		.callback = &urio_write_callback,
 	},
 
 	[URIO_T_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = URIO_BSIZE,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1,},
-		.mh.callback = &urio_read_callback,
+		.bufsize = URIO_BSIZE,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1,},
+		.callback = &urio_read_callback,
 	},
 
 	[URIO_T_WR_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &urio_write_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &urio_write_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
 	},
 
 	[URIO_T_RD_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &urio_read_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &urio_read_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
 	},
 };
 
diff --git a/sys/dev/usb/usb_compat_linux.c b/sys/dev/usb/usb_compat_linux.c
index 9641a81fe1a2..eed72ce93d8a 100644
--- a/sys/dev/usb/usb_compat_linux.c
+++ b/sys/dev/usb/usb_compat_linux.c
@@ -770,10 +770,10 @@ usb_setup_endpoint(struct usb_device *dev,
 		cfg[0].type = type;
 		cfg[0].endpoint = addr & UE_ADDR;
 		cfg[0].direction = addr & (UE_DIR_OUT | UE_DIR_IN);
-		cfg[0].mh.callback = &usb_linux_isoc_callback;
-		cfg[0].mh.bufsize = 0;	/* use wMaxPacketSize */
-		cfg[0].mh.frames = usb_max_isoc_frames(dev);
-		cfg[0].mh.flags.proxy_buffer = 1;
+		cfg[0].callback = &usb_linux_isoc_callback;
+		cfg[0].bufsize = 0;	/* use wMaxPacketSize */
+		cfg[0].frames = usb_max_isoc_frames(dev);
+		cfg[0].flags.proxy_buffer = 1;
 #if 0
 		/*
 		 * The Linux USB API allows non back-to-back
@@ -782,9 +782,9 @@ usb_setup_endpoint(struct usb_device *dev,
 		 * do a copy, and then we need a buffer for
 		 * that. Enable this at your own risk.
 		 */
-		cfg[0].mh.flags.ext_buffer = 1;
+		cfg[0].flags.ext_buffer = 1;
 #endif
-		cfg[0].mh.flags.short_xfer_ok = 1;
+		cfg[0].flags.short_xfer_ok = 1;
 
 		bcopy(cfg, cfg + 1, sizeof(*cfg));
 
@@ -804,11 +804,11 @@ usb_setup_endpoint(struct usb_device *dev,
 		cfg[0].type = type;
 		cfg[0].endpoint = addr & UE_ADDR;
 		cfg[0].direction = addr & (UE_DIR_OUT | UE_DIR_IN);
-		cfg[0].mh.callback = &usb_linux_non_isoc_callback;
-		cfg[0].mh.bufsize = bufsize;
-		cfg[0].mh.flags.ext_buffer = 1;	/* enable zero-copy */
-		cfg[0].mh.flags.proxy_buffer = 1;
-		cfg[0].mh.flags.short_xfer_ok = 1;
+		cfg[0].callback = &usb_linux_non_isoc_callback;
+		cfg[0].bufsize = bufsize;
+		cfg[0].flags.ext_buffer = 1;	/* enable zero-copy */
+		cfg[0].flags.proxy_buffer = 1;
+		cfg[0].flags.short_xfer_ok = 1;
 
 		if (usb2_transfer_setup(dev->bsd_udev, &uhe->bsd_iface_index,
 		    uhe->bsd_xfer, cfg, 1, uhe, &Giant)) {
diff --git a/sys/dev/usb/usb_core.h b/sys/dev/usb/usb_core.h
index 102866490361..71bd1e091ce4 100644
--- a/sys/dev/usb/usb_core.h
+++ b/sys/dev/usb/usb_core.h
@@ -112,6 +112,22 @@
 #define	USB_DEBUG 1
 #endif
 
+/*
+ * The following macro defines if USB transaction translator support
+ * shall be compiled for the USB HUB and USB controller drivers.
+ */
+#ifndef	USB_HAVE_TT_SUPPORT
+#define	USB_HAVE_TT_SUPPORT 1
+#endif
+
+/*
+ * The following macro defines if the USB power daemon shall
+ * be compiled for the USB core.
+ */
+#ifndef	USB_HAVE_POWERD
+#define	USB_HAVE_POWERD 1
+#endif
+
 #ifndef USB_TD_GET_PROC
 #define	USB_TD_GET_PROC(td) (td)->td_proc
 #endif
@@ -277,7 +293,7 @@ typedef uint32_t usb2_ticks_t;		/* system defined */
 #endif
 
 #ifndef USB_HAVE_POWER_MASK_T
-typedef uint32_t usb2_power_mask_t;	/* see "USB_HW_POWER_XXX" */
+typedef uint16_t usb2_power_mask_t;	/* see "USB_HW_POWER_XXX" */
 #endif
 
 /* structures */
@@ -361,10 +377,10 @@ struct usb2_xfer_flags_int {
 };
 
 /*
- * The following structure defines the symmetric part of an USB config
- * structure.
+ * The following structure define an USB configuration, that basically
+ * is used when setting up an USB transfer.
  */
-struct usb2_config_sub {
+struct usb2_config {
 	usb2_callback_t *callback;	/* USB transfer callback */
 	usb2_frlength_t bufsize;	/* total pipe buffer size in bytes */
 	usb2_frcount_t frames;		/* maximum number of USB frames */
@@ -372,20 +388,13 @@ struct usb2_config_sub {
 #define	USB_DEFAULT_INTERVAL	0
 	usb2_timeout_t timeout;		/* transfer timeout in milliseconds */
 	struct usb2_xfer_flags flags;	/* transfer flags */
-};
-
-/*
- * The following structure define an USB configuration, that basically
- * is used when setting up an USB transfer.
- */
-struct usb2_config {
-	struct usb2_config_sub mh;	/* parameters for USB_MODE_HOST */
-	struct usb2_config_sub md;	/* parameters for USB_MODE_DEVICE */
 	uint8_t	type;			/* pipe type */
 	uint8_t	endpoint;		/* pipe number */
 	uint8_t	direction;		/* pipe direction */
 	uint8_t	ep_index;		/* pipe index match to use */
 	uint8_t	if_index;		/* "ifaces" index to use */
+	uint8_t usb_mode;		/* see "USB_MODE_XXX", 
+					 * "USB_MODE_MAX" means any mode! */
 };
 
 /*
diff --git a/sys/dev/usb/usb_device.c b/sys/dev/usb/usb_device.c
index 9ae7b6164038..f497b12bc3d4 100644
--- a/sys/dev/usb/usb_device.c
+++ b/sys/dev/usb/usb_device.c
@@ -172,6 +172,14 @@ usb2_get_pipe(struct usb2_device *udev, uint8_t iface_index,
 	    udev, iface_index, setup->endpoint,
 	    setup->type, setup->direction, setup->ep_index);
 
+	/* check USB mode */
+
+	if ((setup->usb_mode != USB_MODE_MAX) &&
+	    (udev->flags.usb2_mode != setup->usb_mode)) {
+		/* wrong mode - no pipe */
+		return (NULL);
+	}
+
 	/* setup expected endpoint direction mask and value */
 
 	if (setup->direction == UE_DIR_RX) {
@@ -1481,7 +1489,6 @@ usb2_alloc_device(device_t parent_dev, struct usb2_bus *bus,
 	 */
 	udev->power_mode = USB_POWER_MODE_ON;
 	udev->pwr_save.last_xfer_time = ticks;
-
 	/* we are not ready yet */
 	udev->refcount = 1;
 
diff --git a/sys/dev/usb/usb_device.h b/sys/dev/usb/usb_device.h
index 67f7b59ff3e5..2317b07ff607 100644
--- a/sys/dev/usb/usb_device.h
+++ b/sys/dev/usb/usb_device.h
@@ -119,7 +119,6 @@ struct usb2_device {
 	struct usb2_pipe default_pipe;	/* Control Endpoint 0 */
 	struct usb2_pipe *pipes;
 	struct usb2_power_save pwr_save;/* power save data */
-
 	struct usb2_bus *bus;		/* our USB BUS */
 	device_t parent_dev;		/* parent device */
 	struct usb2_device *parent_hub;
diff --git a/sys/dev/usb/usb_generic.c b/sys/dev/usb/usb_generic.c
index f4010226a7f8..27de49b3b639 100644
--- a/sys/dev/usb/usb_generic.c
+++ b/sys/dev/usb/usb_generic.c
@@ -222,28 +222,29 @@ ugen_open_pipe_write(struct usb2_fifo *f)
 	usb2_config[1].type = UE_CONTROL;
 	usb2_config[1].endpoint = 0;
 	usb2_config[1].direction = UE_DIR_ANY;
-	usb2_config[1].mh.timeout = 1000;	/* 1 second */
-	usb2_config[1].mh.interval = 50;/* 50 milliseconds */
-	usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request);
-	usb2_config[1].mh.callback = &ugen_write_clear_stall_callback;
+	usb2_config[1].timeout = 1000;	/* 1 second */
+	usb2_config[1].interval = 50;/* 50 milliseconds */
+	usb2_config[1].bufsize = sizeof(struct usb2_device_request);
+	usb2_config[1].callback = &ugen_write_clear_stall_callback;
+	usb2_config[1].usb_mode = USB_MODE_HOST;
 
 	usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
 	usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
-	usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
-	usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL;
-	usb2_config[0].mh.flags.proxy_buffer = 1;
+	usb2_config[0].direction = UE_DIR_TX;
+	usb2_config[0].interval = USB_DEFAULT_INTERVAL;
+	usb2_config[0].flags.proxy_buffer = 1;
+	usb2_config[0].usb_mode = USB_MODE_MAX;		/* both modes */
 
 	switch (ed->bmAttributes & UE_XFERTYPE) {
 	case UE_INTERRUPT:
 	case UE_BULK:
 		if (f->flag_short) {
-			usb2_config[0].mh.flags.force_short_xfer = 1;
+			usb2_config[0].flags.force_short_xfer = 1;
 		}
-		usb2_config[0].mh.callback = &ugen_default_write_callback;
-		usb2_config[0].mh.timeout = f->timeout;
-		usb2_config[0].mh.frames = 1;
-		usb2_config[0].mh.bufsize = f->bufsize;
-		usb2_config[0].md = usb2_config[0].mh;	/* symmetric config */
+		usb2_config[0].callback = &ugen_default_write_callback;
+		usb2_config[0].timeout = f->timeout;
+		usb2_config[0].frames = 1;
+		usb2_config[0].bufsize = f->bufsize;
 		if (ugen_transfer_setup(f, usb2_config, 2)) {
 			return (EIO);
 		}
@@ -252,12 +253,11 @@ ugen_open_pipe_write(struct usb2_fifo *f)
 		break;
 
 	case UE_ISOCHRONOUS:
-		usb2_config[0].mh.flags.short_xfer_ok = 1;
-		usb2_config[0].mh.bufsize = 0;	/* use default */
-		usb2_config[0].mh.frames = f->nframes;
-		usb2_config[0].mh.callback = &ugen_isoc_write_callback;
-		usb2_config[0].mh.timeout = 0;
-		usb2_config[0].md = usb2_config[0].mh;	/* symmetric config */
+		usb2_config[0].flags.short_xfer_ok = 1;
+		usb2_config[0].bufsize = 0;	/* use default */
+		usb2_config[0].frames = f->nframes;
+		usb2_config[0].callback = &ugen_isoc_write_callback;
+		usb2_config[0].timeout = 0;
 
 		/* clone configuration */
 		usb2_config[1] = usb2_config[0];
@@ -290,28 +290,29 @@ ugen_open_pipe_read(struct usb2_fifo *f)
 	usb2_config[1].type = UE_CONTROL;
 	usb2_config[1].endpoint = 0;
 	usb2_config[1].direction = UE_DIR_ANY;
-	usb2_config[1].mh.timeout = 1000;	/* 1 second */
-	usb2_config[1].mh.interval = 50;/* 50 milliseconds */
-	usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request);
-	usb2_config[1].mh.callback = &ugen_read_clear_stall_callback;
+	usb2_config[1].timeout = 1000;	/* 1 second */
+	usb2_config[1].interval = 50;/* 50 milliseconds */
+	usb2_config[1].bufsize = sizeof(struct usb2_device_request);
+	usb2_config[1].callback = &ugen_read_clear_stall_callback;
+	usb2_config[1].usb_mode = USB_MODE_HOST;
 
 	usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
 	usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
-	usb2_config[0].direction = UE_DIR_IN;
-	usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL;
-	usb2_config[0].mh.flags.proxy_buffer = 1;
+	usb2_config[0].direction = UE_DIR_RX;
+	usb2_config[0].interval = USB_DEFAULT_INTERVAL;
+	usb2_config[0].flags.proxy_buffer = 1;
+	usb2_config[0].usb_mode = USB_MODE_MAX;		/* both modes */
 
 	switch (ed->bmAttributes & UE_XFERTYPE) {
 	case UE_INTERRUPT:
 	case UE_BULK:
 		if (f->flag_short) {
-			usb2_config[0].mh.flags.short_xfer_ok = 1;
+			usb2_config[0].flags.short_xfer_ok = 1;
 		}
-		usb2_config[0].mh.timeout = f->timeout;
-		usb2_config[0].mh.frames = 1;
-		usb2_config[0].mh.callback = &ugen_default_read_callback;
-		usb2_config[0].mh.bufsize = f->bufsize;
-		usb2_config[0].md = usb2_config[0].mh;	/* symmetric config */
+		usb2_config[0].timeout = f->timeout;
+		usb2_config[0].frames = 1;
+		usb2_config[0].callback = &ugen_default_read_callback;
+		usb2_config[0].bufsize = f->bufsize;
 
 		if (ugen_transfer_setup(f, usb2_config, 2)) {
 			return (EIO);
@@ -321,12 +322,11 @@ ugen_open_pipe_read(struct usb2_fifo *f)
 		break;
 
 	case UE_ISOCHRONOUS:
-		usb2_config[0].mh.flags.short_xfer_ok = 1;
-		usb2_config[0].mh.bufsize = 0;	/* use default */
-		usb2_config[0].mh.frames = f->nframes;
-		usb2_config[0].mh.callback = &ugen_isoc_read_callback;
-		usb2_config[0].mh.timeout = 0;
-		usb2_config[0].md = usb2_config[0].mh;	/* symmetric config */
+		usb2_config[0].flags.short_xfer_ok = 1;
+		usb2_config[0].bufsize = 0;	/* use default */
+		usb2_config[0].frames = f->nframes;
+		usb2_config[0].callback = &ugen_isoc_read_callback;
+		usb2_config[0].timeout = 0;
 
 		/* clone configuration */
 		usb2_config[1] = usb2_config[0];
@@ -1463,13 +1463,13 @@ ugen_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
 		usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
 		usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
 		usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
-		usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL;
-		usb2_config[0].mh.flags.proxy_buffer = 1;
-		usb2_config[0].mh.callback = &ugen_default_fs_callback;
-		usb2_config[0].mh.timeout = 0;	/* no timeout */
-		usb2_config[0].mh.frames = u.popen->max_frames;
-		usb2_config[0].mh.bufsize = u.popen->max_bufsize;
-		usb2_config[0].md = usb2_config[0].mh;	/* symmetric config */
+		usb2_config[0].interval = USB_DEFAULT_INTERVAL;
+		usb2_config[0].flags.proxy_buffer = 1;
+		usb2_config[0].callback = &ugen_default_fs_callback;
+		usb2_config[0].timeout = 0;	/* no timeout */
+		usb2_config[0].frames = u.popen->max_frames;
+		usb2_config[0].bufsize = u.popen->max_bufsize;
+		usb2_config[0].usb_mode = USB_MODE_MAX;		/* both modes */
 
 		if (usb2_config[0].type == UE_CONTROL) {
 			if (f->udev->flags.usb2_mode != USB_MODE_HOST) {
diff --git a/sys/dev/usb/usb_handle_request.c b/sys/dev/usb/usb_handle_request.c
index aec9e02c820c..7a9a6974fc7f 100644
--- a/sys/dev/usb/usb_handle_request.c
+++ b/sys/dev/usb/usb_handle_request.c
@@ -398,9 +398,7 @@ usb2_handle_remote_wakeup(struct usb2_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);
-
 	return (0);			/* success */
 }
 
diff --git a/sys/dev/usb/usb_hub.c b/sys/dev/usb/usb_hub.c
index 02f546439489..d12cfeb513c9 100644
--- a/sys/dev/usb/usb_hub.c
+++ b/sys/dev/usb/usb_hub.c
@@ -109,11 +109,11 @@ static const struct usb2_config uhub_config[UHUB_N_TRANSFER] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_ANY,
-		.mh.timeout = 0,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.bufsize = 0,	/* use wMaxPacketSize */
-		.mh.callback = &uhub_intr_callback,
-		.mh.interval = UHUB_INTR_INTERVAL,
+		.timeout = 0,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.bufsize = 0,	/* use wMaxPacketSize */
+		.callback = &uhub_intr_callback,
+		.interval = UHUB_INTR_INTERVAL,
 	},
 };
 
@@ -712,9 +712,10 @@ uhub_attach(device_t dev)
 	}
 	udev->hub = hub;
 
+#if USB_HAVE_TT_SUPPORT
 	/* init FULL-speed ISOCHRONOUS schedule */
 	usb2_fs_isoc_schedule_init_all(hub->fs_isoc_schedule);
-
+#endif
 	/* initialize HUB structure */
 	hub->hubsoftc = sc;
 	hub->explore = &uhub_explore;
@@ -1115,6 +1116,7 @@ usb2_intr_schedule_adjust(struct usb2_device *udev, int16_t len, uint8_t slot)
  * This function initialises an USB FULL speed isochronous schedule
  * entry.
  *------------------------------------------------------------------------*/
+#if USB_HAVE_TT_SUPPORT
 static void
 usb2_fs_isoc_schedule_init_sub(struct usb2_fs_isoc_schedule *fss)
 {
@@ -1123,6 +1125,7 @@ usb2_fs_isoc_schedule_init_sub(struct usb2_fs_isoc_schedule *fss)
 	fss->frame_bytes = (USB_FS_BYTES_PER_HS_UFRAME);
 	fss->frame_slot = 0;
 }
+#endif
 
 /*------------------------------------------------------------------------*
  *	usb2_fs_isoc_schedule_init_all
@@ -1130,6 +1133,7 @@ usb2_fs_isoc_schedule_init_sub(struct usb2_fs_isoc_schedule *fss)
  * 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 usb2_fs_isoc_schedule *fss)
 {
@@ -1140,6 +1144,7 @@ usb2_fs_isoc_schedule_init_all(struct usb2_fs_isoc_schedule *fss)
 		fss++;
 	}
 }
+#endif
 
 /*------------------------------------------------------------------------*
  *	usb2_isoc_time_expand
@@ -1187,6 +1192,7 @@ usb2_isoc_time_expand(struct usb2_bus *bus, uint16_t isoc_time_curr)
  * NOTE: This function depends on being called regularly with
  * intervals less than "USB_ISOC_TIME_MAX".
  *------------------------------------------------------------------------*/
+#if USB_HAVE_TT_SUPPORT
 uint16_t
 usb2_fs_isoc_schedule_isoc_time_expand(struct usb2_device *udev,
     struct usb2_fs_isoc_schedule **pp_start,
@@ -1233,6 +1239,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb2_device *udev,
 	}
 	return (isoc_time);
 }
+#endif
 
 /*------------------------------------------------------------------------*
  *	usb2_fs_isoc_schedule_alloc
@@ -1247,6 +1254,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb2_device *udev,
  *    0: Success
  * Else: Error
  *------------------------------------------------------------------------*/
+#if USB_HAVE_TT_SUPPORT
 uint8_t
 usb2_fs_isoc_schedule_alloc(struct usb2_fs_isoc_schedule *fss,
     uint8_t *pstart, uint16_t len)
@@ -1279,6 +1287,7 @@ usb2_fs_isoc_schedule_alloc(struct usb2_fs_isoc_schedule *fss,
 	*pstart = slot;
 	return (0);			/* success */
 }
+#endif
 
 /*------------------------------------------------------------------------*
  *	usb2_bus_port_get_device
@@ -1411,11 +1420,13 @@ usb2_needs_explore_all(void)
  * properly suspended or resumed according to the device transfer
  * state.
  *------------------------------------------------------------------------*/
+#if USB_HAVE_POWERD
 void
 usb2_bus_power_update(struct usb2_bus *bus)
 {
 	usb2_needs_explore(bus, 0 /* no probe */ );
 }
+#endif
 
 /*------------------------------------------------------------------------*
  *	usb2_transfer_power_ref
@@ -1424,6 +1435,7 @@ usb2_bus_power_update(struct usb2_bus *bus)
  * wakeup the USB device associated with the given USB transfer, if
  * needed.
  *------------------------------------------------------------------------*/
+#if USB_HAVE_POWERD
 void
 usb2_transfer_power_ref(struct usb2_xfer *xfer, int val)
 {
@@ -1493,8 +1505,8 @@ usb2_transfer_power_ref(struct usb2_xfer *xfer, int val)
 			(udev->bus->methods->set_hw_power) (udev->bus);
 		}
 	}
-	return;
 }
+#endif
 
 /*------------------------------------------------------------------------*
  *	usb2_bus_powerd
@@ -1502,6 +1514,7 @@ usb2_transfer_power_ref(struct usb2_xfer *xfer, int val)
  * 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 usb2_bus *bus)
 {
@@ -1625,6 +1638,7 @@ usb2_bus_powerd(struct usb2_bus *bus)
 	}
 	return;
 }
+#endif
 
 /*------------------------------------------------------------------------*
  *	usb2_dev_resume_peer
@@ -1684,6 +1698,7 @@ usb2_dev_resume_peer(struct usb2_device *udev)
 	USB_BUS_LOCK(bus);
 	/* set that this device is now resumed */
 	udev->pwr_save.suspended = 0;
+#if USB_HAVE_POWERD
 	/* make sure that we don't go into suspend right away */
 	udev->pwr_save.last_xfer_time = ticks;
 
@@ -1696,6 +1711,7 @@ usb2_dev_resume_peer(struct usb2_device *udev)
 		bus->hw_power_state |= USB_HW_POWER_INTERRUPT;
 	if (udev->pwr_save.type_refs[UE_ISOCHRONOUS] != 0)
 		bus->hw_power_state |= USB_HW_POWER_ISOC;
+#endif
 	USB_BUS_UNLOCK(bus);
 
 	if (bus->methods->set_hw_power != NULL) {
@@ -1844,7 +1860,7 @@ usb2_set_power_mode(struct usb2_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);
-
-	return;
+#endif
 }
diff --git a/sys/dev/usb/usb_hub.h b/sys/dev/usb/usb_hub.h
index 2dae7af9ed8d..62ab0d733840 100644
--- a/sys/dev/usb/usb_hub.h
+++ b/sys/dev/usb/usb_hub.h
@@ -52,7 +52,9 @@ struct usb2_fs_isoc_schedule {
  * The following structure defines an USB HUB.
  */
 struct usb2_hub {
+#if USB_HAVE_TT_SUPPORT
 	struct usb2_fs_isoc_schedule fs_isoc_schedule[USB_ISOC_TIME_MAX];
+#endif
 	struct usb2_device *hubudev;	/* the HUB device */
 	usb2_error_t (*explore) (struct usb2_device *hub);
 	void   *hubsoftc;
diff --git a/sys/dev/usb/usb_msctest.c b/sys/dev/usb/usb_msctest.c
index bd5fdacee626..960cd95a38db 100644
--- a/sys/dev/usb/usb_msctest.c
+++ b/sys/dev/usb/usb_msctest.c
@@ -137,57 +137,57 @@ static const struct usb2_config bbb_config[ST_MAX] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = sizeof(struct bbb_cbw),
-		.mh.callback = &bbb_command_callback,
-		.mh.timeout = 4 * USB_MS_HZ,	/* 4 seconds */
+		.bufsize = sizeof(struct bbb_cbw),
+		.callback = &bbb_command_callback,
+		.timeout = 4 * USB_MS_HZ,	/* 4 seconds */
 	},
 
 	[ST_DATA_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = BULK_SIZE,
-		.mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
-		.mh.callback = &bbb_data_read_callback,
-		.mh.timeout = 4 * USB_MS_HZ,	/* 4 seconds */
+		.bufsize = BULK_SIZE,
+		.flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
+		.callback = &bbb_data_read_callback,
+		.timeout = 4 * USB_MS_HZ,	/* 4 seconds */
 	},
 
 	[ST_DATA_RD_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &bbb_data_rd_cs_callback,
-		.mh.timeout = 1 * USB_MS_HZ,	/* 1 second  */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &bbb_data_rd_cs_callback,
+		.timeout = 1 * USB_MS_HZ,	/* 1 second  */
 	},
 
 	[ST_DATA_WR] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = BULK_SIZE,
-		.mh.flags = {.proxy_buffer = 1,},
-		.mh.callback = &bbb_data_write_callback,
-		.mh.timeout = 4 * USB_MS_HZ,	/* 4 seconds */
+		.bufsize = BULK_SIZE,
+		.flags = {.proxy_buffer = 1,},
+		.callback = &bbb_data_write_callback,
+		.timeout = 4 * USB_MS_HZ,	/* 4 seconds */
 	},
 
 	[ST_DATA_WR_CS] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &bbb_data_wr_cs_callback,
-		.mh.timeout = 1 * USB_MS_HZ,	/* 1 second  */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &bbb_data_wr_cs_callback,
+		.timeout = 1 * USB_MS_HZ,	/* 1 second  */
 	},
 
 	[ST_STATUS] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = sizeof(struct bbb_csw),
-		.mh.flags = {.short_xfer_ok = 1,},
-		.mh.callback = &bbb_status_callback,
-		.mh.timeout = 1 * USB_MS_HZ,	/* 1 second  */
+		.bufsize = sizeof(struct bbb_csw),
+		.flags = {.short_xfer_ok = 1,},
+		.callback = &bbb_status_callback,
+		.timeout = 1 * USB_MS_HZ,	/* 1 second  */
 	},
 };
 
diff --git a/sys/dev/usb/usb_request.c b/sys/dev/usb/usb_request.c
index edb399f23a4f..05b8c90553fa 100644
--- a/sys/dev/usb/usb_request.c
+++ b/sys/dev/usb/usb_request.c
@@ -319,11 +319,15 @@ usb2_do_request_flags(struct usb2_device *udev, struct mtx *mtx,
 	}
 	USB_XFER_LOCK(xfer);
 
-	if (flags & USB_DELAY_STATUS_STAGE) {
+	if (flags & USB_DELAY_STATUS_STAGE)
 		xfer->flags.manual_status = 1;
-	} else {
+	else
 		xfer->flags.manual_status = 0;
-	}
+
+	if (flags & USB_SHORT_XFER_OK)
+		xfer->flags.short_xfer_ok = 1;
+	else
+		xfer->flags.short_xfer_ok = 0;
 
 	xfer->timeout = timeout;
 
@@ -409,9 +413,6 @@ usb2_do_request_flags(struct usb2_device *udev, struct mtx *mtx,
 
 		if (temp > xfer->actlen) {
 			temp = xfer->actlen;
-			if (!(flags & USB_SHORT_XFER_OK)) {
-				err = USB_ERR_SHORT_XFER;
-			}
 			length = temp;
 		}
 		if (temp > 0) {
diff --git a/sys/dev/usb/usb_transfer.c b/sys/dev/usb/usb_transfer.c
index 58fd877a4005..10b0b9cf24a0 100644
--- a/sys/dev/usb/usb_transfer.c
+++ b/sys/dev/usb/usb_transfer.c
@@ -50,45 +50,7 @@ struct usb2_std_packet_size {
 	uint16_t fixed[4];
 };
 
-/*
- * This table stores the all the allowed packet sizes based on
- * endpoint type and USB speed:
- */
-static const struct usb2_std_packet_size
-	usb2_std_packet_size[4][USB_SPEED_MAX] = {
-
-	[UE_INTERRUPT] = {
-		[USB_SPEED_LOW] = {.range = {0, 8}},
-		[USB_SPEED_FULL] = {.range = {0, 64}},
-		[USB_SPEED_HIGH] = {.range = {0, 1024}},
-		[USB_SPEED_VARIABLE] = {.range = {0, 1024}},
-		[USB_SPEED_SUPER] = {.range = {0, 1024}},
-	},
-
-	[UE_CONTROL] = {
-		[USB_SPEED_LOW] = {.fixed = {8, 8, 8, 8}},
-		[USB_SPEED_FULL] = {.fixed = {8, 16, 32, 64}},
-		[USB_SPEED_HIGH] = {.fixed = {64, 64, 64, 64}},
-		[USB_SPEED_VARIABLE] = {.fixed = {512, 512, 512, 512}},
-		[USB_SPEED_SUPER] = {.fixed = {512, 512, 512, 512}},
-	},
-
-	[UE_BULK] = {
-		[USB_SPEED_LOW] = {.fixed = {0, 0, 0, 0}},	/* invalid */
-		[USB_SPEED_FULL] = {.fixed = {8, 16, 32, 64}},
-		[USB_SPEED_HIGH] = {.fixed = {512, 512, 512, 512}},
-		[USB_SPEED_VARIABLE] = {.fixed = {512, 512, 1024, 1536}},
-		[USB_SPEED_SUPER] = {.fixed = {1024, 1024, 1024, 1024}},
-	},
-
-	[UE_ISOCHRONOUS] = {
-		[USB_SPEED_LOW] = {.fixed = {0, 0, 0, 0}},	/* invalid */
-		[USB_SPEED_FULL] = {.range = {0, 1023}},
-		[USB_SPEED_HIGH] = {.range = {0, 1024}},
-		[USB_SPEED_VARIABLE] = {.range = {0, 3584}},
-		[USB_SPEED_SUPER] = {.range = {0, 1024}},
-	},
-};
+static usb2_callback_t usb2_request_callback;
 
 static const struct usb2_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
 
@@ -98,12 +60,10 @@ static const struct usb2_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control endpoint */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = USB_EP0_BUFSIZE,	/* bytes */
-		.mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
-		.mh.callback = &usb2_do_request_callback,
-		.md.bufsize = USB_EP0_BUFSIZE,	/* bytes */
-		.md.flags = {.proxy_buffer = 1,.short_xfer_ok = 0,},
-		.md.callback = &usb2_handle_request_callback,
+		.bufsize = USB_EP0_BUFSIZE,	/* bytes */
+		.flags = {.proxy_buffer = 1,},
+		.callback = &usb2_request_callback,
+		.usb_mode = USB_MODE_MAX,	/* both modes */
 	},
 
 	/* This transfer is used for generic clear stall only */
@@ -112,10 +72,11 @@ static const struct usb2_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
 		.type = UE_CONTROL,
 		.endpoint = 0x00,	/* Control pipe */
 		.direction = UE_DIR_ANY,
-		.mh.bufsize = sizeof(struct usb2_device_request),
-		.mh.callback = &usb2_do_clear_stall_callback,
-		.mh.timeout = 1000,	/* 1 second */
-		.mh.interval = 50,	/* 50ms */
+		.bufsize = sizeof(struct usb2_device_request),
+		.callback = &usb2_do_clear_stall_callback,
+		.timeout = 1000,	/* 1 second */
+		.interval = 50,	/* 50ms */
+		.usb_mode = USB_MODE_HOST,
 	},
 };
 
@@ -131,6 +92,20 @@ static void	usb2_callback_wrapper(struct usb2_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 usb2_xfer *);
+static void	usb2_get_std_packet_size(struct usb2_std_packet_size *ptr, 
+		    uint8_t type, uint8_t usb_speed);
+
+/*------------------------------------------------------------------------*
+ *	usb2_request_callback
+ *------------------------------------------------------------------------*/
+static void
+usb2_request_callback(struct usb2_xfer *xfer)
+{
+	if (xfer->flags_int.usb2_mode == USB_MODE_DEVICE)
+		usb2_handle_request_callback(xfer);
+	else
+		usb2_do_request_callback(xfer);
+}
 
 /*------------------------------------------------------------------------*
  *	usb2_update_max_frame_size
@@ -320,7 +295,7 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm)
 		MIN_PKT = 8,
 	};
 	struct usb2_xfer *xfer = parm->curr_xfer;
-	const struct usb2_config_sub *setup_sub = parm->curr_setup_sub;
+	const struct usb2_config *setup = parm->curr_setup;
 	struct usb2_endpoint_descriptor *edesc;
 	struct usb2_std_packet_size std_size;
 	usb2_frcount_t n_frlengths;
@@ -343,18 +318,18 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm)
 
 	type = (edesc->bmAttributes & UE_XFERTYPE);
 
-	xfer->flags = setup_sub->flags;
-	xfer->nframes = setup_sub->frames;
-	xfer->timeout = setup_sub->timeout;
-	xfer->callback = setup_sub->callback;
-	xfer->interval = setup_sub->interval;
+	xfer->flags = setup->flags;
+	xfer->nframes = setup->frames;
+	xfer->timeout = setup->timeout;
+	xfer->callback = setup->callback;
+	xfer->interval = setup->interval;
 	xfer->endpoint = edesc->bEndpointAddress;
 	xfer->max_packet_size = UGETW(edesc->wMaxPacketSize);
 	xfer->max_packet_count = 1;
 	/* make a shadow copy: */
 	xfer->flags_int.usb2_mode = parm->udev->flags.usb2_mode;
 
-	parm->bufsize = setup_sub->bufsize;
+	parm->bufsize = setup->bufsize;
 
 	if (parm->speed == USB_SPEED_HIGH) {
 		xfer->max_packet_count += (xfer->max_packet_size >> 11) & 3;
@@ -373,7 +348,7 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm)
 	}
 	/* filter "wMaxPacketSize" according to standard sizes */
 
-	std_size = usb2_std_packet_size[type][parm->speed];
+	usb2_get_std_packet_size(&std_size, type, parm->speed);
 
 	if (std_size.range.min || std_size.range.max) {
 
@@ -779,13 +754,11 @@ usb2_transfer_setup(struct usb2_device *udev,
 	/* sanity checks */
 	for (setup = setup_start, n = 0;
 	    setup != setup_end; setup++, n++) {
-		if ((setup->mh.bufsize == (usb2_frlength_t)-1) ||
-		    (setup->md.bufsize == (usb2_frlength_t)-1)) {
+		if (setup->bufsize == (usb2_frlength_t)-1) {
 			parm.err = USB_ERR_BAD_BUFSIZE;
 			DPRINTF("invalid bufsize\n");
 		}
-		if ((setup->mh.callback == NULL) &&
-		    (setup->md.callback == NULL)) {
+		if (setup->callback == NULL) {
 			parm.err = USB_ERR_NO_CALLBACK;
 			DPRINTF("no callback\n");
 		}
@@ -865,14 +838,8 @@ usb2_transfer_setup(struct usb2_device *udev,
 		for (setup = setup_start, n = 0;
 		    setup != setup_end; setup++, n++) {
 
-			/* select mode specific structure */
-			if (udev->flags.usb2_mode == USB_MODE_HOST) {
-				parm.curr_setup_sub = &setup->mh;
-			} else {
-				parm.curr_setup_sub = &setup->md;
-			}
 			/* skip USB transfers without callbacks: */
-			if (parm.curr_setup_sub->callback == NULL) {
+			if (setup->callback == NULL) {
 				continue;
 			}
 			/* see if there is a matching endpoint */
@@ -880,18 +847,21 @@ usb2_transfer_setup(struct usb2_device *udev,
 			    ifaces[setup->if_index], setup);
 
 			if (!pipe) {
-				if (parm.curr_setup_sub->flags.no_pipe_ok) {
+				if (setup->flags.no_pipe_ok)
+					continue;
+				if ((setup->usb_mode != USB_MODE_MAX) &&
+				    (setup->usb_mode != udev->flags.usb2_mode))
 					continue;
-				}
 				parm.err = USB_ERR_NO_PIPE;
 				goto done;
 			}
-			/* store current setup pointer */
-			parm.curr_setup = setup;
 
 			/* align data properly */
 			parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1));
 
+			/* store current setup pointer */
+			parm.curr_setup = setup;
+
 			if (buf) {
 				/*
 				 * Common initialization of the
@@ -1418,9 +1388,10 @@ usb2_start_hardware(struct usb2_xfer *xfer)
 	/* set "transferring" flag */
 	xfer->flags_int.transferring = 1;
 
+#if USB_HAVE_POWERD
 	/* increment power reference */
 	usb2_transfer_power_ref(xfer, 1);
-
+#endif
 	/*
 	 * Check if the transfer is waiting on a queue, most
 	 * frequently the "done_q":
@@ -1945,9 +1916,10 @@ usb2_callback_wrapper(struct usb2_xfer_queue *pq)
 			USB_BUS_LOCK(xfer->xroot->bus);
 			goto done;
 		}
+#if USB_HAVE_POWERD
 		/* decrement power reference */
 		usb2_transfer_power_ref(xfer, -1);
-
+#endif
 		xfer->flags_int.transferring = 0;
 
 		if (xfer->error) {
@@ -2669,8 +2641,9 @@ usb2_clear_data_toggle(struct usb2_device *udev, struct usb2_pipe *pipe)
  *	.direction = UE_DIR_ANY,
  *	.interval = 50, //50 milliseconds
  *	.bufsize = sizeof(struct usb2_device_request),
- *	.mh.timeout = 1000, //1.000 seconds
- *	.mh.callback = &my_clear_stall_callback, // **
+ *	.timeout = 1000, //1.000 seconds
+ *	.callback = &my_clear_stall_callback, // **
+ *	.usb_mode = USB_MODE_HOST,
  * };
  *
  * ** "my_clear_stall_callback" calls "usb2_clear_stall_callback"
@@ -2749,3 +2722,78 @@ usb2_do_poll(struct usb2_xfer **ppxfer, uint16_t max)
 		    "not supported!\n");
 	}
 }
+
+static void
+usb2_get_std_packet_size(struct usb2_std_packet_size *ptr, 
+    uint8_t type, uint8_t usb_speed)
+{
+	static const uint16_t intr_range_max[USB_SPEED_MAX] = {
+		[USB_SPEED_LOW] = 8,
+		[USB_SPEED_FULL] = 64,
+		[USB_SPEED_HIGH] = 1024,
+		[USB_SPEED_VARIABLE] = 1024,
+		[USB_SPEED_SUPER] = 1024,
+	};
+
+	static const uint16_t isoc_range_max[USB_SPEED_MAX] = {
+		[USB_SPEED_LOW] = 0,	/* invalid */
+		[USB_SPEED_FULL] = 1023,
+		[USB_SPEED_HIGH] = 1024,
+		[USB_SPEED_VARIABLE] = 3584,
+		[USB_SPEED_SUPER] = 1024,
+	};
+
+	static const uint16_t control_min[USB_SPEED_MAX] = {
+		[USB_SPEED_LOW] = 8,
+		[USB_SPEED_FULL] = 8,
+		[USB_SPEED_HIGH] = 64,
+		[USB_SPEED_VARIABLE] = 512,
+		[USB_SPEED_SUPER] = 512,
+	};
+
+	static const uint16_t bulk_min[USB_SPEED_MAX] = {
+		[USB_SPEED_LOW] = 0,	/* not supported */
+		[USB_SPEED_FULL] = 8,
+		[USB_SPEED_HIGH] = 512,
+		[USB_SPEED_VARIABLE] = 512,
+		[USB_SPEED_SUPER] = 1024,
+	};
+
+	uint16_t temp;
+
+	memset(ptr, 0, sizeof(*ptr));
+
+	switch (type) {
+	case UE_INTERRUPT:
+		ptr->range.max = intr_range_max[usb_speed];
+		break;
+	case UE_ISOCHRONOUS:
+		ptr->range.max = isoc_range_max[usb_speed];
+		break;
+	default:
+		if (type == UE_BULK)
+			temp = bulk_min[usb_speed];
+		else /* UE_CONTROL */
+			temp = control_min[usb_speed];
+
+		/* default is fixed */
+		ptr->fixed[0] = temp;
+		ptr->fixed[1] = temp;
+		ptr->fixed[2] = temp;
+		ptr->fixed[3] = temp;
+
+		if (usb_speed == USB_SPEED_FULL) {
+			/* multiple sizes */
+			ptr->fixed[1] = 16;
+			ptr->fixed[2] = 32;
+			ptr->fixed[3] = 64;
+		}
+		if ((usb_speed == USB_SPEED_VARIABLE) &&
+		    (type == UE_BULK)) {
+			/* multiple sizes */
+			ptr->fixed[2] = 1024;
+			ptr->fixed[3] = 1536;
+		}
+		break;
+	}
+}
diff --git a/sys/dev/usb/usb_transfer.h b/sys/dev/usb/usb_transfer.h
index 630fe4dd0bea..a15e8a3c0c96 100644
--- a/sys/dev/usb/usb_transfer.h
+++ b/sys/dev/usb/usb_transfer.h
@@ -93,7 +93,6 @@ struct usb2_setup_params {
 	struct usb2_device *udev;
 	struct usb2_xfer *curr_xfer;
 	const struct usb2_config *curr_setup;
-	const struct usb2_config_sub *curr_setup_sub;
 	const struct usb2_pipe_methods *methods;
 	void   *buf;
 	usb2_frlength_t *xfer_length_ptr;
diff --git a/sys/dev/usb/wlan/if_rum.c b/sys/dev/usb/wlan/if_rum.c
index 5b6e72e70423..856ed3801d5a 100644
--- a/sys/dev/usb/wlan/if_rum.c
+++ b/sys/dev/usb/wlan/if_rum.c
@@ -363,18 +363,18 @@ static const struct usb2_config rum_config[RUM_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = (MCLBYTES + RT2573_TX_DESC_SIZE + 8),
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = rum_bulk_write_callback,
-		.mh.timeout = 5000,	/* ms */
+		.bufsize = (MCLBYTES + RT2573_TX_DESC_SIZE + 8),
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = rum_bulk_write_callback,
+		.timeout = 5000,	/* ms */
 	},
 	[RUM_BULK_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = (MCLBYTES + RT2573_RX_DESC_SIZE),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = rum_bulk_read_callback,
+		.bufsize = (MCLBYTES + RT2573_RX_DESC_SIZE),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = rum_bulk_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/wlan/if_ural.c b/sys/dev/usb/wlan/if_ural.c
index 39e51e1d92fd..919b66df1459 100644
--- a/sys/dev/usb/wlan/if_ural.c
+++ b/sys/dev/usb/wlan/if_ural.c
@@ -339,18 +339,18 @@ static const struct usb2_config ural_config[URAL_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE + 4),
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = ural_bulk_write_callback,
-		.mh.timeout = 5000,	/* ms */
+		.bufsize = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE + 4),
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = ural_bulk_write_callback,
+		.timeout = 5000,	/* ms */
 	},
 	[URAL_BULK_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = (RAL_FRAME_SIZE + RAL_RX_DESC_SIZE),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = ural_bulk_read_callback,
+		.bufsize = (RAL_FRAME_SIZE + RAL_RX_DESC_SIZE),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = ural_bulk_read_callback,
 	},
 };
 
diff --git a/sys/dev/usb/wlan/if_zyd.c b/sys/dev/usb/wlan/if_zyd.c
index b0342e746ef9..6858d55ab4b2 100644
--- a/sys/dev/usb/wlan/if_zyd.c
+++ b/sys/dev/usb/wlan/if_zyd.c
@@ -232,38 +232,38 @@ static const struct usb2_config zyd_config[ZYD_N_TRANSFER] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = ZYD_MAX_TXBUFSZ,
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = zyd_bulk_write_callback,
+		.bufsize = ZYD_MAX_TXBUFSZ,
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = zyd_bulk_write_callback,
 		.ep_index = 0,
-		.mh.timeout = 10000,	/* 10 seconds */
+		.timeout = 10000,	/* 10 seconds */
 	},
 	[ZYD_BULK_RD] = {
 		.type = UE_BULK,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = ZYX_MAX_RXBUFSZ,
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = zyd_bulk_read_callback,
+		.bufsize = ZYX_MAX_RXBUFSZ,
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = zyd_bulk_read_callback,
 		.ep_index = 0,
 	},
 	[ZYD_INTR_WR] = {
 		.type = UE_BULK_INTR,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_OUT,
-		.mh.bufsize = sizeof(struct zyd_cmd),
-		.mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
-		.mh.callback = zyd_intr_write_callback,
-		.mh.timeout = 1000,	/* 1 second */
+		.bufsize = sizeof(struct zyd_cmd),
+		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
+		.callback = zyd_intr_write_callback,
+		.timeout = 1000,	/* 1 second */
 		.ep_index = 1,
 	},
 	[ZYD_INTR_RD] = {
 		.type = UE_INTERRUPT,
 		.endpoint = UE_ADDR_ANY,
 		.direction = UE_DIR_IN,
-		.mh.bufsize = sizeof(struct zyd_cmd),
-		.mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
-		.mh.callback = zyd_intr_read_callback,
+		.bufsize = sizeof(struct zyd_cmd),
+		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
+		.callback = zyd_intr_read_callback,
 	},
 };
 #define zyd_read16_m(sc, val, data)	do {				\