Index: sys/dev/usb/ehci.c
===================================================================
RCS file: /cvsroot/src/sys/dev/usb/ehci.c,v
retrieving revision 1.267.2.3
diff -u -p -r1.267.2.3 ehci.c
--- sys/dev/usb/ehci.c	1 Mar 2020 12:35:16 -0000	1.267.2.3
+++ sys/dev/usb/ehci.c	6 Apr 2020 09:57:59 -0000
@@ -517,7 +517,7 @@ ehci_init(ehci_softc_t *sc)
 	case 3: return EIO;
 	}
 	err = usb_allocmem(&sc->sc_bus, sc->sc_flsize * sizeof(ehci_link_t),
-	    EHCI_FLALIGN_ALIGN, &sc->sc_fldma);
+	    EHCI_FLALIGN_ALIGN, USBMALLOC_COHERENT, &sc->sc_fldma);
 	if (err)
 		return err;
 	DPRINTF("flsize=%jd", sc->sc_flsize, 0, 0, 0);
@@ -2003,7 +2003,7 @@ ehci_open(struct usbd_pipe *pipe)
 	switch (xfertype) {
 	case UE_CONTROL:
 		err = usb_allocmem(&sc->sc_bus, sizeof(usb_device_request_t),
-				   0, &epipe->ctrl.reqdma);
+		    0, USBMALLOC_COHERENT, &epipe->ctrl.reqdma);
 #ifdef EHCI_DEBUG
 		if (err)
 			printf("ehci_open: usb_allocmem()=%d\n", err);
@@ -2803,7 +2803,7 @@ ehci_alloc_sqh(ehci_softc_t *sc)
 		mutex_exit(&sc->sc_lock);
 
 		err = usb_allocmem(&sc->sc_bus, EHCI_SQH_SIZE * EHCI_SQH_CHUNK,
-			  EHCI_PAGE_SIZE, &dma);
+		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT, &dma);
 #ifdef EHCI_DEBUG
 		if (err)
 			printf("ehci_alloc_sqh: usb_allocmem()=%d\n", err);
@@ -2856,7 +2856,7 @@ ehci_alloc_sqtd(ehci_softc_t *sc)
 		mutex_exit(&sc->sc_lock);
 
 		err = usb_allocmem(&sc->sc_bus, EHCI_SQTD_SIZE*EHCI_SQTD_CHUNK,
-			  EHCI_PAGE_SIZE, &dma);
+		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT, &dma);
 #ifdef EHCI_DEBUG
 		if (err)
 			printf("ehci_alloc_sqtd: usb_allocmem()=%d\n", err);
