diff --git a/sys/dev/usb/controller/at91dci.c b/sys/dev/usb/controller/at91dci.c
index 807f89987572..ae18c285a2f7 100644
--- a/sys/dev/usb/controller/at91dci.c
+++ b/sys/dev/usb/controller/at91dci.c
@@ -66,7 +66,7 @@ __FBSDID("$FreeBSD$");
 
 #define	AT9100_DCI_BUS2SC(bus) \
    ((struct at91dci_softc *)(((uint8_t *)(bus)) - \
-   USB_P2U(&(((struct at91dci_softc *)0)->sc_bus))))
+    ((uint8_t *)&(((struct at91dci_softc *)0)->sc_bus))))
 
 #define	AT9100_DCI_PC2SC(pc) \
    AT9100_DCI_BUS2SC(USB_DMATAG_TO_XROOT((pc)->tag_parent)->bus)
diff --git a/sys/dev/usb/controller/atmegadci.c b/sys/dev/usb/controller/atmegadci.c
index 425cfbc09e21..55ab088bba5b 100644
--- a/sys/dev/usb/controller/atmegadci.c
+++ b/sys/dev/usb/controller/atmegadci.c
@@ -59,7 +59,7 @@ __FBSDID("$FreeBSD$");
 
 #define	ATMEGA_BUS2SC(bus) \
    ((struct atmegadci_softc *)(((uint8_t *)(bus)) - \
-   USB_P2U(&(((struct atmegadci_softc *)0)->sc_bus))))
+    ((uint8_t *)&(((struct atmegadci_softc *)0)->sc_bus))))
 
 #define	ATMEGA_PC2SC(pc) \
    ATMEGA_BUS2SC(USB_DMATAG_TO_XROOT((pc)->tag_parent)->bus)
diff --git a/sys/dev/usb/controller/ehci.c b/sys/dev/usb/controller/ehci.c
index 42f41ff37e46..b82fcd5d163a 100644
--- a/sys/dev/usb/controller/ehci.c
+++ b/sys/dev/usb/controller/ehci.c
@@ -66,8 +66,9 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_bus.h>
 #include <dev/usb/controller/ehci.h>
 
-#define	EHCI_BUS2SC(bus) ((ehci_softc_t *)(((uint8_t *)(bus)) - \
-   USB_P2U(&(((ehci_softc_t *)0)->sc_bus))))
+#define	EHCI_BUS2SC(bus) \
+   ((ehci_softc_t *)(((uint8_t *)(bus)) - \
+    ((uint8_t *)&(((ehci_softc_t *)0)->sc_bus))))
 
 #if USB_DEBUG
 static int ehcidebug = 0;
@@ -1729,7 +1730,7 @@ ehci_setup_standard_chain(struct usb2_xfer *xfer, ehci_qh_t **qh_last)
 	    xfer->address, UE_GET_ADDR(xfer->endpoint),
 	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
 
-	temp.average = xfer->max_usb2_frame_size;
+	temp.average = xfer->max_hc_frame_size;
 	temp.max_frame_size = xfer->max_frame_size;
 	temp.sc = EHCI_BUS2SC(xfer->xroot->bus);
 
@@ -3563,7 +3564,7 @@ ehci_xfer_setup(struct usb2_setup_params *parm)
 
 		nqh = 1;
 		nqtd = ((2 * xfer->nframes) + 1	/* STATUS */
-		    + (xfer->max_data_length / xfer->max_usb2_frame_size));
+		    + (xfer->max_data_length / xfer->max_hc_frame_size));
 
 	} else if (parm->methods == &ehci_device_bulk_methods) {
 
@@ -3576,7 +3577,7 @@ ehci_xfer_setup(struct usb2_setup_params *parm)
 
 		nqh = 1;
 		nqtd = ((2 * xfer->nframes)
-		    + (xfer->max_data_length / xfer->max_usb2_frame_size));
+		    + (xfer->max_data_length / xfer->max_hc_frame_size));
 
 	} else if (parm->methods == &ehci_device_intr_methods) {
 
@@ -3598,7 +3599,7 @@ ehci_xfer_setup(struct usb2_setup_params *parm)
 
 		nqh = 1;
 		nqtd = ((2 * xfer->nframes)
-		    + (xfer->max_data_length / xfer->max_usb2_frame_size));
+		    + (xfer->max_data_length / xfer->max_hc_frame_size));
 
 	} else if (parm->methods == &ehci_device_isoc_fs_methods) {
 
diff --git a/sys/dev/usb/controller/ohci.c b/sys/dev/usb/controller/ohci.c
index d453de891eca..9a25b3af4e71 100644
--- a/sys/dev/usb/controller/ohci.c
+++ b/sys/dev/usb/controller/ohci.c
@@ -55,8 +55,9 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/usb_bus.h>
 #include <dev/usb/controller/ohci.h>
 
-#define	OHCI_BUS2SC(bus) ((ohci_softc_t *)(((uint8_t *)(bus)) - \
-   USB_P2U(&(((ohci_softc_t *)0)->sc_bus))))
+#define	OHCI_BUS2SC(bus) \
+   ((ohci_softc_t *)(((uint8_t *)(bus)) - \
+    ((uint8_t *)&(((ohci_softc_t *)0)->sc_bus))))
 
 #if USB_DEBUG
 static int ohcidebug = 0;
@@ -1410,7 +1411,7 @@ ohci_setup_standard_chain(struct usb2_xfer *xfer, ohci_ed_t **ed_last)
 	    xfer->address, UE_GET_ADDR(xfer->endpoint),
 	    xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
 
-	temp.average = xfer->max_usb2_frame_size;
+	temp.average = xfer->max_hc_frame_size;
 	temp.max_frame_size = xfer->max_frame_size;
 
 	/* toggle the DMA set we are using */
@@ -2528,7 +2529,7 @@ ohci_xfer_setup(struct usb2_setup_params *parm)
 
 		nitd = 0;
 		ntd = ((2 * xfer->nframes) + 1	/* STATUS */
-		    + (xfer->max_data_length / xfer->max_usb2_frame_size));
+		    + (xfer->max_data_length / xfer->max_hc_frame_size));
 		nqh = 1;
 
 	} else if (parm->methods == &ohci_device_bulk_methods) {
@@ -2538,7 +2539,7 @@ ohci_xfer_setup(struct usb2_setup_params *parm)
 
 		nitd = 0;
 		ntd = ((2 * xfer->nframes)
-		    + (xfer->max_data_length / xfer->max_usb2_frame_size));
+		    + (xfer->max_data_length / xfer->max_hc_frame_size));
 		nqh = 1;
 
 	} else if (parm->methods == &ohci_device_intr_methods) {
@@ -2548,7 +2549,7 @@ ohci_xfer_setup(struct usb2_setup_params *parm)
 
 		nitd = 0;
 		ntd = ((2 * xfer->nframes)
-		    + (xfer->max_data_length / xfer->max_usb2_frame_size));
+		    + (xfer->max_data_length / xfer->max_hc_frame_size));
 		nqh = 1;
 
 	} else if (parm->methods == &ohci_device_isoc_methods) {
diff --git a/sys/dev/usb/controller/uhci.c b/sys/dev/usb/controller/uhci.c
index de4026d7425c..fcf1a4a47fcf 100644
--- a/sys/dev/usb/controller/uhci.c
+++ b/sys/dev/usb/controller/uhci.c
@@ -59,8 +59,9 @@ __FBSDID("$FreeBSD$");
 #include <dev/usb/controller/uhci.h>
 
 #define	alt_next next
-#define	UHCI_BUS2SC(bus) ((uhci_softc_t *)(((uint8_t *)(bus)) - \
-   USB_P2U(&(((uhci_softc_t *)0)->sc_bus))))
+#define	UHCI_BUS2SC(bus) \
+   ((uhci_softc_t *)(((uint8_t *)(bus)) - \
+    ((uint8_t *)&(((uhci_softc_t *)0)->sc_bus))))
 
 #if USB_DEBUG
 static int uhcidebug = 0;
diff --git a/sys/dev/usb/controller/uss820dci.c b/sys/dev/usb/controller/uss820dci.c
index a5144ca9223b..8d8e0e431c37 100644
--- a/sys/dev/usb/controller/uss820dci.c
+++ b/sys/dev/usb/controller/uss820dci.c
@@ -55,7 +55,7 @@
 
 #define	USS820_DCI_BUS2SC(bus) \
    ((struct uss820dci_softc *)(((uint8_t *)(bus)) - \
-   USB_P2U(&(((struct uss820dci_softc *)0)->sc_bus))))
+    ((uint8_t *)&(((struct uss820dci_softc *)0)->sc_bus))))
 
 #define	USS820_DCI_PC2SC(pc) \
    USS820_DCI_BUS2SC(USB_DMATAG_TO_XROOT((pc)->tag_parent)->bus)
