aboutsummaryrefslogtreecommitdiff
path: root/sys/dev
diff options
context:
space:
mode:
Diffstat (limited to 'sys/dev')
-rw-r--r--sys/dev/usb/ehci.c14
-rw-r--r--sys/dev/usb/ehci_pci.c1
-rw-r--r--sys/dev/usb/ohci.c91
-rw-r--r--sys/dev/usb/uhci.c5
-rw-r--r--sys/dev/usb/usb_mem.c294
-rw-r--r--sys/dev/usb/usb_mem.h45
-rw-r--r--sys/dev/usb/usb_port.h8
-rw-r--r--sys/dev/usb/usbdivar.h2
8 files changed, 360 insertions, 100 deletions
diff --git a/sys/dev/usb/ehci.c b/sys/dev/usb/ehci.c
index ec82b9b21f81..ce069c4ee8d3 100644
--- a/sys/dev/usb/ehci.c
+++ b/sys/dev/usb/ehci.c
@@ -55,8 +55,8 @@
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
-#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/kernel.h>
+#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/device.h>
#include <sys/select.h>
#elif defined(__FreeBSD__)
@@ -65,6 +65,7 @@
#include <sys/bus.h>
#include <machine/bus_pio.h>
#include <machine/bus_memio.h>
+#include <sys/lockmgr.h>
#if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__)
#include <machine/cpu.h>
#endif
@@ -985,12 +986,9 @@ ehci_shutdown(void *v)
usbd_status
ehci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size)
{
-#if defined(__NetBSD__) || defined(__OpenBSD__)
- struct ehci_softc *sc = (struct ehci_softc *)bus;
-#endif
usbd_status err;
- err = usb_allocmem(&sc->sc_bus, size, 0, dma);
+ err = usb_allocmem(bus, size, 0, dma);
#ifdef USB_DEBUG
if (err)
printf("ehci_allocm: usb_allocmem()=%d\n", err);
@@ -1001,11 +999,7 @@ ehci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size)
void
ehci_freem(struct usbd_bus *bus, usb_dma_t *dma)
{
-#if defined(__NetBSD__) || defined(__OpenBSD__)
- struct ehci_softc *sc = (struct ehci_softc *)bus;
-#endif
-
- usb_freemem(&sc->sc_bus, dma);
+ usb_freemem(bus, dma);
}
usbd_xfer_handle
diff --git a/sys/dev/usb/ehci_pci.c b/sys/dev/usb/ehci_pci.c
index 1d6c74579c2a..efbcd4ff17c1 100644
--- a/sys/dev/usb/ehci_pci.c
+++ b/sys/dev/usb/ehci_pci.c
@@ -61,6 +61,7 @@
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/queue.h>
+#include <sys/lockmgr.h>
#include <machine/bus.h>
#include <sys/rman.h>
#include <machine/resource.h>
diff --git a/sys/dev/usb/ohci.c b/sys/dev/usb/ohci.c
index f48d9182715d..7af5dc0943ae 100644
--- a/sys/dev/usb/ohci.c
+++ b/sys/dev/usb/ohci.c
@@ -64,8 +64,8 @@
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
-#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/kernel.h>
+#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/device.h>
#include <sys/select.h>
#elif defined(__FreeBSD__)
@@ -501,8 +501,8 @@ ohci_alloc_std_chain(struct ohci_pipe *opipe, ohci_softc_t *sc,
ohci_soft_td_t *sp, ohci_soft_td_t **ep)
{
ohci_soft_td_t *next, *cur;
- ohci_physaddr_t dataphys, dataphysend;
- u_int32_t intr, tdflags;
+ ohci_physaddr_t dataphys;
+ u_int32_t tdflags;
int offset = 0;
int len, curlen;
usb_dma_t *dma = &xfer->dmabuf;
@@ -513,12 +513,10 @@ ohci_alloc_std_chain(struct ohci_pipe *opipe, ohci_softc_t *sc,
len = alen;
cur = sp;
- dataphys = DMAADDR(dma, 0);
- dataphysend = OHCI_PAGE(DMAADDR(dma, len - 1));
- tdflags = (
+ tdflags = htole32(
(rd ? OHCI_TD_IN : OHCI_TD_OUT) |
(flags & USBD_SHORT_XFER_OK ? OHCI_TD_R : 0) |
- OHCI_TD_NOCC | OHCI_TD_TOGGLE_CARRY);
+ OHCI_TD_NOCC | OHCI_TD_TOGGLE_CARRY | OHCI_TD_NOINTR);
for (;;) {
next = ohci_alloc_std(sc);
@@ -527,20 +525,27 @@ ohci_alloc_std_chain(struct ohci_pipe *opipe, ohci_softc_t *sc,
dataphys = DMAADDR(dma, offset);
- /* The OHCI hardware can handle at most one page crossing. */
-#if defined(__NetBSD__) || defined(__OpenBSD__)
- if (OHCI_PAGE(dataphys) == dataphysend ||
- OHCI_PAGE(dataphys) + OHCI_PAGE_SIZE == dataphysend)
-#elif defined(__FreeBSD__)
- /* XXX This is pretty broken: Because we do not allocate
- * a contiguous buffer (contiguous in physical pages) we
- * can only transfer one page in one go.
- * So check whether the start and end of the buffer are on
- * the same page.
+ /*
+ * The OHCI hardware can handle at most one 4k crossing.
+ * XXX - currently we only allocate contigous buffers, but
+ * the OHCI spec says: If during the data transfer the buffer
+ * address contained in the HC's working copy of
+ * CurrentBufferPointer crosses a 4K boundary, the upper 20
+ * bits of Buffer End are copied to the working value of
+ * CurrentBufferPointer causing the next buffer address to
+ * be the 0th byte in the same 4K page that contains the
+ * last byte of the buffer (the 4K boundary crossing may
+ * occur within a data packet transfer.)
+ *
+ * If/when dma has multiple segments, this will need to
+ * properly handle fragmenting TD's.
+ *
+ * We can describe the above using maxsegsz = 4k and nsegs = 2
+ * in the future.
*/
- if (OHCI_PAGE(dataphys) == dataphysend)
-#endif
- {
+ if (OHCI_PAGE(dataphys) == OHCI_PAGE(DMAADDR(dma, offset +
+ len - 1)) || len - (OHCI_PAGE_SIZE -
+ OHCI_PAGE_OFFSET(dataphys)) <= OHCI_PAGE_SIZE) {
/* we can handle it in this TD */
curlen = len;
} else {
@@ -551,38 +556,36 @@ ohci_alloc_std_chain(struct ohci_pipe *opipe, ohci_softc_t *sc,
* the case of an mbuf cluster). You'll get an early
* short packet.
*/
-#if defined(__NetBSD__) || defined(__OpenBSD__)
/* must use multiple TDs, fill as much as possible. */
curlen = 2 * OHCI_PAGE_SIZE -
- OHCI_PAGE_MASK(dataphys);
- if (curlen > len) /* may have fit in one page */
- curlen = len;
-#elif defined(__FreeBSD__)
- /* See comment above (XXX) */
- curlen = OHCI_PAGE_SIZE -
- OHCI_PAGE_MASK(dataphys);
+ OHCI_PAGE_OFFSET(dataphys);
+ /* the length must be a multiple of the max size */
+ curlen -= curlen %
+ UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize);
+#ifdef DIAGNOSTIC
+ if (curlen == 0)
+ panic("ohci_alloc_std: curlen == 0");
#endif
}
DPRINTFN(4,("ohci_alloc_std_chain: dataphys=0x%08x "
- "dataphysend=0x%08x len=%d curlen=%d\n",
- dataphys, dataphysend,
- len, curlen));
+ "len=%d curlen=%d\n",
+ dataphys, len, curlen));
len -= curlen;
- intr = len == 0 ? OHCI_TD_SET_DI(1) : OHCI_TD_NOINTR;
- cur->td.td_flags = htole32(tdflags | intr);
+ cur->td.td_flags = tdflags;
cur->td.td_cbp = htole32(dataphys);
cur->nexttd = next;
cur->td.td_nexttd = htole32(next->physaddr);
- cur->td.td_be = htole32(dataphys + curlen - 1);
+ cur->td.td_be = htole32(DMAADDR(dma, curlen - 1));
cur->len = curlen;
cur->flags = OHCI_ADD_LEN;
+ cur->xfer = xfer;
DPRINTFN(10,("ohci_alloc_std_chain: cbp=0x%08x be=0x%08x\n",
dataphys, dataphys + curlen - 1));
if (len == 0)
break;
if (len < 0)
- panic("Length went negative: %d curlen %d dma %p offset %08x", len, curlen, *dma, (int)offset);
+ panic("Length went negative: %d curlen %d dma %p offset %08x", len, curlen, dma, (int)0);
DPRINTFN(10,("ohci_alloc_std_chain: extend chain\n"));
offset += curlen;
@@ -592,14 +595,13 @@ ohci_alloc_std_chain(struct ohci_pipe *opipe, ohci_softc_t *sc,
alen % UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize) == 0) {
/* Force a 0 length transfer at the end. */
- cur->td.td_flags = htole32(tdflags | OHCI_TD_NOINTR);
cur = next;
next = ohci_alloc_std(sc);
if (next == NULL)
goto nomem;
- cur->td.td_flags = htole32(tdflags | OHCI_TD_SET_DI(1));
+ cur->td.td_flags = tdflags;
cur->td.td_cbp = 0; /* indicate 0 length packet */
cur->nexttd = next;
cur->td.td_nexttd = htole32(next->physaddr);
@@ -609,8 +611,7 @@ ohci_alloc_std_chain(struct ohci_pipe *opipe, ohci_softc_t *sc,
cur->xfer = xfer;
DPRINTFN(2,("ohci_alloc_std_chain: add 0 xfer\n"));
}
- cur->flags = OHCI_CALL_DONE | OHCI_ADD_LEN;
- *ep = next;
+ *ep = cur;
return (USBD_NORMAL_COMPLETION);
@@ -944,21 +945,13 @@ ohci_init(ohci_softc_t *sc)
usbd_status
ohci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size)
{
-#if defined(__NetBSD__) || defined(__OpenBSD__)
- struct ohci_softc *sc = (struct ohci_softc *)bus;
-#endif
-
- return (usb_allocmem(&sc->sc_bus, size, 0, dma));
+ return (usb_allocmem(bus, size, 0, dma));
}
void
ohci_freem(struct usbd_bus *bus, usb_dma_t *dma)
{
-#if defined(__NetBSD__) || defined(__OpenBSD__)
- struct ohci_softc *sc = (struct ohci_softc *)bus;
-#endif
-
- usb_freemem(&sc->sc_bus, dma);
+ usb_freemem(bus, dma);
}
usbd_xfer_handle
diff --git a/sys/dev/usb/uhci.c b/sys/dev/usb/uhci.c
index cacd810ee531..af4fd4a76deb 100644
--- a/sys/dev/usb/uhci.c
+++ b/sys/dev/usb/uhci.c
@@ -610,14 +610,13 @@ uhci_detach(struct uhci_softc *sc, int flags)
usbd_status
uhci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size)
{
- return (usb_allocmem(&((struct uhci_softc *)bus)->sc_bus, size, 0,
- dma));
+ return (usb_allocmem(bus, size, 0, dma));
}
void
uhci_freem(struct usbd_bus *bus, usb_dma_t *dma)
{
- usb_freemem(&((struct uhci_softc *)bus)->sc_bus, dma);
+ usb_freemem(bus, dma);
}
usbd_xfer_handle
diff --git a/sys/dev/usb/usb_mem.c b/sys/dev/usb/usb_mem.c
new file mode 100644
index 000000000000..f96574f636b0
--- /dev/null
+++ b/sys/dev/usb/usb_mem.c
@@ -0,0 +1,294 @@
+/* $NetBSD: usb_mem.c,v 1.26 2003/02/01 06:23:40 thorpej Exp $ */
+/* $FreeBSD$ */
+
+/*
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Lennart Augustsson (lennart@augustsson.net) at
+ * Carlstedt Research & Technology.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * USB DMA memory allocation.
+ * We need to allocate a lot of small (many 8 byte, some larger)
+ * memory blocks that can be used for DMA. Using the bus_dma
+ * routines directly would incur large overheads in space and time.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/device.h> /* for usbdivar.h */
+#include <machine/bus.h>
+#elif defined(__FreeBSD__)
+#include <sys/endian.h>
+#include <sys/module.h>
+#include <sys/bus.h>
+#endif
+#include <sys/queue.h>
+
+#include <machine/bus.h>
+#include <machine/endian.h>
+
+#ifdef DIAGNOSTIC
+#include <sys/proc.h>
+#endif
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdivar.h> /* just for usb_dma_t */
+#include <dev/usb/usb_mem.h>
+
+#ifdef USB_DEBUG
+#define DPRINTF(x) if (usbdebug) logprintf x
+#define DPRINTFN(n,x) if (usbdebug>(n)) logprintf x
+extern int usbdebug;
+#else
+#define DPRINTF(x)
+#define DPRINTFN(n,x)
+#endif
+
+#define USB_MEM_SMALL 64
+#define USB_MEM_CHUNKS (PAGE_SIZE / 64)
+#define USB_MEM_BLOCK (USB_MEM_SMALL * USB_MEM_CHUNKS)
+
+/* This struct is overlayed on free fragments. */
+struct usb_frag_dma {
+ usb_dma_block_t *block;
+ u_int offs;
+ LIST_ENTRY(usb_frag_dma) next;
+};
+
+Static bus_dmamap_callback_t usbmem_callback;
+Static usbd_status usb_block_allocmem(bus_dma_tag_t, size_t, size_t,
+ usb_dma_block_t **);
+Static void usb_block_freemem(usb_dma_block_t *);
+
+Static LIST_HEAD(, usb_dma_block) usb_blk_freelist =
+ LIST_HEAD_INITIALIZER(usb_blk_freelist);
+Static int usb_blk_nfree = 0;
+/* XXX should have different free list for different tags (for speed) */
+Static LIST_HEAD(, usb_frag_dma) usb_frag_freelist =
+ LIST_HEAD_INITIALIZER(usb_frag_freelist);
+
+Static void
+usbmem_callback(void *arg, bus_dma_segment_t *segs, int nseg, int error)
+{
+ int i;
+ usb_dma_block_t *p = arg;
+
+ if (error == EFBIG) {
+ printf("usb: mapping to large\n");
+ return;
+ }
+
+ p->nsegs = nseg;
+ for (i = 0; i < nseg && i < sizeof p->segs / sizeof *p->segs; i++)
+ p->segs[i] = segs[i];
+}
+
+Static usbd_status
+usb_block_allocmem(bus_dma_tag_t tag, size_t size, size_t align,
+ usb_dma_block_t **dmap)
+{
+ usb_dma_block_t *p;
+ int s;
+
+ DPRINTFN(5, ("usb_block_allocmem: size=%lu align=%lu\n",
+ (u_long)size, (u_long)align));
+
+#ifdef DIAGNOSTIC
+ if (!curproc) {
+ printf("usb_block_allocmem: in interrupt context, size=%lu\n",
+ (unsigned long) size);
+ }
+#endif
+
+ s = splusb();
+ /* First check the free list. */
+ for (p = LIST_FIRST(&usb_blk_freelist); p; p = LIST_NEXT(p, next)) {
+ if (p->tag == tag && p->size >= size && p->align >= align) {
+ LIST_REMOVE(p, next);
+ usb_blk_nfree--;
+ splx(s);
+ *dmap = p;
+ DPRINTFN(6,("usb_block_allocmem: free list size=%lu\n",
+ (u_long)p->size));
+ return (USBD_NORMAL_COMPLETION);
+ }
+ }
+ splx(s);
+
+#ifdef DIAGNOSTIC
+ if (!curproc) {
+ printf("usb_block_allocmem: in interrupt context, failed\n");
+ return (USBD_NOMEM);
+ }
+#endif
+
+ DPRINTFN(6, ("usb_block_allocmem: no free\n"));
+ p = malloc(sizeof *p, M_USB, M_NOWAIT);
+ if (p == NULL)
+ return (USBD_NOMEM);
+
+ if (bus_dma_tag_create(tag, align, 0,
+ BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
+ size, sizeof(p->segs) / sizeof(p->segs[0]), size,
+ BUS_DMA_ALLOCNOW, NULL, NULL, &p->tag) == ENOMEM) {
+ goto free;
+ }
+
+ p->size = size;
+ p->align = align;
+ if (bus_dmamem_alloc(p->tag, &p->kaddr,
+ BUS_DMA_NOWAIT|BUS_DMA_COHERENT, &p->map))
+ goto tagfree;
+
+ if (bus_dmamap_load(p->tag, p->map, p->kaddr, p->size,
+ usbmem_callback, p, 0))
+ goto memfree;
+
+ *dmap = p;
+ return (USBD_NORMAL_COMPLETION);
+
+ /*
+ * XXX - do we need to _unload? is the order of _free and _destroy
+ * correct?
+ */
+memfree:
+ bus_dmamem_free(p->tag, p->kaddr, p->map);
+tagfree:
+ bus_dma_tag_destroy(p->tag);
+free:
+ free(p, M_USB);
+ return (USBD_NOMEM);
+}
+
+/*
+ * Do not free the memory unconditionally since we might be called
+ * from an interrupt context and that is BAD.
+ * XXX when should we really free?
+ */
+Static void
+usb_block_freemem(usb_dma_block_t *p)
+{
+ int s;
+
+ DPRINTFN(6, ("usb_block_freemem: size=%lu\n", (u_long)p->size));
+ s = splusb();
+ LIST_INSERT_HEAD(&usb_blk_freelist, p, next);
+ usb_blk_nfree++;
+ splx(s);
+}
+
+usbd_status
+usb_allocmem(usbd_bus_handle bus, size_t size, size_t align, usb_dma_t *p)
+{
+ bus_dma_tag_t tag = bus->dmatag;
+ usbd_status err;
+ struct usb_frag_dma *f;
+ usb_dma_block_t *b;
+ int i;
+ int s;
+
+ /* compat w/ Net/OpenBSD */
+ if (align == 0)
+ align = 1;
+
+ /* If the request is large then just use a full block. */
+ if (size > USB_MEM_SMALL || align > USB_MEM_SMALL) {
+ DPRINTFN(1, ("usb_allocmem: large alloc %d\n", (int)size));
+ size = (size + USB_MEM_BLOCK - 1) & ~(USB_MEM_BLOCK - 1);
+ err = usb_block_allocmem(tag, size, align, &p->block);
+ if (!err) {
+ p->block->fullblock = 1;
+ p->offs = 0;
+ p->len = size;
+ }
+ return (err);
+ }
+
+ s = splusb();
+ /* Check for free fragments. */
+ for (f = LIST_FIRST(&usb_frag_freelist); f; f = LIST_NEXT(f, next))
+ if (f->block->tag == tag)
+ break;
+ if (f == NULL) {
+ DPRINTFN(1, ("usb_allocmem: adding fragments\n"));
+ err = usb_block_allocmem(tag, USB_MEM_BLOCK, USB_MEM_SMALL,&b);
+ if (err) {
+ splx(s);
+ return (err);
+ }
+ b->fullblock = 0;
+ for (i = 0; i < USB_MEM_BLOCK; i += USB_MEM_SMALL) {
+ f = (struct usb_frag_dma *)((char *)b->kaddr + i);
+ f->block = b;
+ f->offs = i;
+ LIST_INSERT_HEAD(&usb_frag_freelist, f, next);
+ }
+ f = LIST_FIRST(&usb_frag_freelist);
+ }
+ p->block = f->block;
+ p->offs = f->offs;
+ p->len = USB_MEM_SMALL;
+ LIST_REMOVE(f, next);
+ splx(s);
+ DPRINTFN(5, ("usb_allocmem: use frag=%p size=%d\n", f, (int)size));
+ return (USBD_NORMAL_COMPLETION);
+}
+
+void
+usb_freemem(usbd_bus_handle bus, usb_dma_t *p)
+{
+ struct usb_frag_dma *f;
+ int s;
+
+ if (p->block->fullblock) {
+ DPRINTFN(1, ("usb_freemem: large free\n"));
+ usb_block_freemem(p->block);
+ return;
+ }
+ f = KERNADDR(p, 0);
+ f->block = p->block;
+ f->offs = p->offs;
+ s = splusb();
+ LIST_INSERT_HEAD(&usb_frag_freelist, f, next);
+ splx(s);
+ DPRINTFN(5, ("usb_freemem: frag=%p\n", f));
+}
diff --git a/sys/dev/usb/usb_mem.h b/sys/dev/usb/usb_mem.h
index 3889b5d9802c..fa95716f1f2c 100644
--- a/sys/dev/usb/usb_mem.h
+++ b/sys/dev/usb/usb_mem.h
@@ -38,11 +38,14 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
-#if defined(__NetBSD__) || defined(__OpenBSD__)
typedef struct usb_dma_block {
bus_dma_tag_t tag;
bus_dmamap_t map;
+#ifdef __FreeBSD__
+ void *kaddr;
+#else
caddr_t kaddr;
+#endif
bus_dma_segment_t segs[1];
int nsegs;
size_t size;
@@ -51,41 +54,13 @@ typedef struct usb_dma_block {
LIST_ENTRY(usb_dma_block) next;
} usb_dma_block_t;
-#define DMAADDR(dma, o) ((dma)->block->map->dm_segs[0].ds_addr + (dma)->offs + (o))
+#ifdef __FreeBSD__
+#define DMAADDR(dma, o) ((uint32_t)(uintptr_t)(((char *)(dma)->block->segs[0].ds_addr) + (dma)->offs + (o)))
+#else
+#define DMAADDR(dma, o) (((char *)(dma)->block->map->dm_segs[0].ds_addr) + (dma)->offs + (o))
+#endif
#define KERNADDR(dma, o) \
- ((void *)((char *)((dma)->block->kaddr + (dma)->offs) + (o)))
+ ((void *)((char *)((dma)->block->kaddr) + (dma)->offs + (o)))
usbd_status usb_allocmem(usbd_bus_handle,size_t,size_t, usb_dma_t *);
void usb_freemem(usbd_bus_handle, usb_dma_t *);
-
-#elif defined(__FreeBSD__)
-
-/*
- * FreeBSD does not have special functions for dma memory, so let's keep it
- * simple for now.
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/queue.h>
-#include <sys/proc.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/malloc.h>
-#include <sys/kernel.h>
-#include <vm/vm.h>
-#include <vm/pmap.h>
-
-#include <machine/pmap.h> /* for vtophys */
-
-#define usb_allocmem(t,s,a,p) (*(p) = malloc(s, M_USB, M_NOWAIT), (*(p) == NULL? USBD_NOMEM: USBD_NORMAL_COMPLETION))
-#define usb_freemem(t,p) (free(*(p), M_USB))
-
-#ifdef __alpha__
-#define DMAADDR(dma, o) (alpha_XXX_dmamap((vm_offset_t) *(dma) + (o)))
-#else
-#define DMAADDR(dma, o) (vtophys(*(dma) + (o)))
-#endif
-#define KERNADDR(dma, o) ((void *) ((char *)*(dma) + (o)))
-#endif /* __FreeBSD__ */
-
diff --git a/sys/dev/usb/usb_port.h b/sys/dev/usb/usb_port.h
index 82bee013ed39..c48c582087af 100644
--- a/sys/dev/usb/usb_port.h
+++ b/sys/dev/usb/usb_port.h
@@ -360,7 +360,13 @@ MALLOC_DECLARE(M_USBHC);
#define USBDEVUNIT(bdev) device_get_unit(bdev)
#define USBGETSOFTC(bdev) (device_get_softc(bdev))
-#define DECLARE_USB_DMA_T typedef char * usb_dma_t
+#define DECLARE_USB_DMA_T \
+ struct usb_dma_block; \
+ typedef struct { \
+ struct usb_dma_block *block; \
+ u_int offs; \
+ u_int len; \
+ } usb_dma_t
typedef struct thread *usb_proc_ptr;
diff --git a/sys/dev/usb/usbdivar.h b/sys/dev/usb/usbdivar.h
index 0054780a61ad..ae2c092d436c 100644
--- a/sys/dev/usb/usbdivar.h
+++ b/sys/dev/usb/usbdivar.h
@@ -124,9 +124,7 @@ struct usbd_bus {
#endif
#endif
-#if defined(__NetBSD__) || defined(__OpenBSD__)
bus_dma_tag_t dmatag; /* DMA tag */
-#endif
};
struct usbd_device {