@@ -3113,8 +3113,9 @@ ehci_alloc_itd(ehci_softc_t *sc)
 	if (freeitd == NULL) {
 		DPRINTF("allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
+
 		err = usb_allocmem(&sc->sc_bus, EHCI_ITD_SIZE * EHCI_ITD_CHUNK,
-				EHCI_PAGE_SIZE, &dma);
+		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT, &dma);
 
 		if (err) {
 			DPRINTF("alloc returned %jd", err, 0, 0, 0);
@@ -3161,8 +3162,9 @@ ehci_alloc_sitd(ehci_softc_t *sc)
 	if (freesitd == NULL) {
 		DPRINTF("allocating chunk", 0, 0, 0, 0);
 		mutex_exit(&sc->sc_lock);
+
 		err = usb_allocmem(&sc->sc_bus, EHCI_SITD_SIZE * EHCI_SITD_CHUNK,
-				EHCI_PAGE_SIZE, &dma);
+		    EHCI_PAGE_SIZE, USBMALLOC_COHERENT, &dma);
 
 		if (err) {
 			DPRINTF("alloc returned %jd", err, 0, 0,
Index: sys/dev/usb/ohci.c
===================================================================
RCS file: /cvsroot/src/sys/dev/usb/ohci.c,v
retrieving revision 1.289.4.5
diff -u -p -r1.289.4.5 ohci.c
--- sys/dev/usb/ohci.c	1 Mar 2020 12:35:16 -0000	1.289.4.5
+++ sys/dev/usb/ohci.c	6 Apr 2020 09:58:00 -0000
@@ -409,7 +409,7 @@ ohci_alloc_sed(ohci_softc_t *sc)
 		mutex_exit(&sc->sc_lock);
 
 		err = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK,
-			  OHCI_ED_ALIGN, &dma);
+		    OHCI_ED_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return 0;
 
@@ -468,7 +468,7 @@ ohci_alloc_std(ohci_softc_t *sc)
 		mutex_exit(&sc->sc_lock);
 
 		err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
-			  OHCI_TD_ALIGN, &dma);
+		    OHCI_TD_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 
@@ -712,7 +712,7 @@ ohci_alloc_sitd(ohci_softc_t *sc)
 		mutex_exit(&sc->sc_lock);
 
 		err = usb_allocmem(&sc->sc_bus, OHCI_SITD_SIZE * OHCI_SITD_CHUNK,
-			  OHCI_ITD_ALIGN, &dma);
+		    OHCI_ITD_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 		mutex_enter(&sc->sc_lock);
@@ -815,7 +815,7 @@ ohci_init(ohci_softc_t *sc)
 	/* XXX determine alignment by R/W */
 	/* Allocate the HCCA area. */
 	err = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE,
-			 OHCI_HCCA_ALIGN, &sc->sc_hccadma);
+	    OHCI_HCCA_ALIGN, USBMALLOC_COHERENT, &sc->sc_hccadma);
 	if (err) {
 		sc->sc_hcca = NULL;
 		return err;
@@ -2081,8 +2081,8 @@ ohci_open(struct usbd_pipe *pipe)
 		case UE_CONTROL:
 			pipe->up_methods = &ohci_device_ctrl_methods;
 			err = usb_allocmem(&sc->sc_bus,
-				  sizeof(usb_device_request_t),
-				  0, &opipe->ctrl.reqdma);
+			    sizeof(usb_device_request_t), 0,
+			    USBMALLOC_COHERENT, &opipe->ctrl.reqdma);
 			if (err)
 				goto bad;
 			mutex_enter(&sc->sc_lock);
@@ -3461,6 +3461,12 @@ ohci_device_isoc_enter(struct usbd_xfer 
 	DPRINTFN(1, "used=%jd next=%jd xfer=%#jx nframes=%jd",
 	     isoc->inuse, isoc->next, (uintptr_t)xfer, xfer->ux_nframes);
 
+	int isread =
+	    (UE_GET_DIR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress) == UE_DIR_IN);
+
+	usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
+	    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
+
 	if (isoc->next == -1) {
 		/* Not in use yet, schedule it a few frames ahead. */
 		isoc->next = O32TOH(sc->sc_hcca->hcca_frame_number) + 5;
@@ -3632,6 +3638,14 @@ ohci_device_isoc_done(struct usbd_xfer *
 {
 	OHCIHIST_FUNC(); OHCIHIST_CALLED();
 	DPRINTFN(1, "xfer=%#jx", (uintptr_t)xfer, 0, 0, 0);
+
+	int isread =
+	    (UE_GET_DIR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress) == UE_DIR_IN);
+
+	DPRINTFN(10, "xfer=%#jx, actlen=%jd", (uintptr_t)xfer, xfer->ux_actlen,
+	    0, 0);
+	usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
+	    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 }
 
 usbd_status
Index: sys/dev/usb/uhci.c
===================================================================
RCS file: /cvsroot/src/sys/dev/usb/uhci.c,v
retrieving revision 1.288.4.2
diff -u -p -r1.288.4.2 uhci.c
--- sys/dev/usb/uhci.c	1 Mar 2020 12:35:16 -0000	1.288.4.2
+++ sys/dev/usb/uhci.c	6 Apr 2020 09:58:00 -0000
@@ -456,7 +456,7 @@ uhci_init(uhci_softc_t *sc)
 	/* Allocate and initialize real frame array. */
 	err = usb_allocmem(&sc->sc_bus,
 	    UHCI_FRAMELIST_COUNT * sizeof(uhci_physaddr_t),
-	    UHCI_FRAMELIST_ALIGN, &sc->sc_dma);
+	    UHCI_FRAMELIST_ALIGN, USBMALLOC_COHERENT, &sc->sc_dma);
 	if (err)
 		return err;
 	sc->sc_pframes = KERNADDR(&sc->sc_dma, 0);
