diff options
Diffstat (limited to 'sys/dev/usb/ohci.c')
| -rw-r--r-- | sys/dev/usb/ohci.c | 1296 |
1 files changed, 851 insertions, 445 deletions
diff --git a/sys/dev/usb/ohci.c b/sys/dev/usb/ohci.c index fcabdb8c26b..d57b51f1d45 100644 --- a/sys/dev/usb/ohci.c +++ b/sys/dev/usb/ohci.c @@ -1,5 +1,5 @@ -/* $OpenBSD: ohci.c,v 1.7 1999/11/07 21:30:19 fgsch Exp $ */ -/* $NetBSD: ohci.c,v 1.48 1999/09/15 21:14:03 augustss Exp $ */ +/* $OpenBSD: ohci.c,v 1.8 2000/03/26 08:39:45 aaron Exp $ */ +/* $NetBSD: ohci.c,v 1.78 2000/03/20 00:37:00 augustss Exp $ */ /* * Copyright (c) 1998 The NetBSD Foundation, Inc. @@ -47,19 +47,22 @@ #include <sys/param.h> #include <sys/systm.h> -#include <sys/kernel.h> #include <sys/malloc.h> #if defined(__NetBSD__) || defined(__OpenBSD__) +#include <sys/kernel.h> #include <sys/device.h> +#include <sys/select.h> #elif defined(__FreeBSD__) #include <sys/module.h> #include <sys/bus.h> #include <machine/bus_pio.h> #include <machine/bus_memio.h> +#if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__) +#include <machine/cpu.h> +#endif #endif #include <sys/proc.h> #include <sys/queue.h> -#include <sys/select.h> #include <machine/bus.h> #include <machine/endian.h> @@ -75,6 +78,7 @@ #if defined(__FreeBSD__) #include <machine/clock.h> + #define delay(d) DELAY(d) #endif @@ -111,64 +115,77 @@ void ohci_free_sed __P((ohci_softc_t *, ohci_soft_ed_t *)); ohci_soft_td_t *ohci_alloc_std __P((ohci_softc_t *)); void ohci_free_std __P((ohci_softc_t *, ohci_soft_td_t *)); +ohci_soft_itd_t *ohci_alloc_sitd __P((ohci_softc_t *)); +void ohci_free_sitd __P((ohci_softc_t *, ohci_soft_itd_t *)); + +#if 0 void ohci_free_std_chain __P((ohci_softc_t *, ohci_soft_td_t *, ohci_soft_td_t *)); +#endif usbd_status ohci_alloc_std_chain __P((struct ohci_pipe *, ohci_softc_t *, - int, int, int, usb_dma_t *, + int, int, usbd_xfer_handle, ohci_soft_td_t *, ohci_soft_td_t **)); +void ohci_shutdown __P((void *v)); void ohci_power __P((int, void *)); usbd_status ohci_open __P((usbd_pipe_handle)); void ohci_poll __P((struct usbd_bus *)); -void ohci_waitintr __P((ohci_softc_t *, usbd_request_handle)); -void ohci_rhsc __P((ohci_softc_t *, usbd_request_handle)); -void ohci_process_done __P((ohci_softc_t *, ohci_physaddr_t)); +void ohci_softintr __P((struct usbd_bus *)); +void ohci_waitintr __P((ohci_softc_t *, usbd_xfer_handle)); +void ohci_rhsc __P((ohci_softc_t *, usbd_xfer_handle)); -usbd_status ohci_device_request __P((usbd_request_handle reqh)); +usbd_status ohci_device_request __P((usbd_xfer_handle xfer)); void ohci_add_ed __P((ohci_soft_ed_t *, ohci_soft_ed_t *)); void ohci_rem_ed __P((ohci_soft_ed_t *, ohci_soft_ed_t *)); void ohci_hash_add_td __P((ohci_softc_t *, ohci_soft_td_t *)); void ohci_hash_rem_td __P((ohci_softc_t *, ohci_soft_td_t *)); ohci_soft_td_t *ohci_hash_find_td __P((ohci_softc_t *, ohci_physaddr_t)); +usbd_status ohci_setup_isoc __P((usbd_pipe_handle pipe)); +void ohci_device_isoc_enter __P((usbd_xfer_handle)); + usbd_status ohci_allocm __P((struct usbd_bus *, usb_dma_t *, u_int32_t)); void ohci_freem __P((struct usbd_bus *, usb_dma_t *)); -usbd_status ohci_root_ctrl_transfer __P((usbd_request_handle)); -usbd_status ohci_root_ctrl_start __P((usbd_request_handle)); -void ohci_root_ctrl_abort __P((usbd_request_handle)); +usbd_xfer_handle ohci_allocx __P((struct usbd_bus *)); +void ohci_freex __P((struct usbd_bus *, usbd_xfer_handle)); + +usbd_status ohci_root_ctrl_transfer __P((usbd_xfer_handle)); +usbd_status ohci_root_ctrl_start __P((usbd_xfer_handle)); +void ohci_root_ctrl_abort __P((usbd_xfer_handle)); void ohci_root_ctrl_close __P((usbd_pipe_handle)); +void ohci_root_ctrl_done __P((usbd_xfer_handle)); -usbd_status ohci_root_intr_transfer __P((usbd_request_handle)); -usbd_status ohci_root_intr_start __P((usbd_request_handle)); -void ohci_root_intr_abort __P((usbd_request_handle)); +usbd_status ohci_root_intr_transfer __P((usbd_xfer_handle)); +usbd_status ohci_root_intr_start __P((usbd_xfer_handle)); +void ohci_root_intr_abort __P((usbd_xfer_handle)); void ohci_root_intr_close __P((usbd_pipe_handle)); -void ohci_root_intr_done __P((usbd_request_handle)); +void ohci_root_intr_done __P((usbd_xfer_handle)); -usbd_status ohci_device_ctrl_transfer __P((usbd_request_handle)); -usbd_status ohci_device_ctrl_start __P((usbd_request_handle)); -void ohci_device_ctrl_abort __P((usbd_request_handle)); +usbd_status ohci_device_ctrl_transfer __P((usbd_xfer_handle)); +usbd_status ohci_device_ctrl_start __P((usbd_xfer_handle)); +void ohci_device_ctrl_abort __P((usbd_xfer_handle)); void ohci_device_ctrl_close __P((usbd_pipe_handle)); -void ohci_device_ctrl_done __P((usbd_request_handle)); +void ohci_device_ctrl_done __P((usbd_xfer_handle)); -usbd_status ohci_device_bulk_transfer __P((usbd_request_handle)); -usbd_status ohci_device_bulk_start __P((usbd_request_handle)); -void ohci_device_bulk_abort __P((usbd_request_handle)); +usbd_status ohci_device_bulk_transfer __P((usbd_xfer_handle)); +usbd_status ohci_device_bulk_start __P((usbd_xfer_handle)); +void ohci_device_bulk_abort __P((usbd_xfer_handle)); void ohci_device_bulk_close __P((usbd_pipe_handle)); -void ohci_device_bulk_done __P((usbd_request_handle)); +void ohci_device_bulk_done __P((usbd_xfer_handle)); -usbd_status ohci_device_intr_transfer __P((usbd_request_handle)); -usbd_status ohci_device_intr_start __P((usbd_request_handle)); -void ohci_device_intr_abort __P((usbd_request_handle)); +usbd_status ohci_device_intr_transfer __P((usbd_xfer_handle)); +usbd_status ohci_device_intr_start __P((usbd_xfer_handle)); +void ohci_device_intr_abort __P((usbd_xfer_handle)); void ohci_device_intr_close __P((usbd_pipe_handle)); -void ohci_device_intr_done __P((usbd_request_handle)); +void ohci_device_intr_done __P((usbd_xfer_handle)); -usbd_status ohci_device_isoc_transfer __P((usbd_request_handle)); -usbd_status ohci_device_isoc_start __P((usbd_request_handle)); -void ohci_device_isoc_abort __P((usbd_request_handle)); +usbd_status ohci_device_isoc_transfer __P((usbd_xfer_handle)); +usbd_status ohci_device_isoc_start __P((usbd_xfer_handle)); +void ohci_device_isoc_abort __P((usbd_xfer_handle)); void ohci_device_isoc_close __P((usbd_pipe_handle)); -void ohci_device_isoc_done __P((usbd_request_handle)); +void ohci_device_isoc_done __P((usbd_xfer_handle)); usbd_status ohci_device_setintr __P((ohci_softc_t *sc, struct ohci_pipe *pipe, int ival)); @@ -180,15 +197,14 @@ void ohci_rhsc_able __P((ohci_softc_t *, int)); void ohci_close_pipe __P((usbd_pipe_handle pipe, ohci_soft_ed_t *head)); -void ohci_abort_req __P((usbd_request_handle reqh, +void ohci_abort_xfer __P((usbd_xfer_handle xfer, usbd_status status)); -void ohci_abort_req_end __P((void *)); +void ohci_abort_xfer_end __P((void *)); void ohci_device_clear_toggle __P((usbd_pipe_handle pipe)); void ohci_noop __P((usbd_pipe_handle pipe)); #ifdef OHCI_DEBUG -ohci_softc_t *thesc; void ohci_dumpregs __P((ohci_softc_t *)); void ohci_dump_tds __P((ohci_soft_td_t *)); void ohci_dump_td __P((ohci_soft_td_t *)); @@ -209,7 +225,10 @@ static u_int8_t revbits[OHCI_NO_INTRS] = struct ohci_pipe { struct usbd_pipe pipe; ohci_soft_ed_t *sed; - ohci_soft_td_t *tail; + union { + ohci_soft_td_t *td; + ohci_soft_itd_t *itd; + } tail; /* Info needed for different pipe kinds. */ union { /* Control pipe */ @@ -231,6 +250,7 @@ struct ohci_pipe { /* Iso pipe */ struct iso { int xxxxx; + int next, inuse; } iso; } u; }; @@ -239,9 +259,12 @@ struct ohci_pipe { struct usbd_bus_methods ohci_bus_methods = { ohci_open, + ohci_softintr, ohci_poll, ohci_allocm, ohci_freem, + ohci_allocx, + ohci_freex, }; struct usbd_pipe_methods ohci_root_ctrl_methods = { @@ -250,7 +273,7 @@ struct usbd_pipe_methods ohci_root_ctrl_methods = { ohci_root_ctrl_abort, ohci_root_ctrl_close, ohci_noop, - 0, + ohci_root_ctrl_done, }; struct usbd_pipe_methods ohci_root_intr_methods = { @@ -289,7 +312,6 @@ struct usbd_pipe_methods ohci_device_bulk_methods = { ohci_device_bulk_done, }; -#if 0 struct usbd_pipe_methods ohci_device_isoc_methods = { ohci_device_isoc_transfer, ohci_device_isoc_start, @@ -298,8 +320,8 @@ struct usbd_pipe_methods ohci_device_isoc_methods = { ohci_noop, ohci_device_isoc_done, }; -#endif +#if defined(__NetBSD__) || defined(__OpenBSD__) int ohci_activate(self, act) device_ptr_t self; @@ -335,25 +357,28 @@ ohci_detach(sc, flags) return (rv); powerhook_disestablish(sc->sc_powerhook); + shutdownhook_disestablish(sc->sc_shutdownhook); + /* free data structures XXX */ return (rv); } +#endif ohci_soft_ed_t * ohci_alloc_sed(sc) ohci_softc_t *sc; { ohci_soft_ed_t *sed; - usbd_status r; + usbd_status err; int i, offs; usb_dma_t dma; - if (!sc->sc_freeeds) { + if (sc->sc_freeeds == NULL) { DPRINTFN(2, ("ohci_alloc_sed: allocating chunk\n")); - r = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK, + err = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK, OHCI_ED_ALIGN, &dma); - if (r != USBD_NORMAL_COMPLETION) + if (err) return (0); for(i = 0; i < OHCI_SED_CHUNK; i++) { offs = i * OHCI_SED_SIZE; @@ -384,16 +409,18 @@ ohci_alloc_std(sc) ohci_softc_t *sc; { ohci_soft_td_t *std; - usbd_status r; + usbd_status err; int i, offs; usb_dma_t dma; + int s; - if (!sc->sc_freetds) { + if (sc->sc_freetds == NULL) { DPRINTFN(2, ("ohci_alloc_std: allocating chunk\n")); - r = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK, + err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK, OHCI_TD_ALIGN, &dma); - if (r != USBD_NORMAL_COMPLETION) + if (err) return (0); + s = splusb(); for(i = 0; i < OHCI_STD_CHUNK; i++) { offs = i * OHCI_STD_SIZE; std = (ohci_soft_td_t *)((char *)KERNADDR(&dma) +offs); @@ -401,11 +428,18 @@ ohci_alloc_std(sc) std->nexttd = sc->sc_freetds; sc->sc_freetds = std; } + splx(s); } + + s = splusb(); std = sc->sc_freetds; sc->sc_freetds = std->nexttd; memset(&std->td, 0, sizeof(ohci_td_t)); std->nexttd = 0; + + ohci_hash_add_td(sc, std); + splx(s); + return (std); } @@ -414,33 +448,46 @@ ohci_free_std(sc, std) ohci_softc_t *sc; ohci_soft_td_t *std; { + int s; + + s = splusb(); + ohci_hash_rem_td(sc, std); + std->nexttd = sc->sc_freetds; sc->sc_freetds = std; + splx(s); } usbd_status -ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep) - struct ohci_pipe *upipe; +ohci_alloc_std_chain(opipe, sc, alen, rd, xfer, sp, ep) + struct ohci_pipe *opipe; ohci_softc_t *sc; - int len, rd, shortok; - usb_dma_t *dma; + int alen, rd; + usbd_xfer_handle xfer; ohci_soft_td_t *sp, **ep; { ohci_soft_td_t *next, *cur; ohci_physaddr_t dataphys, dataphysend; - u_int32_t intr; - int curlen; + u_int32_t tdflags; + int len, curlen; + usb_dma_t *dma = &xfer->dmabuf; + u_int16_t flags = xfer->flags; - DPRINTFN(len >= 4096,("ohci_alloc_std_chain: start len=%d\n", len)); + DPRINTFN(alen < 4096,("ohci_alloc_std_chain: start len=%d\n", alen)); + + len = alen; cur = sp; dataphys = DMAADDR(dma); dataphysend = OHCI_PAGE(dataphys + len - 1); + tdflags = LE( + (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_NOINTR); + for (;;) { next = ohci_alloc_std(sc); - if (next == 0) { - /* XXX free chain */ - return (USBD_NOMEM); - } + if (next == NULL) + goto nomem; /* The OHCI hardware can handle at most one page crossing. */ if (OHCI_PAGE(dataphys) == dataphysend || @@ -451,6 +498,12 @@ ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep) /* must use multiple TDs, fill as much as possible. */ curlen = 2 * OHCI_PAGE_SIZE - (dataphys & (OHCI_PAGE_SIZE-1)); + /* 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\n"); +#endif } DPRINTFN(4,("ohci_alloc_std_chain: dataphys=0x%08x " "dataphysend=0x%08x len=%d curlen=%d\n", @@ -458,17 +511,14 @@ ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep) len, curlen)); len -= curlen; - intr = len == 0 ? OHCI_TD_SET_DI(1) : OHCI_TD_NOINTR; - cur->td.td_flags = LE( - (rd ? OHCI_TD_IN : OHCI_TD_OUT) | OHCI_TD_NOCC | - intr | OHCI_TD_TOGGLE_CARRY | - (shortok ? OHCI_TD_R : 0)); + cur->td.td_flags = tdflags; cur->td.td_cbp = LE(dataphys); cur->nexttd = next; cur->td.td_nexttd = LE(next->physaddr); cur->td.td_be = LE(dataphys + 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) @@ -477,12 +527,35 @@ ohci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep) dataphys += curlen; cur = next; } - cur->flags = OHCI_CALL_DONE | OHCI_ADD_LEN; - *ep = next; + if ((flags & USBD_FORCE_SHORT_XFER) && + alen % UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize) == 0) { + /* Force a 0 length transfer at the end. */ + + cur = next; + next = ohci_alloc_std(sc); + if (next == NULL) + goto nomem; + + cur->td.td_flags = tdflags; + cur->td.td_cbp = 0; /* indicate 0 length packet */ + cur->nexttd = next; + cur->td.td_nexttd = LE(next->physaddr); + cur->td.td_be = ~0; + cur->len = 0; + cur->flags = 0; + cur->xfer = xfer; + DPRINTFN(2,("ohci_alloc_std_chain: add 0 xfer\n")); + } + *ep = cur; return (USBD_NORMAL_COMPLETION); + +nomem: + /* XXX free chain */ + return (USBD_NOMEM); } +#if 0 void ohci_free_std_chain(sc, std, stdend) ohci_softc_t *sc; @@ -496,84 +569,131 @@ ohci_free_std_chain(sc, std, stdend) ohci_free_std(sc, std); } } +#endif + +ohci_soft_itd_t * +ohci_alloc_sitd(sc) + ohci_softc_t *sc; +{ + ohci_soft_itd_t *sitd; + usbd_status err; + int i, offs; + usb_dma_t dma; + + if (sc->sc_freeitds == NULL) { + DPRINTFN(2, ("ohci_alloc_sitd: allocating chunk\n")); + err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK, + OHCI_TD_ALIGN, &dma); + if (err) + return (0); + for (i = 0; i < OHCI_STD_CHUNK; i++) { + offs = i * OHCI_STD_SIZE; + sitd = (ohci_soft_itd_t *)((char*)KERNADDR(&dma)+offs); + sitd->physaddr = DMAADDR(&dma) + offs; + sitd->nextitd = sc->sc_freeitds; + sc->sc_freeitds = sitd; + } + } + sitd = sc->sc_freeitds; + sc->sc_freeitds = sitd->nextitd; + memset(&sitd->itd, 0, sizeof(ohci_itd_t)); + sitd->nextitd = 0; + return (sitd); +} + +void +ohci_free_sitd(sc, sitd) + ohci_softc_t *sc; + ohci_soft_itd_t *sitd; +{ + sitd->nextitd = sc->sc_freeitds; + sc->sc_freeitds = sitd; +} usbd_status ohci_init(sc) ohci_softc_t *sc; { ohci_soft_ed_t *sed, *psed; - usbd_status r; - int rev; + usbd_status err; int i; - u_int32_t s, ctl, ival, hcr, fm, per; + u_int32_t s, ctl, ival, hcr, fm, per, rev, desca; DPRINTF(("ohci_init: start\n")); - rev = OREAD4(sc, OHCI_REVISION); #if defined(__OpenBSD__) - printf(" version %d.%d%s", + printf(","); #else - printf("%s: OHCI version %d.%d%s\n", USBDEVNAME(sc->sc_bus.bdev), + printf("%s:", USBDEVNAME(sc->sc_bus.bdev)); #endif - OHCI_REV_HI(rev), OHCI_REV_LO(rev), + rev = OREAD4(sc, OHCI_REVISION); + printf(" OHCI version %d.%d%s\n", OHCI_REV_HI(rev), OHCI_REV_LO(rev), OHCI_REV_LEGACY(rev) ? ", legacy support" : ""); if (OHCI_REV_HI(rev) != 1 || OHCI_REV_LO(rev) != 0) { -#if defined(__OpenBSD__) - printf(": unsupported\n"); -#else printf("%s: unsupported OHCI revision\n", USBDEVNAME(sc->sc_bus.bdev)); -#endif + sc->sc_bus.usbrev = USBREV_UNKNOWN; return (USBD_INVAL); -#if defined(__OpenBSD__) - } else { - printf("\n"); -#endif } + sc->sc_bus.usbrev = USBREV_1_0; for (i = 0; i < OHCI_HASH_SIZE; i++) LIST_INIT(&sc->sc_hash_tds[i]); + SIMPLEQ_INIT(&sc->sc_free_xfers); + + /* XXX determine alignment by R/W */ /* Allocate the HCCA area. */ - r = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE, + err = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE, OHCI_HCCA_ALIGN, &sc->sc_hccadma); - if (r != USBD_NORMAL_COMPLETION) - return (r); + if (err) + return (err); sc->sc_hcca = (struct ohci_hcca *)KERNADDR(&sc->sc_hccadma); memset(sc->sc_hcca, 0, OHCI_HCCA_SIZE); sc->sc_eintrs = OHCI_NORMAL_INTRS; + /* Allocate dummy ED that starts the control list. */ sc->sc_ctrl_head = ohci_alloc_sed(sc); - if (!sc->sc_ctrl_head) { - r = USBD_NOMEM; + if (sc->sc_ctrl_head == NULL) { + err = USBD_NOMEM; goto bad1; } sc->sc_ctrl_head->ed.ed_flags |= LE(OHCI_ED_SKIP); + /* Allocate dummy ED that starts the bulk list. */ sc->sc_bulk_head = ohci_alloc_sed(sc); - if (!sc->sc_bulk_head) { - r = USBD_NOMEM; + if (sc->sc_bulk_head == NULL) { + err = USBD_NOMEM; goto bad2; } sc->sc_bulk_head->ed.ed_flags |= LE(OHCI_ED_SKIP); + /* Allocate dummy ED that starts the isochronous list. */ + sc->sc_isoc_head = ohci_alloc_sed(sc); + if (sc->sc_isoc_head == NULL) { + err = USBD_NOMEM; + goto bad3; + } + sc->sc_isoc_head->ed.ed_flags |= LE(OHCI_ED_SKIP); + /* Allocate all the dummy EDs that make up the interrupt tree. */ for (i = 0; i < OHCI_NO_EDS; i++) { sed = ohci_alloc_sed(sc); - if (!sed) { + if (sed == NULL) { while (--i >= 0) ohci_free_sed(sc, sc->sc_eds[i]); - r = USBD_NOMEM; - goto bad3; + err = USBD_NOMEM; + goto bad4; } /* All ED fields are set to 0. */ sc->sc_eds[i] = sed; sed->ed.ed_flags |= LE(OHCI_ED_SKIP); - if (i != 0) { + if (i != 0) psed = sc->sc_eds[(i-1) / 2]; - sed->next = psed; - sed->ed.ed_nexted = LE(psed->physaddr); - } + else + psed = sc->sc_isoc_head; + sed->next = psed; + sed->ed.ed_nexted = LE(psed->physaddr); } /* * Fill HCCA interrupt table. The bit reversal is to get @@ -583,6 +703,17 @@ ohci_init(sc) sc->sc_hcca->hcca_interrupt_table[revbits[i]] = LE(sc->sc_eds[OHCI_NO_EDS-OHCI_NO_INTRS+i]->physaddr); +#ifdef OHCI_DEBUG + if (ohcidebug > 15) { + for (i = 0; i < OHCI_NO_EDS; i++) { + printf("ed#%d ", i); + ohci_dump_ed(sc->sc_eds[i]); + } + printf("iso "); + ohci_dump_ed(sc->sc_isoc_head); + } +#endif + /* Determine in what context we are running. */ ctl = OREAD4(sc, OHCI_CONTROL); if (ctl & OHCI_IR) { @@ -591,7 +722,7 @@ ohci_init(sc) s = OREAD4(sc, OHCI_COMMAND_STATUS); OWRITE4(sc, OHCI_COMMAND_STATUS, s | OHCI_OCR); for (i = 0; i < 100 && (ctl & OHCI_IR); i++) { - delay(1000); + usb_delay_ms(&sc->sc_bus, 1); ctl = OREAD4(sc, OHCI_CONTROL); } if ((ctl & OHCI_IR) == 0) { @@ -605,13 +736,13 @@ ohci_init(sc) DPRINTF(("ohci_init: BIOS active\n")); if ((ctl & OHCI_HCFS_MASK) != OHCI_HCFS_OPERATIONAL) { OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_OPERATIONAL); - delay(USB_RESUME_DELAY * 1000); + usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY); } } else { DPRINTF(("ohci_init: cold started\n")); reset: /* Controller was cold started. */ - delay(USB_BUS_RESET_DELAY * 1000); + usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); } /* @@ -620,7 +751,7 @@ ohci_init(sc) */ DPRINTF(("%s: resetting\n", USBDEVNAME(sc->sc_bus.bdev))); OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET); - delay(USB_BUS_RESET_DELAY * 1000); + usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); /* We now own the host controller and the bus has been reset. */ ival = OHCI_GET_IVAL(OREAD4(sc, OHCI_FM_INTERVAL)); @@ -635,23 +766,24 @@ ohci_init(sc) } if (hcr) { printf("%s: reset timeout\n", USBDEVNAME(sc->sc_bus.bdev)); - r = USBD_IOERROR; - goto bad3; + err = USBD_IOERROR; + goto bad5; } #ifdef OHCI_DEBUG - thesc = sc; if (ohcidebug > 15) ohci_dumpregs(sc); #endif - /* The controller is now in suspend state, we have 2ms to finish. */ + /* The controller is now in SUSPEND state, we have 2ms to finish. */ /* Set up HC registers. */ OWRITE4(sc, OHCI_HCCA, DMAADDR(&sc->sc_hccadma)); OWRITE4(sc, OHCI_CONTROL_HEAD_ED, sc->sc_ctrl_head->physaddr); OWRITE4(sc, OHCI_BULK_HEAD_ED, sc->sc_bulk_head->physaddr); + /* disable all interrupts and then switch on all desired interrupts */ OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS); OWRITE4(sc, OHCI_INTERRUPT_ENABLE, sc->sc_eintrs | OHCI_MIE); + /* switch on desired functional features */ ctl = OREAD4(sc, OHCI_CONTROL); ctl &= ~(OHCI_CBSR_MASK | OHCI_LES | OHCI_HCFS_MASK | OHCI_IR); ctl |= OHCI_PLE | OHCI_IE | OHCI_CLE | OHCI_BLE | @@ -670,7 +802,12 @@ ohci_init(sc) per = OHCI_PERIODIC(ival); /* 90% periodic */ OWRITE4(sc, OHCI_PERIODIC_START, per); - OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC); /* Enable port power */ + /* Fiddle the No OverCurrent Protection bit to avoid chip bug. */ + desca = OREAD4(sc, OHCI_RH_DESCRIPTOR_A); + OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca | OHCI_NOCP); + OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC); /* Enable port power */ + usb_delay_ms(&sc->sc_bus, 5); + OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca); sc->sc_noport = OHCI_GET_NDP(OREAD4(sc, OHCI_RH_DESCRIPTOR_A)); @@ -684,16 +821,22 @@ ohci_init(sc) sc->sc_bus.pipe_size = sizeof(struct ohci_pipe); sc->sc_powerhook = powerhook_establish(ohci_power, sc); + sc->sc_shutdownhook = shutdownhook_establish(ohci_shutdown, sc); return (USBD_NORMAL_COMPLETION); + bad5: + for (i = 0; i < OHCI_NO_EDS; i++) + ohci_free_sed(sc, sc->sc_eds[i]); + bad4: + ohci_free_sed(sc, sc->sc_isoc_head); bad3: ohci_free_sed(sc, sc->sc_ctrl_head); bad2: ohci_free_sed(sc, sc->sc_bulk_head); bad1: usb_freemem(&sc->sc_bus, &sc->sc_hccadma); - return (r); + return (err); } usbd_status @@ -721,7 +864,49 @@ ohci_freem(bus, dma) usb_freemem(&sc->sc_bus, dma); } -#if defined(__NetBSD__) || defined(__OpenBSD__) +usbd_xfer_handle +ohci_allocx(bus) + struct usbd_bus *bus; +{ + struct ohci_softc *sc = (struct ohci_softc *)bus; + usbd_xfer_handle xfer; + + xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers); + if (xfer != NULL) + SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, xfer, next); + else + xfer = malloc(sizeof(*xfer), M_USB, M_NOWAIT); + if (xfer != NULL) + memset(xfer, 0, sizeof *xfer); + return (xfer); +} + +void ohci_freex(bus, xfer) + struct usbd_bus *bus; + usbd_xfer_handle xfer; +{ + struct ohci_softc *sc = (struct ohci_softc *)bus; + + SIMPLEQ_INSERT_HEAD(&sc->sc_free_xfers, xfer, next); +} + +void +ohci_shutdown(v) + void *v; +{ + ohci_softc_t *sc = v; + + DPRINTF(("ohci_shutdown: stopping the HC\n")); + OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET); +} + +/* + * Handle suspend/resume. + * + * We need to switch to polling mode here, because this routine is + * called from an interrupt context. This is all right since we + * are almost suspended anyway. + */ void ohci_power(why, v) int why; @@ -735,12 +920,8 @@ ohci_power(why, v) ohci_dumpregs(sc); #endif } -#endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ #ifdef OHCI_DEBUG -void ohcidump(void); -void ohcidump(void) { ohci_dumpregs(thesc); } - void ohci_dumpregs(sc) ohci_softc_t *sc; @@ -782,11 +963,29 @@ ohci_dumpregs(sc) } #endif +int ohci_intr1 __P((ohci_softc_t *)); + int ohci_intr(p) void *p; { ohci_softc_t *sc = p; + + /* If we get an interrupt while polling, then just ignore it. */ + if (sc->sc_bus.use_polling) { +#ifdef DIAGNOSTIC + printf("ohci_intr: ignored interrupt while polling\n"); +#endif + return (0); + } + + return (ohci_intr1(sc)); +} + +int +ohci_intr1(sc) + ohci_softc_t *sc; +{ u_int32_t intrs, eintrs; ohci_physaddr_t done; @@ -808,8 +1007,10 @@ ohci_intr(p) intrs |= OREAD4(sc, OHCI_INTERRUPT_STATUS); } else intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS); + if (!intrs) return (0); + intrs &= ~OHCI_MIE; OWRITE4(sc, OHCI_INTERRUPT_STATUS, intrs); /* Acknowledge */ eintrs = intrs & sc->sc_eintrs; @@ -818,7 +1019,7 @@ ohci_intr(p) sc->sc_bus.intr_context++; sc->sc_bus.no_intrs++; - DPRINTFN(7, ("ohci_intr: sc=%p intrs=%x(%x) eintr=%x\n", + DPRINTFN(7, ("ohci_intr: sc=%p intrs=0x%x(0x%x) eintr=0x%x\n", sc, (u_int)intrs, OREAD4(sc, OHCI_INTERRUPT_STATUS), (u_int)eintrs)); @@ -828,7 +1029,21 @@ ohci_intr(p) intrs &= ~OHCI_SO; } if (eintrs & OHCI_WDH) { - ohci_process_done(sc, done &~ OHCI_DONE_INTRS); + done &= ~OHCI_DONE_INTRS; + if (sc->sc_done == 0) + sc->sc_done = done; + else { + /* Tack on at end of the sc_dne. */ + ohci_physaddr_t ldone; + ohci_soft_td_t *std; + + for (ldone = sc->sc_done; ldone != 0; + ldone = LE(std->td.td_nexttd)) + std = ohci_hash_find_td(sc, ldone); + std->td.td_nexttd = LE(done); + } + sc->sc_hcca->hcca_done_head = 0; + usb_schedsoftintr(&sc->sc_bus); intrs &= ~OHCI_WDH; } if (eintrs & OHCI_RD) { @@ -842,7 +1057,7 @@ ohci_intr(p) /* XXX what else */ } if (eintrs & OHCI_RHSC) { - ohci_rhsc(sc, sc->sc_intrreqh); + ohci_rhsc(sc, sc->sc_intrxfer); intrs &= ~OHCI_RHSC; /* @@ -890,23 +1105,34 @@ char *ohci_cc_strs[] = { "DATA_UNDERRUN", "BUFFER_OVERRUN", "BUFFER_UNDERRUN", + "reserved", + "reserved", + "NOT ACCESSED", "NOT_ACCESSED", }; #endif void -ohci_process_done(sc, done) - ohci_softc_t *sc; - ohci_physaddr_t done; +ohci_softintr(bus) + struct usbd_bus *bus; { + ohci_softc_t *sc = (ohci_softc_t *)bus; + ohci_physaddr_t done; ohci_soft_td_t *std, *sdone, *stdnext; - usbd_request_handle reqh; - int len, cc; + usbd_xfer_handle xfer; + int len, cc, s; + + sc->sc_bus.intr_context++; + + s = splhardusb(); + done = sc->sc_done; + sc->sc_done = 0; + splx(s); DPRINTFN(10,("ohci_process_done: done=0x%08lx\n", (u_long)done)); /* Reverse the done list. */ - for (sdone = 0; done; done = LE(std->td.td_nexttd)) { + for (sdone = NULL; done != 0; done = LE(std->td.td_nexttd)) { std = ohci_hash_find_td(sc, done); std->dnext = sdone; sdone = std; @@ -920,29 +1146,30 @@ ohci_process_done(sc, done) #endif for (std = sdone; std; std = stdnext) { - reqh = std->reqh; + xfer = std->xfer; stdnext = std->dnext; - DPRINTFN(10, ("ohci_process_done: std=%p reqh=%p hcpriv=%p\n", - std, reqh, reqh->hcpriv)); + DPRINTFN(10, ("ohci_process_done: std=%p xfer=%p hcpriv=%p\n", + std, xfer, xfer ? xfer->hcpriv : 0)); cc = OHCI_TD_GET_CC(LE(std->td.td_flags)); - usb_untimeout(ohci_timeout, reqh, reqh->timo_handle); - if (reqh->status == USBD_CANCELLED || - reqh->status == USBD_TIMEOUT) { + usb_untimeout(ohci_timeout, xfer, xfer->timo_handle); + if (xfer->status == USBD_CANCELLED || + xfer->status == USBD_TIMEOUT) { DPRINTF(("ohci_process_done: cancel/timeout %p\n", - reqh)); + xfer)); /* Handled by abort routine. */ } else if (cc == OHCI_CC_NO_ERROR) { len = std->len; if (std->td.td_cbp != 0) len -= LE(std->td.td_be) - LE(std->td.td_cbp) + 1; + DPRINTFN(10, ("ohci_process_done: len=%d, flags=0x%x\n", + len, std->flags)); if (std->flags & OHCI_ADD_LEN) - reqh->actlen += len; + xfer->actlen += len; if (std->flags & OHCI_CALL_DONE) { - reqh->status = USBD_NORMAL_COMPLETION; - usb_transfer_complete(reqh); + xfer->status = USBD_NORMAL_COMPLETION; + usb_transfer_complete(xfer); } - ohci_hash_rem_td(sc, std); ohci_free_std(sc, std); } else { /* @@ -952,16 +1179,15 @@ ohci_process_done(sc, done) */ ohci_soft_td_t *p, *n; struct ohci_pipe *opipe = - (struct ohci_pipe *)reqh->pipe; + (struct ohci_pipe *)xfer->pipe; - DPRINTFN(-1,("ohci_process_done: error cc=%d (%s)\n", + DPRINTF(("ohci_process_done: error cc=%d (%s)\n", OHCI_TD_GET_CC(LE(std->td.td_flags)), ohci_cc_strs[OHCI_TD_GET_CC(LE(std->td.td_flags))])); /* remove TDs */ - for (p = std; p->reqh == reqh; p = n) { + for (p = std; p->xfer == xfer; p = n) { n = p->nexttd; - ohci_hash_rem_td(sc, p); ohci_free_std(sc, p); } @@ -970,87 +1196,87 @@ ohci_process_done(sc, done) OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF); if (cc == OHCI_CC_STALL) - reqh->status = USBD_STALLED; + xfer->status = USBD_STALLED; else - reqh->status = USBD_IOERROR; - usb_transfer_complete(reqh); + xfer->status = USBD_IOERROR; + usb_transfer_complete(xfer); } } + + sc->sc_bus.intr_context--; } void -ohci_device_ctrl_done(reqh) - usbd_request_handle reqh; +ohci_device_ctrl_done(xfer) + usbd_xfer_handle xfer; { - DPRINTFN(10,("ohci_ctrl_done: reqh=%p\n", reqh)); + DPRINTFN(10,("ohci_ctrl_done: xfer=%p\n", xfer)); #ifdef DIAGNOSTIC - if (!(reqh->rqflags & URQ_REQUEST)) { + if (!(xfer->rqflags & URQ_REQUEST)) { panic("ohci_ctrl_done: not a request\n"); } #endif - reqh->hcpriv = 0; + xfer->hcpriv = NULL; } void -ohci_device_intr_done(reqh) - usbd_request_handle reqh; +ohci_device_intr_done(xfer) + usbd_xfer_handle xfer; { - struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe; + struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe; ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus; ohci_soft_ed_t *sed = opipe->sed; ohci_soft_td_t *data, *tail; + DPRINTFN(10,("ohci_intr_done: xfer=%p, actlen=%d\n", + xfer, xfer->actlen)); - DPRINTFN(10,("ohci_intr_done: reqh=%p, actlen=%d\n", - reqh, reqh->actlen)); + xfer->hcpriv = NULL; - reqh->hcpriv = 0; - - if (reqh->pipe->repeat) { - data = opipe->tail; + if (xfer->pipe->repeat) { + data = opipe->tail.td; tail = ohci_alloc_std(sc); /* XXX should reuse TD */ - if (!tail) { - reqh->status = USBD_NOMEM; + if (tail == NULL) { + xfer->status = USBD_NOMEM; return; } - tail->reqh = 0; + tail->xfer = NULL; data->td.td_flags = LE( OHCI_TD_IN | OHCI_TD_NOCC | OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY); - if (reqh->flags & USBD_SHORT_XFER_OK) + if (xfer->flags & USBD_SHORT_XFER_OK) data->td.td_flags |= LE(OHCI_TD_R); - data->td.td_cbp = LE(DMAADDR(&reqh->dmabuf)); + data->td.td_cbp = LE(DMAADDR(&xfer->dmabuf)); data->nexttd = tail; data->td.td_nexttd = LE(tail->physaddr); - data->td.td_be = LE(LE(data->td.td_cbp) + reqh->length - 1); - data->len = reqh->length; - data->reqh = reqh; + data->td.td_be = LE(LE(data->td.td_cbp) + xfer->length - 1); + data->len = xfer->length; + data->xfer = xfer; data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN; - reqh->hcpriv = data; - reqh->actlen = 0; + xfer->hcpriv = data; + xfer->actlen = 0; - ohci_hash_add_td(sc, data); sed->ed.ed_tailp = LE(tail->physaddr); - opipe->tail = tail; + opipe->tail.td = tail; } } void -ohci_device_bulk_done(reqh) - usbd_request_handle reqh; +ohci_device_bulk_done(xfer) + usbd_xfer_handle xfer; { - DPRINTFN(10,("ohci_bulk_done: reqh=%p, actlen=%d\n", - reqh, reqh->actlen)); + DPRINTFN(10,("ohci_bulk_done: xfer=%p, actlen=%d\n", + xfer, xfer->actlen)); - reqh->hcpriv = 0; + xfer->hcpriv = 0; } void -ohci_rhsc(sc, reqh) +ohci_rhsc(sc, xfer) ohci_softc_t *sc; - usbd_request_handle reqh; + usbd_xfer_handle xfer; { usbd_pipe_handle pipe; struct ohci_pipe *opipe; @@ -1059,36 +1285,43 @@ ohci_rhsc(sc, reqh) int hstatus; hstatus = OREAD4(sc, OHCI_RH_STATUS); - DPRINTF(("ohci_rhsc: sc=%p reqh=%p hstatus=0x%08x\n", - sc, reqh, hstatus)); + DPRINTF(("ohci_rhsc: sc=%p xfer=%p hstatus=0x%08x\n", + sc, xfer, hstatus)); - if (reqh == 0) { + if (xfer == 0) { /* Just ignore the change. */ return; } - pipe = reqh->pipe; + pipe = xfer->pipe; opipe = (struct ohci_pipe *)pipe; - p = KERNADDR(&reqh->dmabuf); - m = min(sc->sc_noport, reqh->length * 8 - 1); - memset(p, 0, reqh->length); + p = KERNADDR(&xfer->dmabuf); + m = min(sc->sc_noport, xfer->length * 8 - 1); + memset(p, 0, xfer->length); for (i = 1; i <= m; i++) { if (OREAD4(sc, OHCI_RH_PORT_STATUS(i)) >> 16) p[i/8] |= 1 << (i%8); } DPRINTF(("ohci_rhsc: change=0x%02x\n", *p)); - reqh->actlen = reqh->length; - reqh->status = USBD_NORMAL_COMPLETION; + xfer->actlen = xfer->length; + xfer->status = USBD_NORMAL_COMPLETION; + + usb_transfer_complete(xfer); +} - usb_transfer_complete(reqh); +void +ohci_root_intr_done(xfer) + usbd_xfer_handle xfer; +{ + xfer->hcpriv = NULL; } void -ohci_root_intr_done(reqh) - usbd_request_handle reqh; +ohci_root_ctrl_done(xfer) + usbd_xfer_handle xfer; { - reqh->hcpriv = 0; + xfer->hcpriv = NULL; } /* @@ -1097,15 +1330,15 @@ ohci_root_intr_done(reqh) * too long. */ void -ohci_waitintr(sc, reqh) +ohci_waitintr(sc, xfer) ohci_softc_t *sc; - usbd_request_handle reqh; + usbd_xfer_handle xfer; { - int timo = reqh->timeout; + int timo = xfer->timeout; int usecs; u_int32_t intrs; - reqh->status = USBD_IN_PROGRESS; + xfer->status = USBD_IN_PROGRESS; for (usecs = timo * 1000000 / hz; usecs > 0; usecs -= 1000) { usb_delay_ms(&sc->sc_bus, 1); intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs; @@ -1115,16 +1348,16 @@ ohci_waitintr(sc, reqh) ohci_dumpregs(sc); #endif if (intrs) { - ohci_intr(sc); - if (reqh->status != USBD_IN_PROGRESS) + ohci_intr1(sc); + if (xfer->status != USBD_IN_PROGRESS) return; } } /* Timeout */ DPRINTF(("ohci_waitintr: timeout\n")); - reqh->status = USBD_TIMEOUT; - usb_transfer_complete(reqh); + xfer->status = USBD_TIMEOUT; + usb_transfer_complete(xfer); /* XXX should free TD */ } @@ -1135,23 +1368,23 @@ ohci_poll(bus) ohci_softc_t *sc = (ohci_softc_t *)bus; if (OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs) - ohci_intr(sc); + ohci_intr1(sc); } usbd_status -ohci_device_request(reqh) - usbd_request_handle reqh; +ohci_device_request(xfer) + usbd_xfer_handle xfer; { - struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe; - usb_device_request_t *req = &reqh->request; + struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe; + usb_device_request_t *req = &xfer->request; usbd_device_handle dev = opipe->pipe.device; ohci_softc_t *sc = (ohci_softc_t *)dev->bus; int addr = dev->address; - ohci_soft_td_t *setup, *data = 0, *stat, *next, *tail; + ohci_soft_td_t *setup, *stat, *next, *tail; ohci_soft_ed_t *sed; int isread; int len; - usbd_status r; + usbd_status err; int s; isread = req->bmRequestType & UT_READ; @@ -1163,54 +1396,44 @@ ohci_device_request(reqh) UGETW(req->wIndex), len, addr, opipe->pipe.endpoint->edesc->bEndpointAddress)); - setup = opipe->tail; + setup = opipe->tail.td; stat = ohci_alloc_std(sc); - if (!stat) { - r = USBD_NOMEM; + if (stat == NULL) { + err = USBD_NOMEM; goto bad1; } tail = ohci_alloc_std(sc); - if (!tail) { - r = USBD_NOMEM; + if (tail == NULL) { + err = USBD_NOMEM; goto bad2; } - tail->reqh = 0; + tail->xfer = NULL; sed = opipe->sed; opipe->u.ctl.length = len; /* Update device address and length since they may have changed. */ /* XXX This only needs to be done once, but it's too early in open. */ + /* XXXX Should not touch ED here! */ sed->ed.ed_flags = LE( (LE(sed->ed.ed_flags) & ~(OHCI_ED_ADDRMASK | OHCI_ED_MAXPMASK)) | OHCI_ED_SET_FA(addr) | OHCI_ED_SET_MAXP(UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize))); + next = stat; + /* Set up data transaction */ if (len != 0) { - data = ohci_alloc_std(sc); - if (!data) { - r = USBD_NOMEM; + ohci_soft_td_t *std = stat; + + err = ohci_alloc_std_chain(opipe, sc, len, isread, xfer, + std, &stat); + stat = stat->nexttd; /* point at free TD */ + if (err) goto bad3; - } - data->td.td_flags = LE( - (isread ? OHCI_TD_IN : OHCI_TD_OUT) | OHCI_TD_NOCC | - OHCI_TD_TOGGLE_1 | OHCI_TD_NOINTR | - (reqh->flags & USBD_SHORT_XFER_OK ? OHCI_TD_R : 0)); - data->td.td_cbp = LE(DMAADDR(&reqh->dmabuf)); - data->nexttd = stat; - data->td.td_nexttd = LE(stat->physaddr); - data->td.td_be = LE(LE(data->td.td_cbp) + len - 1); - data->len = len; - data->reqh = reqh; - data->flags = OHCI_ADD_LEN; - - next = data; - stat->flags = OHCI_CALL_DONE; - } else { - next = stat; - /* XXX ADD_LEN? */ - stat->flags = OHCI_CALL_DONE | OHCI_ADD_LEN; + /* Start toggle at 1 and then use the carried toggle. */ + std->td.td_flags &= LE(~OHCI_TD_TOGGLE_MASK); + std->td.td_flags |= LE(OHCI_TD_TOGGLE_1); } memcpy(KERNADDR(&opipe->u.ctl.reqdma), req, sizeof *req); @@ -1221,20 +1444,21 @@ ohci_device_request(reqh) setup->nexttd = next; setup->td.td_nexttd = LE(next->physaddr); setup->td.td_be = LE(LE(setup->td.td_cbp) + sizeof *req - 1); - setup->len = 0; /* XXX The number of byte we count */ - setup->reqh = reqh; + setup->len = 0; + setup->xfer = xfer; setup->flags = 0; - reqh->hcpriv = setup; + xfer->hcpriv = setup; stat->td.td_flags = LE( - (isread ? OHCI_TD_OUT : OHCI_TD_IN) | OHCI_TD_NOCC | - OHCI_TD_TOGGLE_1 | OHCI_TD_SET_DI(1)); + (isread ? OHCI_TD_OUT : OHCI_TD_IN) | + OHCI_TD_NOCC | OHCI_TD_TOGGLE_1 | OHCI_TD_SET_DI(1)); stat->td.td_cbp = 0; stat->nexttd = tail; stat->td.td_nexttd = LE(tail->physaddr); stat->td.td_be = 0; + stat->flags = OHCI_CALL_DONE; stat->len = 0; - stat->reqh = reqh; + stat->xfer = xfer; #ifdef OHCI_DEBUG if (ohcidebug > 5) { @@ -1246,22 +1470,18 @@ ohci_device_request(reqh) /* Insert ED in schedule */ s = splusb(); - ohci_hash_add_td(sc, setup); - if (len != 0) - ohci_hash_add_td(sc, data); - ohci_hash_add_td(sc, stat); sed->ed.ed_tailp = LE(tail->physaddr); - opipe->tail = tail; + opipe->tail.td = tail; OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF); - if (reqh->timeout && !sc->sc_bus.use_polling) { - usb_timeout(ohci_timeout, reqh, - MS_TO_TICKS(reqh->timeout), reqh->timo_handle); + if (xfer->timeout && !sc->sc_bus.use_polling) { + usb_timeout(ohci_timeout, xfer, + MS_TO_TICKS(xfer->timeout), xfer->timo_handle); } splx(s); -#ifdef OHCI_DEBUG - if (ohcidebug > 5) { - delay(5000); +#if 0 + if (ohcidebug > 10) { + delay(10000); DPRINTF(("ohci_device_request: status=%x\n", OREAD4(sc, OHCI_COMMAND_STATUS))); ohci_dump_ed(sed); @@ -1276,7 +1496,7 @@ ohci_device_request(reqh) bad2: ohci_free_std(sc, stat); bad1: - return (r); + return (err); } /* @@ -1307,9 +1527,9 @@ ohci_rem_ed(sed, head) SPLUSBCHECK; /* XXX */ - for (p = head; p && p->next != sed; p = p->next) + for (p = head; p != NULL && p->next != sed; p = p->next) ; - if (!p) + if (p == NULL) panic("ohci_rem_ed: ED not found\n"); p->next = sed->next; p->ed.ed_nexted = sed->ed.ed_nexted; @@ -1359,7 +1579,7 @@ ohci_hash_find_td(sc, a) ohci_soft_td_t *std; for (std = LIST_FIRST(&sc->sc_hash_tds[h]); - std != 0; + std != NULL; std = LIST_NEXT(std, hnext)) if (std->physaddr == a) return (std); @@ -1370,15 +1590,15 @@ void ohci_timeout(addr) void *addr; { - usbd_request_handle reqh = addr; + usbd_xfer_handle xfer = addr; int s; - DPRINTF(("ohci_timeout: reqh=%p\n", reqh)); + DPRINTF(("ohci_timeout: xfer=%p\n", xfer)); s = splusb(); - reqh->device->bus->intr_context++; - ohci_abort_req(reqh, USBD_TIMEOUT); - reqh->device->bus->intr_context--; + xfer->device->bus->intr_context++; + ohci_abort_xfer(xfer, USBD_TIMEOUT); + xfer->device->bus->intr_context--; splx(s); } @@ -1411,8 +1631,8 @@ void ohci_dump_ed(sed) ohci_soft_ed_t *sed; { - DPRINTF(("ED(%p) at %08lx: addr=%d endpt=%d maxp=%d %b\ntailp=0x%08lx " - "headp=%b nexted=0x%08lx\n", + DPRINTF(("ED(%p) at 0x%08lx: addr=%d endpt=%d maxp=%d %b\ntailp=0x%08lx " + "headsflags=%b headp=%b nexted=0x%08lx\n", sed, (u_long)sed->physaddr, OHCI_ED_GET_FA(LE(sed->ed.ed_flags)), OHCI_ED_GET_EN(LE(sed->ed.ed_flags)), @@ -1422,6 +1642,7 @@ ohci_dump_ed(sed) (u_long)LE(sed->ed.ed_tailp), (u_long)LE(sed->ed.ed_headp), "\20\1HALT\2CARRY", + (u_long)LE(sed->ed.ed_headp), (u_long)LE(sed->ed.ed_nexted))); } #endif @@ -1435,10 +1656,15 @@ ohci_open(pipe) usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc; struct ohci_pipe *opipe = (struct ohci_pipe *)pipe; u_int8_t addr = dev->address; + u_int8_t xfertype = ed->bmAttributes & UE_XFERTYPE; ohci_soft_ed_t *sed; ohci_soft_td_t *std; - usbd_status r; + ohci_soft_itd_t *sitd; + ohci_physaddr_t tdphys; + u_int32_t fmt; + usbd_status err; int s; + int ival; DPRINTFN(1, ("ohci_open: pipe=%p, addr=%d, endpt=%d (%d)\n", pipe, addr, ed->bEndpointAddress, sc->sc_addr)); @@ -1455,30 +1681,43 @@ ohci_open(pipe) } } else { sed = ohci_alloc_sed(sc); - if (sed == 0) + if (sed == NULL) goto bad0; - std = ohci_alloc_std(sc); - if (std == 0) - goto bad1; opipe->sed = sed; - opipe->tail = std; + if (xfertype == UE_ISOCHRONOUS) { + sitd = ohci_alloc_sitd(sc); + if (sitd == NULL) { + ohci_free_sitd(sc, sitd); + goto bad1; + } + opipe->tail.itd = sitd; + tdphys = LE(sitd->physaddr); + fmt = OHCI_ED_FORMAT_ISO; + } else { + std = ohci_alloc_std(sc); + if (std == NULL) { + ohci_free_std(sc, std); + goto bad1; + } + opipe->tail.td = std; + tdphys = LE(std->physaddr); + fmt = OHCI_ED_FORMAT_GEN; + } sed->ed.ed_flags = LE( OHCI_ED_SET_FA(addr) | OHCI_ED_SET_EN(ed->bEndpointAddress) | OHCI_ED_DIR_TD | - (dev->lowspeed ? OHCI_ED_SPEED : 0) | - ((ed->bmAttributes & UE_XFERTYPE) == UE_ISOCHRONOUS ? - OHCI_ED_FORMAT_ISO : OHCI_ED_FORMAT_GEN) | + (dev->lowspeed ? OHCI_ED_SPEED : 0) | fmt | OHCI_ED_SET_MAXP(UGETW(ed->wMaxPacketSize))); - sed->ed.ed_headp = sed->ed.ed_tailp = LE(std->physaddr); + sed->ed.ed_headp = sed->ed.ed_tailp = tdphys; - switch (ed->bmAttributes & UE_XFERTYPE) { + switch (xfertype) { case UE_CONTROL: pipe->methods = &ohci_device_ctrl_methods; - r = usb_allocmem(&sc->sc_bus, + err = usb_allocmem(&sc->sc_bus, sizeof(usb_device_request_t), 0, &opipe->u.ctl.reqdma); - if (r != USBD_NORMAL_COMPLETION) + if (err) goto bad; s = splusb(); ohci_add_ed(sed, sc->sc_ctrl_head); @@ -1486,10 +1725,13 @@ ohci_open(pipe) break; case UE_INTERRUPT: pipe->methods = &ohci_device_intr_methods; - return (ohci_device_setintr(sc, opipe, ed->bInterval)); + ival = pipe->interval; + if (ival == USBD_DEFAULT_INTERVAL) + ival = ed->bInterval; + return (ohci_device_setintr(sc, opipe, ival)); case UE_ISOCHRONOUS: - printf("ohci_open: open iso unimplemented\n"); - return (USBD_INVAL); + pipe->methods = &ohci_device_isoc_methods; + return (ohci_setup_isoc(pipe)); case UE_BULK: pipe->methods = &ohci_device_bulk_methods; s = splusb(); @@ -1526,12 +1768,12 @@ ohci_close_pipe(pipe, head) s = splusb(); #ifdef DIAGNOSTIC sed->ed.ed_flags |= LE(OHCI_ED_SKIP); - if ((sed->ed.ed_tailp & LE(OHCI_TAILMASK)) != - (sed->ed.ed_headp & LE(OHCI_TAILMASK))) { + if ((sed->ed.ed_tailp & LE(OHCI_HEADMASK)) != + (sed->ed.ed_headp & LE(OHCI_HEADMASK))) { ohci_physaddr_t td = sed->ed.ed_headp; ohci_soft_td_t *std; for (std = LIST_FIRST(&sc->sc_hash_tds[HASH(td)]); - std != 0; + std != NULL; std = LIST_NEXT(std, hnext)) if (std->physaddr == td) break; @@ -1540,14 +1782,13 @@ ohci_close_pipe(pipe, head) (int)LE(sed->ed.ed_headp), (int)LE(sed->ed.ed_tailp), pipe, std); usb_delay_ms(&sc->sc_bus, 2); - if ((sed->ed.ed_tailp & LE(OHCI_TAILMASK)) != - (sed->ed.ed_headp & LE(OHCI_TAILMASK))) + if ((sed->ed.ed_tailp & LE(OHCI_HEADMASK)) != + (sed->ed.ed_headp & LE(OHCI_HEADMASK))) printf("ohci_close_pipe: pipe still not empty\n"); } #endif ohci_rem_ed(sed, head); splx(s); - ohci_free_std(sc, opipe->tail); ohci_free_sed(sc, opipe->sed); } @@ -1562,38 +1803,47 @@ ohci_close_pipe(pipe, head) * interrupt processing to process it. */ void -ohci_abort_req(reqh, status) - usbd_request_handle reqh; +ohci_abort_xfer(xfer, status) + usbd_xfer_handle xfer; usbd_status status; { - struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe; + struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe; ohci_soft_ed_t *sed; - DPRINTF(("ohci_abort_req: reqh=%p pipe=%p\n", reqh, opipe)); + DPRINTF(("ohci_abort_xfer: xfer=%p pipe=%p\n", xfer, opipe)); - reqh->status = status; + xfer->status = status; - usb_untimeout(ohci_timeout, reqh, reqh->timo_handle); + usb_untimeout(ohci_timeout, xfer, xfer->timo_handle); sed = opipe->sed; - DPRINTFN(1,("ohci_abort_req: stop ed=%p\n", sed)); + DPRINTFN(1,("ohci_abort_xfer: stop ed=%p\n", sed)); sed->ed.ed_flags |= LE(OHCI_ED_SKIP); /* force hardware skip */ - if (reqh->device->bus->intr_context) { +#if 1 + if (xfer->device->bus->intr_context) { /* We have no process context, so we can't use tsleep(). */ - timeout(ohci_abort_req_end, reqh, hz / USB_FRAMES_PER_SECOND); + timeout(ohci_abort_xfer_end, xfer, hz / USB_FRAMES_PER_SECOND); } else { +#if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__) + KASSERT(intr_nesting_level == 0, + ("ohci_abort_req in interrupt context")); +#endif usb_delay_ms(opipe->pipe.device->bus, 1); - ohci_abort_req_end(reqh); + ohci_abort_xfer_end(xfer); } +#else + delay(1000); + ohci_abort_xfer_end(xfer); +#endif } void -ohci_abort_req_end(v) +ohci_abort_xfer_end(v) void *v; { - usbd_request_handle reqh = v; - struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe; + usbd_xfer_handle xfer = v; + struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe; ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus; ohci_soft_ed_t *sed; ohci_soft_td_t *p, *n; @@ -1601,26 +1851,25 @@ ohci_abort_req_end(v) s = splusb(); - p = reqh->hcpriv; + p = xfer->hcpriv; #ifdef DIAGNOSTIC - if (!p) { - printf("ohci_abort_req: hcpriv==0\n"); + if (p == NULL) { + printf("ohci_abort_xfer: hcpriv==0\n"); return; } #endif - for (; p->reqh == reqh; p = n) { + for (; p->xfer == xfer; p = n) { n = p->nexttd; - ohci_hash_rem_td(sc, p); ohci_free_std(sc, p); } sed = opipe->sed; - DPRINTFN(2,("ohci_abort_req: set hd=%x, tl=%x\n", + DPRINTFN(2,("ohci_abort_xfer: set hd=%x, tl=%x\n", (int)LE(p->physaddr), (int)LE(sed->ed.ed_tailp))); sed->ed.ed_headp = p->physaddr; /* unlink TDs */ sed->ed.ed_flags &= LE(~OHCI_ED_SKIP); /* remove hardware skip */ - usb_transfer_complete(reqh); + usb_transfer_complete(xfer); splx(s); } @@ -1632,8 +1881,8 @@ usb_device_descriptor_t ohci_devd = { USB_DEVICE_DESCRIPTOR_SIZE, UDESC_DEVICE, /* type */ {0x00, 0x01}, /* USB version */ - UCLASS_HUB, /* class */ - USUBCLASS_HUB, /* subclass */ + UDCLASS_HUB, /* class */ + UDSUBCLASS_HUB, /* subclass */ 0, /* protocol */ 64, /* max packet */ {0},{0},{0x00,0x01}, /* device id */ @@ -1660,8 +1909,8 @@ usb_interface_descriptor_t ohci_ifcd = { 0, 0, 1, - UCLASS_HUB, - USUBCLASS_HUB, + UICLASS_HUB, + UISUBCLASS_HUB, 0, 0 }; @@ -1709,40 +1958,40 @@ ohci_str(p, l, s) * Simulate a hardware hub by handling all the necessary requests. */ usbd_status -ohci_root_ctrl_transfer(reqh) - usbd_request_handle reqh; +ohci_root_ctrl_transfer(xfer) + usbd_xfer_handle xfer; { - usbd_status r; + usbd_status err; /* Insert last in queue. */ - r = usb_insert_transfer(reqh); - if (r != USBD_NORMAL_COMPLETION) - return (r); + err = usb_insert_transfer(xfer); + if (err) + return (err); /* Pipe isn't running, start first */ - return (ohci_root_ctrl_start(SIMPLEQ_FIRST(&reqh->pipe->queue))); + return (ohci_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); } usbd_status -ohci_root_ctrl_start(reqh) - usbd_request_handle reqh; +ohci_root_ctrl_start(xfer) + usbd_xfer_handle xfer; { - ohci_softc_t *sc = (ohci_softc_t *)reqh->pipe->device->bus; + ohci_softc_t *sc = (ohci_softc_t *)xfer->pipe->device->bus; usb_device_request_t *req; void *buf = NULL; int port, i; int s, len, value, index, l, totlen = 0; usb_port_status_t ps; usb_hub_descriptor_t hubd; - usbd_status r; + usbd_status err; u_int32_t v; #ifdef DIAGNOSTIC - if (!(reqh->rqflags & URQ_REQUEST)) + if (!(xfer->rqflags & URQ_REQUEST)) /* XXX panic */ return (USBD_INVAL); #endif - req = &reqh->request; + req = &xfer->request; DPRINTFN(4,("ohci_root_ctrl_control type=0x%02x request=%02x\n", req->bmRequestType, req->bRequest)); @@ -1752,7 +2001,7 @@ ohci_root_ctrl_start(reqh) index = UGETW(req->wIndex); if (len != 0) - buf = KERNADDR(&reqh->dmabuf); + buf = KERNADDR(&xfer->dmabuf); #define C(x,y) ((x) | ((y) << 8)) switch(C(req->bRequest, req->bmRequestType)) { @@ -1775,7 +2024,7 @@ ohci_root_ctrl_start(reqh) switch(value >> 8) { case UDESC_DEVICE: if ((value & 0xff) != 0) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } totlen = l = min(len, USB_DEVICE_DESCRIPTOR_SIZE); @@ -1784,7 +2033,7 @@ ohci_root_ctrl_start(reqh) break; case UDESC_CONFIG: if ((value & 0xff) != 0) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } totlen = l = min(len, USB_CONFIG_DESCRIPTOR_SIZE); @@ -1815,7 +2064,7 @@ ohci_root_ctrl_start(reqh) } break; default: - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } break; @@ -1840,14 +2089,14 @@ ohci_root_ctrl_start(reqh) break; case C(UR_SET_ADDRESS, UT_WRITE_DEVICE): if (value >= USB_MAX_DEVICES) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } sc->sc_addr = value; break; case C(UR_SET_CONFIG, UT_WRITE_DEVICE): if (value != 0 && value != 1) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } sc->sc_conf = value; @@ -1857,7 +2106,7 @@ ohci_root_ctrl_start(reqh) case C(UR_SET_FEATURE, UT_WRITE_DEVICE): case C(UR_SET_FEATURE, UT_WRITE_INTERFACE): case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT): - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE): break; @@ -1871,7 +2120,7 @@ ohci_root_ctrl_start(reqh) "port=%d feature=%d\n", index, value)); if (index < 1 || index > sc->sc_noport) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } port = OHCI_RH_PORT_STATUS(index); @@ -1901,7 +2150,7 @@ ohci_root_ctrl_start(reqh) OWRITE4(sc, port, UPS_C_PORT_RESET << 16); break; default: - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } switch(value) { @@ -1920,7 +2169,7 @@ ohci_root_ctrl_start(reqh) break; case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE): if (value != 0) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } v = OREAD4(sc, OHCI_RH_DESCRIPTOR_A); @@ -1942,7 +2191,7 @@ ohci_root_ctrl_start(reqh) break; case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE): if (len != 4) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } memset(buf, 0, len); /* ? XXX */ @@ -1952,11 +2201,11 @@ ohci_root_ctrl_start(reqh) DPRINTFN(8,("ohci_root_ctrl_transfer: get port status i=%d\n", index)); if (index < 1 || index > sc->sc_noport) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } if (len != 4) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } v = OREAD4(sc, OHCI_RH_PORT_STATUS(index)); @@ -1969,13 +2218,13 @@ ohci_root_ctrl_start(reqh) totlen = l; break; case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE): - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE): break; case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER): if (index < 1 || index > sc->sc_noport) { - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } port = OHCI_RH_PORT_STATUS(index); @@ -2004,28 +2253,28 @@ ohci_root_ctrl_start(reqh) OWRITE4(sc, port, UPS_PORT_POWER); break; default: - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } break; default: - r = USBD_IOERROR; + err = USBD_IOERROR; goto ret; } - reqh->actlen = totlen; - r = USBD_NORMAL_COMPLETION; + xfer->actlen = totlen; + err = USBD_NORMAL_COMPLETION; ret: - reqh->status = r; + xfer->status = err; s = splusb(); - usb_transfer_complete(reqh); + usb_transfer_complete(xfer); splx(s); return (USBD_IN_PROGRESS); } /* Abort a root control request. */ void -ohci_root_ctrl_abort(reqh) - usbd_request_handle reqh; +ohci_root_ctrl_abort(xfer) + usbd_xfer_handle xfer; { /* Nothing to do, all transfers are synchronous. */ } @@ -2040,43 +2289,47 @@ ohci_root_ctrl_close(pipe) } usbd_status -ohci_root_intr_transfer(reqh) - usbd_request_handle reqh; +ohci_root_intr_transfer(xfer) + usbd_xfer_handle xfer; { - usbd_status r; + usbd_status err; /* Insert last in queue. */ - r = usb_insert_transfer(reqh); - if (r != USBD_NORMAL_COMPLETION) - return (r); + err = usb_insert_transfer(xfer); + if (err) + return (err); /* Pipe isn't running, start first */ - return (ohci_root_intr_start(SIMPLEQ_FIRST(&reqh->pipe->queue))); + return (ohci_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); } usbd_status -ohci_root_intr_start(reqh) - usbd_request_handle reqh; +ohci_root_intr_start(xfer) + usbd_xfer_handle xfer; { - usbd_pipe_handle pipe = reqh->pipe; + usbd_pipe_handle pipe = xfer->pipe; ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus; - sc->sc_intrreqh = reqh; + sc->sc_intrxfer = xfer; return (USBD_IN_PROGRESS); } /* Abort a root interrupt request. */ void -ohci_root_intr_abort(reqh) - usbd_request_handle reqh; +ohci_root_intr_abort(xfer) + usbd_xfer_handle xfer; { - if (reqh->pipe->intrreqh == reqh) { + int s; + + if (xfer->pipe->intrxfer == xfer) { DPRINTF(("ohci_root_intr_abort: remove\n")); - reqh->pipe->intrreqh = 0; + xfer->pipe->intrxfer = NULL; } - reqh->status = USBD_CANCELLED; - usb_transfer_complete(reqh); + xfer->status = USBD_CANCELLED; + s = splusb(); + usb_transfer_complete(xfer); + splx(s); } /* Close the root pipe. */ @@ -2088,57 +2341,57 @@ ohci_root_intr_close(pipe) DPRINTF(("ohci_root_intr_close\n")); - sc->sc_intrreqh = 0; + sc->sc_intrxfer = NULL; } /************************/ usbd_status -ohci_device_ctrl_transfer(reqh) - usbd_request_handle reqh; +ohci_device_ctrl_transfer(xfer) + usbd_xfer_handle xfer; { - usbd_status r; + usbd_status err; /* Insert last in queue. */ - r = usb_insert_transfer(reqh); - if (r != USBD_NORMAL_COMPLETION) - return (r); + err = usb_insert_transfer(xfer); + if (err) + return (err); /* Pipe isn't running, start first */ - return (ohci_device_ctrl_start(SIMPLEQ_FIRST(&reqh->pipe->queue))); + return (ohci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); } usbd_status -ohci_device_ctrl_start(reqh) - usbd_request_handle reqh; +ohci_device_ctrl_start(xfer) + usbd_xfer_handle xfer; { - ohci_softc_t *sc = (ohci_softc_t *)reqh->pipe->device->bus; - usbd_status r; + ohci_softc_t *sc = (ohci_softc_t *)xfer->pipe->device->bus; + usbd_status err; #ifdef DIAGNOSTIC - if (!(reqh->rqflags & URQ_REQUEST)) { + if (!(xfer->rqflags & URQ_REQUEST)) { /* XXX panic */ printf("ohci_device_ctrl_transfer: not a request\n"); return (USBD_INVAL); } #endif - r = ohci_device_request(reqh); - if (r != USBD_NORMAL_COMPLETION) - return (r); + err = ohci_device_request(xfer); + if (err) + return (err); if (sc->sc_bus.use_polling) - ohci_waitintr(sc, reqh); + ohci_waitintr(sc, xfer); return (USBD_IN_PROGRESS); } /* Abort a device control request. */ void -ohci_device_ctrl_abort(reqh) - usbd_request_handle reqh; +ohci_device_ctrl_abort(xfer) + usbd_xfer_handle xfer; { - DPRINTF(("ohci_device_ctrl_abort: reqh=%p\n", reqh)); - ohci_abort_req(reqh, USBD_CANCELLED); + DPRINTF(("ohci_device_ctrl_abort: xfer=%p\n", xfer)); + ohci_abort_xfer(xfer, USBD_CANCELLED); } /* Close a device control pipe. */ @@ -2146,10 +2399,12 @@ void ohci_device_ctrl_close(pipe) usbd_pipe_handle pipe; { + struct ohci_pipe *opipe = (struct ohci_pipe *)pipe; ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus; DPRINTF(("ohci_device_ctrl_close: pipe=%p\n", pipe)); ohci_close_pipe(pipe, sc->sc_ctrl_head); + ohci_free_std(sc, opipe->tail.td); } /************************/ @@ -2160,7 +2415,7 @@ ohci_device_clear_toggle(pipe) { struct ohci_pipe *opipe = (struct ohci_pipe *)pipe; - opipe->sed->ed.ed_tailp &= LE(~OHCI_TOGGLECARRY); + opipe->sed->ed.ed_headp &= LE(~OHCI_TOGGLECARRY); } void @@ -2170,48 +2425,48 @@ ohci_noop(pipe) } usbd_status -ohci_device_bulk_transfer(reqh) - usbd_request_handle reqh; +ohci_device_bulk_transfer(xfer) + usbd_xfer_handle xfer; { - usbd_status r; + usbd_status err; /* Insert last in queue. */ - r = usb_insert_transfer(reqh); - if (r != USBD_NORMAL_COMPLETION) - return (r); + err = usb_insert_transfer(xfer); + if (err) + return (err); /* Pipe isn't running, start first */ - return (ohci_device_bulk_start(SIMPLEQ_FIRST(&reqh->pipe->queue))); + return (ohci_device_bulk_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); } usbd_status -ohci_device_bulk_start(reqh) - usbd_request_handle reqh; +ohci_device_bulk_start(xfer) + usbd_xfer_handle xfer; { - struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe; + struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe; usbd_device_handle dev = opipe->pipe.device; ohci_softc_t *sc = (ohci_softc_t *)dev->bus; int addr = dev->address; ohci_soft_td_t *data, *tail, *tdp; ohci_soft_ed_t *sed; int s, len, isread, endpt; - usbd_status r; + usbd_status err; #ifdef DIAGNOSTIC - if (reqh->rqflags & URQ_REQUEST) { + if (xfer->rqflags & URQ_REQUEST) { /* XXX panic */ printf("ohci_device_bulk_start: a request\n"); return (USBD_INVAL); } #endif - len = reqh->length; - endpt = reqh->pipe->endpoint->edesc->bEndpointAddress; + len = xfer->length; + endpt = xfer->pipe->endpoint->edesc->bEndpointAddress; isread = UE_GET_DIR(endpt) == UE_DIR_IN; sed = opipe->sed; - DPRINTFN(4,("ohci_device_bulk_start: reqh=%p len=%d isread=%d " - "flags=%d endpt=%d\n", reqh, len, isread, reqh->flags, + DPRINTFN(4,("ohci_device_bulk_start: xfer=%p len=%d isread=%d " + "flags=%d endpt=%d\n", xfer, len, isread, xfer->flags, endpt)); opipe->u.bulk.isread = isread; @@ -2223,15 +2478,18 @@ ohci_device_bulk_start(reqh) OHCI_ED_SET_FA(addr)); /* Allocate a chain of new TDs (including a new tail). */ - data = opipe->tail; - r = ohci_alloc_std_chain(opipe, sc, len, isread, - reqh->flags & USBD_SHORT_XFER_OK, - &reqh->dmabuf, data, &tail); - if (r != USBD_NORMAL_COMPLETION) - return (r); - - tail->reqh = 0; - reqh->hcpriv = data; + data = opipe->tail.td; + err = ohci_alloc_std_chain(opipe, sc, len, isread, xfer, data, &tail); + /* We want interrupt at the end of the transfer. */ + tail->td.td_flags &= LE(~OHCI_TD_INTR_MASK); + tail->td.td_flags |= LE(OHCI_TD_SET_DI(1)); + tail->flags |= OHCI_CALL_DONE; + tail = tail->nexttd; /* point at sentinel */ + if (err) + return (err); + + tail->xfer = NULL; + xfer->hcpriv = data; DPRINTFN(4,("ohci_device_bulk_start: ed_flags=0x%08x td_flags=0x%08x " "td_cbp=0x%08x td_be=0x%08x\n", @@ -2239,7 +2497,7 @@ ohci_device_bulk_start(reqh) (int)LE(data->td.td_cbp), (int)LE(data->td.td_be))); #ifdef OHCI_DEBUG - if (ohcidebug > 4) { + if (ohcidebug > 5) { ohci_dump_ed(sed); ohci_dump_tds(data); } @@ -2248,22 +2506,21 @@ ohci_device_bulk_start(reqh) /* Insert ED in schedule */ s = splusb(); for (tdp = data; tdp != tail; tdp = tdp->nexttd) { - tdp->reqh = reqh; - ohci_hash_add_td(sc, tdp); + tdp->xfer = xfer; } sed->ed.ed_tailp = LE(tail->physaddr); - opipe->tail = tail; + opipe->tail.td = tail; sed->ed.ed_flags &= LE(~OHCI_ED_SKIP); OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF); - if (reqh->timeout && !sc->sc_bus.use_polling) { - usb_timeout(ohci_timeout, reqh, - MS_TO_TICKS(reqh->timeout), reqh->timo_handle); + if (xfer->timeout && !sc->sc_bus.use_polling) { + usb_timeout(ohci_timeout, xfer, + MS_TO_TICKS(xfer->timeout), xfer->timo_handle); } #if 0 /* This goes wrong if we are too slow. */ - if (ohcidebug > 5) { - delay(5000); + if (ohcidebug > 10) { + delay(10000); DPRINTF(("ohci_device_intr_transfer: status=%x\n", OREAD4(sc, OHCI_COMMAND_STATUS))); ohci_dump_ed(sed); @@ -2277,11 +2534,11 @@ ohci_device_bulk_start(reqh) } void -ohci_device_bulk_abort(reqh) - usbd_request_handle reqh; +ohci_device_bulk_abort(xfer) + usbd_xfer_handle xfer; { - DPRINTF(("ohci_device_bulk_abort: reqh=%p\n", reqh)); - ohci_abort_req(reqh, USBD_CANCELLED); + DPRINTF(("ohci_device_bulk_abort: xfer=%p\n", xfer)); + ohci_abort_xfer(xfer, USBD_CANCELLED); } /* @@ -2291,34 +2548,36 @@ void ohci_device_bulk_close(pipe) usbd_pipe_handle pipe; { + struct ohci_pipe *opipe = (struct ohci_pipe *)pipe; ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus; DPRINTF(("ohci_device_bulk_close: pipe=%p\n", pipe)); ohci_close_pipe(pipe, sc->sc_bulk_head); + ohci_free_std(sc, opipe->tail.td); } /************************/ usbd_status -ohci_device_intr_transfer(reqh) - usbd_request_handle reqh; +ohci_device_intr_transfer(xfer) + usbd_xfer_handle xfer; { - usbd_status r; + usbd_status err; /* Insert last in queue. */ - r = usb_insert_transfer(reqh); - if (r != USBD_NORMAL_COMPLETION) - return (r); + err = usb_insert_transfer(xfer); + if (err) + return (err); /* Pipe isn't running, start first */ - return (ohci_device_intr_start(SIMPLEQ_FIRST(&reqh->pipe->queue))); + return (ohci_device_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); } usbd_status -ohci_device_intr_start(reqh) - usbd_request_handle reqh; +ohci_device_intr_start(xfer) + usbd_xfer_handle xfer; { - struct ohci_pipe *opipe = (struct ohci_pipe *)reqh->pipe; + struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe; usbd_device_handle dev = opipe->pipe.device; ohci_softc_t *sc = (ohci_softc_t *)dev->bus; ohci_soft_ed_t *sed = opipe->sed; @@ -2326,36 +2585,36 @@ ohci_device_intr_start(reqh) int len; int s; - DPRINTFN(3, ("ohci_device_intr_transfer: reqh=%p len=%d " + DPRINTFN(3, ("ohci_device_intr_transfer: xfer=%p len=%d " "flags=%d priv=%p\n", - reqh, reqh->length, reqh->flags, reqh->priv)); + xfer, xfer->length, xfer->flags, xfer->priv)); #ifdef DIAGNOSTIC - if (reqh->rqflags & URQ_REQUEST) + if (xfer->rqflags & URQ_REQUEST) panic("ohci_device_intr_transfer: a request\n"); #endif - len = reqh->length; + len = xfer->length; - data = opipe->tail; + data = opipe->tail.td; tail = ohci_alloc_std(sc); - if (!tail) + if (tail == NULL) return (USBD_NOMEM); - tail->reqh = 0; + tail->xfer = NULL; data->td.td_flags = LE( OHCI_TD_IN | OHCI_TD_NOCC | OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY); - if (reqh->flags & USBD_SHORT_XFER_OK) + if (xfer->flags & USBD_SHORT_XFER_OK) data->td.td_flags |= LE(OHCI_TD_R); - data->td.td_cbp = LE(DMAADDR(&reqh->dmabuf)); + data->td.td_cbp = LE(DMAADDR(&xfer->dmabuf)); data->nexttd = tail; data->td.td_nexttd = LE(tail->physaddr); data->td.td_be = LE(LE(data->td.td_cbp) + len - 1); data->len = len; - data->reqh = reqh; + data->xfer = xfer; data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN; - reqh->hcpriv = data; + xfer->hcpriv = data; #ifdef OHCI_DEBUG if (ohcidebug > 5) { @@ -2367,9 +2626,8 @@ ohci_device_intr_start(reqh) /* Insert ED in schedule */ s = splusb(); - ohci_hash_add_td(sc, data); sed->ed.ed_tailp = LE(tail->physaddr); - opipe->tail = tail; + opipe->tail.td = tail; sed->ed.ed_flags &= LE(~OHCI_ED_SKIP); #if 0 @@ -2379,7 +2637,7 @@ ohci_device_intr_start(reqh) * TD is gone. */ if (ohcidebug > 5) { - delay(5000); + usb_delay_ms(&sc->sc_bus, 5); DPRINTF(("ohci_device_intr_transfer: status=%x\n", OREAD4(sc, OHCI_COMMAND_STATUS))); ohci_dump_ed(sed); @@ -2393,14 +2651,14 @@ ohci_device_intr_start(reqh) /* Abort a device control request. */ void -ohci_device_intr_abort(reqh) - usbd_request_handle reqh; +ohci_device_intr_abort(xfer) + usbd_xfer_handle xfer; { - if (reqh->pipe->intrreqh == reqh) { + if (xfer->pipe->intrxfer == xfer) { DPRINTF(("ohci_device_intr_abort: remove\n")); - reqh->pipe->intrreqh = 0; + xfer->pipe->intrxfer = NULL; } - ohci_abort_req(reqh, USBD_CANCELLED); + ohci_abort_xfer(xfer, USBD_CANCELLED); } /* Close a device interrupt pipe. */ @@ -2420,14 +2678,16 @@ ohci_device_intr_close(pipe) pipe, nslots, pos)); s = splusb(); sed->ed.ed_flags |= LE(OHCI_ED_SKIP); - if ((sed->ed.ed_tailp & LE(OHCI_TAILMASK)) != - (sed->ed.ed_headp & LE(OHCI_TAILMASK))) + if ((sed->ed.ed_tailp & LE(OHCI_HEADMASK)) != + (sed->ed.ed_headp & LE(OHCI_HEADMASK))) usb_delay_ms(&sc->sc_bus, 2); for (p = sc->sc_eds[pos]; p && p->next != sed; p = p->next) ; - if (!p) +#ifdef DIAGNOSTIC + if (p == NULL) panic("ohci_device_intr_close: ED not found\n"); +#endif p->next = sed->next; p->ed.ed_nexted = sed->ed.ed_nexted; splx(s); @@ -2435,7 +2695,7 @@ ohci_device_intr_close(pipe) for (j = 0; j < nslots; j++) --sc->sc_bws[(pos * nslots + j) % OHCI_NO_INTRS]; - ohci_free_std(sc, opipe->tail); + ohci_free_std(sc, opipe->tail.td); ohci_free_sed(sc, opipe->sed); } @@ -2504,3 +2764,149 @@ ohci_device_setintr(sc, opipe, ival) return (USBD_NORMAL_COMPLETION); } +/***********************/ + +usbd_status +ohci_device_isoc_transfer(xfer) + usbd_xfer_handle xfer; +{ + usbd_status err; + + DPRINTFN(5,("ohci_device_isoc_transfer: xfer=%p\n", xfer)); + + /* Put it on our queue, */ + err = usb_insert_transfer(xfer); + + /* bail out on error, */ + if (err && err != USBD_IN_PROGRESS) + return (err); + + /* XXX should check inuse here */ + + /* insert into schedule */ + ohci_device_isoc_enter(xfer); + + /* and put on interrupt list if the pipe wasn't running */ + if (!err) + ohci_device_isoc_start(SIMPLEQ_FIRST(&xfer->pipe->queue)); + + return (err); +} + +void +ohci_device_isoc_enter(xfer) + usbd_xfer_handle xfer; +{ + struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe; + usbd_device_handle dev = opipe->pipe.device; + ohci_softc_t *sc = (ohci_softc_t *)dev->bus; + ohci_soft_ed_t *sed = opipe->sed; + struct iso *iso = &opipe->u.iso; + ohci_soft_itd_t *sitd, *nsitd; + ohci_physaddr_t buf, offs; + int i, ncur, nframes; + int ncross; + int s; + + s = splusb(); + sitd = opipe->tail.itd; + buf = DMAADDR(&xfer->dmabuf); + sitd->itd.itd_bp0 = LE(buf & OHCI_ITD_PAGE_MASK); + nframes = xfer->nframes; + offs = buf & OHCI_ITD_OFFSET_MASK; + ncross = 0; + for (i = ncur = 0; i < nframes; i ++, ncur++) { + if (ncur == OHCI_ITD_NOFFSET || /* all offsets used */ + ncross > 1) { /* too many page crossings */ + nsitd = ohci_alloc_sitd(sc); + if (nsitd == NULL) { + /* XXX what now? */ + return; + } + sitd->nextitd = nsitd; + sitd->itd.itd_nextitd = LE(nsitd->physaddr); + sitd->itd.itd_flags = LE( + OHCI_ITD_NOCC | + OHCI_ITD_SET_SF(iso->next) | + OHCI_ITD_NOINTR | + OHCI_ITD_SET_FC(OHCI_ITD_NOFFSET)); + sitd->itd.itd_be = LE(LE(sitd->itd.itd_bp0) + offs - 1); + nsitd->itd.itd_bp0 = LE((buf + offs) & OHCI_ITD_PAGE_MASK); + sitd = nsitd; + iso->next = iso->next + ncur; + ncur = 0; + ncross = 0; + } + /* XXX byte order */ + sitd->itd.itd_offset[i] = + offs | (ncross == 1 ? OHCI_ITD_PAGE_SELECT : 0); + offs += xfer->frlengths[i]; + /* XXX update ncross */ + } + nsitd = ohci_alloc_sitd(sc); + if (nsitd == NULL) { + /* XXX what now? */ + return; + } + sitd->nextitd = nsitd; + sitd->itd.itd_nextitd = LE(nsitd->physaddr); + sitd->itd.itd_flags = LE( + OHCI_ITD_NOCC | + OHCI_ITD_SET_SF(iso->next) | + OHCI_ITD_SET_DI(0) | + OHCI_ITD_SET_FC(ncur)); + sitd->itd.itd_be = LE(LE(sitd->itd.itd_bp0) + offs - 1); + iso->next = iso->next + ncur; + + opipe->tail.itd = nsitd; + sed->ed.ed_tailp = LE(nsitd->physaddr); + /* XXX update ED */ + splx(s); +} + +usbd_status +ohci_device_isoc_start(xfer) + usbd_xfer_handle xfer; +{ + printf("ohci_device_isoc_start: not implemented\n"); + return (USBD_INVAL); +} + +void +ohci_device_isoc_abort(xfer) + usbd_xfer_handle xfer; +{ +} + +void +ohci_device_isoc_done(xfer) + usbd_xfer_handle xfer; +{ + printf("ohci_device_isoc_done: not implemented\n"); +} + +usbd_status +ohci_setup_isoc(pipe) + usbd_pipe_handle pipe; +{ + struct ohci_pipe *opipe = (struct ohci_pipe *)pipe; + struct iso *iso = &opipe->u.iso; + + iso->next = -1; + iso->inuse = 0; + + return (USBD_NORMAL_COMPLETION); +} + +void +ohci_device_isoc_close(pipe) + usbd_pipe_handle pipe; +{ + struct ohci_pipe *opipe = (struct ohci_pipe *)pipe; + ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus; + + DPRINTF(("ohci_device_isoc_close: pipe=%p\n", pipe)); + ohci_close_pipe(pipe, sc->sc_isoc_head); + ohci_free_sitd(sc, opipe->tail.itd); +} + |