diff --git a/sys/dev/usb/storage/ustorage_fs.c b/sys/dev/usb/storage/ustorage_fs.c
index bcb63a5b9f07..926b59eb93c7 100644
--- a/sys/dev/usb/storage/ustorage_fs.c
+++ b/sys/dev/usb/storage/ustorage_fs.c
@@ -59,8 +59,11 @@ SYSCTL_INT(_hw_usb2_ustorage_fs, OID_AUTO, debug, CTLFLAG_RW,
 
 /* Define some limits */
 
-#define	USTORAGE_FS_BULK_SIZE (1UL << 17)
-#define	USTORAGE_FS_MAX_LUN 8
+#ifndef USTORAGE_FS_BULK_SIZE 
+#define	USTORAGE_FS_BULK_SIZE (1UL << 17)	/* bytes */
+#endif
+
+#define	USTORAGE_FS_MAX_LUN 8	/* units */
 
 /*
  * The SCSI ID string must be exactly 28 characters long
@@ -136,7 +139,7 @@ typedef struct {
 
 struct ustorage_fs_lun {
 
-	void   *memory_image;
+	uint8_t	*memory_image;
 
 	uint32_t num_sectors;
 	uint32_t sense_data;
@@ -1370,8 +1373,7 @@ ustorage_fs_read(struct ustorage_fs_softc *sc)
 	file_offset = lba;
 	file_offset <<= 9;
 
-	sc->sc_transfer.data_ptr =
-	    USB_ADD_BYTES(currlun->memory_image, (uint32_t)file_offset);
+	sc->sc_transfer.data_ptr = currlun->memory_image + file_offset;
 
 	return (0);
 }
@@ -1435,8 +1437,7 @@ ustorage_fs_write(struct ustorage_fs_softc *sc)
 	file_offset = lba;
 	file_offset <<= 9;
 
-	sc->sc_transfer.data_ptr =
-	    USB_ADD_BYTES(currlun->memory_image, (uint32_t)file_offset);
+	sc->sc_transfer.data_ptr = currlun->memory_image + file_offset;
 
 	return (0);
 }
diff --git a/sys/dev/usb/usb_bus.h b/sys/dev/usb/usb_bus.h
index d2fecb94621c..126b2c77bf22 100644
--- a/sys/dev/usb/usb_bus.h
+++ b/sys/dev/usb/usb_bus.h
@@ -81,9 +81,9 @@ struct usb2_bus {
 	struct usb2_bus_methods *methods;	/* filled by HC driver */
 	struct usb2_device **devices;
 
-	uint32_t hw_power_state;	/* see USB_HW_POWER_XXX */
-	uint32_t uframe_usage[USB_HS_MICRO_FRAMES_MAX];
-	uint32_t transfer_count[4];
+	usb2_power_mask_t hw_power_state;	/* see USB_HW_POWER_XXX */
+	usb2_size_t uframe_usage[USB_HS_MICRO_FRAMES_MAX];
+
 	uint16_t isoc_time_last;	/* in milliseconds */
 
 	uint8_t	alloc_failed;		/* Set if memory allocation failed. */
diff --git a/sys/dev/usb/usb_busdma.c b/sys/dev/usb/usb_busdma.c
index a4422c6c170a..c8f30ed28b0b 100644
--- a/sys/dev/usb/usb_busdma.c
+++ b/sys/dev/usb/usb_busdma.c
@@ -42,7 +42,7 @@
 #include <dev/usb/usb_bus.h>
 
 #if USB_HAVE_BUSDMA
-static void	usb2_dma_tag_create(struct usb2_dma_tag *, uint32_t, uint32_t);
+static void	usb2_dma_tag_create(struct usb2_dma_tag *, usb2_size_t, usb2_size_t);
 static void	usb2_dma_tag_destroy(struct usb2_dma_tag *);
 #endif
 
@@ -66,7 +66,7 @@ static void	usb2_pc_common_mem_cb(struct usb2_page_cache *,
  * been properly initialized !
  *------------------------------------------------------------------------*/
 void
-usb2_get_page(struct usb2_page_cache *pc, uint32_t offset,
+usb2_get_page(struct usb2_page_cache *pc, usb2_frlength_t offset,
     struct usb2_page_search *res)
 {
 	struct usb2_page *page;
@@ -122,8 +122,8 @@ usb2_get_page(struct usb2_page_cache *pc, uint32_t offset,
  *  usb2_copy_in - copy directly to DMA-able memory
  *------------------------------------------------------------------------*/
 void
-usb2_copy_in(struct usb2_page_cache *cache, uint32_t offset,
-    const void *ptr, uint32_t len)
+usb2_copy_in(struct usb2_page_cache *cache, usb2_frlength_t offset,
+    const void *ptr, usb2_frlength_t len)
 {
 	struct usb2_page_search buf_res;
 
@@ -151,8 +151,8 @@ usb2_copy_in(struct usb2_page_cache *cache, uint32_t offset,
  *------------------------------------------------------------------------*/
 #if USB_HAVE_USER_IO
 int
-usb2_copy_in_user(struct usb2_page_cache *cache, uint32_t offset,
-    const void *ptr, uint32_t len)
+usb2_copy_in_user(struct usb2_page_cache *cache, usb2_frlength_t offset,
+    const void *ptr, usb2_frlength_t len)
 {
 	struct usb2_page_search buf_res;
 	int error;
@@ -182,10 +182,10 @@ usb2_copy_in_user(struct usb2_page_cache *cache, uint32_t offset,
 #if USB_HAVE_MBUF
 struct usb2_m_copy_in_arg {
 	struct usb2_page_cache *cache;
-	uint32_t dst_offset;
+	usb2_frlength_t dst_offset;
 };
 
-static int32_t
+static int
 #ifdef __FreeBSD__
 usb2_m_copy_in_cb(void *arg, void *src, uint32_t count)
 #else
@@ -200,11 +200,11 @@ usb2_m_copy_in_cb(void *arg, caddr_t src, uint32_t count)
 }
 
 void
-usb2_m_copy_in(struct usb2_page_cache *cache, uint32_t dst_offset,
-    struct mbuf *m, uint32_t src_offset, uint32_t src_len)
+usb2_m_copy_in(struct usb2_page_cache *cache, usb2_frlength_t dst_offset,
+    struct mbuf *m, usb2_size_t src_offset, usb2_frlength_t src_len)
 {
 	struct usb2_m_copy_in_arg arg = {cache, dst_offset};
-	register int error;
+	int error;
 
 	error = m_apply(m, src_offset, src_len, &usb2_m_copy_in_cb, &arg);
 }
@@ -216,7 +216,7 @@ usb2_m_copy_in(struct usb2_page_cache *cache, uint32_t dst_offset,
 #if USB_HAVE_USER_IO
 int
 usb2_uiomove(struct usb2_page_cache *pc, struct uio *uio,
-    uint32_t pc_offset, uint32_t len)
+    usb2_frlength_t pc_offset, usb2_frlength_t len)
 {
 	struct usb2_page_search res;
 	int error = 0;
@@ -248,8 +248,8 @@ usb2_uiomove(struct usb2_page_cache *pc, struct uio *uio,
  *  usb2_copy_out - copy directly from DMA-able memory
  *------------------------------------------------------------------------*/
 void
-usb2_copy_out(struct usb2_page_cache *cache, uint32_t offset,
-    void *ptr, uint32_t len)
+usb2_copy_out(struct usb2_page_cache *cache, usb2_frlength_t offset,
+    void *ptr, usb2_frlength_t len)
 {
 	struct usb2_page_search res;
 
@@ -277,8 +277,8 @@ usb2_copy_out(struct usb2_page_cache *cache, uint32_t offset,
  *------------------------------------------------------------------------*/
 #if USB_HAVE_USER_IO
 int
-usb2_copy_out_user(struct usb2_page_cache *cache, uint32_t offset,
-    void *ptr, uint32_t len)
+usb2_copy_out_user(struct usb2_page_cache *cache, usb2_frlength_t offset,
+    void *ptr, usb2_frlength_t len)
 {
 	struct usb2_page_search res;
 	int error;
@@ -306,7 +306,8 @@ usb2_copy_out_user(struct usb2_page_cache *cache, uint32_t offset,
  *  usb2_bzero - zero DMA-able memory
  *------------------------------------------------------------------------*/
 void
-usb2_bzero(struct usb2_page_cache *cache, uint32_t offset, uint32_t len)
+usb2_bzero(struct usb2_page_cache *cache, usb2_frlength_t offset,
+    usb2_frlength_t len)
 {
 	struct usb2_page_search res;
 
@@ -343,7 +344,7 @@ usb2_dma_lock_cb(void *arg, bus_dma_lock_op_t op)
  *------------------------------------------------------------------------*/
 static void
 usb2_dma_tag_create(struct usb2_dma_tag *udt,
-    uint32_t size, uint32_t align)
+    usb2_size_t size, usb2_size_t align)
 {
 	bus_dma_tag_t tag;
 
@@ -408,7 +409,7 @@ usb2_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs,
 	struct usb2_dma_parent_tag *uptag;
 	struct usb2_page_cache *pc;
 	struct usb2_page *pg;
-	uint32_t rem;
+	usb2_size_t rem;
 	uint8_t owned;
 
 	pc = arg;
@@ -471,7 +472,7 @@ usb2_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs,
  *------------------------------------------------------------------------*/
 uint8_t
 usb2_pc_alloc_mem(struct usb2_page_cache *pc, struct usb2_page *pg,
-    uint32_t size, uint32_t align)
+    usb2_size_t size, usb2_size_t align)
 {
 	struct usb2_dma_parent_tag *uptag;
 	struct usb2_dma_tag *utag;
@@ -594,7 +595,7 @@ usb2_pc_free_mem(struct usb2_page_cache *pc)
  * Else: Error
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_pc_load_mem(struct usb2_page_cache *pc, uint32_t size, uint8_t sync)
+usb2_pc_load_mem(struct usb2_page_cache *pc, usb2_size_t size, uint8_t sync)
 {
 	/* setup page cache */
 	pc->page_offset_buf = 0;
@@ -695,7 +696,7 @@ usb2_pc_cpu_flush(struct usb2_page_cache *pc)
  * Else: Failure
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_pc_dmamap_create(struct usb2_page_cache *pc, uint32_t size)
+usb2_pc_dmamap_create(struct usb2_page_cache *pc, usb2_size_t size)
 {
 	struct usb2_xfer_root *info;
 	struct usb2_dma_tag *utag;
@@ -751,9 +752,9 @@ usb2_pc_dmamap_destroy(struct usb2_page_cache *pc)
  *------------------------------------------------------------------------*/
 static void
 usb2_dma_tag_create(struct usb2_dma_tag *udt,
-    uint32_t size, uint32_t align)
+    usb2_size_t size, usb2_size_t align)
 {
-	uint32_t nseg;
+	usb2_size_t nseg;
 
 	if (align == 1) {
 		nseg = (2 + (size / USB_PAGE_SIZE));
@@ -789,7 +790,7 @@ usb2_pc_common_mem_cb(struct usb2_page_cache *pc, bus_dma_segment_t *segs,
 {
 	struct usb2_dma_parent_tag *uptag;
 	struct usb2_page *pg;
-	uint32_t rem;
+	usb2_size_t rem;
 	uint8_t ext_seg;		/* extend last segment */
 
 	uptag = pc->tag_parent;
@@ -855,7 +856,7 @@ usb2_pc_common_mem_cb(struct usb2_page_cache *pc, bus_dma_segment_t *segs,
  *------------------------------------------------------------------------*/
 uint8_t
 usb2_pc_alloc_mem(struct usb2_page_cache *pc, struct usb2_page *pg,
-    uint32_t size, uint32_t align)
+    usb2_size_t size, usb2_size_t align)
 {
 	struct usb2_dma_parent_tag *uptag;
 	struct usb2_dma_tag *utag;
@@ -978,7 +979,7 @@ usb2_pc_free_mem(struct usb2_page_cache *pc)
  * Else: Error
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_pc_load_mem(struct usb2_page_cache *pc, uint32_t size, uint8_t sync)
+usb2_pc_load_mem(struct usb2_page_cache *pc, usb2_size_t size, uint8_t sync)
 {
 	int error;
 
@@ -1028,7 +1029,7 @@ usb2_pc_load_mem(struct usb2_page_cache *pc, uint32_t size, uint8_t sync)
 void
 usb2_pc_cpu_invalidate(struct usb2_page_cache *pc)
 {
-	uint32_t len;
+	usb2_size_t len;
 
 	len = pc->page_offset_end - pc->page_offset_buf;
 
@@ -1046,7 +1047,7 @@ usb2_pc_cpu_invalidate(struct usb2_page_cache *pc)
 void
 usb2_pc_cpu_flush(struct usb2_page_cache *pc)
 {
-	uint32_t len;
+	usb2_size_t len;
 
 	len = pc->page_offset_end - pc->page_offset_buf;
 
@@ -1066,7 +1067,7 @@ usb2_pc_cpu_flush(struct usb2_page_cache *pc)
  * Else: Failure
  *------------------------------------------------------------------------*/
 uint8_t
-usb2_pc_dmamap_create(struct usb2_page_cache *pc, uint32_t size)
+usb2_pc_dmamap_create(struct usb2_page_cache *pc, usb2_size_t size)
 {
 	struct usb2_xfer_root *info;
 	struct usb2_dma_tag *utag;
@@ -1123,7 +1124,7 @@ usb2_pc_dmamap_destroy(struct usb2_page_cache *pc)
  *------------------------------------------------------------------------*/
 struct usb2_dma_tag *
 usb2_dma_tag_find(struct usb2_dma_parent_tag *udpt,
-    uint32_t size, uint32_t align)
+    usb2_size_t size, usb2_size_t align)
 {
 	struct usb2_dma_tag *udt;
 	uint8_t nudt;
@@ -1232,7 +1233,7 @@ usb2_bdma_work_loop(struct usb2_xfer_queue *pq)
 {
 	struct usb2_xfer_root *info;
 	struct usb2_xfer *xfer;
-	uint32_t nframes;
+	usb2_frcount_t nframes;
 
 	xfer = pq->curr;
 	info = xfer->xroot;
@@ -1248,7 +1249,7 @@ usb2_bdma_work_loop(struct usb2_xfer_queue *pq)
 	}
 	if (!xfer->flags_int.bdma_setup) {
 		struct usb2_page *pg;
-		uint32_t frlength_0;
+		usb2_frlength_t frlength_0;
 		uint8_t isread;
 
 		xfer->flags_int.bdma_setup = 1;
@@ -1381,7 +1382,7 @@ void
 usb2_bdma_pre_sync(struct usb2_xfer *xfer)
 {
 	struct usb2_page_cache *pc;
-	uint32_t nframes;
+	usb2_frcount_t nframes;
 
 	if (xfer->flags_int.isochronous_xfr) {
 		/* only one frame buffer */
@@ -1414,7 +1415,7 @@ void
 usb2_bdma_post_sync(struct usb2_xfer *xfer)
 {
 	struct usb2_page_cache *pc;
-	uint32_t nframes;
+	usb2_frcount_t nframes;
 
 	if (xfer->flags_int.isochronous_xfr) {
 		/* only one frame buffer */
diff --git a/sys/dev/usb/usb_busdma.h b/sys/dev/usb/usb_busdma.h
index 48b4d29a5ce5..26a65880b924 100644
--- a/sys/dev/usb/usb_busdma.h
+++ b/sys/dev/usb/usb_busdma.h
@@ -76,7 +76,7 @@ struct usb2_page_search {
 #if USB_HAVE_BUSDMA
 	bus_size_t physaddr;
 #endif
-	uint32_t length;
+	usb2_size_t length;
 };
 
 /*
@@ -103,8 +103,8 @@ struct usb2_page_cache {
 	int	n_seg;
 #endif
 #if USB_HAVE_BUSDMA
-	uint32_t page_offset_buf;
-	uint32_t page_offset_end;
+	usb2_size_t page_offset_buf;
+	usb2_size_t page_offset_end;
 	uint8_t	isread:1;		/* set if we are currently reading
 					 * from the memory. Else write. */
 	uint8_t	ismultiseg:1;		/* set if we can have multiple
@@ -142,47 +142,47 @@ struct usb2_dma_tag {
 	struct usb2_dma_parent_tag *tag_parent;
 	bus_dma_tag_t tag;
 
-	uint32_t align;
-	uint32_t size;
+	usb2_size_t align;
+	usb2_size_t size;
 #endif
 #if USB_HAVE_BUSDMA && defined(__NetBSD__)
-	uint32_t n_seg;
+	usb2_size_t n_seg;
 #endif
 };
 
 /* function prototypes */
 
 int	usb2_uiomove(struct usb2_page_cache *pc, struct uio *uio,
-	    uint32_t pc_offset, uint32_t len);
+	    usb2_frlength_t pc_offset, usb2_frlength_t len);
 struct usb2_dma_tag *usb2_dma_tag_find(struct usb2_dma_parent_tag *udpt,
-	    uint32_t size, uint32_t align);
+	    usb2_size_t size, usb2_size_t align);
 uint8_t	usb2_pc_alloc_mem(struct usb2_page_cache *pc, struct usb2_page *pg,
-	    uint32_t size, uint32_t align);
-uint8_t	usb2_pc_dmamap_create(struct usb2_page_cache *pc, uint32_t size);
-uint8_t	usb2_pc_load_mem(struct usb2_page_cache *pc, uint32_t size,
+	    usb2_size_t size, usb2_size_t align);
+uint8_t	usb2_pc_dmamap_create(struct usb2_page_cache *pc, usb2_size_t size);
+uint8_t	usb2_pc_load_mem(struct usb2_page_cache *pc, usb2_size_t size,
 	    uint8_t sync);
 void	usb2_bdma_done_event(struct usb2_dma_parent_tag *udpt);
 void	usb2_bdma_post_sync(struct usb2_xfer *xfer);
 void	usb2_bdma_pre_sync(struct usb2_xfer *xfer);
 void	usb2_bdma_work_loop(struct usb2_xfer_queue *pq);
-void	usb2_bzero(struct usb2_page_cache *cache, uint32_t offset,
-	    uint32_t len);
-void	usb2_copy_in(struct usb2_page_cache *cache, uint32_t offset,
-	    const void *ptr, uint32_t len);
-int	usb2_copy_in_user(struct usb2_page_cache *cache, uint32_t offset,
-	    const void *ptr, uint32_t len);
-void	usb2_copy_out(struct usb2_page_cache *cache, uint32_t offset,
-	    void *ptr, uint32_t len);
-int	usb2_copy_out_user(struct usb2_page_cache *cache, uint32_t offset,
-	    void *ptr, uint32_t len);
+void	usb2_bzero(struct usb2_page_cache *cache, usb2_frlength_t offset,
+	    usb2_frlength_t len);
+void	usb2_copy_in(struct usb2_page_cache *cache, usb2_frlength_t offset,
+	    const void *ptr, usb2_frlength_t len);
+int	usb2_copy_in_user(struct usb2_page_cache *cache, usb2_frlength_t offset,
+	    const void *ptr, usb2_frlength_t len);
+void	usb2_copy_out(struct usb2_page_cache *cache, usb2_frlength_t offset,
+	    void *ptr, usb2_frlength_t len);
+int	usb2_copy_out_user(struct usb2_page_cache *cache, usb2_frlength_t offset,
+	    void *ptr, usb2_frlength_t len);
 void	usb2_dma_tag_setup(struct usb2_dma_parent_tag *udpt,
 	    struct usb2_dma_tag *udt, bus_dma_tag_t dmat, struct mtx *mtx,
 	    usb2_dma_callback_t *func, uint8_t ndmabits, uint8_t nudt);
 void	usb2_dma_tag_unsetup(struct usb2_dma_parent_tag *udpt);
-void	usb2_get_page(struct usb2_page_cache *pc, uint32_t offset,
+void	usb2_get_page(struct usb2_page_cache *pc, usb2_frlength_t offset,
 	    struct usb2_page_search *res);
-void	usb2_m_copy_in(struct usb2_page_cache *cache, uint32_t dst_offset,
-	    struct mbuf *m, uint32_t src_offset, uint32_t src_len);
+void	usb2_m_copy_in(struct usb2_page_cache *cache, usb2_frlength_t dst_offset,
+	    struct mbuf *m, usb2_size_t src_offset, usb2_frlength_t src_len);
 void	usb2_pc_cpu_flush(struct usb2_page_cache *pc);
 void	usb2_pc_cpu_invalidate(struct usb2_page_cache *pc);
 void	usb2_pc_dmamap_destroy(struct usb2_page_cache *pc);
diff --git a/sys/dev/usb/usb_compat_linux.c b/sys/dev/usb/usb_compat_linux.c
index b422df1010d3..9641a81fe1a2 100644
--- a/sys/dev/usb/usb_compat_linux.c
+++ b/sys/dev/usb/usb_compat_linux.c
@@ -67,7 +67,7 @@ static usb2_callback_t usb_linux_non_isoc_callback;
 static usb_complete_t usb_linux_wait_complete;
 
 static uint16_t	usb_max_isoc_frames(struct usb_device *);
-static int	usb_start_wait_urb(struct urb *, uint32_t, uint16_t *);
+static int	usb_start_wait_urb(struct urb *, usb2_timeout_t, uint16_t *);
 static const struct usb_device_id *usb_linux_lookup_id(
 		    const struct usb_device_id *, struct usb2_attach_arg *);
 static struct	usb_driver *usb_linux_get_usb_driver(struct usb_linux_softc *);
@@ -564,7 +564,7 @@ usb_clear_halt(struct usb_device *dev, struct usb_host_endpoint *uhe)
  * Linux USB transfers.
  *------------------------------------------------------------------------*/
 static int
-usb_start_wait_urb(struct urb *urb, uint32_t timeout, uint16_t *p_actlen)
+usb_start_wait_urb(struct urb *urb, usb2_timeout_t timeout, uint16_t *p_actlen)
 {
 	int err;
 
@@ -620,7 +620,7 @@ int
 usb_control_msg(struct usb_device *dev, struct usb_host_endpoint *uhe,
     uint8_t request, uint8_t requesttype,
     uint16_t value, uint16_t index, void *data,
-    uint16_t size, uint32_t timeout)
+    uint16_t size, usb2_timeout_t timeout)
 {
 	struct usb2_device_request req;
 	struct urb *urb;
@@ -741,7 +741,7 @@ usb_set_interface(struct usb_device *dev, uint8_t iface_no, uint8_t alt_index)
  *------------------------------------------------------------------------*/
 int
 usb_setup_endpoint(struct usb_device *dev,
-    struct usb_host_endpoint *uhe, uint32_t bufsize)
+    struct usb_host_endpoint *uhe, usb2_size_t bufsize)
 {
 	struct usb2_config cfg[2];
 	uint8_t type = uhe->desc.bmAttributes & UE_XFERTYPE;
@@ -836,7 +836,7 @@ usb_linux_create_usb_device(struct usb2_device *udev, device_t dev)
 	struct usb_interface *p_ui = NULL;
 	struct usb_host_interface *p_uhi = NULL;
 	struct usb_host_endpoint *p_uhe = NULL;
-	uint32_t size;
+	usb2_size_t size;
 	uint16_t niface_total;
 	uint16_t nedesc;
 	uint16_t iface_no_curr;
@@ -971,7 +971,7 @@ struct urb *
 usb_alloc_urb(uint16_t iso_packets, uint16_t mem_flags)
 {
 	struct urb *urb;
-	uint32_t size;
+	usb2_size_t size;
 
 	if (iso_packets == 0xFFFF) {
 		/*
@@ -1102,7 +1102,7 @@ usb_ifnum_to_if(struct usb_device *dev, uint8_t iface_no)
  *	usb_buffer_alloc
  *------------------------------------------------------------------------*/
 void   *
-usb_buffer_alloc(struct usb_device *dev, uint32_t size, uint16_t mem_flags, uint8_t *dma_addr)
+usb_buffer_alloc(struct usb_device *dev, usb2_size_t size, uint16_t mem_flags, uint8_t *dma_addr)
 {
 	return (malloc(size, M_USBDEV, M_WAITOK | M_ZERO));
 }
@@ -1193,7 +1193,7 @@ usb_linux_free_device(struct usb_device *dev)
  *	usb_buffer_free
  *------------------------------------------------------------------------*/
 void
-usb_buffer_free(struct usb_device *dev, uint32_t size,
+usb_buffer_free(struct usb_device *dev, usb2_size_t size,
     void *addr, uint8_t dma_addr)
 {
 	free(addr, M_USBDEV);
@@ -1326,9 +1326,9 @@ usb_linux_complete(struct usb2_xfer *xfer)
 static void
 usb_linux_isoc_callback(struct usb2_xfer *xfer)
 {
-	uint32_t max_frame = xfer->max_frame_size;
-	uint32_t offset;
-	uint16_t x;
+	usb2_frlength_t max_frame = xfer->max_frame_size;
+	usb2_frlength_t offset;
+	usb2_frcount_t x;
 	struct urb *urb = xfer->priv_fifo;
 	struct usb_host_endpoint *uhe = xfer->priv_sc;
 	struct usb_iso_packet_descriptor *uipd;
@@ -1500,7 +1500,7 @@ usb_linux_non_isoc_callback(struct usb2_xfer *xfer)
 	struct urb *urb = xfer->priv_fifo;
 	struct usb_host_endpoint *uhe = xfer->priv_sc;
 	uint8_t *ptr;
-	uint32_t max_bulk = xfer->max_data_length;
+	usb2_frlength_t max_bulk = xfer->max_data_length;
 	uint8_t data_frame = xfer->flags_int.control_xfr ? 1 : 0;
 
 	DPRINTF("\n");
diff --git a/sys/dev/usb/usb_compat_linux.h b/sys/dev/usb/usb_compat_linux.h
index 8ebb7e3a7827..c63d82e42daa 100644
--- a/sys/dev/usb/usb_compat_linux.h
+++ b/sys/dev/usb/usb_compat_linux.h
@@ -321,7 +321,7 @@ struct usb_host_endpoint {
 
 	uint8_t *extra;			/* Extra descriptors */
 
-	uint32_t fbsd_buf_size;
+	usb2_frlength_t fbsd_buf_size;
 
 	uint16_t extralen;
 
@@ -406,10 +406,10 @@ struct urb {
 	void   *context;		/* (in) context for completion */
 	usb_complete_t *complete;	/* (in) completion routine */
 
-	uint32_t transfer_buffer_length;/* (in) data buffer length */
-	uint32_t actual_length;		/* (return) actual transfer length */
-	uint32_t bsd_length_rem;
-	uint32_t timeout;		/* FreeBSD specific */
+	usb2_size_t transfer_buffer_length;/* (in) data buffer length */
+	usb2_size_t bsd_length_rem;
+	usb2_size_t actual_length;	/* (return) actual transfer length */
+	usb2_timeout_t timeout;		/* FreeBSD specific */
 
 	uint16_t transfer_flags;	/* (in) */
 #define	URB_SHORT_NOT_OK	0x0001	/* report short transfers like errors */
@@ -420,8 +420,8 @@ struct urb {
 #define	URB_WAIT_WAKEUP		0x0010	/* custom flags */
 #define	URB_IS_SLEEPING		0x0020	/* custom flags */
 
-	uint16_t start_frame;		/* (modify) start frame (ISO) */
-	uint16_t number_of_packets;	/* (in) number of ISO packets */
+	usb2_frcount_t start_frame;	/* (modify) start frame (ISO) */
+	usb2_frcount_t number_of_packets;	/* (in) number of ISO packets */
 	uint16_t interval;		/* (modify) transfer interval
 					 * (INT/ISO) */
 	uint16_t error_count;		/* (return) number of ISO errors */
@@ -441,11 +441,11 @@ int	usb_unlink_urb(struct urb *urb);
 int	usb_clear_halt(struct usb_device *dev, struct usb_host_endpoint *uhe);
 int	usb_control_msg(struct usb_device *dev, struct usb_host_endpoint *pipe,
 	    uint8_t request, uint8_t requesttype, uint16_t value,
-	    uint16_t index, void *data, uint16_t size, uint32_t timeout);
+	    uint16_t index, void *data, uint16_t size, usb2_timeout_t timeout);
 int	usb_set_interface(struct usb_device *dev, uint8_t ifnum,
 	    uint8_t alternate);
 int	usb_setup_endpoint(struct usb_device *dev,
-	    struct usb_host_endpoint *uhe, uint32_t bufsize);
+	    struct usb_host_endpoint *uhe, usb2_frlength_t bufsize);
 
 struct usb_host_endpoint *usb_find_host_endpoint(struct usb_device *dev,
 	    uint8_t type, uint8_t ep);
@@ -454,11 +454,11 @@ struct usb_host_interface *usb_altnum_to_altsetting(
 	    const struct usb_interface *intf, uint8_t alt_index);
 struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, uint8_t iface_no);
 
-void   *usb_buffer_alloc(struct usb_device *dev, uint32_t size,
+void   *usb_buffer_alloc(struct usb_device *dev, usb2_size_t size,
 	    uint16_t mem_flags, uint8_t *dma_addr);
 void   *usb_get_intfdata(struct usb_interface *intf);
 
-void	usb_buffer_free(struct usb_device *dev, uint32_t size, void *addr, uint8_t dma_addr);
+void	usb_buffer_free(struct usb_device *dev, usb2_size_t size, void *addr, uint8_t dma_addr);
 void	usb_free_urb(struct urb *urb);
 void	usb_init_urb(struct urb *urb);
 void	usb_kill_urb(struct urb *urb);
diff --git a/sys/dev/usb/usb_controller.h b/sys/dev/usb/usb_controller.h
index ed329d850f9d..24a95bd0220e 100644
--- a/sys/dev/usb/usb_controller.h
+++ b/sys/dev/usb/usb_controller.h
@@ -45,7 +45,7 @@ struct usb2_endpoint_descriptor;
 
 /* typedefs */
 
-typedef void (usb2_bus_mem_sub_cb_t)(struct usb2_bus *bus, struct usb2_page_cache *pc, struct usb2_page *pg, uint32_t size, uint32_t align);
+typedef void (usb2_bus_mem_sub_cb_t)(struct usb2_bus *bus, struct usb2_page_cache *pc, struct usb2_page *pg, usb2_size_t size, usb2_size_t align);
 typedef void (usb2_bus_mem_cb_t)(struct usb2_bus *bus, usb2_bus_mem_sub_cb_t *scb);
 
 /*
@@ -175,7 +175,7 @@ struct usb2_hw_ep_scratch {
  */
 struct usb2_temp_setup {
 	void   *buf;
-	uint32_t size;
+	usb2_size_t size;
 	uint8_t	usb2_speed;
 	uint8_t	self_powered;
 	uint8_t	bNumEndpoints;
diff --git a/sys/dev/usb/usb_core.h b/sys/dev/usb/usb_core.h
index 69d396548370..1e4d96cdb9ff 100644
--- a/sys/dev/usb/usb_core.h
+++ b/sys/dev/usb/usb_core.h
@@ -163,6 +163,10 @@
 					 * data packet */
 #define	USB_HUB_MAX_DEPTH 5
 
+#ifndef USB_EP0_BUFSIZE
+#define	USB_EP0_BUFSIZE		1024	/* bytes */
+#endif
+
 /* USB transfer states */
 
 #define	USB_ST_SETUP       0
@@ -229,30 +233,26 @@ typedef uint8_t usb2_error_t;		/* see "USB_ERR_XXX" */
 typedef uint32_t usb2_timeout_t;	/* milliseconds */
 #endif
 
-#ifndef USB_HAVE_LENGTH_T
-typedef uint32_t usb2_length_t;		/* bytes */
+#ifndef USB_HAVE_FRLENGTH_T
+typedef uint32_t usb2_frlength_t;	/* bytes */
 #endif
 
-#ifndef USB_HAVE_FRAMES_T
-typedef uint32_t usb2_frames_t;		/* units */
-#endif
-
-#ifndef USB_HAVE_INTERVAL_T
-typedef uint32_t usb2_interval_t;	/* milliseconds */
+#ifndef USB_HAVE_FRCOUNT_T
+typedef uint32_t usb2_frcount_t;	/* units */
 #endif
 
 #ifndef USB_HAVE_SIZE_T
 typedef uint32_t usb2_size_t;		/* bytes */
 #endif
 
-#ifndef USB_HAVE_REFS_T
-typedef uint32_t usb2_refs_t;		/* units */
-#endif
-
 #ifndef USB_HAVE_TICKS_T
 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" */
+#endif
+
 /* structures */
 
 /*
@@ -339,11 +339,11 @@ struct usb2_xfer_flags_int {
  */
 struct usb2_config_sub {
 	usb2_callback_t *callback;	/* USB transfer callback */
-	uint32_t bufsize;		/* total pipe buffer size in bytes */
-	uint32_t frames;		/* maximum number of USB frames */
-	uint16_t interval;		/* interval in milliseconds */
+	usb2_frlength_t bufsize;	/* total pipe buffer size in bytes */
+	usb2_frcount_t frames;		/* maximum number of USB frames */
+	usb2_timeout_t interval;	/* interval in milliseconds */
 #define	USB_DEFAULT_INTERVAL	0
-	uint16_t timeout;		/* transfer timeout in milliseconds */
+	usb2_timeout_t timeout;		/* transfer timeout in milliseconds */
 	struct usb2_xfer_flags flags;	/* transfer flags */
 };
 
@@ -382,29 +382,29 @@ struct usb2_xfer {
 	void   *priv_sc;		/* device driver data pointer 1 */
 	void   *priv_fifo;		/* device driver data pointer 2 */
 	void   *local_buffer;
-	uint32_t *frlengths;
+	usb2_frlength_t *frlengths;
 	struct usb2_page_cache *frbuffers;
 	usb2_callback_t *callback;
 
-	uint32_t max_usb2_frame_size;
-	uint32_t max_data_length;
-	uint32_t sumlen;		/* sum of all lengths in bytes */
-	uint32_t actlen;		/* actual length in bytes */
-	uint32_t timeout;		/* milliseconds */
+	usb2_frlength_t max_hc_frame_size;
+	usb2_frlength_t max_data_length;
+	usb2_frlength_t sumlen;		/* sum of all lengths in bytes */
+	usb2_frlength_t actlen;		/* actual length in bytes */
+	usb2_timeout_t timeout;		/* milliseconds */
 #define	USB_NO_TIMEOUT 0
 #define	USB_DEFAULT_TIMEOUT 5000	/* 5000 ms = 5 seconds */
 
-	uint32_t max_frame_count;	/* initial value of "nframes" after
+	usb2_frcount_t max_frame_count;	/* initial value of "nframes" after
 					 * setup */
-	uint32_t nframes;		/* number of USB frames to transfer */
-	uint32_t aframes;		/* actual number of USB frames
+	usb2_frcount_t nframes;		/* number of USB frames to transfer */
+	usb2_frcount_t aframes;		/* actual number of USB frames
 					 * transferred */
 
 	uint16_t max_packet_size;
 	uint16_t max_frame_size;
 	uint16_t qh_pos;
 	uint16_t isoc_time_complete;	/* in ms */
-	uint16_t interval;		/* milliseconds */
+	usb2_timeout_t interval;	/* milliseconds */
 
 	uint8_t	address;		/* physical USB address */
 	uint8_t	endpoint;		/* physical USB endpoint */
@@ -489,9 +489,9 @@ usb2_error_t usb2_transfer_setup(struct usb2_device *udev,
 	    const struct usb2_config *setup_start, uint16_t n_setup,
 	    void *priv_sc, struct mtx *priv_mtx);
 void	usb2_set_frame_data(struct usb2_xfer *xfer, void *ptr,
-	    uint32_t frindex);
-void	usb2_set_frame_offset(struct usb2_xfer *xfer, uint32_t offset,
-	    uint32_t frindex);
+	    usb2_frcount_t frindex);
+void	usb2_set_frame_offset(struct usb2_xfer *xfer, usb2_frlength_t offset,
+	    usb2_frcount_t frindex);
 void	usb2_start_hardware(struct usb2_xfer *xfer);
 void	usb2_transfer_clear_stall(struct usb2_xfer *xfer);
 void	usb2_transfer_drain(struct usb2_xfer *xfer);
diff --git a/sys/dev/usb/usb_dev.c b/sys/dev/usb/usb_dev.c
index 6dbc6ae44677..29e8b423deb0 100644
--- a/sys/dev/usb/usb_dev.c
+++ b/sys/dev/usb/usb_dev.c
@@ -1688,7 +1688,7 @@ usb2_fifo_attach(struct usb2_device *udev, void *priv_sc,
  * Else failure
  *------------------------------------------------------------------------*/
 int
-usb2_fifo_alloc_buffer(struct usb2_fifo *f, uint32_t bufsize,
+usb2_fifo_alloc_buffer(struct usb2_fifo *f, usb2_size_t bufsize,
     uint16_t nbuf)
 {
 	usb2_fifo_free_buffer(f);
@@ -1753,11 +1753,11 @@ usb2_fifo_detach(struct usb2_fifo_sc *f_sc)
 	DPRINTFN(2, "detached %p\n", f_sc);
 }
 
-uint32_t
+usb2_size_t
 usb2_fifo_put_bytes_max(struct usb2_fifo *f)
 {
 	struct usb2_mbuf *m;
-	uint32_t len;
+	usb2_size_t len;
 
 	USB_IF_POLL(&f->free_q, m);
 
@@ -1778,10 +1778,10 @@ usb2_fifo_put_bytes_max(struct usb2_fifo *f)
  *------------------------------------------------------------------------*/
 void
 usb2_fifo_put_data(struct usb2_fifo *f, struct usb2_page_cache *pc,
-    uint32_t offset, uint32_t len, uint8_t what)
+    usb2_frlength_t offset, usb2_frlength_t len, uint8_t what)
 {
 	struct usb2_mbuf *m;
-	uint32_t io_len;
+	usb2_frlength_t io_len;
 
 	while (len || (what == 1)) {
 
@@ -1816,10 +1816,10 @@ usb2_fifo_put_data(struct usb2_fifo *f, struct usb2_page_cache *pc,
 
 void
 usb2_fifo_put_data_linear(struct usb2_fifo *f, void *ptr,
-    uint32_t len, uint8_t what)
+    usb2_size_t len, uint8_t what)
 {
 	struct usb2_mbuf *m;
-	uint32_t io_len;
+	usb2_size_t io_len;
 
 	while (len || (what == 1)) {
 
@@ -1853,7 +1853,7 @@ usb2_fifo_put_data_linear(struct usb2_fifo *f, void *ptr,
 }
 
 uint8_t
-usb2_fifo_put_data_buffer(struct usb2_fifo *f, void *ptr, uint32_t len)
+usb2_fifo_put_data_buffer(struct usb2_fifo *f, void *ptr, usb2_size_t len)
 {
 	struct usb2_mbuf *m;
 
@@ -1889,11 +1889,11 @@ usb2_fifo_put_data_error(struct usb2_fifo *f)
  *------------------------------------------------------------------------*/
 uint8_t
 usb2_fifo_get_data(struct usb2_fifo *f, struct usb2_page_cache *pc,
-    uint32_t offset, uint32_t len, uint32_t *actlen,
+    usb2_frlength_t offset, usb2_frlength_t len, usb2_frlength_t *actlen,
     uint8_t what)
 {
 	struct usb2_mbuf *m;
-	uint32_t io_len;
+	usb2_frlength_t io_len;
 	uint8_t tr_data = 0;
 
 	actlen[0] = 0;
@@ -1955,10 +1955,10 @@ usb2_fifo_get_data(struct usb2_fifo *f, struct usb2_page_cache *pc,
 
 uint8_t
 usb2_fifo_get_data_linear(struct usb2_fifo *f, void *ptr,
-    uint32_t len, uint32_t *actlen, uint8_t what)
+    usb2_size_t len, usb2_size_t *actlen, uint8_t what)
 {
 	struct usb2_mbuf *m;
-	uint32_t io_len;
+	usb2_size_t io_len;
 	uint8_t tr_data = 0;
 
 	actlen[0] = 0;
@@ -2019,7 +2019,7 @@ usb2_fifo_get_data_linear(struct usb2_fifo *f, void *ptr,
 }
 
 uint8_t
-usb2_fifo_get_data_buffer(struct usb2_fifo *f, void **pptr, uint32_t *plen)
+usb2_fifo_get_data_buffer(struct usb2_fifo *f, void **pptr, usb2_size_t *plen)
 {
 	struct usb2_mbuf *m;
 
diff --git a/sys/dev/usb/usb_dev.h b/sys/dev/usb/usb_dev.h
index e1c8b9436e75..af252c56ec70 100644
--- a/sys/dev/usb/usb_dev.h
+++ b/sys/dev/usb/usb_dev.h
@@ -135,9 +135,9 @@ struct usb2_fifo {
 	void   *priv_sc0;		/* client data */
 	void   *priv_sc1;		/* client data */
 	void   *queue_data;
-	uint32_t timeout;		/* timeout in milliseconds */
-	uint32_t bufsize;		/* BULK and INTERRUPT buffer size */
-	uint16_t nframes;		/* for isochronous mode */
+	usb2_timeout_t timeout;		/* timeout in milliseconds */
+	usb2_frlength_t bufsize;		/* BULK and INTERRUPT buffer size */
+	usb2_frcount_t nframes;		/* for isochronous mode */
 	uint16_t dev_ep_index;		/* our device endpoint index */
 	uint8_t	flag_sleeping;		/* set if FIFO is sleeping */
 	uint8_t	flag_iscomplete;	/* set if a USB transfer is complete */
@@ -175,17 +175,18 @@ int	usb2_fifo_attach(struct usb2_device *udev, void *priv_sc,
 void	usb2_fifo_detach(struct usb2_fifo_sc *f_sc);
 uint32_t usb2_fifo_put_bytes_max(struct usb2_fifo *fifo);
 void	usb2_fifo_put_data(struct usb2_fifo *fifo, struct usb2_page_cache *pc,
-	    uint32_t offset, uint32_t len, uint8_t what);
+	    usb2_frlength_t offset, usb2_frlength_t len, uint8_t what);
 void	usb2_fifo_put_data_linear(struct usb2_fifo *fifo, void *ptr,
-	    uint32_t len, uint8_t what);
-uint8_t	usb2_fifo_put_data_buffer(struct usb2_fifo *f, void *ptr, uint32_t len);
+	    usb2_size_t len, uint8_t what);
+uint8_t	usb2_fifo_put_data_buffer(struct usb2_fifo *f, void *ptr, usb2_size_t len);
 void	usb2_fifo_put_data_error(struct usb2_fifo *fifo);
 uint8_t	usb2_fifo_get_data(struct usb2_fifo *fifo, struct usb2_page_cache *pc,
-	    uint32_t offset, uint32_t len, uint32_t *actlen, uint8_t what);
+	    usb2_frlength_t offset, usb2_frlength_t len, usb2_frlength_t *actlen,
+	    uint8_t what);
 uint8_t	usb2_fifo_get_data_linear(struct usb2_fifo *fifo, void *ptr,
-	    uint32_t len, uint32_t *actlen, uint8_t what);
+	    usb2_size_t len, usb2_size_t *actlen, uint8_t what);
 uint8_t	usb2_fifo_get_data_buffer(struct usb2_fifo *f, void **pptr,
-	    uint32_t *plen);
+	    usb2_size_t *plen);
 void	usb2_fifo_get_data_error(struct usb2_fifo *fifo);
 uint8_t	usb2_fifo_opened(struct usb2_fifo *fifo);
 void	usb2_fifo_free(struct usb2_fifo *f);
diff --git a/sys/dev/usb/usb_device.c b/sys/dev/usb/usb_device.c
index 4fcac83ecf8a..d08e8b97f4e0 100644
--- a/sys/dev/usb/usb_device.c
+++ b/sys/dev/usb/usb_device.c
@@ -1397,7 +1397,7 @@ usb2_alloc_device(device_t parent_dev, struct usb2_bus *bus,
 	udev->depth = depth;
 	udev->bus = bus;
 	udev->address = USB_START_ADDR;	/* default value */
-	udev->plugtime = (uint32_t)ticks;
+	udev->plugtime = (usb2_ticks_t)ticks;
 	/*
 	 * We need to force the power mode to "on" because there are plenty
 	 * of USB devices out there that do not work very well with
diff --git a/sys/dev/usb/usb_device.h b/sys/dev/usb/usb_device.h
index 3ec5ad5f7a6e..29d3aa91708d 100644
--- a/sys/dev/usb/usb_device.h
+++ b/sys/dev/usb/usb_device.h
@@ -87,10 +87,10 @@ struct usb2_device_flags {
  * in this structure is protected by the USB BUS lock.
  */
 struct usb2_power_save {
-	int	last_xfer_time;		/* copy of "ticks" */
-	uint32_t type_refs[4];		/* transfer reference count */
-	uint32_t read_refs;		/* data read references */
-	uint32_t write_refs;		/* data write references */
+	usb2_ticks_t last_xfer_time;	/* copy of "ticks" */
+	usb2_size_t type_refs[4];	/* transfer reference count */
+	usb2_size_t read_refs;		/* data read references */
+	usb2_size_t write_refs;		/* data write references */
 	uint8_t	suspended;		/* set if USB device is suspended */
 };
 
@@ -128,7 +128,7 @@ struct usb2_device {
 
 	LIST_HEAD(,usb2_fs_privdata) pd_list;
 
-	uint32_t plugtime;		/* copy of "ticks" */
+	usb2_ticks_t plugtime;		/* copy of "ticks" */
 
 	uint16_t refcount;
 #define	USB_DEV_REF_MAX 0xffff
diff --git a/sys/dev/usb/usb_generic.c b/sys/dev/usb/usb_generic.c
index d7995894e270..6a1a9daf69a6 100644
--- a/sys/dev/usb/usb_generic.c
+++ b/sys/dev/usb/usb_generic.c
@@ -428,7 +428,7 @@ static void
 ugen_default_write_callback(struct usb2_xfer *xfer)
 {
 	struct usb2_fifo *f = xfer->priv_sc;
-	uint32_t actlen;
+	usb2_frlength_t actlen;
 
 	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
 
@@ -500,8 +500,8 @@ static void
 ugen_isoc_read_callback(struct usb2_xfer *xfer)
 {
 	struct usb2_fifo *f = xfer->priv_sc;
-	uint32_t offset;
-	uint16_t n;
+	usb2_frlength_t offset;
+	usb2_frcount_t n;
 
 	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
 
@@ -539,9 +539,9 @@ static void
 ugen_isoc_write_callback(struct usb2_xfer *xfer)
 {
 	struct usb2_fifo *f = xfer->priv_sc;
-	uint32_t actlen;
-	uint32_t offset;
-	uint16_t n;
+	usb2_frlength_t actlen;
+	usb2_frlength_t offset;
+	usb2_frcount_t n;
 
 	DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
 
@@ -1020,10 +1020,10 @@ ugen_fs_copy_in(struct usb2_fifo *f, uint8_t ep_index)
 	struct usb2_fs_endpoint fs_ep;
 	void *uaddr;			/* userland pointer */
 	void *kaddr;
-	uint32_t offset;
+	usb2_frlength_t offset;
+	usb2_frlength_t rem;
+	usb2_frcount_t n;
 	uint32_t length;
-	uint32_t n;
-	uint32_t rem;
 	int error;
 	uint8_t isread;
 
@@ -1197,21 +1197,21 @@ ugen_fs_copy_out(struct usb2_fifo *f, uint8_t ep_index)
 	struct usb2_fs_endpoint *fs_ep_uptr;	/* userland ptr */
 	void *uaddr;			/* userland ptr */
 	void *kaddr;
-	uint32_t offset;
+	usb2_frlength_t offset;
+	usb2_frlength_t rem;
+	usb2_frcount_t n;
 	uint32_t length;
 	uint32_t temp;
-	uint32_t n;
-	uint32_t rem;
 	int error;
 	uint8_t isread;
 
-	if (ep_index >= f->fs_ep_max) {
+	if (ep_index >= f->fs_ep_max)
 		return (EINVAL);
-	}
+
 	xfer = f->fs_xfer[ep_index];
-	if (xfer == NULL) {
+	if (xfer == NULL)
 		return (EINVAL);
-	}
+
 	mtx_lock(f->priv_mtx);
 	if (usb2_transfer_pending(xfer)) {
 		mtx_unlock(f->priv_mtx);
@@ -1614,7 +1614,7 @@ ugen_get_frame_size(struct usb2_fifo *f, void *addr)
 static int
 ugen_set_buffer_size(struct usb2_fifo *f, void *addr)
 {
-	uint32_t t;
+	usb2_frlength_t t;
 
 	if (*(int *)addr < 1024)
 		t = 1024;
diff --git a/sys/dev/usb/usb_hid.c b/sys/dev/usb/usb_hid.c
index 21c32d6ee1d2..29caf38500cd 100644
--- a/sys/dev/usb/usb_hid.c
+++ b/sys/dev/usb/usb_hid.c
@@ -105,7 +105,7 @@ hid_clear_local(struct hid_item *c)
  *	hid_start_parse
  *------------------------------------------------------------------------*/
 struct hid_data *
-hid_start_parse(const void *d, int len, int kindset)
+hid_start_parse(const void *d, usb2_size_t len, int kindset)
 {
 	struct hid_data *s;
 
@@ -490,7 +490,7 @@ hid_get_item(struct hid_data *s, struct hid_item *h)
  *	hid_report_size
  *------------------------------------------------------------------------*/
 int
-hid_report_size(const void *buf, int len, enum hid_kind k, uint8_t *id)
+hid_report_size(const void *buf, usb2_size_t len, enum hid_kind k, uint8_t *id)
 {
 	struct hid_data *d;
 	struct hid_item h;
@@ -543,7 +543,7 @@ hid_report_size(const void *buf, int len, enum hid_kind k, uint8_t *id)
  *	hid_locate
  *------------------------------------------------------------------------*/
 int
-hid_locate(const void *desc, int size, uint32_t u, enum hid_kind k,
+hid_locate(const void *desc, usb2_size_t size, uint32_t u, enum hid_kind k,
     struct hid_location *loc, uint32_t *flags, uint8_t *id)
 {
 	struct hid_data *d;
@@ -575,7 +575,7 @@ hid_locate(const void *desc, int size, uint32_t u, enum hid_kind k,
  *	hid_get_data
  *------------------------------------------------------------------------*/
 uint32_t
-hid_get_data(const uint8_t *buf, uint32_t len, struct hid_location *loc)
+hid_get_data(const uint8_t *buf, usb2_size_t len, struct hid_location *loc)
 {
 	uint32_t hpos = loc->pos;
 	uint32_t hsize = loc->size;
@@ -618,7 +618,7 @@ hid_get_data(const uint8_t *buf, uint32_t len, struct hid_location *loc)
  *	hid_is_collection
  *------------------------------------------------------------------------*/
 int
-hid_is_collection(const void *desc, int size, uint32_t usage)
+hid_is_collection(const void *desc, usb2_size_t size, uint32_t usage)
 {
 	struct hid_data *hd;
 	struct hid_item hi;
diff --git a/sys/dev/usb/usb_hid.h b/sys/dev/usb/usb_hid.h
index 0711c473fe31..f3356bbbbe6d 100644
--- a/sys/dev/usb/usb_hid.h
+++ b/sys/dev/usb/usb_hid.h
@@ -74,17 +74,17 @@ struct hid_item {
 
 /* prototypes from "usb2_hid.c" */
 
-struct hid_data *hid_start_parse(const void *d, int len, int kindset);
+struct hid_data *hid_start_parse(const void *d, usb2_size_t len, int kindset);
 void	hid_end_parse(struct hid_data *s);
 int	hid_get_item(struct hid_data *s, struct hid_item *h);
-int	hid_report_size(const void *buf, int len, enum hid_kind k,
+int	hid_report_size(const void *buf, usb2_size_t len, enum hid_kind k,
 	    uint8_t *id);
-int	hid_locate(const void *desc, int size, uint32_t usage,
+int	hid_locate(const void *desc, usb2_size_t size, uint32_t usage,
 	    enum hid_kind kind, struct hid_location *loc,
 	    uint32_t *flags, uint8_t *id);
-uint32_t hid_get_data(const uint8_t *buf, uint32_t len,
+uint32_t hid_get_data(const uint8_t *buf, usb2_size_t len,
 	    struct hid_location *loc);
-int	hid_is_collection(const void *desc, int size, uint32_t usage);
+int	hid_is_collection(const void *desc, usb2_size_t size, uint32_t usage);
 struct usb2_hid_descriptor *hid_get_descriptor_from_usb(
 	    struct usb2_config_descriptor *cd,
 	    struct usb2_interface_descriptor *id);
diff --git a/sys/dev/usb/usb_hub.c b/sys/dev/usb/usb_hub.c
index 596edebd8389..e08f49268cf3 100644
--- a/sys/dev/usb/usb_hub.c
+++ b/sys/dev/usb/usb_hub.c
@@ -1030,9 +1030,9 @@ uhub_child_pnpinfo_string(device_t parent, device_t child,
  *   The best Transaction Translation slot for an interrupt endpoint.
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_intr_find_best_slot(uint32_t *ptr, uint8_t start, uint8_t end)
+usb2_intr_find_best_slot(usb2_size_t *ptr, uint8_t start, uint8_t end)
 {
-	uint32_t max = 0xffffffff;
+	usb2_size_t max = 0 - 1;
 	uint8_t x;
 	uint8_t y;
 
@@ -1422,7 +1422,7 @@ usb2_bus_power_update(struct usb2_bus *bus)
 void
 usb2_transfer_power_ref(struct usb2_xfer *xfer, int val)
 {
-	static const uint32_t power_mask[4] = {
+	static const usb2_power_mask_t power_mask[4] = {
 		[UE_CONTROL] = USB_HW_POWER_CONTROL,
 		[UE_BULK] = USB_HW_POWER_BULK,
 		[UE_INTERRUPT] = USB_HW_POWER_INTERRUPT,
@@ -1501,10 +1501,10 @@ void
 usb2_bus_powerd(struct usb2_bus *bus)
 {
 	struct usb2_device *udev;
-	unsigned int temp;
-	unsigned int limit;
-	unsigned int mintime;
-	uint32_t type_refs[5];
+	usb2_ticks_t temp;
+	usb2_ticks_t limit;
+	usb2_ticks_t mintime;
+	usb2_size_t type_refs[5];
 	uint8_t x;
 	uint8_t rem_wakeup;
 
@@ -1727,7 +1727,6 @@ usb2_dev_suspend_peer(struct usb2_device *udev)
 {
 	struct usb2_device *hub;
 	struct usb2_device *child;
-	uint32_t temp;
 	int err;
 	uint8_t x;
 	uint8_t nports;
@@ -1800,6 +1799,7 @@ usb2_dev_suspend_peer(struct usb2_device *udev)
 	USB_BUS_UNLOCK(udev->bus);
 
 	if (udev->bus->methods->device_suspend != NULL) {
+		usb2_timeout_t temp;
 
 		/* suspend device on the USB controller */
 		(udev->bus->methods->device_suspend) (udev);
diff --git a/sys/dev/usb/usb_hub.h b/sys/dev/usb/usb_hub.h
index 87d85b357722..2dae7af9ed8d 100644
--- a/sys/dev/usb/usb_hub.h
+++ b/sys/dev/usb/usb_hub.h
@@ -56,7 +56,7 @@ struct usb2_hub {
 	struct usb2_device *hubudev;	/* the HUB device */
 	usb2_error_t (*explore) (struct usb2_device *hub);
 	void   *hubsoftc;
-	uint32_t uframe_usage[USB_HS_MICRO_FRAMES_MAX];
+	usb2_size_t uframe_usage[USB_HS_MICRO_FRAMES_MAX];
 	uint16_t portpower;		/* mA per USB port */
 	uint8_t	isoc_last_time;
 	uint8_t	nports;
diff --git a/sys/dev/usb/usb_lookup.c b/sys/dev/usb/usb_lookup.c
index a8fa271ffb37..6c707ce9d7b2 100644
--- a/sys/dev/usb/usb_lookup.c
+++ b/sys/dev/usb/usb_lookup.c
@@ -42,7 +42,7 @@
  * Else: Pointer to matching entry.
  *------------------------------------------------------------------------*/
 const struct usb2_device_id *
-usb2_lookup_id_by_info(const struct usb2_device_id *id, uint32_t sizeof_id,
+usb2_lookup_id_by_info(const struct usb2_device_id *id, usb2_size_t sizeof_id,
     const struct usb2_lookup_info *info)
 {
 	const struct usb2_device_id *id_end;
@@ -121,7 +121,7 @@ usb2_lookup_id_by_info(const struct usb2_device_id *id, uint32_t sizeof_id,
  * Else: Failure
  *------------------------------------------------------------------------*/
 int
-usb2_lookup_id_by_uaa(const struct usb2_device_id *id, uint32_t sizeof_id,
+usb2_lookup_id_by_uaa(const struct usb2_device_id *id, usb2_size_t sizeof_id,
     struct usb2_attach_arg *uaa)
 {
 	id = usb2_lookup_id_by_info(id, sizeof_id, &uaa->info);
diff --git a/sys/dev/usb/usb_lookup.h b/sys/dev/usb/usb_lookup.h
index e4472923795f..74d02e5072fa 100644
--- a/sys/dev/usb/usb_lookup.h
+++ b/sys/dev/usb/usb_lookup.h
@@ -114,9 +114,9 @@ struct usb2_device_id {
   (((const uint8_t *)((did)->driver_info)) - ((const uint8_t *)0))
 
 const struct usb2_device_id *usb2_lookup_id_by_info(
-	    const struct usb2_device_id *id, uint32_t sizeof_id,
+	    const struct usb2_device_id *id, usb2_size_t sizeof_id,
 	    const struct usb2_lookup_info *info);
 int	usb2_lookup_id_by_uaa(const struct usb2_device_id *id,
-	    uint32_t sizeof_id, struct usb2_attach_arg *uaa);
+	    usb2_size_t sizeof_id, struct usb2_attach_arg *uaa);
 
 #endif					/* _USB2_LOOKUP_H_ */
diff --git a/sys/dev/usb/usb_mbuf.c b/sys/dev/usb/usb_mbuf.c
index 3ae6ee64c61b..e4d92b6375a6 100644
--- a/sys/dev/usb/usb_mbuf.c
+++ b/sys/dev/usb/usb_mbuf.c
@@ -36,12 +36,12 @@
  *------------------------------------------------------------------------*/
 void   *
 usb2_alloc_mbufs(struct malloc_type *type, struct usb2_ifqueue *ifq,
-    uint32_t block_size, uint16_t nblocks)
+    usb2_size_t block_size, uint16_t nblocks)
 {
 	struct usb2_mbuf *m_ptr;
 	uint8_t *data_ptr;
 	void *free_ptr = NULL;
-	uint32_t alloc_size;
+	usb2_size_t alloc_size;
 
 	/* align data */
 	block_size += ((-block_size) & (USB_HOST_ALIGN - 1));
diff --git a/sys/dev/usb/usb_mbuf.h b/sys/dev/usb/usb_mbuf.h
index 109340cbfefc..c748dbc79a93 100644
--- a/sys/dev/usb/usb_mbuf.h
+++ b/sys/dev/usb/usb_mbuf.h
@@ -37,8 +37,8 @@ struct usb2_mbuf {
 	struct usb2_mbuf *usb2_nextpkt;
 	struct usb2_mbuf *usb2_next;
 
-	uint32_t cur_data_len;
-	uint32_t max_data_len;
+	usb2_size_t cur_data_len;
+	usb2_size_t max_data_len;
 	uint8_t last_packet:1;
 	uint8_t unused:7;
 };
@@ -51,8 +51,8 @@ struct usb2_ifqueue {
 	struct usb2_mbuf *ifq_head;
 	struct usb2_mbuf *ifq_tail;
 
-	uint32_t ifq_len;
-	uint32_t ifq_maxlen;
+	usb2_size_t ifq_len;
+	usb2_size_t ifq_maxlen;
 };
 
 #define	USB_IF_ENQUEUE(ifq, m) do {		\
@@ -97,6 +97,6 @@ struct usb2_ifqueue {
 
 /* prototypes */
 void   *usb2_alloc_mbufs(struct malloc_type *type, struct usb2_ifqueue *ifq,
-	    uint32_t block_size, uint16_t nblocks);
+	    usb2_size_t block_size, uint16_t nblocks);
 
 #endif					/* _USB2_MBUF_H_ */
diff --git a/sys/dev/usb/usb_msctest.c b/sys/dev/usb/usb_msctest.c
index d41d8c968a6d..4f1004ee9475 100644
--- a/sys/dev/usb/usb_msctest.c
+++ b/sys/dev/usb/usb_msctest.c
@@ -109,10 +109,10 @@ struct bbb_transfer {
 
 	uint8_t *data_ptr;
 
-	uint32_t data_len;		/* bytes */
-	uint32_t data_rem;		/* bytes */
-	uint32_t data_timeout;		/* ms */
-	uint32_t actlen;		/* bytes */
+	usb2_size_t data_len;		/* bytes */
+	usb2_size_t data_rem;		/* bytes */
+	usb2_timeout_t data_timeout;	/* ms */
+	usb2_frlength_t actlen;		/* bytes */
 
 	uint8_t	cmd_len;		/* bytes */
 	uint8_t	dir;
@@ -265,7 +265,7 @@ bbb_command_callback(struct usb2_xfer *xfer)
 		tag = UGETDW(sc->cbw.dCBWTag) + 1;
 		USETDW(sc->cbw.dCBWSignature, CBWSIGNATURE);
 		USETDW(sc->cbw.dCBWTag, tag);
-		USETDW(sc->cbw.dCBWDataTransferLength, sc->data_len);
+		USETDW(sc->cbw.dCBWDataTransferLength, (uint32_t)sc->data_len);
 		sc->cbw.bCBWFlags = ((sc->dir == DIR_IN) ? CBWFLAGS_IN : CBWFLAGS_OUT);
 		sc->cbw.bCBWLUN = sc->lun;
 		sc->cbw.bCDBLength = sc->cmd_len;
@@ -289,7 +289,7 @@ static void
 bbb_data_read_callback(struct usb2_xfer *xfer)
 {
 	struct bbb_transfer *sc = xfer->priv_sc;
-	uint32_t max_bulk = xfer->max_data_length;
+	usb2_frlength_t max_bulk = xfer->max_data_length;
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
@@ -340,7 +340,7 @@ static void
 bbb_data_write_callback(struct usb2_xfer *xfer)
 {
 	struct bbb_transfer *sc = xfer->priv_sc;
-	uint32_t max_bulk = xfer->max_data_length;
+	usb2_frlength_t max_bulk = xfer->max_data_length;
 
 	switch (USB_GET_STATE(xfer)) {
 	case USB_ST_TRANSFERRED:
@@ -438,8 +438,8 @@ bbb_status_callback(struct usb2_xfer *xfer)
  *------------------------------------------------------------------------*/
 static uint8_t
 bbb_command_start(struct bbb_transfer *sc, uint8_t dir, uint8_t lun,
-    void *data_ptr, uint32_t data_len, uint8_t cmd_len,
-    uint32_t data_timeout)
+    void *data_ptr, usb2_size_t data_len, uint8_t cmd_len,
+    usb2_timeout_t data_timeout)
 {
 	sc->lun = lun;
 	sc->dir = data_len ? dir : DIR_NONE;
diff --git a/sys/dev/usb/usb_process.c b/sys/dev/usb/usb_process.c
index 03542843f296..5ec46d1328a1 100644
--- a/sys/dev/usb/usb_process.c
+++ b/sys/dev/usb/usb_process.c
@@ -243,7 +243,7 @@ usb2_proc_msignal(struct usb2_process *up, void *_pm0, void *_pm1)
 	struct usb2_proc_msg *pm0 = _pm0;
 	struct usb2_proc_msg *pm1 = _pm1;
 	struct usb2_proc_msg *pm2;
-	uint32_t d;
+	usb2_size_t d;
 	uint8_t t;
 
 	/* check if gone, return dummy value */
diff --git a/sys/dev/usb/usb_process.h b/sys/dev/usb/usb_process.h
index 756b92913adb..c151f66b70e9 100644
--- a/sys/dev/usb/usb_process.h
+++ b/sys/dev/usb/usb_process.h
@@ -51,7 +51,7 @@ typedef void (usb2_proc_callback_t)(struct usb2_proc_msg *hdr);
 struct usb2_proc_msg {
 	TAILQ_ENTRY(usb2_proc_msg) pm_qentry;
 	usb2_proc_callback_t *pm_callback;
-	uint32_t pm_num;
+	usb2_size_t pm_num;
 };
 
 /*
@@ -66,7 +66,7 @@ struct usb2_process {
 	struct thread *up_curtd;
 	struct mtx *up_mtx;
 
-	uint32_t up_msg_num;
+	usb2_size_t up_msg_num;
 
 	uint8_t	up_prio;
 	uint8_t	up_gone;
diff --git a/sys/dev/usb/usb_request.c b/sys/dev/usb/usb_request.c
index ba9ee61d749e..37e276176793 100644
--- a/sys/dev/usb/usb_request.c
+++ b/sys/dev/usb/usb_request.c
@@ -228,15 +228,15 @@ usb2_do_clear_stall_callback(struct usb2_xfer *xfer)
  *------------------------------------------------------------------------*/
 usb2_error_t
 usb2_do_request_flags(struct usb2_device *udev, struct mtx *mtx,
-    struct usb2_device_request *req, void *data, uint32_t flags,
-    uint16_t *actlen, uint32_t timeout)
+    struct usb2_device_request *req, void *data, uint16_t flags,
+    uint16_t *actlen, usb2_timeout_t timeout)
 {
 	struct usb2_xfer *xfer;
 	const void *desc;
 	int err = 0;
-	uint32_t start_ticks;
-	uint32_t delta_ticks;
-	uint32_t max_ticks;
+	usb2_ticks_t start_ticks;
+	usb2_ticks_t delta_ticks;
+	usb2_ticks_t max_ticks;
 	uint16_t length;
 	uint16_t temp;
 
@@ -487,8 +487,8 @@ usb2_do_request_flags(struct usb2_device *udev, struct mtx *mtx,
  *------------------------------------------------------------------------*/
 usb2_error_t
 usb2_do_request_proc(struct usb2_device *udev, struct usb2_process *pproc,
-    struct usb2_device_request *req, void *data, uint32_t flags,
-    uint16_t *actlen, uint32_t timeout)
+    struct usb2_device_request *req, void *data, uint16_t flags,
+    uint16_t *actlen, usb2_timeout_t timeout)
 {
 	usb2_error_t err;
 	uint16_t len;
diff --git a/sys/dev/usb/usb_request.h b/sys/dev/usb/usb_request.h
index 402daa002c3e..7daef4c6f2b5 100644
--- a/sys/dev/usb/usb_request.h
+++ b/sys/dev/usb/usb_request.h
@@ -30,11 +30,11 @@
 struct usb2_process;
 
 usb2_error_t usb2_do_request_flags(struct usb2_device *udev, struct mtx *mtx,
-		    struct usb2_device_request *req, void *data, uint32_t flags,
-		    uint16_t *actlen, uint32_t timeout);
+		    struct usb2_device_request *req, void *data, uint16_t flags,
+		    uint16_t *actlen, usb2_timeout_t timeout);
 usb2_error_t usb2_do_request_proc(struct usb2_device *udev, struct usb2_process *pproc,
-		    struct usb2_device_request *req, void *data, uint32_t flags,
-		    uint16_t *actlen, uint32_t timeout);
+		    struct usb2_device_request *req, void *data, uint16_t flags,
+		    uint16_t *actlen, usb2_timeout_t timeout);
 usb2_error_t usb2_req_clear_hub_feature(struct usb2_device *udev,
 		    struct mtx *mtx, uint16_t sel);
 usb2_error_t usb2_req_clear_port_feature(struct usb2_device *udev,
diff --git a/sys/dev/usb/usb_sw_transfer.c b/sys/dev/usb/usb_sw_transfer.c
index 439ed9c88734..9fcb69a65bd3 100644
--- a/sys/dev/usb/usb_sw_transfer.c
+++ b/sys/dev/usb/usb_sw_transfer.c
@@ -62,7 +62,7 @@ usb2_sw_transfer(struct usb2_sw_transfer *std,
     usb2_sw_transfer_func_t *func)
 {
 	struct usb2_xfer *xfer;
-	uint32_t len;
+	usb2_frlength_t len;
 	uint8_t shortpkt = 0;
 
 	xfer = std->xfer;
diff --git a/sys/dev/usb/usb_transfer.c b/sys/dev/usb/usb_transfer.c
index 48463a014c6d..9f590e0d7f5c 100644
--- a/sys/dev/usb/usb_transfer.c
+++ b/sys/dev/usb/usb_transfer.c
@@ -98,10 +98,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 = 1024,	/* bytes */
+		.mh.bufsize = USB_EP0_BUFSIZE,	/* bytes */
 		.mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
 		.mh.callback = &usb2_do_request_callback,
-		.md.bufsize = 1024,	/* bytes */
+		.md.bufsize = USB_EP0_BUFSIZE,	/* bytes */
 		.md.flags = {.proxy_buffer = 1,.short_xfer_ok = 0,},
 		.md.callback = &usb2_handle_request_callback,
 	},
@@ -163,7 +163,7 @@ usb2_update_max_frame_size(struct usb2_xfer *xfer)
  *    0: no DMA delay required
  * Else: milliseconds of DMA delay
  *------------------------------------------------------------------------*/
-uint32_t
+usb2_timeout_t
 usb2_get_dma_delay(struct usb2_bus *bus)
 {
 	uint32_t temp = 0;
@@ -194,18 +194,18 @@ usb2_get_dma_delay(struct usb2_bus *bus)
 #if USB_HAVE_BUSDMA
 uint8_t
 usb2_transfer_setup_sub_malloc(struct usb2_setup_params *parm,
-    struct usb2_page_cache **ppc, uint32_t size, uint32_t align,
-    uint32_t count)
+    struct usb2_page_cache **ppc, usb2_size_t size, usb2_size_t align,
+    usb2_size_t count)
 {
 	struct usb2_page_cache *pc;
 	struct usb2_page *pg;
 	void *buf;
-	uint32_t n_dma_pc;
-	uint32_t n_obj;
-	uint32_t x;
-	uint32_t y;
-	uint32_t r;
-	uint32_t z;
+	usb2_size_t n_dma_pc;
+	usb2_size_t n_obj;
+	usb2_size_t x;
+	usb2_size_t y;
+	usb2_size_t r;
+	usb2_size_t z;
 
 	USB_ASSERT(align > 1, ("Invalid alignment, 0x%08x!\n",
 	    align));
@@ -324,9 +324,9 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm)
 	const struct usb2_config_sub *setup_sub = parm->curr_setup_sub;
 	struct usb2_endpoint_descriptor *edesc;
 	struct usb2_std_packet_size std_size;
-	uint32_t n_frlengths;
-	uint32_t n_frbuffers;
-	uint32_t x;
+	usb2_frcount_t n_frlengths;
+	usb2_frcount_t n_frbuffers;
+	usb2_frcount_t x;
 	uint8_t type;
 	uint8_t zmps;
 
@@ -406,7 +406,7 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm)
 
 	if (type == UE_ISOCHRONOUS) {
 
-		uint32_t frame_limit;
+		uint16_t frame_limit;
 
 		xfer->interval = 0;	/* not used, must be zero */
 		xfer->flags_int.isochronous_xfr = 1;	/* set flag */
@@ -680,11 +680,11 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm)
 	}
 	/* subtract USB frame remainder from "hc_max_frame_size" */
 
-	xfer->max_usb2_frame_size =
+	xfer->max_hc_frame_size =
 	    (parm->hc_max_frame_size -
 	    (parm->hc_max_frame_size % xfer->max_frame_size));
 
-	if (xfer->max_usb2_frame_size == 0) {
+	if (xfer->max_hc_frame_size == 0) {
 		parm->err = USB_ERR_INVAL;
 		goto done;
 	}
@@ -717,7 +717,7 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm)
 		/*
 		 * Set some dummy values so that we avoid division by zero:
 		 */
-		xfer->max_usb2_frame_size = 1;
+		xfer->max_hc_frame_size = 1;
 		xfer->max_frame_size = 1;
 		xfer->max_packet_size = 1;
 		xfer->max_data_length = 0;
@@ -780,8 +780,8 @@ usb2_transfer_setup(struct usb2_device *udev,
 	/* sanity checks */
 	for (setup = setup_start, n = 0;
 	    setup != setup_end; setup++, n++) {
-		if ((setup->mh.bufsize == 0xffffffff) ||
-		    (setup->md.bufsize == 0xffffffff)) {
+		if ((setup->mh.bufsize == (usb2_frlength_t)-1) ||
+		    (setup->md.bufsize == (usb2_frlength_t)-1)) {
 			parm.err = USB_ERR_BAD_BUFSIZE;
 			DPRINTF("invalid bufsize\n");
 		}
@@ -1075,13 +1075,13 @@ static void
 usb2_transfer_unsetup_sub(struct usb2_xfer_root *info, uint8_t needs_delay)
 {
 	struct usb2_page_cache *pc;
-	uint32_t temp;
 
 	USB_BUS_LOCK_ASSERT(info->bus, MA_OWNED);
 
 	/* wait for any outstanding DMA operations */
 
 	if (needs_delay) {
+		usb2_timeout_t temp;
 		temp = usb2_get_dma_delay(info->bus);
 		usb2_pause_mtx(&info->bus->bus_mtx,
 		    USB_MS_TO_TICKS(temp));
@@ -1244,7 +1244,7 @@ usb2_control_transfer_init(struct usb2_xfer *xfer)
 static uint8_t
 usb2_start_hardware_sub(struct usb2_xfer *xfer)
 {
-	uint32_t len;
+	usb2_frlength_t len;
 
 	/* Check for control endpoint stall */
 	if (xfer->flags.stall_pipe) {
@@ -1373,7 +1373,7 @@ usb2_start_hardware_sub(struct usb2_xfer *xfer)
 void
 usb2_start_hardware(struct usb2_xfer *xfer)
 {
-	uint32_t x;
+	usb2_frcount_t x;
 
 	DPRINTF("xfer=%p, pipe=%p, nframes=%d, dir=%s\n",
 	    xfer, xfer->pipe, xfer->nframes, USB_GET_DATA_ISREAD(xfer) ?
@@ -1775,7 +1775,7 @@ usb2_transfer_drain(struct usb2_xfer *xfer)
  * than zero gives undefined results!
  *------------------------------------------------------------------------*/
 void
-usb2_set_frame_data(struct usb2_xfer *xfer, void *ptr, uint32_t frindex)
+usb2_set_frame_data(struct usb2_xfer *xfer, void *ptr, usb2_frcount_t frindex)
 {
 	/* set virtual address to load and length */
 	xfer->frbuffers[frindex].buffer = ptr;
@@ -1788,8 +1788,8 @@ usb2_set_frame_data(struct usb2_xfer *xfer, void *ptr, uint32_t frindex)
  * of the USB DMA buffer allocated for this USB transfer.
  *------------------------------------------------------------------------*/
 void
-usb2_set_frame_offset(struct usb2_xfer *xfer, uint32_t offset,
-    uint32_t frindex)
+usb2_set_frame_offset(struct usb2_xfer *xfer, usb2_frlength_t offset,
+    usb2_frcount_t frindex)
 {
 	USB_ASSERT(!xfer->flags.ext_buffer, ("Cannot offset data frame "
 	    "when the USB buffer is external!\n"));
@@ -2307,7 +2307,7 @@ usb2_pipe_start(struct usb2_xfer_queue *pq)
  *------------------------------------------------------------------------*/
 void
 usb2_transfer_timeout_ms(struct usb2_xfer *xfer,
-    void (*cb) (void *arg), uint32_t ms)
+    void (*cb) (void *arg), usb2_timeout_t ms)
 {
 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
 
@@ -2337,7 +2337,7 @@ static uint8_t
 usb2_callback_wrapper_sub(struct usb2_xfer *xfer)
 {
 	struct usb2_pipe *pipe;
-	uint32_t x;
+	usb2_frcount_t x;
 
 	if ((!xfer->flags_int.open) &&
 	    (!xfer->flags_int.did_close)) {
@@ -2357,7 +2357,7 @@ usb2_callback_wrapper_sub(struct usb2_xfer *xfer)
 	    (xfer->error == USB_ERR_TIMEOUT)) &&
 	    (!xfer->flags_int.did_dma_delay)) {
 
-		uint32_t temp;
+		usb2_timeout_t temp;
 
 		/* only delay once */
 		xfer->flags_int.did_dma_delay = 1;
diff --git a/sys/dev/usb/usb_transfer.h b/sys/dev/usb/usb_transfer.h
index 023a1e3a4b9a..630fe4dd0bea 100644
--- a/sys/dev/usb/usb_transfer.h
+++ b/sys/dev/usb/usb_transfer.h
@@ -39,8 +39,7 @@ struct usb2_done_msg {
 #define	USB_DMATAG_TO_XROOT(dpt)				\
   ((struct usb2_xfer_root *)(					\
    ((uint8_t *)(dpt)) -						\
-   ((uint8_t *)&((struct usb2_xfer_root *)0)->dma_parent_tag) +	\
-   ((uint8_t *)0)))
+   ((uint8_t *)&((struct usb2_xfer_root *)0)->dma_parent_tag)))
 
 /*
  * The following structure is used to keep information about memory
@@ -68,14 +67,15 @@ struct usb2_xfer_root {
 	struct usb2_bus *bus;		/* pointer to USB bus (cached) */
 	struct usb2_device *udev;	/* pointer to USB device */
 
-	uint32_t memory_size;
-	uint32_t setup_refcount;
-	uint32_t page_size;
-	uint32_t dma_nframes;		/* number of page caches to load */
-	uint32_t dma_currframe;		/* currect page cache number */
-	uint32_t dma_frlength_0;	/* length of page cache zero */
+	usb2_size_t memory_size;
+	usb2_size_t setup_refcount;
+#if USB_HAVE_BUSDMA
+	usb2_frcount_t dma_nframes;	/* number of page caches to load */
+	usb2_frcount_t dma_currframe;	/* currect page cache number */
+	usb2_frlength_t dma_frlength_0;	/* length of page cache zero */
 	uint8_t	dma_error;		/* set if virtual memory could not be
 					 * loaded */
+#endif
 	uint8_t	done_sleep;		/* set if done thread is sleeping */
 };
 
@@ -96,13 +96,13 @@ struct usb2_setup_params {
 	const struct usb2_config_sub *curr_setup_sub;
 	const struct usb2_pipe_methods *methods;
 	void   *buf;
-	uint32_t *xfer_length_ptr;
+	usb2_frlength_t *xfer_length_ptr;
 
-	uint32_t size[7];
-	uint32_t bufsize;
-	uint32_t bufsize_max;
-	uint32_t hc_max_frame_size;
+	usb2_size_t size[7];
+	usb2_frlength_t bufsize;
+	usb2_frlength_t bufsize_max;
 
+	uint16_t hc_max_frame_size;
 	uint16_t hc_max_packet_size;
 	uint8_t	hc_max_packet_count;
 	uint8_t	speed;
@@ -113,8 +113,8 @@ struct usb2_setup_params {
 /* function prototypes */
 
 uint8_t	usb2_transfer_setup_sub_malloc(struct usb2_setup_params *parm,
-	    struct usb2_page_cache **ppc, uint32_t size, uint32_t align,
-	    uint32_t count);
+	    struct usb2_page_cache **ppc, usb2_size_t size, usb2_size_t align,
+	    usb2_size_t count);
 void	usb2_command_wrapper(struct usb2_xfer_queue *pq,
 	    struct usb2_xfer *xfer);
 void	usb2_pipe_enter(struct usb2_xfer *xfer);
@@ -132,8 +132,8 @@ usb2_callback_t usb2_do_request_callback;
 usb2_callback_t usb2_handle_request_callback;
 usb2_callback_t usb2_do_clear_stall_callback;
 void	usb2_transfer_timeout_ms(struct usb2_xfer *xfer,
-	    void (*cb) (void *arg), uint32_t ms);
-uint32_t usb2_get_dma_delay(struct usb2_bus *bus);
+	    void (*cb) (void *arg), usb2_timeout_t ms);
+usb2_timeout_t usb2_get_dma_delay(struct usb2_bus *bus);
 void	usb2_transfer_power_ref(struct usb2_xfer *xfer, int val);
 
 #endif					/* _USB2_TRANSFER_H_ */