@@ -1845,7 +1845,7 @@ uhci_alloc_std(uhci_softc_t *sc)
 		mutex_exit(&sc->sc_lock);
 
 		err = usb_allocmem(&sc->sc_bus, UHCI_STD_SIZE * UHCI_STD_CHUNK,
-			  UHCI_TD_ALIGN, &dma);
+		    UHCI_TD_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 
@@ -1912,7 +1912,7 @@ uhci_alloc_sqh(uhci_softc_t *sc)
 		mutex_exit(&sc->sc_lock);
 
 		err = usb_allocmem(&sc->sc_bus, UHCI_SQH_SIZE * UHCI_SQH_CHUNK,
-			  UHCI_QH_ALIGN, &dma);
+		    UHCI_QH_ALIGN, USBMALLOC_COHERENT, &dma);
 		if (err)
 			return NULL;
 
@@ -2199,7 +2199,6 @@ uhci_device_bulk_init(struct usbd_xfer *
 	int len = xfer->ux_bufsize;
 	int err = 0;
 
-
 	UHCIHIST_FUNC(); UHCIHIST_CALLED();
 	DPRINTFN(3, "xfer=%#jx len=%jd flags=%jd", (uintptr_t)xfer, len,
 	    xfer->ux_flags, 0);
@@ -2917,6 +2916,9 @@ uhci_device_isoc_transfer(struct usbd_xf
 
 	KASSERT(xfer->ux_nframes != 0);
 
+	usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length,
+	    rd ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
+
 	mutex_enter(&sc->sc_lock);
 	next = isoc->next;
 	if (next == -1) {
@@ -3480,8 +3482,8 @@ uhci_open(struct usbd_pipe *pipe)
 				goto bad;
 			}
 			err = usb_allocmem(&sc->sc_bus,
-				  sizeof(usb_device_request_t),
-				  0, &upipe->ctrl.reqdma);
+			    sizeof(usb_device_request_t), 0,
+			    USBMALLOC_COHERENT, &upipe->ctrl.reqdma);
 			if (err) {
 				uhci_free_sqh(sc, upipe->ctrl.sqh);
 				uhci_free_std(sc, upipe->ctrl.setup);
Index: sys/dev/usb/usb_mem.c
===================================================================
RCS file: /cvsroot/src/sys/dev/usb/usb_mem.c,v
retrieving revision 1.70.10.2
diff -u -p -r1.70.10.2 usb_mem.c
--- sys/dev/usb/usb_mem.c	13 Sep 2019 06:51:58 -0000	1.70.10.2
+++ sys/dev/usb/usb_mem.c	6 Apr 2020 09:58:00 -0000
@@ -79,7 +79,7 @@ struct usb_frag_dma {
 };
 
 Static usbd_status	usb_block_allocmem(bus_dma_tag_t, size_t, size_t,
-					   usb_dma_block_t **, bool);
+			    u_int, usb_dma_block_t **);
 Static void		usb_block_freemem(usb_dma_block_t *);
 
 LIST_HEAD(usb_dma_block_qh, usb_dma_block);
@@ -110,24 +110,31 @@ usb_mem_init(void)
 
 Static usbd_status
 usb_block_allocmem(bus_dma_tag_t tag, size_t size, size_t align,
-		   usb_dma_block_t **dmap, bool multiseg)
+    u_int flags, usb_dma_block_t **dmap)
 {
 	usb_dma_block_t *b;
 	int error;
 
 	USBHIST_FUNC();
-	USBHIST_CALLARGS(usbdebug, "size=%ju align=%ju", size, align, 0, 0);
+	USBHIST_CALLARGS(usbdebug, "size=%ju align=%ju flags=%#jx", size, align, flags, 0);
 
 	ASSERT_SLEEPABLE();
 	KASSERT(size != 0);
 	KASSERT(mutex_owned(&usb_blk_lock));
 
+	bool multiseg = (flags & USBMALLOC_MULTISEG) != 0;
+	bool coherent = (flags & USBMALLOC_COHERENT) != 0;
+	u_int dmaflags = coherent ? USB_DMA_COHERENT : 0;
+
 	/* First check the free list. */
 	LIST_FOREACH(b, &usb_blk_freelist, next) {
 		/* Don't allocate multiple segments to unwilling callers */
 		if (b->nsegs != 1 && !multiseg)
 			continue;
-		if (b->tag == tag && b->size >= size && b->align >= align) {
+		if (b->tag == tag &&
+		    b->size >= size &&
+		    b->align >= align &&
+		    (b->flags & USB_DMA_COHERENT) == dmaflags) {
 			LIST_REMOVE(b, next);
 			usb_blk_nfree--;
 			*dmap = b;
@@ -143,6 +150,7 @@ usb_block_allocmem(bus_dma_tag_t tag, si
 	b->tag = tag;
 	b->size = size;
 	b->align = align;
+	b->flags = dmaflags;
 
 	if (!multiseg)
 		/* Caller wants one segment */
@@ -159,8 +167,8 @@ usb_block_allocmem(bus_dma_tag_t tag, si
 	if (error)
 		goto free0;
 
-	error = bus_dmamem_map(tag, b->segs, b->nsegs, b->size,
-			       &b->kaddr, BUS_DMA_WAITOK|BUS_DMA_COHERENT);
+	error = bus_dmamem_map(tag, b->segs, b->nsegs, b->size, &b->kaddr,
+	    BUS_DMA_WAITOK | (coherent ? BUS_DMA_COHERENT : 0));
 	if (error)
 		goto free1;
 
@@ -249,15 +257,8 @@ usb_block_freemem(usb_dma_block_t *b)
 }
 
 usbd_status
-usb_allocmem(struct usbd_bus *bus, size_t size, size_t align, usb_dma_t *p)
-{
-
-	return usb_allocmem_flags(bus, size, align, p, 0);
-}
-
-usbd_status
-usb_allocmem_flags(struct usbd_bus *bus, size_t size, size_t align, usb_dma_t *p,
-		   int flags)
+usb_allocmem(struct usbd_bus *bus, size_t size, size_t align, u_int flags,
+    usb_dma_t *p)
 {
 	bus_dma_tag_t tag = bus->ub_dmatag;
 	usbd_status err;
@@ -265,7 +266,6 @@ usb_allocmem_flags(struct usbd_bus *bus,
 	usb_dma_block_t *b;
 	int i;
 	static ONCE_DECL(init_control);
-	bool frag;
 
 	USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
 
@@ -273,19 +273,20 @@ usb_allocmem_flags(struct usbd_bus *bus,
 
 	RUN_ONCE(&init_control, usb_mem_init);
 
-	frag = (flags & USBMALLOC_MULTISEG);
+	u_int dmaflags = (flags & USBMALLOC_COHERENT) ? USB_DMA_COHERENT : 0;
 
 	/* If the request is large then just use a full block. */
 	if (size > USB_MEM_SMALL || align > USB_MEM_SMALL) {
 		DPRINTFN(1, "large alloc %jd", size, 0, 0, 0);
 		size = (size + USB_MEM_BLOCK - 1) & ~(USB_MEM_BLOCK - 1);
 		mutex_enter(&usb_blk_lock);
-		err = usb_block_allocmem(tag, size, align, &p->udma_block, frag);
+		err = usb_block_allocmem(tag, size, align, flags,
+		    &p->udma_block);
 		if (!err) {
 #ifdef DEBUG
 			LIST_INSERT_HEAD(&usb_blk_fulllist, p->udma_block, next);
 #endif
-			p->udma_block->flags = USB_DMA_FULLBLOCK;
+			p->udma_block->flags = USB_DMA_FULLBLOCK | dmaflags;
 			p->udma_offs = 0;
 		}
 		mutex_exit(&usb_blk_lock);
@@ -298,13 +299,15 @@ usb_allocmem_flags(struct usbd_bus *bus,
 		KDASSERTMSG(usb_valid_block_p(f->ufd_block, &usb_blk_fraglist),
 		    "%s: usb frag %p: unknown block pointer %p",
 		    __func__, f, f->ufd_block);
-		if (f->ufd_block->tag == tag)
+		if (f->ufd_block->tag == tag &&
+		    (f->ufd_block->flags & USB_DMA_COHERENT) == dmaflags)
 			break;
 	}
 	if (f == NULL) {
 		DPRINTFN(1, "adding fragments", 0, 0, 0, 0);
-		err = usb_block_allocmem(tag, USB_MEM_BLOCK, USB_MEM_SMALL, &b,
-					 false);
+
+		err = usb_block_allocmem(tag, USB_MEM_BLOCK, USB_MEM_SMALL,
+		    flags, &b);
 		if (err) {
 			mutex_exit(&usb_blk_lock);
 			return err;
@@ -410,6 +413,6 @@ void
 usb_syncmem(usb_dma_t *p, bus_addr_t offset, bus_size_t len, int ops)
 {
 
-	bus_dmamap_sync(p->udma_block->tag, p->udma_block->map, p->udma_offs + offset,
-	    len, ops);
+	bus_dmamap_sync(p->udma_block->tag, p->udma_block->map,
+	    p->udma_offs + offset, len, ops);
 }
Index: sys/dev/usb/usb_mem.h
===================================================================
RCS file: /cvsroot/src/sys/dev/usb/usb_mem.h,v
retrieving revision 1.31
diff -u -p -r1.31 usb_mem.h
--- sys/dev/usb/usb_mem.h	23 Apr 2016 10:15:32 -0000	1.31
+++ sys/dev/usb/usb_mem.h	6 Apr 2020 09:58:00 -0000
@@ -41,15 +41,16 @@ typedef struct usb_dma_block {
 	size_t size;
 	size_t align;
 	int flags;
-#define USB_DMA_FULLBLOCK	0x0001
+#define USB_DMA_FULLBLOCK	__BIT(0)
+#define USB_DMA_COHERENT	__BIT(1)
+
 	LIST_ENTRY(usb_dma_block) next;
 } usb_dma_block_t;
 
-#define USBMALLOC_MULTISEG	1
+#define USBMALLOC_MULTISEG	__BIT(0)
+#define USBMALLOC_COHERENT	__BIT(1)
 
-usbd_status	usb_allocmem(struct usbd_bus *, size_t, size_t, usb_dma_t *);
-usbd_status	usb_allocmem_flags(struct usbd_bus *, size_t, size_t, usb_dma_t *,
-			int);
+usbd_status	usb_allocmem(struct usbd_bus *, size_t, size_t, u_int, usb_dma_t *);
 void		usb_freemem(struct usbd_bus *, usb_dma_t *);
 void		usb_syncmem(usb_dma_t *, bus_addr_t, bus_size_t, int);
 
Index: sys/dev/usb/usbdi.c
===================================================================
RCS file: /cvsroot/src/sys/dev/usb/usbdi.c,v
retrieving revision 1.182.4.4
diff -u -p -r1.182.4.4 usbdi.c
--- sys/dev/usb/usbdi.c	3 Apr 2020 12:27:55 -0000	1.182.4.4
+++ sys/dev/usb/usbdi.c	6 Apr 2020 09:58:00 -0000
@@ -408,7 +408,8 @@ usbd_alloc_buffer(struct usbd_xfer *xfer
 	if (bus->ub_usedma) {
 		usb_dma_t *dmap = &xfer->ux_dmabuf;
 
-		int err = usb_allocmem_flags(bus, size, 0, dmap, bus->ub_dmaflags);
+		KASSERT((bus->ub_dmaflags & USBMALLOC_COHERENT) == 0);
+		int err = usb_allocmem(bus, size, 0, bus->ub_dmaflags, dmap);
 		if (err) {
 			return NULL;
 		}
Index: sys/dev/usb/xhci.c
===================================================================
RCS file: /cvsroot/src/sys/dev/usb/xhci.c,v
retrieving revision 1.107.2.5
diff -u -p -r1.107.2.5 xhci.c
--- sys/dev/usb/xhci.c	1 Mar 2020 12:35:16 -0000	1.107.2.5
+++ sys/dev/usb/xhci.c	6 Apr 2020 09:58:01 -0000
@@ -1068,7 +1068,7 @@ xhci_init(struct xhci_softc *sc)
 	if (sc->sc_maxspbuf != 0) {
 		err = usb_allocmem(&sc->sc_bus,
 		    sizeof(uint64_t) * sc->sc_maxspbuf, sizeof(uint64_t),
-		    &sc->sc_spbufarray_dma);
+		    USBMALLOC_COHERENT, &sc->sc_spbufarray_dma);
 		if (err) {
 			aprint_error_dev(sc->sc_dev,
 			    "spbufarray init fail, err %d\n", err);
@@ -1082,7 +1082,7 @@ xhci_init(struct xhci_softc *sc)
 			usb_dma_t * const dma = &sc->sc_spbuf_dma[i];
 			/* allocate contexts */
 			err = usb_allocmem(&sc->sc_bus, sc->sc_pgsz,
-			    sc->sc_pgsz, dma);
+			    sc->sc_pgsz, USBMALLOC_COHERENT, dma);
 			if (err) {
 				aprint_error_dev(sc->sc_dev,
 				    "spbufarray_dma init fail, err %d\n", err);
@@ -1130,7 +1130,7 @@ xhci_init(struct xhci_softc *sc)
 	    XHCI_EVENT_RING_SEGMENT_TABLE_ALIGN);
 	KASSERTMSG(size <= (512 * 1024), "eventst size %zu too large", size);
 	align = XHCI_EVENT_RING_SEGMENT_TABLE_ALIGN;
-	err = usb_allocmem(&sc->sc_bus, size, align, dma);
+	err = usb_allocmem(&sc->sc_bus, size, align, USBMALLOC_COHERENT, dma);
 	if (err) {
 		aprint_error_dev(sc->sc_dev, "eventst init fail, err %d\n",
 		    err);
@@ -1149,7 +1149,7 @@ xhci_init(struct xhci_softc *sc)
 	size = (1 + sc->sc_maxslots) * sizeof(uint64_t);
 	KASSERTMSG(size <= 2048, "dcbaa size %zu too large", size);
 	align = XHCI_DEVICE_CONTEXT_BASE_ADDRESS_ARRAY_ALIGN;
-	err = usb_allocmem(&sc->sc_bus, size, align, dma);
+	err = usb_allocmem(&sc->sc_bus, size, align, USBMALLOC_COHERENT, dma);
 	if (err) {
 		aprint_error_dev(sc->sc_dev, "dcbaa init fail, err %d\n", err);
 		rv = ENOMEM;
@@ -2496,7 +2496,7 @@ xhci_ring_init(struct xhci_softc * const
 	XHCIHIST_CALLARGS("xr %#jx ntrb %#jx align %#jx",
 	    (uintptr_t)xr, ntrb, align, 0);
 
-	err = usb_allocmem(&sc->sc_bus, size, align, &xr->xr_dma);
+	err = usb_allocmem(&sc->sc_bus, size, align, USBMALLOC_COHERENT, &xr->xr_dma);
 	if (err)
 		return err;
 	mutex_init(&xr->xr_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
@@ -2917,13 +2917,13 @@ xhci_init_slot(struct usbd_device *dev, 
 
 	/* allocate contexts */
 	err = usb_allocmem(&sc->sc_bus, sc->sc_pgsz, sc->sc_pgsz,
-	    &xs->xs_dc_dma);
+	    USBMALLOC_COHERENT, &xs->xs_dc_dma);
 	if (err)
 		return err;
 	memset(KERNADDR(&xs->xs_dc_dma, 0), 0, sc->sc_pgsz);
 
 	err = usb_allocmem(&sc->sc_bus, sc->sc_pgsz, sc->sc_pgsz,
-	    &xs->xs_ic_dma);
+	    USBMALLOC_COHERENT, &xs->xs_ic_dma);
 	if (err)
 		goto bad1;
 	memset(KERNADDR(&xs->xs_ic_dma, 0), 0, sc->sc_pgsz);
@@ -3814,7 +3814,7 @@ xhci_device_ctrl_start(struct usbd_xfer 
 	struct xhci_ring * const tr = &xs->xs_ep[dci].xe_tr;
 	struct xhci_xfer * const xx = XHCI_XFER2XXFER(xfer);
 	usb_device_request_t * const req = &xfer->ux_request;
-	const int isread = usbd_xfer_isread(xfer);
+	const bool isread = usbd_xfer_isread(xfer);
 	const uint32_t len = UGETW(req->wLength);
 	usb_dma_t * const dma = &xfer->ux_dmabuf;
 	uint64_t parameter;
@@ -3855,9 +3855,12 @@ xhci_device_ctrl_start(struct usbd_xfer 
 		    XHCI_TRB_2_BYTES_SET(len);
 		control = (isread ? XHCI_TRB_3_DIR_IN : 0) |
 		    XHCI_TRB_3_TYPE_SET(XHCI_TRB_TYPE_DATA_STAGE) |
-		    (usbd_xfer_isread(xfer) ? XHCI_TRB_3_ISP_BIT : 0) |
+		    (isread ? XHCI_TRB_3_ISP_BIT : 0) |
 		    XHCI_TRB_3_IOC_BIT;
 		xhci_soft_trb_put(&xx->xx_trb[i++], parameter, status, control);
+
+		usb_syncmem(dma, 0, len,
+		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 	}
 
 	parameter = 0;
@@ -3968,6 +3971,11 @@ xhci_device_bulk_start(struct usbd_xfer 
 	KASSERT((xfer->ux_rqflags & URQ_REQUEST) == 0);
 
 	parameter = DMAADDR(dma, 0);
+	const bool isread = usbd_xfer_isread(xfer);
+	if (len)
+		usb_syncmem(dma, 0, len,
+		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
+
 	/*
 	 * XXX: (dsl) The physical buffer must not cross a 64k boundary.
 	 * If the user supplied buffer crosses such a boundary then 2
@@ -3984,7 +3992,7 @@ xhci_device_bulk_start(struct usbd_xfer 
 	    XHCI_TRB_2_TDSZ_SET(0) |
 	    XHCI_TRB_2_BYTES_SET(len);
 	control = XHCI_TRB_3_TYPE_SET(XHCI_TRB_TYPE_NORMAL) |
-	    (usbd_xfer_isread(xfer) ? XHCI_TRB_3_ISP_BIT : 0) |
+	    (isread ? XHCI_TRB_3_ISP_BIT : 0) |
 	    XHCI_TRB_3_IOC_BIT;
 	xhci_soft_trb_put(&xx->xx_trb[i++], parameter, status, control);
 
@@ -4012,7 +4020,7 @@ xhci_device_bulk_done(struct usbd_xfer *
 	struct xhci_slot * const xs = xfer->ux_pipe->up_dev->ud_hcpriv;
 	const u_int dci = xhci_ep_get_dci(xfer->ux_pipe->up_endpoint->ue_edesc);
 #endif
-	const int isread = usbd_xfer_isread(xfer);
+	const bool isread = usbd_xfer_isread(xfer);
 
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("%#jx slot %ju dci %ju",
@@ -4088,14 +4096,18 @@ xhci_device_intr_start(struct usbd_xfer 
 
 	KASSERT((xfer->ux_rqflags & URQ_REQUEST) == 0);
 
+	const bool isread = usbd_xfer_isread(xfer);
+	if (len)
+		usb_syncmem(dma, 0, len,
+		    isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
+
 	parameter = DMAADDR(dma, 0);
 	KASSERTMSG(len <= 0x10000, "len %d", len);
 	status = XHCI_TRB_2_IRQ_SET(0) |
 	    XHCI_TRB_2_TDSZ_SET(0) |
 	    XHCI_TRB_2_BYTES_SET(len);
 	control = XHCI_TRB_3_TYPE_SET(XHCI_TRB_TYPE_NORMAL) |
-	    (usbd_xfer_isread(xfer) ? XHCI_TRB_3_ISP_BIT : 0) |
-	    XHCI_TRB_3_IOC_BIT;
+	    (isread ? XHCI_TRB_3_ISP_BIT : 0) | XHCI_TRB_3_IOC_BIT;
 	xhci_soft_trb_put(&xx->xx_trb[i++], parameter, status, control);
 
 	if (!polling)
@@ -4123,7 +4135,7 @@ xhci_device_intr_done(struct usbd_xfer *
 	struct xhci_slot * const xs = xfer->ux_pipe->up_dev->ud_hcpriv;
 	const u_int dci = xhci_ep_get_dci(xfer->ux_pipe->up_endpoint->ue_edesc);
 #endif
-	const int isread = usbd_xfer_isread(xfer);
+	const bool isread = usbd_xfer_isread(xfer);
 
 	XHCIHIST_FUNC();
 	XHCIHIST_CALLARGS("%#jx slot %ju dci %ju",
Index: sys/external/bsd/dwc2/dwc2.c
===================================================================
RCS file: /cvsroot/src/sys/external/bsd/dwc2/dwc2.c,v
retrieving revision 1.59.4.3
diff -u -p -r1.59.4.3 dwc2.c
--- sys/external/bsd/dwc2/dwc2.c	1 Mar 2020 12:35:16 -0000	1.59.4.3
+++ sys/external/bsd/dwc2/dwc2.c	6 Apr 2020 09:58:01 -0000
@@ -405,7 +405,7 @@ dwc2_open(struct usbd_pipe *pipe)
 	case UE_CONTROL:
 		pipe->up_methods = &dwc2_device_ctrl_methods;
 		err = usb_allocmem(&sc->sc_bus, sizeof(usb_device_request_t),
-		    0, &dpipe->req_dma);
+		    0, USBMALLOC_COHERENT, &dpipe->req_dma);
 		if (err)
 			return err;
 		break;
Index: sys/external/bsd/dwc2/dist/dwc2_hcd.c
===================================================================
RCS file: /cvsroot/src/sys/external/bsd/dwc2/dist/dwc2_hcd.c,v
retrieving revision 1.23
diff -u -p -r1.23 dwc2_hcd.c
--- sys/external/bsd/dwc2/dist/dwc2_hcd.c	14 Jul 2019 13:55:43 -0000	1.23
+++ sys/external/bsd/dwc2/dist/dwc2_hcd.c	6 Apr 2020 09:58:01 -0000
@@ -733,7 +733,7 @@ static int dwc2_hc_setup_align_buf(struc
 		qh->dw_align_buf = NULL;
 		qh->dw_align_buf_dma = 0;
 		err = usb_allocmem(&hsotg->hsotg_sc->sc_bus, buf_size, 0,
-				   &qh->dw_align_buf_usbdma);
+		    USBMALLOC_COHERENT, &qh->dw_align_buf_usbdma);
 		if (!err) {
 			usb_dma_t *ud = &qh->dw_align_buf_usbdma;
 
@@ -2392,8 +2392,8 @@ int dwc2_hcd_init(struct dwc2_hsotg *hso
 	hsotg->status_buf = NULL;
 	if (hsotg->core_params->dma_enable > 0) {
 		retval = usb_allocmem(&hsotg->hsotg_sc->sc_bus,
-				      DWC2_HCD_STATUS_BUF_SIZE, 0,
-				      &hsotg->status_buf_usbdma);
+		    DWC2_HCD_STATUS_BUF_SIZE, 0, USBMALLOC_COHERENT,
+		    &hsotg->status_buf_usbdma);
 		if (!retval) {
 			hsotg->status_buf = KERNADDR(&hsotg->status_buf_usbdma, 0);
 			hsotg->status_buf_dma = DMAADDR(&hsotg->status_buf_usbdma, 0);
Index: sys/external/bsd/dwc2/dist/dwc2_hcdddma.c
===================================================================
RCS file: /cvsroot/src/sys/external/bsd/dwc2/dist/dwc2_hcdddma.c,v
retrieving revision 1.8
diff -u -p -r1.8 dwc2_hcdddma.c
--- sys/external/bsd/dwc2/dist/dwc2_hcdddma.c	24 Feb 2016 22:14:39 -0000	1.8
+++ sys/external/bsd/dwc2/dist/dwc2_hcdddma.c	6 Apr 2020 09:58:01 -0000
@@ -106,7 +106,7 @@ static int dwc2_desc_list_alloc(struct d
 						dwc2_max_desc_num(qh);
 
 	err = usb_allocmem(&hsotg->hsotg_sc->sc_bus, qh->desc_list_sz, 0,
-	    &qh->desc_list_usbdma);
+	    USBMALLOC_COHERENT, &qh->desc_list_usbdma);
 
 	if (err)
 		return -ENOMEM;
@@ -147,7 +147,7 @@ static int dwc2_frame_list_alloc(struct 
 	hsotg->frame_list_sz = 4 * FRLISTEN_64_SIZE;
 	hsotg->frame_list = NULL;
 	err = usb_allocmem(&hsotg->hsotg_sc->sc_bus, hsotg->frame_list_sz,
-	    0, &hsotg->frame_list_usbdma);
+	    0, USBMALLOC_COHERENT, &hsotg->frame_list_usbdma);
 
 	if (!err) {
 		hsotg->frame_list = KERNADDR(&hsotg->frame_list_usbdma, 0);