Index: ehci.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/ehci.c,v retrieving revision 1.40 diff -u -r1.40 ehci.c --- ehci.c 16 Jan 2006 19:23:59 -0000 1.40 +++ ehci.c 20 Jan 2006 01:12:29 -0000 @@ -657,7 +657,7 @@ pipe = xfer->pipe; - p = KERNADDR(&xfer->dmabuf, 0); + p = xfer->buffer; m = min(sc->sc_noport, xfer->length * 8 - 1); memset(p, 0, xfer->length); for (i = 1; i <= m; i++) { @@ -1733,7 +1733,7 @@ index = UGETW(req->wIndex); if (len != 0) - buf = KERNADDR(&xfer->dmabuf, 0); + buf = xfer->buffer; #define C(x,y) ((x) | ((y) << 8)) switch(C(req->bRequest, req->bmRequestType)) { @@ -2300,18 +2300,16 @@ ehci_soft_qtd_t **sp, ehci_soft_qtd_t **ep) { ehci_soft_qtd_t *next, *cur; - ehci_physaddr_t dataphys, dataphyspage, dataphyslastpage, nextphys; + ehci_physaddr_t dataphys, nextphys; u_int32_t qtdstatus; - int len, curlen, mps, offset; + int adj, len, curlen, mps, offset, pagelen, seg, segoff; int i, tog; - usb_dma_t *dma = &xfer->dmabuf; + struct usb_dma_mapping *dma = &xfer->dmamap; DPRINTFN(alen<4*4096,("ehci_alloc_sqtd_chain: start len=%d\n", alen)); offset = 0; len = alen; - dataphys = DMAADDR(dma, 0); - dataphyslastpage = EHCI_PAGE(DMAADDR(dma, len - 1)); #if 0 printf("status=%08x toggle=%d\n", epipe->sqh->qh.qh_qtd.qtd_status, epipe->nexttoggle); @@ -2330,60 +2328,60 @@ *sp = cur; if (cur == NULL) goto nomem; + seg = 0; + segoff = 0; for (;;) { - dataphyspage = EHCI_PAGE(dataphys); + curlen = 0; + /* The EHCI hardware can handle at most 5 pages. */ -#if defined(__NetBSD__) || defined(__OpenBSD__) - if (dataphyslastpage - dataphyspage < - EHCI_QTD_NBUFFERS * EHCI_PAGE_SIZE) { - /* we can handle it in this QTD */ - curlen = len; - } -#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. - */ - if (dataphyspage == dataphyslastpage) { - curlen = len; + for (i = 0; i < EHCI_QTD_NBUFFERS && curlen < len; i++) { + KASSERT(seg < dma->nsegs, + ("ehci_alloc_sqtd_chain: overrun")); + dataphys = dma->segs[seg].ds_addr + segoff; + pagelen = dma->segs[seg].ds_len - segoff; + if (pagelen > len - curlen) + pagelen = len - curlen; + if (pagelen > EHCI_PAGE_SIZE - + EHCI_PAGE_OFFSET(dataphys)) + pagelen = EHCI_PAGE_SIZE - + EHCI_PAGE_OFFSET(dataphys); + segoff += pagelen; + if (segoff >= dma->segs[seg].ds_len) { + KASSERT(segoff == dma->segs[seg].ds_len, + ("ehci_alloc_sqtd_chain: overlap")); + seg++; + segoff = 0; + } + + cur->qtd.qtd_buffer[i] = htole32(dataphys); + cur->qtd.qtd_buffer_hi[i] = 0; + curlen += pagelen; + + /* + * Must stop if there is any gap before or after + * the page boundary. + */ + if (EHCI_PAGE_OFFSET(dataphys + pagelen) != 0) + break; + if (seg < dma->nsegs && EHCI_PAGE_OFFSET(segoff + + dma->segs[seg].ds_addr) != 0) + break; } -#endif - else { -#if defined(__NetBSD__) || defined(__OpenBSD__) - /* must use multiple TDs, fill as much as possible. */ - curlen = EHCI_QTD_NBUFFERS * EHCI_PAGE_SIZE - - EHCI_PAGE_OFFSET(dataphys); -#ifdef DIAGNOSTIC - if (curlen > len) { - printf("ehci_alloc_sqtd_chain: curlen=0x%x " - "len=0x%x offs=0x%x\n", curlen, len, - EHCI_PAGE_OFFSET(dataphys)); - printf("lastpage=0x%x page=0x%x phys=0x%x\n", - dataphyslastpage, dataphyspage, - dataphys); - curlen = len; + /* Adjust down to a multiple of mps if not at the end. */ + if (curlen < len && curlen % mps != 0) { + adj = curlen % mps; + curlen -= adj; + KASSERT(curlen > 0, + ("ehci_alloc_sqtd_chain: need to copy")); + segoff -= adj; + if (segoff < 0) { + seg--; + segoff += dma->segs[seg].ds_len; } -#endif -#elif defined(__FreeBSD__) - /* See comment above (XXX) */ - curlen = EHCI_PAGE_SIZE - - EHCI_PAGE_MASK(dataphys); -#endif - /* the length must be a multiple of the max size */ - curlen -= curlen % mps; - DPRINTFN(1,("ehci_alloc_sqtd_chain: multiple QTDs, " - "curlen=%d\n", curlen)); -#ifdef DIAGNOSTIC - if (curlen == 0) - panic("ehci_alloc_std: curlen == 0"); -#endif + KASSERT(seg >= 0 && segoff >= 0, + ("ehci_alloc_sqtd_chain: adjust to mps")); } - DPRINTFN(4,("ehci_alloc_sqtd_chain: dataphys=0x%08x " - "dataphyslastpage=0x%08x len=%d curlen=%d\n", - dataphys, dataphyslastpage, - len, curlen)); + len -= curlen; if (len != 0) { @@ -2396,27 +2394,13 @@ nextphys = EHCI_NULL; } - for (i = 0; i * EHCI_PAGE_SIZE < curlen; i++) { - ehci_physaddr_t a = dataphys + i * EHCI_PAGE_SIZE; - if (i != 0) /* use offset only in first buffer */ - a = EHCI_PAGE(a); - cur->qtd.qtd_buffer[i] = htole32(a); - cur->qtd.qtd_buffer_hi[i] = 0; -#ifdef DIAGNOSTIC - if (i >= EHCI_QTD_NBUFFERS) { - printf("ehci_alloc_sqtd_chain: i=%d\n", i); - goto nomem; - } -#endif - } cur->nextqtd = next; cur->qtd.qtd_next = cur->qtd.qtd_altnext = nextphys; cur->qtd.qtd_status = htole32(qtdstatus | EHCI_QTD_SET_BYTES(curlen)); cur->xfer = xfer; cur->len = curlen; - DPRINTFN(10,("ehci_alloc_sqtd_chain: cbp=0x%08x end=0x%08x\n", - dataphys, dataphys + curlen)); + DPRINTFN(10,("ehci_alloc_sqtd_chain: curlen=%d\n", curlen)); /* adjust the toggle based on the number of packets in this qtd */ if (((curlen + mps - 1) / mps) & 1) { @@ -2427,7 +2411,6 @@ break; DPRINTFN(10,("ehci_alloc_sqtd_chain: extend chain\n")); offset += curlen; - dataphys = DMAADDR(dma, offset); cur = next; } cur->qtd.qtd_status |= htole32(EHCI_QTD_IOC); Index: ehci_pci.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/ehci_pci.c,v retrieving revision 1.21 diff -u -r1.21 ehci_pci.c --- ehci_pci.c 16 Jan 2006 19:23:59 -0000 1.21 +++ ehci_pci.c 2 Feb 2006 02:23:10 -0000 @@ -58,6 +58,8 @@ #include #include #include +#include +#include #include #include #include @@ -420,6 +422,30 @@ } sc->sc_ncomp = ncomp; + /* Allocate a parent dma tag for DMA maps */ + err = bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT, + BUS_SPACE_MAXADDR, NULL, NULL, BUS_SPACE_MAXSIZE_32BIT, + USB_DMA_NSEG, BUS_SPACE_MAXSIZE_32BIT, 0, NULL, NULL, + &sc->sc_bus.parent_dmatag); + if (err) { + device_printf(self, "Could not allocate parent DMA tag (%d)\n", + err); + ehci_pci_detach(self); + return ENXIO; + } + + /* Allocate a dma tag for transfer buffers */ + err = bus_dma_tag_create(sc->sc_bus.parent_dmatag, 1, 0, + BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, + BUS_SPACE_MAXSIZE_32BIT, USB_DMA_NSEG, BUS_SPACE_MAXSIZE_32BIT, 0, + busdma_lock_mutex, &Giant, &sc->sc_bus.buffer_dmatag); + if (err) { + device_printf(self, "Could not allocate buffer DMA tag (%d)\n", + err); + ehci_pci_detach(self); + return ENXIO; + } + ehci_pci_takecontroller(self); err = ehci_init(sc); if (!err) { @@ -450,6 +476,10 @@ */ if (sc->iot && sc->ioh) bus_space_write_4(sc->iot, sc->ioh, EHCI_USBINTR, 0); + if (sc->sc_bus.parent_dmatag != NULL) + bus_dma_tag_destroy(sc->sc_bus.parent_dmatag); + if (sc->sc_bus.buffer_dmatag != NULL) + bus_dma_tag_destroy(sc->sc_bus.buffer_dmatag); if (sc->irq_res && sc->ih) { int err = bus_teardown_intr(self, sc->irq_res, sc->ih); Index: ohci.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/ohci.c,v retrieving revision 1.156 diff -u -r1.156 ohci.c --- ohci.c 15 Jan 2006 20:41:04 -0000 1.156 +++ ohci.c 2 Feb 2006 02:05:57 -0000 @@ -511,11 +511,11 @@ ohci_soft_td_t *sp, ohci_soft_td_t **ep) { ohci_soft_td_t *next, *cur; - ohci_physaddr_t dataphys; + ohci_physaddr_t dataphys, physend; u_int32_t tdflags; int offset = 0; - int len, curlen; - usb_dma_t *dma = &xfer->dmabuf; + int len, maxp, curlen, curlen2, seg, segoff; + struct usb_dma_mapping *dma = &xfer->dmamap; u_int16_t flags = xfer->flags; DPRINTFN(alen < 4096,("ohci_alloc_std_chain: start len=%d\n", alen)); @@ -523,22 +523,22 @@ len = alen; cur = sp; + maxp = UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize); 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_SET_DI(6)); + seg = 0; + segoff = 0; for (;;) { next = ohci_alloc_std(sc); if (next == NULL) goto nomem; - dataphys = DMAADDR(dma, offset); - /* * 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 + * 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 @@ -546,34 +546,67 @@ * 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. - * - * Note that if we are gathering data from multiple SMALL - * segments, e.g. mbufs, we need to do special gymnastics, - * e.g. bounce buffering or data aggregation, - * BEFORE WE GET HERE because a bulk USB transfer must - * consist of maximally sized packets right up to the end. - * A shorter than maximal packet means that it is the end - * of the transfer. If the data transfer length is a - * multiple of the packet size, then a 0 byte - * packet will be the signal of the end of transfer. - * Since packets can't cross TDs this means that - * each TD except the last one must cover an exact multiple - * of the maximal packet length. */ - if (OHCI_PAGE_OFFSET(dataphys) + len <= (2 * OHCI_PAGE_SIZE)) { - /* We can handle all that remains in this TD */ + KASSERT(seg < dma->nsegs, ("ohci_alloc_std_chain: overrun")); + dataphys = dma->segs[seg].ds_addr + segoff; + curlen = dma->segs[seg].ds_len - segoff; + if (curlen > len) curlen = len; + physend = dataphys + curlen - 1; + if (OHCI_PAGE(dataphys) != OHCI_PAGE(physend)) { + /* Truncate to two OHCI pages if there are more. */ + if (curlen > 2 * OHCI_PAGE_SIZE - + OHCI_PAGE_OFFSET(dataphys)) + curlen = 2 * OHCI_PAGE_SIZE - + OHCI_PAGE_OFFSET(dataphys); + if (curlen < len) + curlen -= curlen % maxp; + physend = dataphys + curlen - 1; + } else if (OHCI_PAGE_OFFSET(physend + 1) == 0 && curlen < len && + curlen + segoff == dma->segs[seg].ds_len) { + /* We can possibly include another segment. */ + KASSERT(seg + 1 < dma->nsegs, + ("ohci_alloc_std_chain: overrun2")); + seg++; + + /* Determine how much of the second segment to use. */ + curlen2 = dma->segs[seg].ds_len; + if (curlen + curlen2 > len) + curlen2 = len - curlen; + if (OHCI_PAGE(dma->segs[seg].ds_addr) != + OHCI_PAGE(dma->segs[seg].ds_addr + curlen2 - 1)) + curlen2 = OHCI_PAGE_SIZE - + OHCI_PAGE_OFFSET(dma->segs[seg].ds_addr); + if (curlen + curlen2 < len) + curlen2 -= (curlen + curlen2) % maxp; + + if (curlen2 > 0) { + /* We can include a second segment */ + segoff = curlen2; + physend = dma->segs[seg].ds_addr + curlen2 - 1; + curlen += curlen2; + } else { + /* Second segment not usable now. */ + seg--; + segoff += curlen; + } } else { - /* must use multiple TDs, fill as much as possible. */ - curlen = 2 * OHCI_PAGE_SIZE - - OHCI_PAGE_OFFSET(dataphys); - /* the length must be a multiple of the max size */ - curlen -= curlen % - UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize); - KASSERT((curlen != 0), ("ohci_alloc_std: curlen == 0")); + /* Simple case where there is just one OHCI page. */ + segoff += curlen; + } + if (curlen == 0 && len != 0) { + /* + * A maxp length packet would need to be split. + * This shouldn't be possible if PAGE_SIZE >= 4k + * and the buffer is contiguous in virtual memory. + */ + panic("ohci_alloc_std_chain: XXX need to copy"); + } + if (segoff >= dma->segs[seg].ds_len) { + KASSERT(segoff == dma->segs[seg].ds_len, + ("ohci_alloc_std_chain: overlap")); + seg++; + segoff = 0; } DPRINTFN(4,("ohci_alloc_std_chain: dataphys=0x%08x " "len=%d curlen=%d\n", @@ -584,7 +617,7 @@ cur->td.td_cbp = htole32(dataphys); cur->nexttd = next; cur->td.td_nexttd = htole32(next->physaddr); - cur->td.td_be = htole32(DMAADDR(dma, offset + curlen - 1)); + cur->td.td_be = htole32(physend); cur->len = curlen; cur->flags = OHCI_ADD_LEN; cur->xfer = xfer; @@ -1574,6 +1607,7 @@ ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus; ohci_soft_ed_t *sed = opipe->sed; ohci_soft_td_t *data, *tail; + ohci_physaddr_t dataphys, physend; DPRINTFN(10,("ohci_device_intr_done: xfer=%p, actlen=%d\n", @@ -1595,11 +1629,35 @@ OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY); if (xfer->flags & USBD_SHORT_XFER_OK) data->td.td_flags |= htole32(OHCI_TD_R); - data->td.td_cbp = htole32(DMAADDR(&xfer->dmabuf, 0)); + /* + * Assume a short mapping with no complications, which + * should always be true for <= 4k buffers in contiguous + * virtual memory. The data can take the following forms: + * 1 segment in 1 OHCI page + * 1 segment in 2 OHCI pages + * 2 segments in 2 OHCI pages + * (see comment in ohci_alloc_std_chain() for details) + */ + KASSERT(xfer->length > 0 && xfer->length <= OHCI_PAGE_SIZE, + ("ohci_device_intr_done: bad length %u", + (u_int)xfer->length)); + dataphys = xfer->dmamap.segs[0].ds_addr; + physend = dataphys + xfer->length - 1; + if (xfer->dmamap.nsegs == 2) { + KASSERT(OHCI_PAGE_OFFSET(dataphys + + xfer->dmamap.segs[0].ds_len) == 0, + ("ohci_device_intr_done: bad seg 0 termination")); + physend = xfer->dmamap.segs[1].ds_addr + + xfer->length - xfer->dmamap.segs[0].ds_len - 1; + } else { + KASSERT(xfer->dmamap.nsegs == 1, + ("ohci_device_intr_done: bad seg count %d", + (u_int)xfer->dmamap.nsegs)); + } + data->td.td_cbp = htole32(dataphys); data->nexttd = tail; data->td.td_nexttd = htole32(tail->physaddr); - data->td.td_be = htole32(le32toh(data->td.td_cbp) + - xfer->length - 1); + data->td.td_be = htole32(physend); data->len = xfer->length; data->xfer = xfer; data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN; @@ -1639,7 +1697,7 @@ pipe = xfer->pipe; - p = KERNADDR(&xfer->dmabuf, 0); + p = xfer->buffer; m = min(sc->sc_noport, xfer->length * 8 - 1); memset(p, 0, xfer->length); for (i = 1; i <= m; i++) { @@ -2516,7 +2574,7 @@ index = UGETW(req->wIndex); if (len != 0) - buf = KERNADDR(&xfer->dmabuf, 0); + buf = xfer->buffer; #define C(x,y) ((x) | ((y) << 8)) switch(C(req->bRequest, req->bmRequestType)) { @@ -3097,6 +3155,7 @@ ohci_softc_t *sc = (ohci_softc_t *)dev->bus; ohci_soft_ed_t *sed = opipe->sed; ohci_soft_td_t *data, *tail; + ohci_physaddr_t dataphys, physend; int len; int s; @@ -3125,10 +3184,34 @@ OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY); if (xfer->flags & USBD_SHORT_XFER_OK) data->td.td_flags |= htole32(OHCI_TD_R); - data->td.td_cbp = htole32(DMAADDR(&xfer->dmabuf, 0)); + /* + * Assume a short mapping with no complications, which + * should always be true for <= 4k buffers in contiguous + * virtual memory. The data can take the following forms: + * 1 segment in 1 OHCI page + * 1 segment in 2 OHCI pages + * 2 segments in 2 OHCI pages + * (see comment in ohci_alloc_std_chain() for details) + */ + KASSERT(len > 0 && xfer->length <= OHCI_PAGE_SIZE, + ("ohci_device_intr_done: bad length %d", len)); + dataphys = xfer->dmamap.segs[0].ds_addr; + physend = dataphys + len - 1; + if (xfer->dmamap.nsegs == 2) { + KASSERT(OHCI_PAGE_OFFSET(dataphys + + xfer->dmamap.segs[0].ds_len) == 0, + ("ohci_device_intr_done: bad seg 0 termination")); + physend = xfer->dmamap.segs[1].ds_addr + len - + xfer->dmamap.segs[0].ds_len - 1; + } else { + KASSERT(xfer->dmamap.nsegs == 1, + ("ohci_device_intr_done: bad seg count %d", + (u_int)xfer->dmamap.nsegs)); + } + data->td.td_cbp = htole32(dataphys); data->nexttd = tail; data->td.td_nexttd = htole32(tail->physaddr); - data->td.td_be = htole32(le32toh(data->td.td_cbp) + len - 1); + data->td.td_be = htole32(physend); data->len = len; data->xfer = xfer; data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN; @@ -3358,13 +3441,14 @@ } sitd = opipe->tail.itd; - buf = DMAADDR(&xfer->dmabuf, 0); + buf = xfer->dmamap.segs[0].ds_addr; bp0 = OHCI_PAGE(buf); offs = OHCI_PAGE_OFFSET(buf); nframes = xfer->nframes; xfer->hcpriv = sitd; for (i = ncur = 0; i < nframes; i++, ncur++) { noffs = offs + xfer->frlengths[i]; + /* XXX, fixme. */ if (ncur == OHCI_ITD_NOFFSET || /* all offsets used */ OHCI_PAGE(buf + noffs) > bp0 + OHCI_PAGE_SIZE) { /* too many page crossings */ Index: ohci_pci.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/ohci_pci.c,v retrieving revision 1.45 diff -u -r1.45 ohci_pci.c --- ohci_pci.c 16 Jan 2006 19:07:05 -0000 1.45 +++ ohci_pci.c 20 Jan 2006 01:12:29 -0000 @@ -55,6 +55,8 @@ #include #include #include +#include +#include #include #include #include @@ -303,6 +305,30 @@ ohci_pci_detach(self); return ENXIO; } + + /* Allocate a parent dma tag for DMA maps */ + err = bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT, + BUS_SPACE_MAXADDR, NULL, NULL, BUS_SPACE_MAXSIZE_32BIT, + USB_DMA_NSEG, BUS_SPACE_MAXSIZE_32BIT, 0, NULL, NULL, + &sc->sc_bus.parent_dmatag); + if (err) { + device_printf(self, "Could not allocate parent DMA tag (%d)\n", + err); + ohci_pci_detach(self); + return ENXIO; + } + /* Allocate a dma tag for transfer buffers */ + err = bus_dma_tag_create(sc->sc_bus.parent_dmatag, 1, 0, + BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, + BUS_SPACE_MAXSIZE_32BIT, USB_DMA_NSEG, BUS_SPACE_MAXSIZE_32BIT, 0, + busdma_lock_mutex, &Giant, &sc->sc_bus.buffer_dmatag); + if (err) { + device_printf(self, "Could not allocate transfer tag (%d)\n", + err); + ohci_pci_detach(self); + return ENXIO; + } + err = ohci_init(sc); if (!err) { sc->sc_flags |= OHCI_SCFLG_DONEINIT; @@ -327,6 +353,11 @@ sc->sc_flags &= ~OHCI_SCFLG_DONEINIT; } + if (sc->sc_bus.parent_dmatag != NULL) + bus_dma_tag_destroy(sc->sc_bus.parent_dmatag); + if (sc->sc_bus.buffer_dmatag != NULL) + bus_dma_tag_destroy(sc->sc_bus.buffer_dmatag); + if (sc->irq_res && sc->ih) { int err = bus_teardown_intr(self, sc->irq_res, sc->ih); @@ -345,7 +376,8 @@ sc->irq_res = NULL; } if (sc->io_res) { - bus_release_resource(self, SYS_RES_MEMORY, PCI_CBMEM, sc->io_res); + bus_release_resource(self, SYS_RES_MEMORY, PCI_CBMEM, + sc->io_res); sc->io_res = NULL; sc->iot = 0; sc->ioh = 0; Index: sl811hs.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/sl811hs.c,v retrieving revision 1.2 diff -u -r1.2 sl811hs.c --- sl811hs.c 4 Dec 2005 10:06:04 -0000 1.2 +++ sl811hs.c 1 Feb 2006 00:49:08 -0000 @@ -548,7 +548,7 @@ usb_callout(sc->sc_poll_handle, sc->sc_interval, slhci_poll_hub, xfer); /* USB spec 11.13.3 (p.260) */ - p = KERNADDR(&xfer->dmabuf, 0); + p = xfer->buffer; p[0] = 0; if ((sc->sc_flags & (SLF_INSERT | SLF_RESET))) { p[0] = 2; @@ -767,7 +767,7 @@ index = UGETW(req->wIndex); if (len) - buf = KERNADDR(&xfer->dmabuf, 0); + buf = xfer->buffer; #ifdef SLHCI_DEBUG if ((slhci_debug & D_TRACE)) @@ -1197,7 +1197,7 @@ actlen = 0; len = UGETW(req->wLength); if (len) { - buf = KERNADDR(&xfer->dmabuf, 0); + buf = xfer->buffer; if (req->bmRequestType & UT_READ) pid = SL11_PID_IN; for (; actlen < len; ) { @@ -1226,7 +1226,7 @@ if((slhci_debug & D_TRACE) && UGETW(req->wLength) > 0){ int i; for(i=0; i < UGETW(req->wLength); i++) - printf("%02x", *(unsigned char*)(KERNADDR(&xfer->dmabuf, i))); + printf("%02x", ((unsigned char *)xfer->buffer)[i]); printf(" "); } #endif @@ -1318,7 +1318,7 @@ /* interrupt transfer */ pid = (UE_GET_DIR(pipe->endpoint->edesc->bEndpointAddress) == UE_DIR_IN) ? SL11_PID_IN : SL11_PID_OUT; - buf = KERNADDR(&xfer->dmabuf, 0); + buf = xfer->buffer; r = slhci_transaction(sc, pipe, pid, xfer->length, buf, 0/*toggle*/); if (r < 0) { Index: uhci.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/uhci.c,v retrieving revision 1.163 diff -u -r1.163 uhci.c --- uhci.c 15 Jan 2006 20:41:04 -0000 1.163 +++ uhci.c 1 Feb 2006 00:42:15 -0000 @@ -199,7 +199,8 @@ Static void uhci_free_std_chain(uhci_softc_t *, uhci_soft_td_t *, uhci_soft_td_t *); Static usbd_status uhci_alloc_std_chain(struct uhci_pipe *, - uhci_softc_t *, int, int, u_int16_t, usb_dma_t *, + uhci_softc_t *, int, int, u_int16_t, + usbd_xfer_handle xfer, uhci_soft_td_t **, uhci_soft_td_t **); Static void uhci_poll_hub(void *); Static void uhci_waitintr(uhci_softc_t *, usbd_xfer_handle); @@ -207,6 +208,7 @@ Static void uhci_idone(uhci_intr_info_t *); Static void uhci_abort_xfer(usbd_xfer_handle, usbd_status status); +Static void uhci_transfer_complete(usbd_xfer_handle xfer); Static void uhci_timeout(void *); Static void uhci_timeout_task(void *); @@ -493,7 +495,7 @@ clsqh = uhci_alloc_sqh(sc); if (clsqh == NULL) return (USBD_NOMEM); - clsqh->hlink = bsqh; + clsqh->hlink = chsqh; clsqh->qh.qh_hlink = htole32(chsqh->physaddr | UHCI_PTR_QH); clsqh->elink = NULL; clsqh->qh.qh_elink = htole32(UHCI_PTR_T); @@ -969,7 +971,8 @@ { usbd_xfer_handle xfer = addr; usbd_pipe_handle pipe = xfer->pipe; - uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus; + usbd_device_handle dev = pipe->device; + uhci_softc_t *sc = (uhci_softc_t *)dev->bus; int s; u_char *p; @@ -977,7 +980,7 @@ usb_callout(sc->sc_poll_handle, sc->sc_ival, uhci_poll_hub, xfer); - p = KERNADDR(&xfer->dmabuf, 0); + p = xfer->buffer; p[0] = 0; if (UREAD2(sc, UHCI_PORTSC1) & (UHCI_PORTSC_CSC|UHCI_PORTSC_OCIC)) p[0] |= 1<<1; @@ -990,9 +993,9 @@ xfer->actlen = 1; xfer->status = USBD_NORMAL_COMPLETION; s = splusb(); - xfer->device->bus->intr_context++; - usb_transfer_complete(xfer); - xfer->device->bus->intr_context--; + dev->bus->intr_context++; + uhci_transfer_complete(xfer); + dev->bus->intr_context--; splx(s); } @@ -1498,7 +1501,7 @@ } end: - usb_transfer_complete(xfer); + uhci_transfer_complete(xfer); DPRINTFN(12, ("uhci_idone: ii=%p done\n", ii)); } @@ -1659,6 +1662,7 @@ std = KERNADDR(&dma, offs); std->physaddr = DMAADDR(&dma, offs); std->link.std = sc->sc_freetds; + std->aux_dma.block = NULL; /* XXX */ sc->sc_freetds = std; } } @@ -1679,6 +1683,11 @@ } std->td.td_token = htole32(TD_IS_FREE); #endif + /* XXX */ + if (std->aux_dma.block != NULL) { + usb_freemem(&sc->sc_bus, &std->aux_dma); + std->aux_dma.block = NULL; + } std->link.std = sc->sc_freetds; sc->sc_freetds = std; } @@ -1732,12 +1741,12 @@ usbd_status uhci_alloc_std_chain(struct uhci_pipe *upipe, uhci_softc_t *sc, int len, - int rd, u_int16_t flags, usb_dma_t *dma, + int rd, u_int16_t flags, usbd_xfer_handle xfer, uhci_soft_td_t **sp, uhci_soft_td_t **ep) { - uhci_soft_td_t *p, *lastp; - uhci_physaddr_t lastlink; - int i, ntd, l, tog, maxp; + struct usb_dma_mapping *dma = &xfer->dmamap; + uhci_soft_td_t *p, *prevp, *startp; + int err, i, ntd, l, tog, maxp, seg, segoff; u_int32_t status; int addr = upipe->pipe.device->address; int endpt = upipe->pipe.endpoint->edesc->bEndpointAddress; @@ -1760,29 +1769,31 @@ return (USBD_NORMAL_COMPLETION); } tog = upipe->nexttoggle; - if (ntd % 2 == 0) - tog ^= 1; - upipe->nexttoggle = tog ^ 1; - lastp = NULL; - lastlink = UHCI_PTR_T; - ntd--; + prevp = NULL; + startp = NULL; status = UHCI_TD_ZERO_ACTLEN(UHCI_TD_SET_ERRCNT(3) | UHCI_TD_ACTIVE); if (upipe->pipe.device->speed == USB_SPEED_LOW) status |= UHCI_TD_LS; if (flags & USBD_SHORT_XFER_OK) status |= UHCI_TD_SPD; - for (i = ntd; i >= 0; i--) { + seg = 0; + segoff = 0; + for (i = 0; i < ntd; i++) { p = uhci_alloc_std(sc); if (p == NULL) { - uhci_free_std_chain(sc, lastp, NULL); + uhci_free_std_chain(sc, startp, NULL); return (USBD_NOMEM); } - p->link.std = lastp; - p->td.td_link = htole32(lastlink | UHCI_PTR_VF | UHCI_PTR_TD); - lastp = p; - lastlink = p->physaddr; + p->link.std = NULL; + if (prevp != NULL) { + prevp->link.std = p; + prevp->td.td_link = htole32(p->physaddr | UHCI_PTR_VF | + UHCI_PTR_TD); + } else { + startp = p; + } p->td.td_status = htole32(status); - if (i == ntd) { + if (i == ntd - 1) { /* last TD */ l = len % maxp; if (l == 0 && !(flags & USBD_FORCE_SHORT_XFER)) @@ -1793,10 +1804,48 @@ p->td.td_token = htole32(rd ? UHCI_TD_IN (l, endpt, addr, tog) : UHCI_TD_OUT(l, endpt, addr, tog)); - p->td.td_buffer = htole32(DMAADDR(dma, i * maxp)); + + KASSERT(seg < dma->nsegs, + ("uhci_alloc_std_chain: too few segments")); + if (l > dma->segs[seg].ds_len - segoff) { + /* UHCI can't handle non-contiguous data. */ + err = usb_allocmem(&sc->sc_bus, l, maxp, &p->aux_dma); + if (err) { + uhci_free_std_chain(sc, startp, NULL); + return (err); + } + if (!rd) { + bcopy((char *)xfer->buffer + i * maxp, + KERNADDR(&p->aux_dma, 0), l); + bus_dmamap_sync(p->aux_dma.block->tag, + p->aux_dma.block->map, + BUS_DMASYNC_PREWRITE); + } + p->td.td_buffer = htole32(DMAADDR(&p->aux_dma, 0)); + l -= dma->segs[seg].ds_len - segoff; + seg++; + KASSERT(seg < dma->nsegs, + ("uhci_alloc_std_chain: too few segments 2")); + segoff = 0; + } else { + p->td.td_buffer = htole32(dma->segs[seg].ds_addr + + segoff); + } + segoff += l; + if (segoff >= dma->segs[seg].ds_len) { + KASSERT(segoff == dma->segs[seg].ds_len, + ("uhci_alloc_std_chain: overlap")); + if (i * maxp + l != len) { + seg++; + segoff = 0; + } + } + prevp = p; tog ^= 1; } - *sp = lastp; + prevp->td.td_link = htole32(UHCI_PTR_T | UHCI_PTR_VF | UHCI_PTR_TD); + upipe->nexttoggle = tog; + *sp = startp; DPRINTFN(10, ("uhci_alloc_std_chain: nexttog=%d\n", upipe->nexttoggle)); return (USBD_NORMAL_COMPLETION); @@ -1863,8 +1912,8 @@ upipe->u.bulk.isread = isread; upipe->u.bulk.length = len; - err = uhci_alloc_std_chain(upipe, sc, len, isread, xfer->flags, - &xfer->dmabuf, &data, &dataend); + err = uhci_alloc_std_chain(upipe, sc, len, isread, xfer->flags, xfer, + &data, &dataend); if (err) return (err); dataend->td.td_status |= htole32(UHCI_TD_IOC); @@ -1950,7 +1999,7 @@ xfer->status = status; /* make software ignore it */ usb_uncallout(xfer->timeout_handle, uhci_timeout, xfer); usb_rem_task(xfer->pipe->device, &UXFER(xfer)->abort_task); - usb_transfer_complete(xfer); + uhci_transfer_complete(xfer); splx(s); return; } @@ -2020,10 +2069,48 @@ uxfer->uhci_xfer_flags &= ~UHCI_XFER_ABORTWAIT; wakeup(&uxfer->uhci_xfer_flags); } - usb_transfer_complete(xfer); + uhci_transfer_complete(xfer); splx(s); } +/* + * Perform any UHCI-specific transfer completion operations, then + * call usb_transfer_complete(). + */ +Static void +uhci_transfer_complete(usbd_xfer_handle xfer) +{ + uhci_intr_info_t *ii = &UXFER(xfer)->iinfo; + struct uhci_pipe *upipe = (struct uhci_pipe *)xfer->pipe; + uhci_soft_td_t *p; + int l, maxp, ofs; + + /* Copy back from any auxillary buffers after a read operation. */ + /* XXX, must be an easier way to detect reads... */ + if (((xfer->rqflags & URQ_REQUEST) && + (xfer->request.bmRequestType & UT_READ)) || + (xfer->pipe->endpoint->edesc->bEndpointAddress & UE_DIR_IN)) { + maxp = UGETW(upipe->pipe.endpoint->edesc->wMaxPacketSize); + ofs = 0; + for (p = ii->stdstart; p != NULL && ofs < xfer->actlen; + p = p->link.std) { + if (p->aux_dma.block != NULL) { + bus_dmamap_sync(p->aux_dma.block->tag, + p->aux_dma.block->map, + BUS_DMASYNC_POSTREAD); + l = xfer->actlen - ofs; + if (l > maxp) + l = maxp; + bcopy(KERNADDR(&p->aux_dma, 0), + (char *)xfer->buffer + ofs, l); + } + ofs += maxp; + } + } + + usb_transfer_complete(xfer); +} + /* Close a device bulk pipe. */ void uhci_device_bulk_close(usbd_pipe_handle pipe) @@ -2122,9 +2209,8 @@ upipe->u.intr.isread = isread; - err = uhci_alloc_std_chain(upipe, sc, xfer->length, isread, - xfer->flags, &xfer->dmabuf, &data, - &dataend); + err = uhci_alloc_std_chain(upipe, sc, xfer->length, isread, xfer->flags, + xfer, &data, &dataend); if (err) return (err); dataend->td.td_status |= htole32(UHCI_TD_IOC); @@ -2262,7 +2348,7 @@ if (len != 0) { upipe->nexttoggle = 1; err = uhci_alloc_std_chain(upipe, sc, len, isread, xfer->flags, - &xfer->dmabuf, &data, &dataend); + xfer, &data, &dataend); if (err) return (err); next = data; @@ -2390,7 +2476,7 @@ struct iso *iso = &upipe->u.iso; uhci_soft_td_t *std; u_int32_t buf, len, status; - int s, i, next, nframes; + int s, i, next, nframes, seg, segoff; DPRINTFN(5,("uhci_device_isoc_enter: used=%d next=%d xfer=%p " "nframes=%d\n", @@ -2420,7 +2506,8 @@ xfer->status = USBD_IN_PROGRESS; UXFER(xfer)->curframe = next; - buf = DMAADDR(&xfer->dmabuf, 0); + seg = 0; + segoff = 0; status = UHCI_TD_ZERO_ACTLEN(UHCI_TD_SET_ERRCNT(0) | UHCI_TD_ACTIVE | UHCI_TD_IOS); @@ -2431,7 +2518,17 @@ if (++next >= UHCI_VFRAMELIST_COUNT) next = 0; len = xfer->frlengths[i]; - std->td.td_buffer = htole32(buf); + KASSERT(seg < xfer->dmamap.nsegs, + ("uhci_device_isoc_enter: too few segments")); + std->td.td_buffer = htole32(xfer->dmamap.segs[seg].ds_addr + + segoff); + segoff += len; + if (segoff >= xfer->dmamap.segs[seg].ds_len) { + KASSERT(segoff == xfer->dmamap.segs[seg].ds_len, + ("uhci_device_isoc_enter: overlap")); + segoff = 0; + seg++; + } if (i == nframes - 1) status |= UHCI_TD_IOC; std->td.td_status = htole32(status); @@ -2542,7 +2639,7 @@ UXFER(xfer)->iinfo.isdone = 1; #endif /* Run callback and remove from interrupt list. */ - usb_transfer_complete(xfer); + uhci_transfer_complete(xfer); splx(s); } @@ -2690,6 +2787,8 @@ return; } #endif + ii->stdstart = NULL; + ii->stdend = NULL; } void @@ -2719,8 +2818,8 @@ /* This alloc cannot fail since we freed the chain above. */ uhci_alloc_std_chain(upipe, sc, xfer->length, - upipe->u.intr.isread, xfer->flags, - &xfer->dmabuf, &data, &dataend); + upipe->u.intr.isread, xfer->flags, xfer, + &data, &dataend); dataend->td.td_status |= htole32(UHCI_TD_IOC); #ifdef USB_DEBUG @@ -2748,8 +2847,11 @@ /* The ii is already on the examined list, just leave it. */ } else { DPRINTFN(5,("uhci_device_intr_done: removing\n")); - if (uhci_active_intr_info(ii)) + if (uhci_active_intr_info(ii)) { uhci_del_intr_info(ii); + ii->stdstart = NULL; + ii->stdend = NULL; + } } } @@ -2778,6 +2880,8 @@ if (upipe->u.ctl.length != 0) uhci_free_std_chain(sc, ii->stdstart->link.std, ii->stdend); + ii->stdstart = NULL; + ii->stdend = NULL; DPRINTFN(5, ("uhci_device_ctrl_done: length=%d\n", xfer->actlen)); } @@ -2801,6 +2905,8 @@ uhci_remove_bulk(sc, upipe->u.bulk.sqh); uhci_free_std_chain(sc, ii->stdstart, NULL); + ii->stdstart = NULL; + ii->stdend = NULL; DPRINTFN(5, ("uhci_device_bulk_done: length=%d\n", xfer->actlen)); } @@ -2833,7 +2939,7 @@ DPRINTFN(4, ("uhci_remove_intr: n=%d sqh=%p\n", sqh->pos, sqh)); /* See comment in uhci_remove_ctrl() */ - if (!(sqh->qh.qh_elink & htole32(UHCI_PTR_T))) { + while (!(sqh->qh.qh_elink & htole32(UHCI_PTR_T))) { sqh->qh.qh_elink = htole32(UHCI_PTR_T); delay(UHCI_QH_REMOVE_DELAY); } @@ -3201,7 +3307,7 @@ index = UGETW(req->wIndex); if (len != 0) - buf = KERNADDR(&xfer->dmabuf, 0); + buf = xfer->buffer; #define C(x,y) ((x) | ((y) << 8)) switch(C(req->bRequest, req->bmRequestType)) { @@ -3491,7 +3597,7 @@ ret: xfer->status = err; s = splusb(); - usb_transfer_complete(xfer); + uhci_transfer_complete(xfer); splx(s); return (USBD_IN_PROGRESS); } @@ -3527,7 +3633,7 @@ #ifdef DIAGNOSTIC UXFER(xfer)->iinfo.isdone = 1; #endif - usb_transfer_complete(xfer); + uhci_transfer_complete(xfer); } usbd_status Index: uhci_pci.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/uhci_pci.c,v retrieving revision 1.57 diff -u -r1.57 uhci_pci.c --- uhci_pci.c 1 Mar 2005 07:50:11 -0000 1.57 +++ uhci_pci.c 20 Jan 2006 01:12:29 -0000 @@ -54,6 +54,8 @@ #include #include #include +#include +#include #include #include #if defined(__FreeBSD__) @@ -348,6 +350,29 @@ #endif pci_write_config(self, PCI_LEGSUP, PCI_LEGSUP_USBPIRQDEN, 2); + /* Allocate a parent dma tag for DMA maps */ + err = bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT, + BUS_SPACE_MAXADDR, NULL, NULL, BUS_SPACE_MAXSIZE_32BIT, + USB_DMA_NSEG, BUS_SPACE_MAXSIZE_32BIT, 0, NULL, NULL, + &sc->sc_bus.parent_dmatag); + if (err) { + device_printf(self, "Could not allocate parent DMA tag (%d)\n", + err); + uhci_pci_detach(self); + return ENXIO; + } + /* Allocate a dma tag for transfer buffers */ + err = bus_dma_tag_create(sc->sc_bus.parent_dmatag, 1, 0, + BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, + BUS_SPACE_MAXSIZE_32BIT, USB_DMA_NSEG, BUS_SPACE_MAXSIZE_32BIT, 0, + busdma_lock_mutex, &Giant, &sc->sc_bus.buffer_dmatag); + if (err) { + device_printf(self, "Could not allocate transfer tag (%d)\n", + err); + uhci_pci_detach(self); + return ENXIO; + } + err = uhci_init(sc); if (!err) { sc->sc_flags |= UHCI_SCFLG_DONEINIT; @@ -372,6 +397,10 @@ sc->sc_flags &= ~UHCI_SCFLG_DONEINIT; } + if (sc->sc_bus.parent_dmatag != NULL) + bus_dma_tag_destroy(sc->sc_bus.parent_dmatag); + if (sc->sc_bus.buffer_dmatag != NULL) + bus_dma_tag_destroy(sc->sc_bus.buffer_dmatag); if (sc->irq_res && sc->ih) { int err = bus_teardown_intr(self, sc->irq_res, sc->ih); Index: uhcireg.h =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/uhcireg.h,v retrieving revision 1.22 diff -u -r1.22 uhcireg.h --- uhcireg.h 6 Jan 2005 01:43:28 -0000 1.22 +++ uhcireg.h 1 Feb 2006 01:48:53 -0000 @@ -140,8 +140,8 @@ */ typedef struct { - uhci_physaddr_t td_link; - u_int32_t td_status; + volatile uhci_physaddr_t td_link; + volatile u_int32_t td_status; #define UHCI_TD_GET_ACTLEN(s) (((s) + 1) & 0x3ff) #define UHCI_TD_ZERO_ACTLEN(t) ((t) | 0x3ff) #define UHCI_TD_BITSTUFF 0x00020000 @@ -157,7 +157,7 @@ #define UHCI_TD_GET_ERRCNT(s) (((s) >> 27) & 3) #define UHCI_TD_SET_ERRCNT(n) ((n) << 27) #define UHCI_TD_SPD 0x20000000 - u_int32_t td_token; + volatile u_int32_t td_token; #define UHCI_TD_PID_IN 0x00000069 #define UHCI_TD_PID_OUT 0x000000e1 #define UHCI_TD_PID_SETUP 0x0000002d @@ -171,7 +171,7 @@ #define UHCI_TD_SET_MAXLEN(l) (((l)-1) << 21) #define UHCI_TD_GET_MAXLEN(s) ((((s) >> 21) + 1) & 0x7ff) #define UHCI_TD_MAXLEN_MASK 0xffe00000 - u_int32_t td_buffer; + volatile u_int32_t td_buffer; } uhci_td_t; #define UHCI_TD_ERROR (UHCI_TD_BITSTUFF|UHCI_TD_CRCTO|UHCI_TD_BABBLE|UHCI_TD_DBUFFER|UHCI_TD_STALLED) @@ -186,8 +186,8 @@ UHCI_TD_SET_DT(dt)) typedef struct { - uhci_physaddr_t qh_hlink; - uhci_physaddr_t qh_elink; + volatile uhci_physaddr_t qh_hlink; + volatile uhci_physaddr_t qh_elink; } uhci_qh_t; #endif /* _DEV_PCI_UHCIREG_H_ */ Index: uhcivar.h =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/uhcivar.h,v retrieving revision 1.40 diff -u -r1.40 uhcivar.h --- uhcivar.h 19 Mar 2005 19:08:46 -0000 1.40 +++ uhcivar.h 1 Feb 2006 00:28:25 -0000 @@ -100,6 +100,7 @@ uhci_td_t td; /* The real TD, must be first */ uhci_soft_td_qh_t link; /* soft version of the td_link field */ uhci_physaddr_t physaddr; /* TD's physical address. */ + usb_dma_t aux_dma; /* Auxillary storage if needed. */ }; /* * Make the size such that it is a multiple of UHCI_TD_ALIGN. This way Index: umass.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/umass.c,v retrieving revision 1.128 diff -u -r1.128 umass.c --- umass.c 9 Jan 2006 01:33:53 -0000 1.128 +++ umass.c 20 Jan 2006 01:12:29 -0000 @@ -482,6 +482,10 @@ UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I, FORCE_SHORT_INQUIRY }, + { 0x090a, 0x1100, RID_WILDCARD, + UMASS_PROTO_UFI | UMASS_PROTO_CBI, + NO_QUIRKS + }, { VID_EOT, PID_EOT, RID_EOT, 0, 0 } }; Index: usb_mem.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/usb_mem.c,v retrieving revision 1.8 diff -u -r1.8 usb_mem.c --- usb_mem.c 10 Jan 2006 22:55:35 -0000 1.8 +++ usb_mem.c 20 Jan 2006 01:12:29 -0000 @@ -230,7 +230,7 @@ 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; + bus_dma_tag_t tag = bus->parent_dmatag; usbd_status err; struct usb_frag_dma *f; usb_dma_block_t *b; Index: usb_port.h =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/usb_port.h,v retrieving revision 1.75 diff -u -r1.75 usb_port.h --- usb_port.h 18 Sep 2005 11:45:39 -0000 1.75 +++ usb_port.h 20 Jan 2006 01:12:29 -0000 @@ -47,6 +47,8 @@ #ifndef _USB_PORT_H #define _USB_PORT_H +#define USB_DEBUG + /* * Macro's to cope with the differences between operating systems. */ Index: usbdi.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/usbdi.c,v retrieving revision 1.92 diff -u -r1.92 usbdi.c --- usbdi.c 8 Dec 2005 03:08:17 -0000 1.92 +++ usbdi.c 1 Feb 2006 00:37:59 -0000 @@ -87,6 +87,10 @@ Static usbd_status usbd_open_pipe_ival (usbd_interface_handle, u_int8_t, u_int8_t, usbd_pipe_handle *, int); Static int usbd_xfer_isread(usbd_xfer_handle xfer); +Static void usbd_start_transfer(void *arg, bus_dma_segment_t *segs, int nseg, + int error); +Static void usbd_alloc_callback(void *arg, bus_dma_segment_t *segs, int nseg, + int error); Static int usbd_nbuses = 0; @@ -283,7 +287,7 @@ usbd_transfer(usbd_xfer_handle xfer) { usbd_pipe_handle pipe = xfer->pipe; - usb_dma_t *dmap = &xfer->dmabuf; + struct usb_dma_mapping *dmap = &xfer->dmamap; usbd_status err; u_int size; int s; @@ -302,43 +306,36 @@ size = xfer->length; /* If there is no buffer, allocate one. */ if (!(xfer->rqflags & URQ_DEV_DMABUF) && size != 0) { - struct usbd_bus *bus = pipe->device->bus; + bus_dma_tag_t tag = pipe->device->bus->buffer_dmatag; #ifdef DIAGNOSTIC if (xfer->rqflags & URQ_AUTO_DMABUF) printf("usbd_transfer: has old buffer!\n"); #endif - err = bus->methods->allocm(bus, dmap, size); + err = bus_dmamap_create(tag, 0, &dmap->map); if (err) - return (err); - xfer->rqflags |= URQ_AUTO_DMABUF; - } - - /* Copy data if going out. */ - if (!(xfer->flags & USBD_NO_COPY) && size != 0 && - !usbd_xfer_isread(xfer)) - memcpy(KERNADDR(dmap, 0), xfer->buffer, size); - - err = pipe->methods->transfer(xfer); - - if (err != USBD_IN_PROGRESS && err) { - /* The transfer has not been queued, so free buffer. */ - if (xfer->rqflags & URQ_AUTO_DMABUF) { - struct usbd_bus *bus = pipe->device->bus; + return (USBD_NOMEM); - bus->methods->freem(bus, &xfer->dmabuf); + xfer->rqflags |= URQ_AUTO_DMABUF; + err = bus_dmamap_load(tag, dmap->map, xfer->buffer, size, + usbd_start_transfer, xfer, 0); + if (err != 0 && err != EINPROGRESS) { xfer->rqflags &= ~URQ_AUTO_DMABUF; + bus_dmamap_destroy(tag, dmap->map); + return (USBD_INVAL); } + } else if (size != 0) { + usbd_start_transfer(xfer, dmap->segs, dmap->nsegs, 0); + } else { + usbd_start_transfer(xfer, NULL, 0, 0); } if (!(xfer->flags & USBD_SYNCHRONOUS)) - return (err); + return (xfer->done ? 0 : USBD_IN_PROGRESS); /* Sync transfer, wait for completion. */ - if (err != USBD_IN_PROGRESS) - return (err); s = splusb(); - if (!xfer->done) { + while (!xfer->done) { if (pipe->device->bus->use_polling) panic("usbd_transfer: not done"); tsleep(xfer, PRIBIO, "usbsyn", 0); @@ -347,6 +344,51 @@ return (xfer->status); } +Static void +usbd_start_transfer(void *arg, bus_dma_segment_t *segs, int nseg, int error) +{ + usbd_xfer_handle xfer = arg; + usbd_pipe_handle pipe = xfer->pipe; + struct usb_dma_mapping *dmap = &xfer->dmamap; + bus_dma_tag_t tag = pipe->device->bus->buffer_dmatag; + int err, i; + + if (error != 0) { + KASSERT(xfer->rqflags & URQ_AUTO_DMABUF, + ("usbd_start_transfer: error with non-auto buf")); + if (nseg > 0) + bus_dmamap_unload(tag, dmap->map); + bus_dmamap_destroy(tag, dmap->map); + /* XXX */ + usb_insert_transfer(xfer); + xfer->status = USBD_IOERROR; + usb_transfer_complete(xfer); + return; + } + + if (segs != dmap->segs) { + for (i = 0; i < nseg; i++) + dmap->segs[i] = segs[i]; + dmap->nsegs = nseg; + } + + if (segs > 0 && !usbd_xfer_isread(xfer)) + bus_dmamap_sync(tag, dmap->map, BUS_DMASYNC_PREWRITE); + err = pipe->methods->transfer(xfer); + if (err != USBD_IN_PROGRESS && err) { + if (xfer->rqflags & URQ_AUTO_DMABUF) { + bus_dmamap_unload(tag, dmap->map); + bus_dmamap_destroy(tag, dmap->map); + xfer->rqflags &= ~URQ_AUTO_DMABUF; + } + /* XXX */ + usb_insert_transfer(xfer); + xfer->status = err; + usb_transfer_complete(xfer); + return; + } +} + /* Like usbd_transfer(), but waits for completion. */ usbd_status usbd_sync_transfer(usbd_xfer_handle xfer) @@ -355,42 +397,103 @@ return (usbd_transfer(xfer)); } +struct usbd_allocstate { + usbd_xfer_handle xfer; + int done; + int error; + int waiting; +}; + void * usbd_alloc_buffer(usbd_xfer_handle xfer, u_int32_t size) { - struct usbd_bus *bus = xfer->device->bus; + struct usbd_allocstate allocstate; + struct usb_dma_mapping *dmap = &xfer->dmamap; + bus_dma_tag_t tag = xfer->device->bus->buffer_dmatag; + void *buf; usbd_status err; + int error, s; -#ifdef DIAGNOSTIC - if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF)) - printf("usbd_alloc_buffer: xfer already has a buffer\n"); -#endif - err = bus->methods->allocm(bus, &xfer->dmabuf, size); + KASSERT((xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF)) == 0, + ("usbd_alloc_buffer: xfer already has a buffer")); + err = bus_dmamap_create(tag, 0, &dmap->map); if (err) return (NULL); + buf = malloc(size, M_USB, M_WAITOK); + + allocstate.xfer = xfer; + allocstate.done = 0; + allocstate.error = 0; + allocstate.waiting = 0; + error = bus_dmamap_load(tag, dmap->map, buf, size, usbd_alloc_callback, + &allocstate, 0); + if (error && error != EINPROGRESS) { + bus_dmamap_destroy(tag, dmap->map); + free(buf, M_USB); + return (NULL); + } + if (error == EINPROGRESS) { + /* Wait for completion. */ + s = splusb(); + allocstate.waiting = 1; + while (!allocstate.done) + tsleep(&allocstate, PRIBIO, "usbdab", 0); + splx(s); + error = allocstate.error; + } + if (error) { + bus_dmamap_unload(tag, dmap->map); + bus_dmamap_destroy(tag, dmap->map); + free(buf, M_USB); + return (NULL); + } + + xfer->allocbuf = buf; xfer->rqflags |= URQ_DEV_DMABUF; - return (KERNADDR(&xfer->dmabuf, 0)); + return (buf); } void usbd_free_buffer(usbd_xfer_handle xfer) { -#ifdef DIAGNOSTIC - if (!(xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))) { - printf("usbd_free_buffer: no buffer\n"); - return; - } -#endif - xfer->rqflags &= ~(URQ_DEV_DMABUF | URQ_AUTO_DMABUF); - xfer->device->bus->methods->freem(xfer->device->bus, &xfer->dmabuf); + struct usb_dma_mapping *dmap = &xfer->dmamap; + bus_dma_tag_t tag = xfer->device->bus->buffer_dmatag; + + KASSERT((xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF)) == + URQ_DEV_DMABUF, ("usbd_free_buffer: no/auto buffer")); + + xfer->rqflags &= ~URQ_DEV_DMABUF; + bus_dmamap_unload(tag, dmap->map); + bus_dmamap_destroy(tag, dmap->map); + free(xfer->allocbuf, M_USB); + xfer->allocbuf = NULL; } void * usbd_get_buffer(usbd_xfer_handle xfer) { if (!(xfer->rqflags & URQ_DEV_DMABUF)) - return (0); - return (KERNADDR(&xfer->dmabuf, 0)); + return (NULL); + return (xfer->allocbuf); +} + +Static void +usbd_alloc_callback(void *arg, bus_dma_segment_t *segs, int nseg, int error) +{ + struct usbd_allocstate *allocstate = arg; + usbd_xfer_handle xfer = allocstate->xfer; + struct usb_dma_mapping *dmap = &xfer->dmamap; + int i; + + allocstate->error = error; + if (error == 0) { + for (i = 0; i < nseg; i++) + dmap->segs[i] = segs[i]; + dmap->nsegs = nseg; + } + allocstate->done = 1; + if (allocstate->waiting) + wakeup(&allocstate); } usbd_xfer_handle @@ -411,7 +514,7 @@ usbd_free_xfer(usbd_xfer_handle xfer) { DPRINTFN(5,("usbd_free_xfer: %p\n", xfer)); - if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF)) + if (xfer->rqflags & URQ_DEV_DMABUF) usbd_free_buffer(xfer); #if defined(__NetBSD__) && defined(DIAGNOSTIC) if (callout_pending(&xfer->timeout_handle)) { @@ -760,6 +863,7 @@ pipe, xfer, pipe->methods)); /* Make the HC abort it (and invoke the callback). */ pipe->methods->abort(xfer); + KASSERT(SIMPLEQ_FIRST(&pipe->queue) != xfer, ("usbd_ar_pipe")); /* XXX only for non-0 usbd_clear_endpoint_stall(pipe); */ } pipe->aborting = 0; @@ -771,7 +875,8 @@ usb_transfer_complete(usbd_xfer_handle xfer) { usbd_pipe_handle pipe = xfer->pipe; - usb_dma_t *dmap = &xfer->dmabuf; + struct usb_dma_mapping *dmap = &xfer->dmamap; + bus_dma_tag_t tag = pipe->device->bus->buffer_dmatag; int sync = xfer->flags & USBD_SYNCHRONOUS; int erred = xfer->status == USBD_CANCELLED || xfer->status == USBD_TIMEOUT; @@ -801,23 +906,14 @@ if (polling) pipe->running = 0; - if (!(xfer->flags & USBD_NO_COPY) && xfer->actlen != 0 && - usbd_xfer_isread(xfer)) { -#ifdef DIAGNOSTIC - if (xfer->actlen > xfer->length) { - printf("usb_transfer_complete: actlen > len %d > %d\n", - xfer->actlen, xfer->length); - xfer->actlen = xfer->length; - } -#endif - memcpy(xfer->buffer, KERNADDR(dmap, 0), xfer->actlen); - } + if (xfer->actlen != 0 && usbd_xfer_isread(xfer)) + bus_dmamap_sync(tag, dmap->map, BUS_DMASYNC_POSTREAD); - /* if we allocated the buffer in usbd_transfer() we free it here. */ + /* if we mapped the buffer in usbd_transfer() we unmap it here. */ if (xfer->rqflags & URQ_AUTO_DMABUF) { if (!repeat) { - struct usbd_bus *bus = pipe->device->bus; - bus->methods->freem(bus, dmap); + bus_dmamap_unload(tag, dmap->map); + bus_dmamap_destroy(tag, dmap->map); xfer->rqflags &= ~URQ_AUTO_DMABUF; } } @@ -825,11 +921,10 @@ if (!repeat) { /* Remove request from queue. */ #ifdef DIAGNOSTIC - if (xfer != SIMPLEQ_FIRST(&pipe->queue)) - printf("usb_transfer_complete: bad dequeue %p != %p\n", - xfer, SIMPLEQ_FIRST(&pipe->queue)); xfer->busy_free = XFER_BUSY; #endif + KASSERT(SIMPLEQ_FIRST(&pipe->queue) == xfer, + ("usb_transfer_complete: bad dequeue")); SIMPLEQ_REMOVE_HEAD(&pipe->queue, next); } DPRINTFN(5,("usb_transfer_complete: repeat=%d new head=%p\n", @@ -893,6 +988,7 @@ xfer->busy_free = XFER_ONQU; #endif s = splusb(); + KASSERT(SIMPLEQ_FIRST(&pipe->queue) != xfer, ("usb_insert_transfer")); SIMPLEQ_INSERT_TAIL(&pipe->queue, xfer, next); if (pipe->running) err = USBD_IN_PROGRESS; Index: usbdivar.h =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/dev/usb/usbdivar.h,v retrieving revision 1.43 diff -u -r1.43 usbdivar.h --- usbdivar.h 6 Jan 2005 01:43:29 -0000 1.43 +++ usbdivar.h 20 Jan 2006 01:12:29 -0000 @@ -129,7 +129,8 @@ #endif #endif - bus_dma_tag_t dmatag; /* DMA tag */ + bus_dma_tag_t parent_dmatag; /* Base DMA tag */ + bus_dma_tag_t buffer_dmatag; /* Tag for transfer buffers */ }; struct usbd_device { @@ -186,6 +187,15 @@ struct usbd_pipe_methods *methods; }; +#define USB_DMA_NSEG (btoc(MAXPHYS) + 1) + +/* DMA-capable memory buffer. */ +struct usb_dma_mapping { + bus_dma_segment_t segs[USB_DMA_NSEG]; /* The physical segments. */ + int nsegs; /* Number of segments. */ + bus_dmamap_t map; /* DMA mapping. */ +}; + struct usbd_xfer { struct usbd_pipe *pipe; void *priv; @@ -213,7 +223,8 @@ /* For memory allocation */ struct usbd_device *device; - usb_dma_t dmabuf; + struct usb_dma_mapping dmamap; + void *allocbuf; int rqflags; #define URQ_REQUEST 0x01