Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/sys/dev/usb/motg.c,v rcsdiff: /ftp/cvs/cvsroot/src/sys/dev/usb/motg.c,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.12 retrieving revision 1.12.2.24 diff -u -p -r1.12 -r1.12.2.24 --- src/sys/dev/usb/motg.c 2014/09/13 19:02:00 1.12 +++ src/sys/dev/usb/motg.c 2015/12/19 09:56:41 1.12.2.24 @@ -1,4 +1,4 @@ -/* $NetBSD: motg.c,v 1.12 2014/09/13 19:02:00 jmcneill Exp $ */ +/* $NetBSD: motg.c,v 1.12.2.24 2015/12/19 09:56:41 skrll Exp $ */ /* * Copyright (c) 1998, 2004, 2011, 2012, 2014 The NetBSD Foundation, Inc. @@ -42,19 +42,20 @@ #include "opt_motg.h" #include -__KERNEL_RCSID(0, "$NetBSD: motg.c,v 1.12 2014/09/13 19:02:00 jmcneill Exp $"); +__KERNEL_RCSID(0, "$NetBSD: motg.c,v 1.12.2.24 2015/12/19 09:56:41 skrll Exp $"); #include -#include + +#include +#include +#include #include #include -#include -#include -#include #include #include -#include -#include +#include +#include +#include #include @@ -62,7 +63,7 @@ __KERNEL_RCSID(0, "$NetBSD: motg.c,v 1.1 #include #include #include -#include +#include #ifdef MOTG_ALLWINNER #include @@ -71,21 +72,53 @@ __KERNEL_RCSID(0, "$NetBSD: motg.c,v 1.1 #endif #include -#include +#include + +#ifdef USB_DEBUG +#ifndef MOTG_DEBUG +#define motgdebug 0 +#else +int motgdebug = 0; + +SYSCTL_SETUP(sysctl_hw_motg_setup, "sysctl hw.motg setup") +{ + int err; + const struct sysctlnode *rnode; + const struct sysctlnode *cnode; + + err = sysctl_createv(clog, 0, NULL, &rnode, + CTLFLAG_PERMANENT, CTLTYPE_NODE, "motg", + SYSCTL_DESCR("motg global controls"), + NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL); + + if (err) + goto fail; + + /* control debugging printfs */ + err = sysctl_createv(clog, 0, &rnode, &cnode, + CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, + "debug", SYSCTL_DESCR("Enable debugging output"), + NULL, 0, &motgdebug, sizeof(motgdebug), CTL_CREATE, CTL_EOL); + if (err) + goto fail; + + return; +fail: + aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err); +} + +#endif /* MOTG_DEBUG */ +#endif /* USB_DEBUG */ -#define MOTG_DEBUG -#ifdef MOTG_DEBUG -#define DPRINTF(x) if (motgdebug) printf x -#define DPRINTFN(n,x) if (motgdebug & (n)) printf x #define MD_ROOT 0x0002 #define MD_CTRL 0x0004 #define MD_BULK 0x0008 -// int motgdebug = MD_ROOT | MD_CTRL | MD_BULK; -int motgdebug = 0; -#else -#define DPRINTF(x) -#define DPRINTFN(n,x) -#endif + +#define DPRINTF(FMT,A,B,C,D) USBHIST_LOGN(motgdebug,1,FMT,A,B,C,D) +#define DPRINTFN(N,FMT,A,B,C,D) USBHIST_LOGM(motgdebug,N,FMT,A,B,C,D) +#define MOTGHIST_FUNC() USBHIST_FUNC() +#define MOTGHIST_CALLED(name) USBHIST_CALLED(motgdebug) + /* various timeouts, for various speeds */ /* control NAK timeouts */ @@ -101,56 +134,52 @@ int motgdebug = 0; #define NAK_TO_BULK_HIGH 0 static void motg_hub_change(struct motg_softc *); -static usbd_status motg_root_ctrl_transfer(usbd_xfer_handle); -static usbd_status motg_root_ctrl_start(usbd_xfer_handle); -static void motg_root_ctrl_abort(usbd_xfer_handle); -static void motg_root_ctrl_close(usbd_pipe_handle); -static void motg_root_ctrl_done(usbd_xfer_handle); - -static usbd_status motg_root_intr_transfer(usbd_xfer_handle); -static usbd_status motg_root_intr_start(usbd_xfer_handle); -static void motg_root_intr_abort(usbd_xfer_handle); -static void motg_root_intr_close(usbd_pipe_handle); -static void motg_root_intr_done(usbd_xfer_handle); -static usbd_status motg_open(usbd_pipe_handle); +static usbd_status motg_root_intr_transfer(struct usbd_xfer *); +static usbd_status motg_root_intr_start(struct usbd_xfer *); +static void motg_root_intr_abort(struct usbd_xfer *); +static void motg_root_intr_close(struct usbd_pipe *); +static void motg_root_intr_done(struct usbd_xfer *); + +static usbd_status motg_open(struct usbd_pipe *); static void motg_poll(struct usbd_bus *); static void motg_softintr(void *); -static usbd_status motg_allocm(struct usbd_bus *, usb_dma_t *, u_int32_t); -static void motg_freem(struct usbd_bus *, usb_dma_t *); -static usbd_xfer_handle motg_allocx(struct usbd_bus *); -static void motg_freex(struct usbd_bus *, usbd_xfer_handle); +static struct usbd_xfer * + motg_allocx(struct usbd_bus *, unsigned int); +static void motg_freex(struct usbd_bus *, struct usbd_xfer *); static void motg_get_lock(struct usbd_bus *, kmutex_t **); -static void motg_noop(usbd_pipe_handle pipe); +static int motg_roothub_ctrl(struct usbd_bus *, usb_device_request_t *, + void *, int); + +static void motg_noop(struct usbd_pipe *pipe); static usbd_status motg_portreset(struct motg_softc*); -static usbd_status motg_device_ctrl_transfer(usbd_xfer_handle); -static usbd_status motg_device_ctrl_start(usbd_xfer_handle); -static void motg_device_ctrl_abort(usbd_xfer_handle); -static void motg_device_ctrl_close(usbd_pipe_handle); -static void motg_device_ctrl_done(usbd_xfer_handle); +static usbd_status motg_device_ctrl_transfer(struct usbd_xfer *); +static usbd_status motg_device_ctrl_start(struct usbd_xfer *); +static void motg_device_ctrl_abort(struct usbd_xfer *); +static void motg_device_ctrl_close(struct usbd_pipe *); +static void motg_device_ctrl_done(struct usbd_xfer *); static usbd_status motg_device_ctrl_start1(struct motg_softc *); -static void motg_device_ctrl_read(usbd_xfer_handle); +static void motg_device_ctrl_read(struct usbd_xfer *); static void motg_device_ctrl_intr_rx(struct motg_softc *); static void motg_device_ctrl_intr_tx(struct motg_softc *); -static usbd_status motg_device_data_transfer(usbd_xfer_handle); -static usbd_status motg_device_data_start(usbd_xfer_handle); +static usbd_status motg_device_data_transfer(struct usbd_xfer *); +static usbd_status motg_device_data_start(struct usbd_xfer *); static usbd_status motg_device_data_start1(struct motg_softc *, struct motg_hw_ep *); -static void motg_device_data_abort(usbd_xfer_handle); -static void motg_device_data_close(usbd_pipe_handle); -static void motg_device_data_done(usbd_xfer_handle); +static void motg_device_data_abort(struct usbd_xfer *); +static void motg_device_data_close(struct usbd_pipe *); +static void motg_device_data_done(struct usbd_xfer *); static void motg_device_intr_rx(struct motg_softc *, int); static void motg_device_intr_tx(struct motg_softc *, int); -static void motg_device_data_read(usbd_xfer_handle); -static void motg_device_data_write(usbd_xfer_handle); +static void motg_device_data_read(struct usbd_xfer *); +static void motg_device_data_write(struct usbd_xfer *); -static void motg_waitintr(struct motg_softc *, usbd_xfer_handle); -static void motg_device_clear_toggle(usbd_pipe_handle); -static void motg_device_xfer_abort(usbd_xfer_handle); +static void motg_waitintr(struct motg_softc *, struct usbd_xfer *); +static void motg_device_clear_toggle(struct usbd_pipe *); +static void motg_device_xfer_abort(struct usbd_xfer *); -#define MOTG_INTR_ENDPT 1 #define UBARR(sc) bus_space_barrier((sc)->sc_iot, (sc)->sc_ioh, 0, (sc)->sc_size, \ BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE) #define UWRITE1(sc, r, x) \ @@ -191,74 +220,65 @@ UREAD4(struct motg_softc *sc, bus_size_t static void musbotg_pull_common(struct motg_softc *sc, uint8_t on) { - uint8_t val; + uint8_t val; - val = UREAD1(sc, MUSB2_REG_POWER); - if (on) - val |= MUSB2_MASK_SOFTC; - else - val &= ~MUSB2_MASK_SOFTC; + val = UREAD1(sc, MUSB2_REG_POWER); + if (on) + val |= MUSB2_MASK_SOFTC; + else + val &= ~MUSB2_MASK_SOFTC; - UWRITE1(sc, MUSB2_REG_POWER, val); + UWRITE1(sc, MUSB2_REG_POWER, val); } const struct usbd_bus_methods motg_bus_methods = { - .open_pipe = motg_open, - .soft_intr = motg_softintr, - .do_poll = motg_poll, - .allocm = motg_allocm, - .freem = motg_freem, - .allocx = motg_allocx, - .freex = motg_freex, - .get_lock = motg_get_lock, - .new_device = NULL, -}; - -const struct usbd_pipe_methods motg_root_ctrl_methods = { - .transfer = motg_root_ctrl_transfer, - .start = motg_root_ctrl_start, - .abort = motg_root_ctrl_abort, - .close = motg_root_ctrl_close, - .cleartoggle = motg_noop, - .done = motg_root_ctrl_done, + .ubm_open = motg_open, + .ubm_softint = motg_softintr, + .ubm_dopoll = motg_poll, + .ubm_allocx = motg_allocx, + .ubm_freex = motg_freex, + .ubm_getlock = motg_get_lock, + .ubm_rhctrl = motg_roothub_ctrl, }; const struct usbd_pipe_methods motg_root_intr_methods = { - .transfer = motg_root_intr_transfer, - .start = motg_root_intr_start, - .abort = motg_root_intr_abort, - .close = motg_root_intr_close, - .cleartoggle = motg_noop, - .done = motg_root_intr_done, + .upm_transfer = motg_root_intr_transfer, + .upm_start = motg_root_intr_start, + .upm_abort = motg_root_intr_abort, + .upm_close = motg_root_intr_close, + .upm_cleartoggle = motg_noop, + .upm_done = motg_root_intr_done, }; const struct usbd_pipe_methods motg_device_ctrl_methods = { - .transfer = motg_device_ctrl_transfer, - .start = motg_device_ctrl_start, - .abort = motg_device_ctrl_abort, - .close = motg_device_ctrl_close, - .cleartoggle = motg_noop, - .done = motg_device_ctrl_done, + .upm_transfer = motg_device_ctrl_transfer, + .upm_start = motg_device_ctrl_start, + .upm_abort = motg_device_ctrl_abort, + .upm_close = motg_device_ctrl_close, + .upm_cleartoggle = motg_noop, + .upm_done = motg_device_ctrl_done, }; const struct usbd_pipe_methods motg_device_data_methods = { - .transfer = motg_device_data_transfer, - .start = motg_device_data_start, - .abort = motg_device_data_abort, - .close = motg_device_data_close, - .cleartoggle = motg_device_clear_toggle, - .done = motg_device_data_done, + .upm_transfer = motg_device_data_transfer, + .upm_start = motg_device_data_start, + .upm_abort = motg_device_data_abort, + .upm_close = motg_device_data_close, + .upm_cleartoggle = motg_device_clear_toggle, + .upm_done = motg_device_data_done, }; -usbd_status +int motg_init(struct motg_softc *sc) { uint32_t nrx, ntx, val; int dynfifo; int offset, i; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + if (sc->sc_mode == MOTG_MODE_DEVICE) - return USBD_NORMAL_COMPLETION; /* not supported */ + return ENOTSUP; /* not supported */ /* disable all interrupts */ UWRITE1(sc, MUSB2_REG_INTUSBE, 0); @@ -291,7 +311,7 @@ motg_init(struct motg_softc *sc) UWRITE1(sc, MUSB2_REG_DEVCTL, val); } delay(1000); - DPRINTF(("DEVCTL 0x%x\n", UREAD1(sc, MUSB2_REG_DEVCTL))); + DPRINTF("DEVCTL 0x%x", UREAD1(sc, MUSB2_REG_DEVCTL), 0, 0, 0); /* disable testmode */ @@ -315,7 +335,7 @@ motg_init(struct motg_softc *sc) /* these numbers exclude the control endpoint */ - DPRINTF(("RX/TX endpoints: %u/%u\n", nrx, ntx)); + DPRINTFN(1,"RX/TX endpoints: %u/%u", nrx, ntx, 0, 0); sc->sc_ep_max = MAX(nrx, ntx); } else { @@ -323,13 +343,13 @@ motg_init(struct motg_softc *sc) } if (sc->sc_ep_max == 0) { aprint_error_dev(sc->sc_dev, " no endpoints\n"); - return USBD_INVAL; + return -1; } KASSERT(sc->sc_ep_max <= MOTG_MAX_HW_EP); /* read out configuration data */ val = UREAD1(sc, MUSB2_REG_CONFDATA); - DPRINTF(("Config Data: 0x%02x\n", val)); + DPRINTF("Config Data: 0x%02x", val, 0, 0, 0); dynfifo = (val & MUSB2_MASK_CD_DYNFIFOSZ) ? 1 : 0; @@ -338,7 +358,7 @@ motg_init(struct motg_softc *sc) "assuming 16Kbytes of FIFO RAM\n"); } - DPRINTF(("HW version: 0x%04x\n", UREAD1(sc, MUSB2_REG_HWVERS))); + DPRINTF("HW version: 0x%04x\n", UREAD1(sc, MUSB2_REG_HWVERS), 0, 0, 0); /* initialise endpoint profiles */ sc->sc_in_ep[0].ep_fifo_size = 64; @@ -361,8 +381,8 @@ motg_init(struct motg_softc *sc) fifotx_size = (val & MUSB2_MASK_TX_FSIZE); } - DPRINTF(("Endpoint %u FIFO size: IN=%u, OUT=%u, DYN=%d\n", - i, fifotx_size, fiforx_size, dynfifo)); + DPRINTF("Endpoint %u FIFO size: IN=%u, OUT=%u, DYN=%d", + i, fifotx_size, fiforx_size, dynfifo); if (dynfifo) { if (sc->sc_ep_fifosize) { @@ -429,7 +449,7 @@ motg_init(struct motg_softc *sc) } - DPRINTF(("Dynamic FIFO size = %d bytes\n", offset)); + DPRINTF("Dynamic FIFO size = %d bytes", offset, 0, 0, 0); /* turn on default interrupts */ @@ -444,35 +464,39 @@ motg_init(struct motg_softc *sc) "motgxfer", NULL, IPL_USB, NULL, NULL, NULL); mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB); - mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED); + mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_USB); /* Set up the bus struct. */ - sc->sc_bus.methods = &motg_bus_methods; - sc->sc_bus.pipe_size = sizeof(struct motg_pipe); - sc->sc_bus.usbrev = USBREV_2_0; - sc->sc_bus.hci_private = sc; + sc->sc_bus.ub_methods = &motg_bus_methods; + sc->sc_bus.ub_pipesize= sizeof(struct motg_pipe); + sc->sc_bus.ub_revision = USBREV_2_0; + sc->sc_bus.ub_usedma = false; + sc->sc_bus.ub_hcpriv = sc; snprintf(sc->sc_vendor, sizeof(sc->sc_vendor), "Mentor Graphics"); sc->sc_child = config_found(sc->sc_dev, &sc->sc_bus, usbctlprint); - return USBD_NORMAL_COMPLETION; + return 0; } static int -motg_select_ep(struct motg_softc *sc, usbd_pipe_handle pipe) +motg_select_ep(struct motg_softc *sc, struct usbd_pipe *pipe) { - struct motg_pipe *otgpipe = (struct motg_pipe *)pipe; - usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc; + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(pipe); + usb_endpoint_descriptor_t *ed = pipe->up_endpoint->ue_edesc; struct motg_hw_ep *ep; int i, size; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + ep = (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) ? sc->sc_in_ep : sc->sc_out_ep; - size = UE_GET_SIZE(UGETW(pipe->endpoint->edesc->wMaxPacketSize)); + size = UE_GET_SIZE(UGETW(pipe->up_endpoint->ue_edesc->wMaxPacketSize)); for (i = sc->sc_ep_max; i >= 1; i--) { - DPRINTF(("%s_ep[%d].ep_fifo_size %d size %d ref %d\n", - (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) ? - "in" : "out", i, ep[i].ep_fifo_size, size, ep[i].refcount)); + DPRINTF(UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN ? + "in_ep[%d].ep_fifo_size %d size %d ref %d" : + "out_ep[%d].ep_fifo_size %d size %d ref %d", i, + ep[i].ep_fifo_size, size, ep[i].refcount); if (ep[i].ep_fifo_size >= size) { /* found a suitable endpoint */ otgpipe->hw_ep = &ep[i]; @@ -495,37 +519,39 @@ motg_select_ep(struct motg_softc *sc, us /* Open a new pipe. */ usbd_status -motg_open(usbd_pipe_handle pipe) +motg_open(struct usbd_pipe *pipe) { - struct motg_softc *sc = pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)pipe; - usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc; - - DPRINTF(("motg_open: pipe=%p, addr=%d, endpt=%d (%d)\n", - pipe, pipe->device->address, - ed->bEndpointAddress, sc->sc_root_addr)); + struct motg_softc *sc = MOTG_PIPE2SC(pipe); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(pipe); + usb_endpoint_descriptor_t *ed = pipe->up_endpoint->ue_edesc; + uint8_t rhaddr = pipe->up_dev->ud_bus->ub_rhaddr; + + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + + DPRINTF("pipe=%p, addr=%d, endpt=%d (%d)", pipe, + pipe->up_dev->ud_addr, ed->bEndpointAddress, rhaddr); if (sc->sc_dying) return USBD_IOERROR; /* toggle state needed for bulk endpoints */ - otgpipe->nexttoggle = pipe->endpoint->datatoggle; + otgpipe->nexttoggle = pipe->up_endpoint->ue_toggle; - if (pipe->device->address == sc->sc_root_addr) { + if (pipe->up_dev->ud_addr == rhaddr) { switch (ed->bEndpointAddress) { case USB_CONTROL_ENDPOINT: - pipe->methods = &motg_root_ctrl_methods; + pipe->up_methods = &roothub_ctrl_methods; break; - case UE_DIR_IN | MOTG_INTR_ENDPT: - pipe->methods = &motg_root_intr_methods; + case UE_DIR_IN | USBROOTHUB_INTR_ENDPT: + pipe->up_methods = &motg_root_intr_methods; break; default: - return (USBD_INVAL); + return USBD_INVAL; } } else { switch (ed->bmAttributes & UE_XFERTYPE) { case UE_CONTROL: - pipe->methods = &motg_device_ctrl_methods; + pipe->up_methods = &motg_device_ctrl_methods; /* always use sc_in_ep[0] for in and out */ otgpipe->hw_ep = &sc->sc_in_ep[0]; mutex_enter(&sc->sc_lock); @@ -537,16 +563,15 @@ motg_open(usbd_pipe_handle pipe) case UE_BULK: case UE_INTERRUPT: DPRINTFN(MD_BULK, - ("new %s %s pipe wMaxPacketSize %d\n", - (ed->bmAttributes & UE_XFERTYPE) == UE_BULK ? - "bulk" : "interrupt", - (UE_GET_DIR(pipe->endpoint->edesc->bEndpointAddress) == UE_DIR_IN) ? "read" : "write", - UGETW(pipe->endpoint->edesc->wMaxPacketSize))); + "type %d dir %d pipe wMaxPacketSize %d", + UE_GET_XFERTYPE(ed->bmAttributes), + UE_GET_DIR(pipe->up_endpoint->ue_edesc->bEndpointAddress), + UGETW(pipe->up_endpoint->ue_edesc->wMaxPacketSize), 0); if (motg_select_ep(sc, pipe) != 0) goto bad; KASSERT(otgpipe->hw_ep != NULL); - pipe->methods = &motg_device_data_methods; - otgpipe->nexttoggle = pipe->endpoint->datatoggle; + pipe->up_methods = &motg_device_data_methods; + otgpipe->nexttoggle = pipe->up_endpoint->ue_toggle; break; default: goto bad; @@ -557,26 +582,27 @@ motg_open(usbd_pipe_handle pipe) #endif /* notyet */ } } - return (USBD_NORMAL_COMPLETION); + return USBD_NORMAL_COMPLETION; bad: - return (USBD_NOMEM); + return USBD_NOMEM; } void motg_softintr(void *v) { struct usbd_bus *bus = v; - struct motg_softc *sc = bus->hci_private; + struct motg_softc *sc = MOTG_BUS2SC(bus); uint16_t rx_status, tx_status; uint8_t ctrl_status; uint32_t val; int i; - KASSERT(sc->sc_bus.use_polling || mutex_owned(&sc->sc_lock)); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); - DPRINTFN(MD_ROOT | MD_CTRL, - ("%s: motg_softintr\n", device_xname(sc->sc_dev))); + KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock)); + + DPRINTFN(MD_ROOT | MD_CTRL, "sc %p", sc, 0 ,0 ,0); mutex_spin_enter(&sc->sc_intr_lock); rx_status = sc->sc_intr_rx_ep; @@ -592,8 +618,7 @@ motg_softintr(void *v) if (ctrl_status & (MUSB2_MASK_IRESET | MUSB2_MASK_IRESUME | MUSB2_MASK_ISUSP | MUSB2_MASK_ICONN | MUSB2_MASK_IDISC)) { - DPRINTFN(MD_ROOT | MD_CTRL, ("motg_softintr bus 0x%x\n", - ctrl_status)); + DPRINTFN(MD_ROOT | MD_CTRL, "bus 0x%x", ctrl_status, 0, 0, 0); if (ctrl_status & MUSB2_MASK_IRESET) { sc->sc_isreset = 1; @@ -607,8 +632,8 @@ motg_softintr(void *v) sc->sc_high_speed = 1; else sc->sc_high_speed = 0; - DPRINTFN(MD_ROOT | MD_CTRL, ("motg_softintr speed %d\n", - sc->sc_high_speed)); + DPRINTFN(MD_ROOT | MD_CTRL, "speed %d", sc->sc_high_speed, + 0, 0, 0); /* turn off interrupts */ val = MUSB2_MASK_IRESET; @@ -681,7 +706,7 @@ motg_softintr(void *v) void motg_poll(struct usbd_bus *bus) { - struct motg_softc *sc = bus->hci_private; + struct motg_softc *sc = MOTG_BUS2SC(bus); sc->sc_intr_poll(sc->sc_intr_poll_arg); mutex_enter(&sc->sc_lock); @@ -698,8 +723,7 @@ motg_intr(struct motg_softc *sc, uint16_ sc->sc_intr_rx_ep = rx_ep; sc->sc_intr_ctrl = ctrl; - if (!sc->sc_bus.use_polling) { - sc->sc_bus.no_intrs++; + if (!sc->sc_bus.ub_usepolling) { usb_schedsoftintr(&sc->sc_bus); } return 1; @@ -709,8 +733,10 @@ int motg_intr_vbus(struct motg_softc *sc, int vbus) { uint8_t val; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + if (sc->sc_mode == MOTG_MODE_HOST && vbus == 0) { - DPRINTF(("motg_intr_vbus: vbus down, try to re-enable\n")); + DPRINTF("vbus down, try to re-enable", 0, 0, 0, 0); /* try to re-enter session for Host mode */ val = UREAD1(sc, MUSB2_REG_DEVCTL); val |= MUSB2_MASK_SESS; @@ -719,58 +745,33 @@ motg_intr_vbus(struct motg_softc *sc, in return 1; } -usbd_status -motg_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size) -{ - struct motg_softc *sc = bus->hci_private; - usbd_status status; - - status = usb_allocmem(&sc->sc_bus, size, 0, dma); - if (status == USBD_NOMEM) - status = usb_reserve_allocm(&sc->sc_dma_reserve, dma, size); - return status; -} - -void -motg_freem(struct usbd_bus *bus, usb_dma_t *dma) -{ - if (dma->block->flags & USB_DMA_RESERVE) { - usb_reserve_freem(&((struct motg_softc *)bus)->sc_dma_reserve, - dma); - return; - } - usb_freemem(&((struct motg_softc *)bus)->sc_bus, dma); -} - -usbd_xfer_handle -motg_allocx(struct usbd_bus *bus) +struct usbd_xfer * +motg_allocx(struct usbd_bus *bus, unsigned int nframes) { - struct motg_softc *sc = bus->hci_private; - usbd_xfer_handle xfer; + struct motg_softc *sc = MOTG_BUS2SC(bus); + struct usbd_xfer *xfer; xfer = pool_cache_get(sc->sc_xferpool, PR_NOWAIT); if (xfer != NULL) { memset(xfer, 0, sizeof(struct motg_xfer)); - UXFER(xfer)->sc = sc; #ifdef DIAGNOSTIC - // XXX UXFER(xfer)->iinfo.isdone = 1; - xfer->busy_free = XFER_BUSY; + xfer->ux_state = XFER_BUSY; #endif } - return (xfer); + return xfer; } void -motg_freex(struct usbd_bus *bus, usbd_xfer_handle xfer) +motg_freex(struct usbd_bus *bus, struct usbd_xfer *xfer) { - struct motg_softc *sc = bus->hci_private; + struct motg_softc *sc = MOTG_BUS2SC(bus); #ifdef DIAGNOSTIC - if (xfer->busy_free != XFER_BUSY) { + if (xfer->ux_state != XFER_BUSY) { printf("motg_freex: xfer=%p not busy, 0x%08x\n", xfer, - xfer->busy_free); + xfer->ux_state); } - xfer->busy_free = XFER_FREE; + xfer->ux_state = XFER_FREE; #endif pool_cache_put(sc->sc_xferpool, xfer); } @@ -778,252 +779,77 @@ motg_freex(struct usbd_bus *bus, usbd_xf static void motg_get_lock(struct usbd_bus *bus, kmutex_t **lock) { - struct motg_softc *sc = bus->hci_private; + struct motg_softc *sc = MOTG_BUS2SC(bus); *lock = &sc->sc_lock; } /* - * Data structures and routines to emulate the root hub. - */ -usb_device_descriptor_t motg_devd = { - USB_DEVICE_DESCRIPTOR_SIZE, - UDESC_DEVICE, /* type */ - {0x00, 0x01}, /* USB version */ - UDCLASS_HUB, /* class */ - UDSUBCLASS_HUB, /* subclass */ - UDPROTO_FSHUB, /* protocol */ - 64, /* max packet */ - {0},{0},{0x00,0x01}, /* device id */ - 1,2,0, /* string indicies */ - 1 /* # of configurations */ -}; - -const usb_config_descriptor_t motg_confd = { - USB_CONFIG_DESCRIPTOR_SIZE, - UDESC_CONFIG, - {USB_CONFIG_DESCRIPTOR_SIZE + - USB_INTERFACE_DESCRIPTOR_SIZE + - USB_ENDPOINT_DESCRIPTOR_SIZE}, - 1, - 1, - 0, - UC_ATTR_MBO | UC_SELF_POWERED, - 0 /* max power */ -}; - -const usb_interface_descriptor_t motg_ifcd = { - USB_INTERFACE_DESCRIPTOR_SIZE, - UDESC_INTERFACE, - 0, - 0, - 1, - UICLASS_HUB, - UISUBCLASS_HUB, - UIPROTO_FSHUB, - 0 -}; - -const usb_endpoint_descriptor_t motg_endpd = { - USB_ENDPOINT_DESCRIPTOR_SIZE, - UDESC_ENDPOINT, - UE_DIR_IN | MOTG_INTR_ENDPT, - UE_INTERRUPT, - {8}, - 255 -}; - -const usb_hub_descriptor_t motg_hubd = { - USB_HUB_DESCRIPTOR_SIZE, - UDESC_HUB, - 1, - { UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL, 0 }, - 50, /* power on to power good */ - 0, - { 0x00 }, /* port is removable */ - { 0 }, -}; - -/* - * Simulate a hardware hub by handling all the necessary requests. + * Routines to emulate the root hub. */ -usbd_status -motg_root_ctrl_transfer(usbd_xfer_handle xfer) -{ - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - usbd_status err; - - /* Insert last in queue. */ - mutex_enter(&sc->sc_lock); - err = usb_insert_transfer(xfer); - mutex_exit(&sc->sc_lock); - if (err) - return (err); - - /* - * Pipe isn't running (otherwise err would be USBD_INPROG), - * so start it first. - */ - return (motg_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); -} - -usbd_status -motg_root_ctrl_start(usbd_xfer_handle xfer) -{ - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - usb_device_request_t *req; - void *buf = NULL; - int len, value, index, status, change, l, totlen = 0; +Static int +motg_roothub_ctrl(struct usbd_bus *bus, usb_device_request_t *req, + void *buf, int buflen) +{ + struct motg_softc *sc = MOTG_BUS2SC(bus); + int status, change, totlen = 0; + uint16_t len, value, index; usb_port_status_t ps; usbd_status err; uint32_t val; - if (sc->sc_dying) - return (USBD_IOERROR); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); -#ifdef DIAGNOSTIC - if (!(xfer->rqflags & URQ_REQUEST)) - panic("motg_root_ctrl_start: not a request"); -#endif - req = &xfer->request; + if (sc->sc_dying) + return -1; - DPRINTFN(MD_ROOT,("motg_root_ctrl_control type=0x%02x request=%02x\n", - req->bmRequestType, req->bRequest)); + DPRINTFN(MD_ROOT, "type=0x%02x request=%02x", req->bmRequestType, + req->bRequest, 0, 0); len = UGETW(req->wLength); value = UGETW(req->wValue); index = UGETW(req->wIndex); - if (len != 0) - buf = KERNADDR(&xfer->dmabuf, 0); - #define C(x,y) ((x) | ((y) << 8)) - switch(C(req->bRequest, req->bmRequestType)) { - case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE): - case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE): - case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT): - /* - * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops - * for the integrated root hub. - */ - break; - case C(UR_GET_CONFIG, UT_READ_DEVICE): - if (len > 0) { - *(u_int8_t *)buf = sc->sc_root_conf; - totlen = 1; - } - break; + switch (C(req->bRequest, req->bmRequestType)) { case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE): - DPRINTFN(MD_ROOT,("motg_root_ctrl_control wValue=0x%04x\n", value)); - if (len == 0) - break; - switch(value >> 8) { - case UDESC_DEVICE: - if ((value & 0xff) != 0) { - err = USBD_IOERROR; - goto ret; - } - totlen = l = min(len, USB_DEVICE_DESCRIPTOR_SIZE); - USETW(motg_devd.idVendor, sc->sc_id_vendor); - memcpy(buf, &motg_devd, l); - break; - case UDESC_CONFIG: - if ((value & 0xff) != 0) { - err = USBD_IOERROR; - goto ret; - } - totlen = l = min(len, USB_CONFIG_DESCRIPTOR_SIZE); - memcpy(buf, &motg_confd, l); - buf = (char *)buf + l; - len -= l; - l = min(len, USB_INTERFACE_DESCRIPTOR_SIZE); - totlen += l; - memcpy(buf, &motg_ifcd, l); - buf = (char *)buf + l; - len -= l; - l = min(len, USB_ENDPOINT_DESCRIPTOR_SIZE); - totlen += l; - memcpy(buf, &motg_endpd, l); + DPRINTFN(MD_ROOT, "wValue=0x%04x", value, 0, 0, 0); + switch (value) { + case C(0, UDESC_DEVICE): { + usb_device_descriptor_t devd; + + totlen = min(buflen, sizeof(devd)); + memcpy(&devd, buf, totlen); + USETW(devd.idVendor, sc->sc_id_vendor); + memcpy(buf, &devd, totlen); break; - case UDESC_STRING: + } + case C(1, UDESC_STRING): #define sd ((usb_string_descriptor_t *)buf) - switch (value & 0xff) { - case 0: /* Language table */ - totlen = usb_makelangtbl(sd, len); - break; - case 1: /* Vendor */ - totlen = usb_makestrdesc(sd, len, - sc->sc_vendor); - break; - case 2: /* Product */ - totlen = usb_makestrdesc(sd, len, - "MOTG root hub"); - break; - } -#undef sd + /* Vendor */ + totlen = usb_makestrdesc(sd, len, sc->sc_vendor); break; + case C(2, UDESC_STRING): + /* Product */ + totlen = usb_makestrdesc(sd, len, "MOTG root hub"); + break; +#undef sd default: - err = USBD_IOERROR; - goto ret; - } - break; - case C(UR_GET_INTERFACE, UT_READ_INTERFACE): - if (len > 0) { - *(u_int8_t *)buf = 0; - totlen = 1; - } - break; - case C(UR_GET_STATUS, UT_READ_DEVICE): - if (len > 1) { - USETW(((usb_status_t *)buf)->wStatus,UDS_SELF_POWERED); - totlen = 2; - } - break; - case C(UR_GET_STATUS, UT_READ_INTERFACE): - case C(UR_GET_STATUS, UT_READ_ENDPOINT): - if (len > 1) { - USETW(((usb_status_t *)buf)->wStatus, 0); - totlen = 2; - } - break; - case C(UR_SET_ADDRESS, UT_WRITE_DEVICE): - if (value >= USB_MAX_DEVICES) { - err = USBD_IOERROR; - goto ret; - } - sc->sc_root_addr = value; - break; - case C(UR_SET_CONFIG, UT_WRITE_DEVICE): - if (value != 0 && value != 1) { - err = USBD_IOERROR; - goto ret; + /* default from usbroothub */ + return buflen; } - sc->sc_root_conf = value; - break; - case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE): - break; - case C(UR_SET_FEATURE, UT_WRITE_DEVICE): - case C(UR_SET_FEATURE, UT_WRITE_INTERFACE): - case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT): - err = USBD_IOERROR; - goto ret; - case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE): - break; - case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT): break; /* Hub requests */ case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE): break; case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER): DPRINTFN(MD_ROOT, - ("motg_root_ctrl_control: UR_CLEAR_PORT_FEATURE " - "port=%d feature=%d\n", - index, value)); + "UR_CLEAR_PORT_FEATURE port=%d feature=%d", index, value, + 0, 0); if (index != 1) { - err = USBD_IOERROR; - goto ret; + return -1; } - switch(value) { + switch (value) { case UHF_PORT_ENABLE: sc->sc_port_enabled = 0; break; @@ -1052,8 +878,7 @@ motg_root_ctrl_start(usbd_xfer_handle xf break; case UHF_C_PORT_RESET: sc->sc_isreset = 0; - err = USBD_NORMAL_COMPLETION; - goto ret; + break; case UHF_PORT_POWER: /* XXX todo */ break; @@ -1062,40 +887,32 @@ motg_root_ctrl_start(usbd_xfer_handle xf case UHF_PORT_LOW_SPEED: case UHF_C_PORT_SUSPEND: default: - err = USBD_IOERROR; - goto ret; + return -1; } break; case C(UR_GET_BUS_STATE, UT_READ_CLASS_OTHER): - err = USBD_IOERROR; - goto ret; + return -1; case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE): if (len == 0) break; if ((value & 0xff) != 0) { - err = USBD_IOERROR; - goto ret; + return -1; } - l = min(len, USB_HUB_DESCRIPTOR_SIZE); - totlen = l; - memcpy(buf, &motg_hubd, l); + totlen = buflen; break; case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE): if (len != 4) { - err = USBD_IOERROR; - goto ret; + return -1; } memset(buf, 0, len); totlen = len; break; case C(UR_GET_STATUS, UT_READ_CLASS_OTHER): if (index != 1) { - err = USBD_IOERROR; - goto ret; + return -1; } if (len != 4) { - err = USBD_IOERROR; - goto ret; + return -1; } status = change = 0; if (sc->sc_connected) @@ -1119,19 +936,16 @@ motg_root_ctrl_start(usbd_xfer_handle xf change |= UPS_C_PORT_RESET; USETW(ps.wPortStatus, status); USETW(ps.wPortChange, change); - l = min(len, sizeof ps); - memcpy(buf, &ps, l); - totlen = l; + totlen = min(len, sizeof(ps)); + memcpy(buf, &ps, totlen); break; case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE): - err = USBD_IOERROR; - goto ret; + return -1; case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE): break; case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER): if (index != 1) { - err = USBD_IOERROR; - goto ret; + return -1; } switch(value) { case UHF_PORT_ENABLE: @@ -1150,11 +964,12 @@ motg_root_ctrl_start(usbd_xfer_handle xf break; case UHF_PORT_RESET: err = motg_portreset(sc); - goto ret; + if (err != USBD_NORMAL_COMPLETION) + return -1; + return 0; case UHF_PORT_POWER: /* XXX todo */ - err = USBD_NORMAL_COMPLETION; - goto ret; + return 0; case UHF_C_PORT_CONNECTION: case UHF_C_PORT_ENABLE: case UHF_C_PORT_OVER_CURRENT: @@ -1164,65 +979,36 @@ motg_root_ctrl_start(usbd_xfer_handle xf case UHF_C_PORT_SUSPEND: case UHF_C_PORT_RESET: default: - err = USBD_IOERROR; - goto ret; + return -1; } break; default: - err = USBD_IOERROR; - goto ret; + /* default from usbroothub */ + return buflen; } - xfer->actlen = totlen; - err = USBD_NORMAL_COMPLETION; - ret: - xfer->status = err; - mutex_enter(&sc->sc_lock); - usb_transfer_complete(xfer); - mutex_exit(&sc->sc_lock); - return (USBD_IN_PROGRESS); -} - -/* Abort a root control request. */ -void -motg_root_ctrl_abort(usbd_xfer_handle xfer) -{ - /* Nothing to do, all transfers are synchronous. */ -} - -/* Close the root pipe. */ -void -motg_root_ctrl_close(usbd_pipe_handle pipe) -{ - DPRINTFN(MD_ROOT, ("motg_root_ctrl_close\n")); -} -void -motg_root_ctrl_done(usbd_xfer_handle xfer) -{ + return totlen; } /* Abort a root interrupt request. */ void -motg_root_intr_abort(usbd_xfer_handle xfer) +motg_root_intr_abort(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; + struct motg_softc *sc = MOTG_XFER2SC(xfer); KASSERT(mutex_owned(&sc->sc_lock)); - KASSERT(xfer->pipe->intrxfer == xfer); + KASSERT(xfer->ux_pipe->up_intrxfer == xfer); sc->sc_intr_xfer = NULL; -#ifdef DIAGNOSTIC - // XXX UXFER(xfer)->iinfo.isdone = 1; -#endif - xfer->status = USBD_CANCELLED; + xfer->ux_status = USBD_CANCELLED; usb_transfer_complete(xfer); } usbd_status -motg_root_intr_transfer(usbd_xfer_handle xfer) +motg_root_intr_transfer(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; + struct motg_softc *sc = MOTG_XFER2SC(xfer); usbd_status err; /* Insert last in queue. */ @@ -1230,51 +1016,53 @@ motg_root_intr_transfer(usbd_xfer_handle err = usb_insert_transfer(xfer); mutex_exit(&sc->sc_lock); if (err) - return (err); + return err; /* * Pipe isn't running (otherwise err would be USBD_INPROG), * start first */ - return (motg_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); + return motg_root_intr_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue)); } /* Start a transfer on the root interrupt pipe */ usbd_status -motg_root_intr_start(usbd_xfer_handle xfer) +motg_root_intr_start(struct usbd_xfer *xfer) { - usbd_pipe_handle pipe = xfer->pipe; - struct motg_softc *sc = pipe->device->bus->hci_private; + struct usbd_pipe *pipe = xfer->ux_pipe; + struct motg_softc *sc = MOTG_PIPE2SC(pipe); + + MOTGHIST_FUNC(); MOTGHIST_CALLED(); - DPRINTFN(MD_ROOT, ("motg_root_intr_start: xfer=%p len=%d flags=%d\n", - xfer, xfer->length, xfer->flags)); + DPRINTFN(MD_ROOT, "xfer=%p len=%d flags=%d", xfer, xfer->ux_length, + xfer->ux_flags, 0); if (sc->sc_dying) - return (USBD_IOERROR); + return USBD_IOERROR; sc->sc_intr_xfer = xfer; - return (USBD_IN_PROGRESS); + return USBD_IN_PROGRESS; } /* Close the root interrupt pipe. */ void -motg_root_intr_close(usbd_pipe_handle pipe) +motg_root_intr_close(struct usbd_pipe *pipe) { - struct motg_softc *sc = pipe->device->bus->hci_private; + struct motg_softc *sc = MOTG_PIPE2SC(pipe); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); KASSERT(mutex_owned(&sc->sc_lock)); sc->sc_intr_xfer = NULL; - DPRINTFN(MD_ROOT, ("motg_root_intr_close\n")); } void -motg_root_intr_done(usbd_xfer_handle xfer) +motg_root_intr_done(struct usbd_xfer *xfer) { } void -motg_noop(usbd_pipe_handle pipe) +motg_noop(struct usbd_pipe *pipe) { } @@ -1282,6 +1070,7 @@ static usbd_status motg_portreset(struct motg_softc *sc) { uint32_t val; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); val = UREAD1(sc, MUSB2_REG_POWER); val |= MUSB2_MASK_RESET; @@ -1299,12 +1088,11 @@ motg_portreset(struct motg_softc *sc) sc->sc_high_speed = 1; else sc->sc_high_speed = 0; - DPRINTFN(MD_ROOT | MD_CTRL, ("motg_portreset speed %d\n", - sc->sc_high_speed)); + DPRINTFN(MD_ROOT | MD_CTRL, "speed %d", sc->sc_high_speed, 0, 0, 0); sc->sc_isreset = 1; sc->sc_port_enabled = 1; - return (USBD_NORMAL_COMPLETION); + return USBD_NORMAL_COMPLETION; } /* @@ -1313,28 +1101,28 @@ motg_portreset(struct motg_softc *sc) static void motg_hub_change(struct motg_softc *sc) { - usbd_xfer_handle xfer = sc->sc_intr_xfer; - usbd_pipe_handle pipe; + struct usbd_xfer *xfer = sc->sc_intr_xfer; + struct usbd_pipe *pipe; u_char *p; - DPRINTFN(MD_ROOT, ("motg_hub_change\n")); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); if (xfer == NULL) return; /* the interrupt pipe is not open */ - pipe = xfer->pipe; - if (pipe->device == NULL || pipe->device->bus == NULL) + pipe = xfer->ux_pipe; + if (pipe->up_dev == NULL || pipe->up_dev->ud_bus == NULL) return; /* device has detached */ - p = KERNADDR(&xfer->dmabuf, 0); + p = xfer->ux_buf; p[0] = 1<<1; - xfer->actlen = 1; - xfer->status = USBD_NORMAL_COMPLETION; + xfer->ux_actlen = 1; + xfer->ux_status = USBD_NORMAL_COMPLETION; usb_transfer_complete(xfer); } static uint8_t -motg_speed(u_int8_t speed) +motg_speed(uint8_t speed) { switch(speed) { case USB_SPEED_LOW: @@ -1350,7 +1138,7 @@ motg_speed(u_int8_t speed) } static uint8_t -motg_type(u_int8_t type) +motg_type(uint8_t type) { switch(type) { case UE_CONTROL: @@ -1368,27 +1156,27 @@ motg_type(u_int8_t type) } static void -motg_setup_endpoint_tx(usbd_xfer_handle xfer) +motg_setup_endpoint_tx(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; - usbd_device_handle dev = otgpipe->pipe.device; + struct motg_softc *sc = MOTG_XFER2SC(xfer); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); + struct usbd_device *dev = otgpipe->pipe.up_dev; int epnumber = otgpipe->hw_ep->ep_number; - UWRITE1(sc, MUSB2_REG_TXFADDR(epnumber), dev->address); - if (dev->myhsport) { + UWRITE1(sc, MUSB2_REG_TXFADDR(epnumber), dev->ud_addr); + if (dev->ud_myhsport) { UWRITE1(sc, MUSB2_REG_TXHADDR(epnumber), - dev->myhsport->parent->address); + dev->ud_myhsport->up_parent->ud_addr); UWRITE1(sc, MUSB2_REG_TXHUBPORT(epnumber), - dev->myhsport->portno); + dev->ud_myhsport->up_portno); } else { UWRITE1(sc, MUSB2_REG_TXHADDR(epnumber), 0); UWRITE1(sc, MUSB2_REG_TXHUBPORT(epnumber), 0); } UWRITE1(sc, MUSB2_REG_TXTI, - motg_speed(dev->speed) | - UE_GET_ADDR(xfer->pipe->endpoint->edesc->bEndpointAddress) | - motg_type(UE_GET_XFERTYPE(xfer->pipe->endpoint->edesc->bmAttributes)) + motg_speed(dev->ud_speed) | + UE_GET_ADDR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress) | + motg_type(UE_GET_XFERTYPE(xfer->ux_pipe->up_endpoint->ue_edesc->bmAttributes)) ); if (epnumber == 0) { if (sc->sc_high_speed) { @@ -1398,7 +1186,7 @@ motg_setup_endpoint_tx(usbd_xfer_handle UWRITE1(sc, MUSB2_REG_TXNAKLIMIT, NAK_TO_CTRL); } } else { - if ((xfer->pipe->endpoint->edesc->bmAttributes & UE_XFERTYPE) + if ((xfer->ux_pipe->up_endpoint->ue_edesc->bmAttributes & UE_XFERTYPE) == UE_BULK) { if (sc->sc_high_speed) { UWRITE1(sc, MUSB2_REG_TXNAKLIMIT, @@ -1417,27 +1205,27 @@ motg_setup_endpoint_tx(usbd_xfer_handle } static void -motg_setup_endpoint_rx(usbd_xfer_handle xfer) +motg_setup_endpoint_rx(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - usbd_device_handle dev = xfer->pipe->device; - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; + struct motg_softc *sc = MOTG_XFER2SC(xfer); + struct usbd_device *dev = xfer->ux_pipe->up_dev; + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); int epnumber = otgpipe->hw_ep->ep_number; - UWRITE1(sc, MUSB2_REG_RXFADDR(epnumber), dev->address); - if (dev->myhsport) { + UWRITE1(sc, MUSB2_REG_RXFADDR(epnumber), dev->ud_addr); + if (dev->ud_myhsport) { UWRITE1(sc, MUSB2_REG_RXHADDR(epnumber), - dev->myhsport->parent->address); + dev->ud_myhsport->up_parent->ud_addr); UWRITE1(sc, MUSB2_REG_RXHUBPORT(epnumber), - dev->myhsport->portno); + dev->ud_myhsport->up_portno); } else { UWRITE1(sc, MUSB2_REG_RXHADDR(epnumber), 0); UWRITE1(sc, MUSB2_REG_RXHUBPORT(epnumber), 0); } UWRITE1(sc, MUSB2_REG_RXTI, - motg_speed(dev->speed) | - UE_GET_ADDR(xfer->pipe->endpoint->edesc->bEndpointAddress) | - motg_type(UE_GET_XFERTYPE(xfer->pipe->endpoint->edesc->bmAttributes)) + motg_speed(dev->ud_speed) | + UE_GET_ADDR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress) | + motg_type(UE_GET_XFERTYPE(xfer->ux_pipe->up_endpoint->ue_edesc->bmAttributes)) ); if (epnumber == 0) { if (sc->sc_high_speed) { @@ -1447,7 +1235,7 @@ motg_setup_endpoint_rx(usbd_xfer_handle UWRITE1(sc, MUSB2_REG_TXNAKLIMIT, NAK_TO_CTRL); } } else { - if ((xfer->pipe->endpoint->edesc->bmAttributes & UE_XFERTYPE) + if ((xfer->ux_pipe->up_endpoint->ue_edesc->bmAttributes & UE_XFERTYPE) == UE_BULK) { if (sc->sc_high_speed) { UWRITE1(sc, MUSB2_REG_RXNAKLIMIT, @@ -1466,37 +1254,37 @@ motg_setup_endpoint_rx(usbd_xfer_handle } static usbd_status -motg_device_ctrl_transfer(usbd_xfer_handle xfer) +motg_device_ctrl_transfer(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; + struct motg_softc *sc = MOTG_XFER2SC(xfer); usbd_status err; /* Insert last in queue. */ mutex_enter(&sc->sc_lock); err = usb_insert_transfer(xfer); - xfer->status = USBD_NOT_STARTED; + xfer->ux_status = USBD_NOT_STARTED; mutex_exit(&sc->sc_lock); if (err) - return (err); + return err; /* * Pipe isn't running (otherwise err would be USBD_INPROG), * so start it first. */ - return (motg_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); + return motg_device_ctrl_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue)); } static usbd_status -motg_device_ctrl_start(usbd_xfer_handle xfer) +motg_device_ctrl_start(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; + struct motg_softc *sc = MOTG_XFER2SC(xfer); usbd_status err; mutex_enter(&sc->sc_lock); err = motg_device_ctrl_start1(sc); mutex_exit(&sc->sc_lock); if (err != USBD_IN_PROGRESS) return err; - if (sc->sc_bus.use_polling) + if (sc->sc_bus.ub_usepolling) motg_waitintr(sc, xfer); return USBD_IN_PROGRESS; } @@ -1505,16 +1293,18 @@ static usbd_status motg_device_ctrl_start1(struct motg_softc *sc) { struct motg_hw_ep *ep = &sc->sc_in_ep[0]; - usbd_xfer_handle xfer = NULL; + struct usbd_xfer *xfer = NULL; struct motg_pipe *otgpipe; usbd_status err = 0; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); if (sc->sc_dying) - return (USBD_IOERROR); + return USBD_IOERROR; if (!sc->sc_connected) - return (USBD_IOERROR); + return USBD_IOERROR; if (ep->xfer != NULL) { err = USBD_IN_PROGRESS; @@ -1522,10 +1312,9 @@ motg_device_ctrl_start1(struct motg_soft } /* locate the first pipe with work to do */ SIMPLEQ_FOREACH(otgpipe, &ep->ep_pipes, ep_pipe_list) { - xfer = SIMPLEQ_FIRST(&otgpipe->pipe.queue); - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_start1 pipe %p xfer %p status %d\n", - otgpipe, xfer, (xfer != NULL) ? xfer->status : 0)); + xfer = SIMPLEQ_FIRST(&otgpipe->pipe.up_queue); + DPRINTFN(MD_CTRL, "pipe %p xfer %p status %d", + otgpipe, xfer, (xfer != NULL) ? xfer->ux_status : 0, 0); if (xfer != NULL) { /* move this pipe to the end of the list */ @@ -1540,32 +1329,34 @@ motg_device_ctrl_start1(struct motg_soft err = USBD_NOT_STARTED; goto end; } - xfer->status = USBD_IN_PROGRESS; - KASSERT(otgpipe == (struct motg_pipe *)xfer->pipe); + xfer->ux_status = USBD_IN_PROGRESS; + KASSERT(otgpipe == MOTG_PIPE2MPIPE(xfer->ux_pipe)); KASSERT(otgpipe->hw_ep == ep); #ifdef DIAGNOSTIC - if (!(xfer->rqflags & URQ_REQUEST)) + if (!(xfer->ux_rqflags & URQ_REQUEST)) panic("motg_device_ctrl_transfer: not a request"); #endif - // KASSERT(xfer->actlen == 0); - xfer->actlen = 0; + // KASSERT(xfer->ux_actlen == 0); + xfer->ux_actlen = 0; ep->xfer = xfer; - ep->datalen = xfer->length; + ep->datalen = xfer->ux_length; if (ep->datalen > 0) - ep->data = KERNADDR(&xfer->dmabuf, 0); + ep->data = xfer->ux_buf; else ep->data = NULL; - if ((xfer->flags & USBD_FORCE_SHORT_XFER) && + if ((xfer->ux_flags & USBD_FORCE_SHORT_XFER) && (ep->datalen % 64) == 0) ep->need_short_xfer = 1; else ep->need_short_xfer = 0; /* now we need send this request */ DPRINTFN(MD_CTRL, - ("motg_device_ctrl_start1(%p) send data %p len %d short %d speed %d to %d\n", - xfer, ep->data, ep->datalen, ep->need_short_xfer, xfer->pipe->device->speed, - xfer->pipe->device->address)); + "xfer %p send data %p len %d short %d", + xfer, ep->data, ep->datalen, ep->need_short_xfer); + DPRINTFN(MD_CTRL, + "xfer %p ... speed %d to %d", xfer->ux_pipe->up_dev->ud_speed, + xfer->ux_pipe->up_dev->ud_addr, 0, 0); KASSERT(ep->phase == IDLE); ep->phase = SETUP; /* select endpoint 0 */ @@ -1573,10 +1364,10 @@ motg_device_ctrl_start1(struct motg_soft /* fifo should be empty at this point */ KASSERT((UREAD1(sc, MUSB2_REG_TXCSRL) & MUSB2_MASK_CSR0L_TXPKTRDY) == 0); /* send data */ - // KASSERT(((vaddr_t)(&xfer->request) & 3) == 0); - KASSERT(sizeof(xfer->request) == 8); + // KASSERT(((vaddr_t)(&xfer->ux_request) & 3) == 0); + KASSERT(sizeof(xfer->ux_request) == 8); bus_space_write_multi_1(sc->sc_iot, sc->sc_ioh, MUSB2_REG_EPFIFO(0), - (void *)&xfer->request, sizeof(xfer->request)); + (void *)&xfer->ux_request, sizeof(xfer->ux_request)); motg_setup_endpoint_tx(xfer); /* start transaction */ @@ -1585,16 +1376,16 @@ motg_device_ctrl_start1(struct motg_soft end: if (err) - return (err); + return err; - return (USBD_IN_PROGRESS); + return USBD_IN_PROGRESS; } static void -motg_device_ctrl_read(usbd_xfer_handle xfer) +motg_device_ctrl_read(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; + struct motg_softc *sc = MOTG_XFER2SC(xfer); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); /* assume endpoint already selected */ motg_setup_endpoint_rx(xfer); /* start transaction */ @@ -1606,13 +1397,15 @@ static void motg_device_ctrl_intr_rx(struct motg_softc *sc) { struct motg_hw_ep *ep = &sc->sc_in_ep[0]; - usbd_xfer_handle xfer = ep->xfer; + struct usbd_xfer *xfer = ep->xfer; uint8_t csr; int datalen, max_datalen; char *data; bool got_short; usbd_status new_status = USBD_IN_PROGRESS; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); #ifdef DIAGNOSTIC @@ -1620,14 +1413,13 @@ motg_device_ctrl_intr_rx(struct motg_sof ep->phase != STATUS_IN) panic("motg_device_ctrl_intr_rx: bad phase %d", ep->phase); #endif - /* select endpoint 0 */ + /* select endpoint 0 */ UWRITE1(sc, MUSB2_REG_EPINDEX, 0); /* read out FIFO status */ csr = UREAD1(sc, MUSB2_REG_TXCSRL); - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_rx phase %d csr 0x%x xfer %p status %d\n", - ep->phase, csr, xfer, (xfer != NULL) ? xfer->status : 0)); + DPRINTFN(MD_CTRL, "phase %d csr 0x%x xfer %p status %d", + ep->phase, csr, xfer, (xfer != NULL) ? xfer->ux_status : 0); if (csr & MUSB2_MASK_CSR0L_NAKTIMO) { csr &= ~MUSB2_MASK_CSR0L_REQPKT; @@ -1650,7 +1442,7 @@ motg_device_ctrl_intr_rx(struct motg_sof if ((csr & MUSB2_MASK_CSR0L_RXPKTRDY) == 0) return; /* no data yet */ - if (xfer == NULL || xfer->status != USBD_IN_PROGRESS) + if (xfer == NULL || xfer->ux_status != USBD_IN_PROGRESS) goto complete; if (ep->phase == STATUS_IN) { @@ -1659,11 +1451,9 @@ motg_device_ctrl_intr_rx(struct motg_sof goto complete; } datalen = UREAD2(sc, MUSB2_REG_RXCOUNT); - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_rx phase %d datalen %d\n", - ep->phase, datalen)); - KASSERT(UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize) > 0); - max_datalen = min(UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize), + DPRINTFN(MD_CTRL, "phase %d datalen %d", ep->phase, datalen, 0, 0); + KASSERT(UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize) > 0); + max_datalen = min(UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize), ep->datalen); if (datalen > max_datalen) { new_status = USBD_IOERROR; @@ -1676,20 +1466,17 @@ motg_device_ctrl_intr_rx(struct motg_sof data = ep->data; ep->data += datalen; ep->datalen -= datalen; - xfer->actlen += datalen; + xfer->ux_actlen += datalen; if (((vaddr_t)data & 0x3) == 0 && (datalen >> 2) > 0) { - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_rx r4 data %p len %d\n", - data, datalen)); + DPRINTFN(MD_CTRL, "r4 data %p len %d", data, datalen, + 0, 0); bus_space_read_multi_4(sc->sc_iot, sc->sc_ioh, MUSB2_REG_EPFIFO(0), (void *)data, datalen >> 2); data += (datalen & ~0x3); datalen -= (datalen & ~0x3); } - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_rx r1 data %p len %d\n", - data, datalen)); + DPRINTFN(MD_CTRL, "r1 data %p len %d", data, datalen, 0, 0); if (datalen) { bus_space_read_multi_1(sc->sc_iot, sc->sc_ioh, MUSB2_REG_EPFIFO(0), data, datalen); @@ -1716,9 +1503,9 @@ motg_device_ctrl_intr_rx(struct motg_sof complete: ep->phase = IDLE; ep->xfer = NULL; - if (xfer && xfer->status == USBD_IN_PROGRESS) { + if (xfer && xfer->ux_status == USBD_IN_PROGRESS) { KASSERT(new_status != USBD_IN_PROGRESS); - xfer->status = new_status; + xfer->ux_status = new_status; usb_transfer_complete(xfer); } motg_device_ctrl_start1(sc); @@ -1728,12 +1515,14 @@ static void motg_device_ctrl_intr_tx(struct motg_softc *sc) { struct motg_hw_ep *ep = &sc->sc_in_ep[0]; - usbd_xfer_handle xfer = ep->xfer; + struct usbd_xfer *xfer = ep->xfer; uint8_t csr; int datalen; char *data; usbd_status new_status = USBD_IN_PROGRESS; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); if (ep->phase == DATA_IN || ep->phase == STATUS_IN) { motg_device_ctrl_intr_rx(sc); @@ -1745,13 +1534,12 @@ motg_device_ctrl_intr_tx(struct motg_sof ep->phase != STATUS_OUT) panic("motg_device_ctrl_intr_tx: bad phase %d", ep->phase); #endif - /* select endpoint 0 */ + /* select endpoint 0 */ UWRITE1(sc, MUSB2_REG_EPINDEX, 0); csr = UREAD1(sc, MUSB2_REG_TXCSRL); - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_tx phase %d csr 0x%x xfer %p status %d\n", - ep->phase, csr, xfer, (xfer != NULL) ? xfer->status : 0)); + DPRINTFN(MD_CTRL, "phase %d csr 0x%x xfer %p status %d", + ep->phase, csr, xfer, (xfer != NULL) ? xfer->ux_status : 0); if (csr & MUSB2_MASK_CSR0L_RXSTALL) { /* command not accepted */ @@ -1790,9 +1578,8 @@ motg_device_ctrl_intr_tx(struct motg_sof * we have sent status and got no error; * declare transfer complete */ - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_tx %p status %d complete\n", - xfer, xfer->status)); + DPRINTFN(MD_CTRL, "xfer %p status %d complete", xfer, + xfer->ux_status, 0, 0); new_status = USBD_NORMAL_COMPLETION; goto complete; } @@ -1800,16 +1587,15 @@ motg_device_ctrl_intr_tx(struct motg_sof if (ep->need_short_xfer) { ep->need_short_xfer = 0; /* one more data phase */ - if (xfer->request.bmRequestType & UT_READ) { - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_tx %p to DATA_IN\n", xfer)); + if (xfer->ux_request.bmRequestType & UT_READ) { + DPRINTFN(MD_CTRL, "xfer %p to DATA_IN", xfer, + 0, 0, 0); motg_device_ctrl_read(xfer); return; } /* else fall back to DATA_OUT */ } else { - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_tx %p to STATUS_IN, csrh 0x%x\n", - xfer, UREAD1(sc, MUSB2_REG_TXCSRH))); + DPRINTFN(MD_CTRL, "xfer %p to STATUS_IN, csrh 0x%x", + xfer, UREAD1(sc, MUSB2_REG_TXCSRH), 0, 0); ep->phase = STATUS_IN; UWRITE1(sc, MUSB2_REG_RXCSRH, UREAD1(sc, MUSB2_REG_RXCSRH) | @@ -1821,22 +1607,21 @@ motg_device_ctrl_intr_tx(struct motg_sof return; } } - if (xfer->request.bmRequestType & UT_READ) { + if (xfer->ux_request.bmRequestType & UT_READ) { motg_device_ctrl_read(xfer); return; } /* setup a dataout phase */ datalen = min(ep->datalen, - UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize)); + UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize)); ep->phase = DATA_OUT; - DPRINTFN(MD_CTRL, - ("motg_device_ctrl_intr_tx %p to DATA_OUT, csrh 0x%x\n", xfer, - UREAD1(sc, MUSB2_REG_TXCSRH))); + DPRINTFN(MD_CTRL, "xfer %p to DATA_OUT, csrh 0x%x", xfer, + UREAD1(sc, MUSB2_REG_TXCSRH), 0, 0); if (datalen) { data = ep->data; ep->data += datalen; ep->datalen -= datalen; - xfer->actlen += datalen; + xfer->ux_actlen += datalen; if (((vaddr_t)data & 0x3) == 0 && (datalen >> 2) > 0) { bus_space_write_multi_4(sc->sc_iot, sc->sc_ioh, @@ -1857,9 +1642,9 @@ motg_device_ctrl_intr_tx(struct motg_sof complete: ep->phase = IDLE; ep->xfer = NULL; - if (xfer && xfer->status == USBD_IN_PROGRESS) { + if (xfer && xfer->ux_status == USBD_IN_PROGRESS) { KASSERT(new_status != USBD_IN_PROGRESS); - xfer->status = new_status; + xfer->ux_status = new_status; usb_transfer_complete(xfer); } motg_device_ctrl_start1(sc); @@ -1867,24 +1652,26 @@ complete: /* Abort a device control request. */ void -motg_device_ctrl_abort(usbd_xfer_handle xfer) +motg_device_ctrl_abort(struct usbd_xfer *xfer) { - DPRINTFN(MD_CTRL, ("motg_device_ctrl_abort:\n")); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + motg_device_xfer_abort(xfer); } /* Close a device control pipe */ void -motg_device_ctrl_close(usbd_pipe_handle pipe) +motg_device_ctrl_close(struct usbd_pipe *pipe) { - struct motg_softc *sc __diagused = pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)pipe; + struct motg_softc *sc __diagused = MOTG_PIPE2SC(pipe); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(pipe); struct motg_pipe *otgpipeiter; - DPRINTFN(MD_CTRL, ("motg_device_ctrl_close:\n")); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); KASSERT(otgpipe->hw_ep->xfer == NULL || - otgpipe->hw_ep->xfer->pipe != pipe); + otgpipe->hw_ep->xfer->ux_pipe != pipe); SIMPLEQ_FOREACH(otgpipeiter, &otgpipe->hw_ep->ep_pipes, ep_pipe_list) { if (otgpipeiter == otgpipe) { @@ -1900,50 +1687,54 @@ motg_device_ctrl_close(usbd_pipe_handle } void -motg_device_ctrl_done(usbd_xfer_handle xfer) +motg_device_ctrl_done(struct usbd_xfer *xfer) { - struct motg_pipe *otgpipe __diagused = (struct motg_pipe *)xfer->pipe; - DPRINTFN(MD_CTRL, ("motg_device_ctrl_done:\n")); + struct motg_pipe *otgpipe __diagused = MOTG_PIPE2MPIPE(xfer->ux_pipe); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(otgpipe->hw_ep->xfer != xfer); } static usbd_status -motg_device_data_transfer(usbd_xfer_handle xfer) +motg_device_data_transfer(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; + struct motg_softc *sc = MOTG_XFER2SC(xfer); usbd_status err; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + /* Insert last in queue. */ mutex_enter(&sc->sc_lock); - DPRINTF(("motg_device_data_transfer(%p) status %d\n", - xfer, xfer->status)); + DPRINTF("xfer %p status %d", xfer, xfer->ux_status, 0, 0); err = usb_insert_transfer(xfer); - xfer->status = USBD_NOT_STARTED; + xfer->ux_status = USBD_NOT_STARTED; mutex_exit(&sc->sc_lock); if (err) - return (err); + return err; /* * Pipe isn't running (otherwise err would be USBD_INPROG), * so start it first. */ - return (motg_device_data_start(SIMPLEQ_FIRST(&xfer->pipe->queue))); + return motg_device_data_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue)); } static usbd_status -motg_device_data_start(usbd_xfer_handle xfer) +motg_device_data_start(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; + struct motg_softc *sc = MOTG_XFER2SC(xfer); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); usbd_status err; + + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + mutex_enter(&sc->sc_lock); - DPRINTF(("motg_device_data_start(%p) status %d\n", - xfer, xfer->status)); + DPRINTF("xfer %p status %d", xfer, xfer->ux_status, 0, 0); err = motg_device_data_start1(sc, otgpipe->hw_ep); mutex_exit(&sc->sc_lock); if (err != USBD_IN_PROGRESS) return err; - if (sc->sc_bus.use_polling) + if (sc->sc_bus.ub_usepolling) motg_waitintr(sc, xfer); return USBD_IN_PROGRESS; } @@ -1951,17 +1742,19 @@ motg_device_data_start(usbd_xfer_handle static usbd_status motg_device_data_start1(struct motg_softc *sc, struct motg_hw_ep *ep) { - usbd_xfer_handle xfer = NULL; + struct usbd_xfer *xfer = NULL; struct motg_pipe *otgpipe; usbd_status err = 0; uint32_t val __diagused; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); if (sc->sc_dying) - return (USBD_IOERROR); + return USBD_IOERROR; if (!sc->sc_connected) - return (USBD_IOERROR); + return USBD_IOERROR; if (ep->xfer != NULL) { err = USBD_IN_PROGRESS; @@ -1969,10 +1762,9 @@ motg_device_data_start1(struct motg_soft } /* locate the first pipe with work to do */ SIMPLEQ_FOREACH(otgpipe, &ep->ep_pipes, ep_pipe_list) { - xfer = SIMPLEQ_FIRST(&otgpipe->pipe.queue); - DPRINTFN(MD_BULK, - ("motg_device_data_start1 pipe %p xfer %p status %d\n", - otgpipe, xfer, (xfer != NULL) ? xfer->status : 0)); + xfer = SIMPLEQ_FIRST(&otgpipe->pipe.up_queue); + DPRINTFN(MD_BULK, "pipe %p xfer %p status %d", otgpipe, xfer, + (xfer != NULL) ? xfer->ux_status : 0, 0); if (xfer != NULL) { /* move this pipe to the end of the list */ SIMPLEQ_REMOVE(&ep->ep_pipes, otgpipe, @@ -1986,36 +1778,37 @@ motg_device_data_start1(struct motg_soft err = USBD_NOT_STARTED; goto end; } - xfer->status = USBD_IN_PROGRESS; - KASSERT(otgpipe == (struct motg_pipe *)xfer->pipe); + xfer->ux_status = USBD_IN_PROGRESS; + KASSERT(otgpipe == MOTG_PIPE2MPIPE(xfer->ux_pipe)); KASSERT(otgpipe->hw_ep == ep); #ifdef DIAGNOSTIC - if (xfer->rqflags & URQ_REQUEST) + if (xfer->ux_rqflags & URQ_REQUEST) panic("motg_device_data_transfer: a request"); #endif - // KASSERT(xfer->actlen == 0); - xfer->actlen = 0; + // KASSERT(xfer->ux_actlen == 0); + xfer->ux_actlen = 0; ep->xfer = xfer; - ep->datalen = xfer->length; + ep->datalen = xfer->ux_length; KASSERT(ep->datalen > 0); - ep->data = KERNADDR(&xfer->dmabuf, 0); - if ((xfer->flags & USBD_FORCE_SHORT_XFER) && + ep->data = xfer->ux_buf; + if ((xfer->ux_flags & USBD_FORCE_SHORT_XFER) && (ep->datalen % 64) == 0) ep->need_short_xfer = 1; else ep->need_short_xfer = 0; /* now we need send this request */ DPRINTFN(MD_BULK, - ("motg_device_data_start1(%p) %s data %p len %d short %d speed %d to %d\n", - xfer, - UE_GET_DIR(xfer->pipe->endpoint->edesc->bEndpointAddress) == UE_DIR_IN ? "read" : "write", - ep->data, ep->datalen, ep->need_short_xfer, xfer->pipe->device->speed, - xfer->pipe->device->address)); + UE_GET_DIR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress) == UE_DIR_IN ? + "xfer %p in data %p len %d short %d" : + "xfer %p out data %p len %d short %d", + xfer, ep->data, ep->datalen, ep->need_short_xfer); + DPRINTFN(MD_BULK, "... speed %d to %d", xfer->ux_pipe->up_dev->ud_speed, + xfer->ux_pipe->up_dev->ud_addr, 0, 0); KASSERT(ep->phase == IDLE); /* select endpoint */ UWRITE1(sc, MUSB2_REG_EPINDEX, ep->ep_number); - if (UE_GET_DIR(xfer->pipe->endpoint->edesc->bEndpointAddress) + if (UE_GET_DIR(xfer->ux_pipe->up_endpoint->ue_edesc->bEndpointAddress) == UE_DIR_IN) { val = UREAD1(sc, MUSB2_REG_RXCSRL); KASSERT((val & MUSB2_MASK_CSRL_RXPKTRDY) == 0); @@ -2028,24 +1821,26 @@ motg_device_data_start1(struct motg_soft } end: if (err) - return (err); + return err; - return (USBD_IN_PROGRESS); + return USBD_IN_PROGRESS; } static void -motg_device_data_read(usbd_xfer_handle xfer) +motg_device_data_read(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; + struct motg_softc *sc = MOTG_XFER2SC(xfer); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); uint32_t val; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); /* assume endpoint already selected */ motg_setup_endpoint_rx(xfer); /* Max packet size */ UWRITE2(sc, MUSB2_REG_RXMAXP, - UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize)); + UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize)); /* Data Toggle */ val = UREAD1(sc, MUSB2_REG_RXCSRH); val |= MUSB2_MASK_CSRH_RXDT_WREN; @@ -2055,40 +1850,40 @@ motg_device_data_read(usbd_xfer_handle x val &= ~MUSB2_MASK_CSRH_RXDT_VAL; UWRITE1(sc, MUSB2_REG_RXCSRH, val); - DPRINTFN(MD_BULK, - ("motg_device_data_read %p to DATA_IN on ep %d, csrh 0x%x\n", - xfer, otgpipe->hw_ep->ep_number, UREAD1(sc, MUSB2_REG_RXCSRH))); + DPRINTFN(MD_BULK, "%p to DATA_IN on ep %d, csrh 0x%x", + xfer, otgpipe->hw_ep->ep_number, UREAD1(sc, MUSB2_REG_RXCSRH), 0); /* start transaction */ UWRITE1(sc, MUSB2_REG_RXCSRL, MUSB2_MASK_CSRL_RXREQPKT); otgpipe->hw_ep->phase = DATA_IN; } static void -motg_device_data_write(usbd_xfer_handle xfer) +motg_device_data_write(struct usbd_xfer *xfer) { - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; + struct motg_softc *sc = MOTG_XFER2SC(xfer); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); struct motg_hw_ep *ep = otgpipe->hw_ep; int datalen; char *data; uint32_t val; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(xfer!=NULL); KASSERT(mutex_owned(&sc->sc_lock)); datalen = min(ep->datalen, - UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize)); + UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize)); ep->phase = DATA_OUT; - DPRINTFN(MD_BULK, - ("motg_device_data_write %p to DATA_OUT on ep %d, len %d csrh 0x%x\n", - xfer, ep->ep_number, datalen, UREAD1(sc, MUSB2_REG_TXCSRH))); + DPRINTFN(MD_BULK, "%p to DATA_OUT on ep %d, len %d csrh 0x%x", + xfer, ep->ep_number, datalen, UREAD1(sc, MUSB2_REG_TXCSRH)); /* assume endpoint already selected */ /* write data to fifo */ data = ep->data; ep->data += datalen; ep->datalen -= datalen; - xfer->actlen += datalen; + xfer->ux_actlen += datalen; if (((vaddr_t)data & 0x3) == 0 && (datalen >> 2) > 0) { bus_space_write_multi_4(sc->sc_iot, sc->sc_ioh, @@ -2105,7 +1900,7 @@ motg_device_data_write(usbd_xfer_handle motg_setup_endpoint_tx(xfer); /* Max packet size */ UWRITE2(sc, MUSB2_REG_TXMAXP, - UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize)); + UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize)); /* Data Toggle */ val = UREAD1(sc, MUSB2_REG_TXCSRH); val |= MUSB2_MASK_CSRH_TXDT_WREN; @@ -2123,26 +1918,25 @@ static void motg_device_intr_rx(struct motg_softc *sc, int epnumber) { struct motg_hw_ep *ep = &sc->sc_in_ep[epnumber]; - usbd_xfer_handle xfer = ep->xfer; + struct usbd_xfer *xfer = ep->xfer; uint8_t csr; int datalen, max_datalen; char *data; bool got_short; usbd_status new_status = USBD_IN_PROGRESS; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); KASSERT(ep->ep_number == epnumber); - DPRINTFN(MD_BULK, - ("motg_device_intr_rx on ep %d\n", epnumber)); - /* select endpoint */ + DPRINTFN(MD_BULK, "on ep %d", epnumber, 0, 0, 0); + /* select endpoint */ UWRITE1(sc, MUSB2_REG_EPINDEX, epnumber); /* read out FIFO status */ csr = UREAD1(sc, MUSB2_REG_RXCSRL); - DPRINTFN(MD_BULK, - ("motg_device_intr_rx phase %d csr 0x%x\n", - ep->phase, csr)); + DPRINTFN(MD_BULK, "phase %d csr 0x%x", ep->phase, csr ,0 ,0); if ((csr & (MUSB2_MASK_CSRL_RXNAKTO | MUSB2_MASK_CSRL_RXSTALL | MUSB2_MASK_CSRL_RXERROR | MUSB2_MASK_CSRL_RXPKTRDY)) == 0) @@ -2172,21 +1966,19 @@ motg_device_intr_rx(struct motg_softc *s } KASSERT(csr & MUSB2_MASK_CSRL_RXPKTRDY); - if (xfer == NULL || xfer->status != USBD_IN_PROGRESS) { + if (xfer == NULL || xfer->ux_status != USBD_IN_PROGRESS) { UWRITE1(sc, MUSB2_REG_RXCSRL, 0); goto complete; } - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); otgpipe->nexttoggle = otgpipe->nexttoggle ^ 1; datalen = UREAD2(sc, MUSB2_REG_RXCOUNT); - DPRINTFN(MD_BULK, - ("motg_device_intr_rx phase %d datalen %d\n", - ep->phase, datalen)); - KASSERT(UE_GET_SIZE(UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize)) > 0); + DPRINTFN(MD_BULK, "phase %d datalen %d", ep->phase, datalen ,0 ,0); + KASSERT(UE_GET_SIZE(UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize)) > 0); max_datalen = min( - UE_GET_SIZE(UGETW(xfer->pipe->endpoint->edesc->wMaxPacketSize)), + UE_GET_SIZE(UGETW(xfer->ux_pipe->up_endpoint->ue_edesc->wMaxPacketSize)), ep->datalen); if (datalen > max_datalen) { new_status = USBD_IOERROR; @@ -2199,21 +1991,18 @@ motg_device_intr_rx(struct motg_softc *s data = ep->data; ep->data += datalen; ep->datalen -= datalen; - xfer->actlen += datalen; + xfer->ux_actlen += datalen; if (((vaddr_t)data & 0x3) == 0 && (datalen >> 2) > 0) { - DPRINTFN(MD_BULK, - ("motg_device_intr_rx r4 data %p len %d\n", - data, datalen)); + DPRINTFN(MD_BULK, "r4 data %p len %d", data, datalen, + 0, 0); bus_space_read_multi_4(sc->sc_iot, sc->sc_ioh, MUSB2_REG_EPFIFO(ep->ep_number), (void *)data, datalen >> 2); data += (datalen & ~0x3); datalen -= (datalen & ~0x3); } - DPRINTFN(MD_BULK, - ("motg_device_intr_rx r1 data %p len %d\n", - data, datalen)); + DPRINTFN(MD_BULK, "r1 data %p len %d", data, datalen ,0 ,0); if (datalen) { bus_space_read_multi_1(sc->sc_iot, sc->sc_ioh, MUSB2_REG_EPFIFO(ep->ep_number), data, datalen); @@ -2231,14 +2020,13 @@ motg_device_intr_rx(struct motg_softc *s motg_device_data_read(xfer); return; complete: - DPRINTFN(MD_BULK, - ("motg_device_intr_rx xfer %p complete, status %d\n", xfer, - (xfer != NULL) ? xfer->status : 0)); + DPRINTFN(MD_BULK, "xfer %p complete, status %d", xfer, + (xfer != NULL) ? xfer->ux_status : 0, 0, 0); ep->phase = IDLE; ep->xfer = NULL; - if (xfer && xfer->status == USBD_IN_PROGRESS) { + if (xfer && xfer->ux_status == USBD_IN_PROGRESS) { KASSERT(new_status != USBD_IN_PROGRESS); - xfer->status = new_status; + xfer->ux_status = new_status; usb_transfer_complete(xfer); } motg_device_data_start1(sc, ep); @@ -2248,23 +2036,22 @@ static void motg_device_intr_tx(struct motg_softc *sc, int epnumber) { struct motg_hw_ep *ep = &sc->sc_out_ep[epnumber]; - usbd_xfer_handle xfer = ep->xfer; + struct usbd_xfer *xfer = ep->xfer; uint8_t csr; struct motg_pipe *otgpipe; usbd_status new_status = USBD_IN_PROGRESS; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); KASSERT(ep->ep_number == epnumber); - DPRINTFN(MD_BULK, - ("motg_device_intr_tx on ep %d\n", epnumber)); - /* select endpoint */ + DPRINTFN(MD_BULK, " on ep %d", epnumber, 0, 0, 0); + /* select endpoint */ UWRITE1(sc, MUSB2_REG_EPINDEX, epnumber); csr = UREAD1(sc, MUSB2_REG_TXCSRL); - DPRINTFN(MD_BULK, - ("motg_device_intr_tx phase %d csr 0x%x\n", - ep->phase, csr)); + DPRINTFN(MD_BULK, "phase %d csr 0x%x", ep->phase, csr, 0, 0); if (csr & (MUSB2_MASK_CSRL_TXSTALLED|MUSB2_MASK_CSRL_TXERROR)) { /* command not accepted */ @@ -2287,8 +2074,8 @@ motg_device_intr_tx(struct motg_softc *s UWRITE1(sc, MUSB2_REG_TXCSRL, csr); delay(1000); csr = UREAD1(sc, MUSB2_REG_TXCSRL); - DPRINTFN(MD_BULK, ("TX fifo flush ep %d CSR 0x%x\n", - epnumber, csr)); + DPRINTFN(MD_BULK, "TX fifo flush ep %d CSR 0x%x", + epnumber, csr, 0, 0); } goto complete; } @@ -2296,14 +2083,14 @@ motg_device_intr_tx(struct motg_softc *s /* data still not sent */ return; } - if (xfer == NULL || xfer->status != USBD_IN_PROGRESS) + if (xfer == NULL || xfer->ux_status != USBD_IN_PROGRESS) goto complete; #ifdef DIAGNOSTIC if (ep->phase != DATA_OUT) panic("motg_device_intr_tx: bad phase %d", ep->phase); #endif - otgpipe = (struct motg_pipe *)xfer->pipe; + otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); otgpipe->nexttoggle = otgpipe->nexttoggle ^ 1; if (ep->datalen == 0) { @@ -2319,18 +2106,17 @@ motg_device_intr_tx(struct motg_softc *s return; complete: - DPRINTFN(MD_BULK, - ("motg_device_intr_tx xfer %p complete, status %d\n", xfer, - (xfer != NULL) ? xfer->status : 0)); + DPRINTFN(MD_BULK, "xfer %p complete, status %d", xfer, + (xfer != NULL) ? xfer->ux_status : 0, 0, 0); #ifdef DIAGNOSTIC - if (xfer && xfer->status == USBD_IN_PROGRESS && ep->phase != DATA_OUT) + if (xfer && xfer->ux_status == USBD_IN_PROGRESS && ep->phase != DATA_OUT) panic("motg_device_intr_tx: bad phase %d", ep->phase); #endif ep->phase = IDLE; ep->xfer = NULL; - if (xfer && xfer->status == USBD_IN_PROGRESS) { + if (xfer && xfer->ux_status == USBD_IN_PROGRESS) { KASSERT(new_status != USBD_IN_PROGRESS); - xfer->status = new_status; + xfer->ux_status = new_status; usb_transfer_complete(xfer); } motg_device_data_start1(sc, ep); @@ -2338,31 +2124,31 @@ complete: /* Abort a device control request. */ void -motg_device_data_abort(usbd_xfer_handle xfer) +motg_device_data_abort(struct usbd_xfer *xfer) { -#ifdef DIAGNOSTIC - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; -#endif + struct motg_softc __diagused *sc = MOTG_XFER2SC(xfer); KASSERT(mutex_owned(&sc->sc_lock)); - DPRINTFN(MD_BULK, ("motg_device_data_abort:\n")); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + motg_device_xfer_abort(xfer); } /* Close a device control pipe */ void -motg_device_data_close(usbd_pipe_handle pipe) +motg_device_data_close(struct usbd_pipe *pipe) { - struct motg_softc *sc __diagused = pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)pipe; + struct motg_softc *sc __diagused = MOTG_PIPE2SC(pipe); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(pipe); struct motg_pipe *otgpipeiter; - DPRINTFN(MD_CTRL, ("motg_device_data_close:\n")); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(mutex_owned(&sc->sc_lock)); KASSERT(otgpipe->hw_ep->xfer == NULL || - otgpipe->hw_ep->xfer->pipe != pipe); + otgpipe->hw_ep->xfer->ux_pipe != pipe); - pipe->endpoint->datatoggle = otgpipe->nexttoggle; + pipe->up_endpoint->ue_toggle = otgpipe->nexttoggle; SIMPLEQ_FOREACH(otgpipeiter, &otgpipe->hw_ep->ep_pipes, ep_pipe_list) { if (otgpipeiter == otgpipe) { /* remove from list */ @@ -2377,10 +2163,11 @@ motg_device_data_close(usbd_pipe_handle } void -motg_device_data_done(usbd_xfer_handle xfer) +motg_device_data_done(struct usbd_xfer *xfer) { - struct motg_pipe *otgpipe __diagused = (struct motg_pipe *)xfer->pipe; - DPRINTFN(MD_CTRL, ("motg_device_data_done:\n")); + struct motg_pipe *otgpipe __diagused = MOTG_PIPE2MPIPE(xfer->ux_pipe); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + KASSERT(otgpipe->hw_ep->xfer != xfer); } @@ -2391,13 +2178,14 @@ motg_device_data_done(usbd_xfer_handle x * Only used during boot when interrupts are not enabled yet. */ void -motg_waitintr(struct motg_softc *sc, usbd_xfer_handle xfer) +motg_waitintr(struct motg_softc *sc, struct usbd_xfer *xfer) { - int timo = xfer->timeout; + int timo = xfer->ux_timeout; + MOTGHIST_FUNC(); MOTGHIST_CALLED(); mutex_enter(&sc->sc_lock); - DPRINTF(("motg_waitintr: timeout = %dms\n", timo)); + DPRINTF("timeout = %dms", timo, 0, 0, 0); for (; timo >= 0; timo--) { mutex_exit(&sc->sc_lock); @@ -2406,12 +2194,12 @@ motg_waitintr(struct motg_softc *sc, usb motg_poll(&sc->sc_bus); mutex_spin_exit(&sc->sc_intr_lock); mutex_enter(&sc->sc_lock); - if (xfer->status != USBD_IN_PROGRESS) + if (xfer->ux_status != USBD_IN_PROGRESS) goto done; } /* Timeout */ - DPRINTF(("motg_waitintr: timeout\n")); + DPRINTF("timeout", 0, 0, 0, 0); panic("motg_waitintr: timeout"); /* XXX handle timeout ! */ @@ -2420,33 +2208,34 @@ done: } void -motg_device_clear_toggle(usbd_pipe_handle pipe) +motg_device_clear_toggle(struct usbd_pipe *pipe) { - struct motg_pipe *otgpipe = (struct motg_pipe *)pipe; + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(pipe); otgpipe->nexttoggle = 0; } /* Abort a device control request. */ static void -motg_device_xfer_abort(usbd_xfer_handle xfer) +motg_device_xfer_abort(struct usbd_xfer *xfer) { int wake; uint8_t csr; - struct motg_softc *sc = xfer->pipe->device->bus->hci_private; - struct motg_pipe *otgpipe = (struct motg_pipe *)xfer->pipe; + struct motg_softc *sc = MOTG_XFER2SC(xfer); + struct motg_pipe *otgpipe = MOTG_PIPE2MPIPE(xfer->ux_pipe); KASSERT(mutex_owned(&sc->sc_lock)); - DPRINTF(("motg_device_xfer_abort:\n")); - if (xfer->hcflags & UXFER_ABORTING) { - DPRINTF(("motg_device_xfer_abort: already aborting\n")); - xfer->hcflags |= UXFER_ABORTWAIT; - while (xfer->hcflags & UXFER_ABORTING) - cv_wait(&xfer->hccv, &sc->sc_lock); + MOTGHIST_FUNC(); MOTGHIST_CALLED(); + + if (xfer->ux_hcflags & UXFER_ABORTING) { + DPRINTF("already aborting", 0, 0, 0, 0); + xfer->ux_hcflags |= UXFER_ABORTWAIT; + while (xfer->ux_hcflags & UXFER_ABORTING) + cv_wait(&xfer->ux_hccv, &sc->sc_lock); return; } - xfer->hcflags |= UXFER_ABORTING; + xfer->ux_hcflags |= UXFER_ABORTING; if (otgpipe->hw_ep->xfer == xfer) { - KASSERT(xfer->status == USBD_IN_PROGRESS); + KASSERT(xfer->ux_status == USBD_IN_PROGRESS); otgpipe->hw_ep->xfer = NULL; if (otgpipe->hw_ep->ep_number > 0) { /* select endpoint */ @@ -2472,10 +2261,10 @@ motg_device_xfer_abort(usbd_xfer_handle otgpipe->hw_ep->phase = IDLE; } } - xfer->status = USBD_CANCELLED; /* make software ignore it */ - wake = xfer->hcflags & UXFER_ABORTWAIT; - xfer->hcflags &= ~(UXFER_ABORTING | UXFER_ABORTWAIT); + xfer->ux_status = USBD_CANCELLED; /* make software ignore it */ + wake = xfer->ux_hcflags & UXFER_ABORTWAIT; + xfer->ux_hcflags &= ~(UXFER_ABORTING | UXFER_ABORTWAIT); usb_transfer_complete(xfer); if (wake) - cv_broadcast(&xfer->hccv); + cv_broadcast(&xfer->ux_hccv); }