usbd_status usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe, u_int16_t flags, u_int32_t timeout, void *buf, u_int32_t *size, const char *lbl) { usbd_status err; USBHIST_FUNC(); USBHIST_CALLED(usbdebug); usbd_setup_xfer(xfer, pipe, 0, buf, *size, flags, timeout, NULL); DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes\n", *size)); err = usbd_sync_transfer_sig(xfer); usbd_get_xfer_status(xfer, NULL, NULL, size, NULL); DPRINTFN(1,("usbd_intr_transfer: transferred %d\n", *size)); if (err) { DPRINTF(("usbd_intr_transfer: error=%d\n", err)); usbd_clear_endpoint_stall(pipe); } USBHIST_LOG(usbdebug, "<- done err %d", xfer, err, 0, 0); return (err); }
static usbd_status start_output_transfer(struct umidi_endpoint *ep) { usbd_status rv; u_int32_t length; int i; length = (ep->next_slot - ep->buffer) * sizeof *ep->buffer; DPRINTFN(200,("umidi out transfer: start %p end %p length %u\n", ep->buffer, ep->next_slot, length)); usbd_setup_xfer(ep->xfer, ep->pipe, (usbd_private_handle)ep, ep->buffer, length, USBD_NO_COPY, USBD_NO_TIMEOUT, out_intr); rv = usbd_transfer(ep->xfer); /* * Once the transfer is scheduled, no more adding to partial * packets within it. */ if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) { for (i=0; i<UMIDI_MAX_EPJACKS; ++i) if (NULL != ep->jacks[i]) ep->jacks[i]->midiman_ppkt = NULL; } return rv; }
Static int cdce_encap(struct cdce_softc *sc, struct mbuf *m, int idx) { struct ue_chain *c; usbd_status err; int extra = 0; c = &sc->cdce_cdata.ue_tx_chain[idx]; m_copydata(m, 0, m->m_pkthdr.len, c->ue_buf); if (sc->cdce_flags & CDCE_ZAURUS) { /* Zaurus wants a 32-bit CRC appended to every frame */ u_int32_t crc; crc = htole32(crc32(c->ue_buf, m->m_pkthdr.len)); bcopy(&crc, c->ue_buf + m->m_pkthdr.len, 4); extra = 4; } c->ue_mbuf = m; usbd_setup_xfer(c->ue_xfer, sc->cdce_bulkout_pipe, c, c->ue_buf, m->m_pkthdr.len + extra, 0, 10000, cdce_txeof); err = usbd_transfer(c->ue_xfer); if (err != USBD_IN_PROGRESS) { cdce_stop(sc); return (EIO); } sc->cdce_cdata.ue_tx_cnt++; return (0); }
usbd_status ucomstartread(struct ucom_softc *sc) { usbd_status err; DPRINTFN(5,("ucomstartread: start\n")); #ifdef DIAGNOSTIC if (sc->sc_ixfer == NULL) { DPRINTF(("ucomstartread: null ixfer\n")); return (USBD_INVAL); } #endif if (sc->sc_bulkin_pipe != NULL) { usbd_setup_xfer(sc->sc_ixfer, sc->sc_bulkin_pipe, (void *)sc, sc->sc_ibuf, sc->sc_ibufsize, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, ucomreadcb); err = usbd_transfer(sc->sc_ixfer); if (err != USBD_IN_PROGRESS) { DPRINTF(("ucomstartread: err=%s\n", usbd_errstr(err))); return (err); } } return (USBD_NORMAL_COMPLETION); }
int uriowrite(dev_t dev, struct uio *uio, int flag) { struct urio_softc *sc; struct usbd_xfer *xfer; usbd_status err; void *bufp; u_int32_t n; int error = 0; sc = urio_cd.cd_devs[URIOUNIT(dev)]; DPRINTFN(5, ("uriowrite: unit=%d, len=%ld\n", URIOUNIT(dev), (long)uio->uio_resid)); if (usbd_is_dying(sc->sc_udev)) return (EIO); xfer = usbd_alloc_xfer(sc->sc_udev); if (xfer == NULL) return (ENOMEM); bufp = usbd_alloc_buffer(xfer, URIO_BSIZE); if (bufp == NULL) { usbd_free_xfer(xfer); return (ENOMEM); } sc->sc_refcnt++; while ((n = min(URIO_BSIZE, uio->uio_resid)) != 0) { error = uiomove(bufp, n, uio); if (error) break; DPRINTFN(1, ("uriowrite: transfer %d bytes\n", n)); usbd_setup_xfer(xfer, sc->sc_out_pipe, 0, bufp, n, USBD_NO_COPY | USBD_SYNCHRONOUS, URIO_RW_TIMEOUT, NULL); err = usbd_transfer(xfer); DPRINTFN(2, ("uriowrite: err=%d\n", err)); if (err) { usbd_clear_endpoint_stall(sc->sc_out_pipe); if (err == USBD_TIMEOUT) error = ETIMEDOUT; else error = EIO; break; } } usbd_free_xfer(xfer); if (--sc->sc_refcnt < 0) usb_detach_wakeup(&sc->sc_dev); DPRINTFN(5, ("uriowrite: done unit=%d, error=%d\n", URIOUNIT(dev), error)); return (error); }
usbd_status uirda_start_read(struct uirda_softc *sc) { usbd_status err; DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc, sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE)); if (sc->sc_dying) return (USBD_IOERROR); if (sc->sc_rd_err) { sc->sc_rd_err = 0; DPRINTF(("uirda_start_read: clear stall\n")); usbd_clear_endpoint_stall(sc->sc_rd_pipe); } usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, sc->sc_params.maxsize + sc->sc_hdszi, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, uirda_rd_cb); err = usbd_transfer(sc->sc_rd_xfer); if (err != USBD_IN_PROGRESS) { DPRINTF(("uirda_start_read: err=%d\n", err)); return (err); } return (USBD_NORMAL_COMPLETION); }
usbd_status uhidev_write(struct uhidev_softc *sc, void *data, int len) { usbd_status error; DPRINTF(("uhidev_write: data=%p, len=%d\n", data, len)); if (sc->sc_opipe == NULL) return USBD_INVAL; #ifdef UHIDEV_DEBUG if (uhidevdebug > 50) { u_int32_t i; u_int8_t *d = data; DPRINTF(("uhidev_write: data =")); for (i = 0; i < len; i++) DPRINTF((" %02x", d[i])); DPRINTF(("\n")); } #endif usbd_setup_xfer(sc->sc_owxfer, sc->sc_opipe, 0, data, len, USBD_SYNCHRONOUS | USBD_CATCH, 0, NULL); error = usbd_transfer(sc->sc_owxfer); if (error) usbd_clear_endpoint_stall(sc->sc_opipe); return (error); }
Static usbd_status ucomstartread(struct ucom_softc *sc) { usbd_status err; DPRINTF(("ucomstartread: start\n")); sc->sc_state &= ~UCS_RXSTOP; if (sc->sc_bulkin_pipe == NULL) return (USBD_NORMAL_COMPLETION); usbd_setup_xfer(sc->sc_ixfer, sc->sc_bulkin_pipe, (usbd_private_handle)sc, sc->sc_ibuf, sc->sc_ibufsize, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, ucomreadcb); err = usbd_transfer(sc->sc_ixfer); if (err != USBD_IN_PROGRESS) { DPRINTF(("ucomstartread: err = %s\n", usbd_errstr(err))); return (err); } return (USBD_NORMAL_COMPLETION); }
usbd_status usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe, u_int16_t flags, u_int32_t timeout, void *buf, u_int32_t *size, char *lbl) { usbd_status err; int s, error; usbd_setup_xfer(xfer, pipe, 0, buf, *size, flags, timeout, usbd_intr_transfer_cb); DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes\n", *size)); s = splusb(); /* don't want callback until tsleep() */ err = usbd_transfer(xfer); if (err != USBD_IN_PROGRESS) { splx(s); return (err); } error = tsleep(xfer, PZERO | PCATCH, lbl, 0); splx(s); if (error) { DPRINTF(("usbd_intr_transfer: tsleep=%d\n", error)); usbd_abort_pipe(pipe); return (USBD_INTERRUPTED); } usbd_get_xfer_status(xfer, NULL, NULL, size, &err); DPRINTFN(1,("usbd_intr_transfer: transferred %d\n", *size)); if (err) { DPRINTF(("usbd_intr_transfer: error=%d\n", err)); usbd_clear_endpoint_stall(pipe); } return (err); }
Static int udbp_setup_in_transfer(udbp_p sc) { void *priv = sc; /* XXX this should probably be some pointer to * struct describing the transfer (mbuf?) * See also below. */ usbd_status err; /* XXX * How should we arrange for 2 extra bytes at the start of the * packet? */ /* Initialise a USB transfer and then schedule it */ (void) usbd_setup_xfer( sc->sc_bulkin_xfer, sc->sc_bulkin_pipe, priv, sc->sc_bulkin_buffer, sc->sc_bulkin_bufferlen, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, udbp_in_transfer_cb); err = usbd_transfer(sc->sc_bulkin_xfer); if (err && err != USBD_IN_PROGRESS) { DPRINTF(("%s: failed to setup in-transfer, %s\n", USBDEVNAME(sc->sc_dev), usbd_errstr(err))); return(err); } return (USBD_NORMAL_COMPLETION); }
void ubt_xmit_acl_start(struct ubt_softc *sc) { struct mbuf *m; usbd_status status; int len; if (sc->sc_dying) return; if (IF_QEMPTY(&sc->sc_aclwr_queue)) return; sc->sc_refcnt++; sc->sc_aclwr_busy = 1; IF_DEQUEUE(&sc->sc_aclwr_queue, m); KKASSERT(m != NULL); DPRINTFN(15, "%s: xmit ACL packet (%d bytes)\n", device_get_nameunit(sc->sc_dev), m->m_pkthdr.len); len = m->m_pkthdr.len - 1; if (len > UBT_BUFSIZ_ACL) { DPRINTF("%s: truncating ACL packet (%d => %d)!\n", device_get_nameunit(sc->sc_dev), len, UBT_BUFSIZ_ACL); len = UBT_BUFSIZ_ACL; } m_copydata(m, 1, len, sc->sc_aclwr_buf); m_freem(m); sc->sc_stats.acl_tx++; sc->sc_stats.byte_tx += len; usbd_setup_xfer(sc->sc_aclwr_xfer, sc->sc_aclwr_pipe, sc, sc->sc_aclwr_buf, len, USBD_NO_COPY | USBD_FORCE_SHORT_XFER, UBT_ACL_TIMEOUT, ubt_xmit_acl_complete); status = usbd_transfer(sc->sc_aclwr_xfer); KKASSERT(status != USBD_NORMAL_COMPLETION); if (status != USBD_IN_PROGRESS) { DPRINTF("usbd_transfer status=%s (%d)\n", usbd_errstr(status), status); sc->sc_refcnt--; sc->sc_aclwr_busy = 0; } }
/* * A frame has been uploaded: pass the resulting mbuf up to * the higher level protocols. */ static void lgue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) { struct lgue_softc *sc; struct mbuf *m; struct ifnet *ifp; int total_len; sc = priv; if (sc->lgue_dying) return; ifp = &sc->lgue_arpcom.ac_if; total_len = 0; if (!(ifp->if_flags & IFF_RUNNING)) return; if (status != USBD_NORMAL_COMPLETION) { if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) return; if (usbd_ratecheck(&sc->lgue_rx_notice)) { if_printf(ifp, "usb error on rx:%s\n", usbd_errstr(status)); } if (status == USBD_STALLED) usbd_clear_endpoint_stall(sc->lgue_ep[LGUE_ENDPT_RX]); goto done; } usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL); if (total_len < sizeof(struct ether_header)) { IFNET_STAT_INC(ifp, ierrors, 1); goto done; } if (lgue_newbuf(sc, total_len, &m) == ENOBUFS) { IFNET_STAT_INC(ifp, ierrors, 1); return; } IFNET_STAT_INC(ifp, ipackets, 1); m_copyback(m, 0, total_len, sc->lgue_rx_buf); m->m_pkthdr.rcvif = ifp; m->m_pkthdr.len = m->m_len = total_len; usb_ether_input(m); lgue_rxstart(ifp); return; done: usbd_setup_xfer(sc->lgue_rx_xfer, sc->lgue_ep[LGUE_ENDPT_RX], sc, sc->lgue_rx_buf, LGUE_BUFSZ, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, lgue_rxeof); usbd_transfer(sc->lgue_rx_xfer); }
/* Call at spltty() */ static void ucom_submit_write(struct ucom_softc *sc, struct ucom_buffer *ub) { usbd_setup_xfer(ub->ub_xfer, sc->sc_bulkout_pipe, (usbd_private_handle)sc, ub->ub_data, ub->ub_len, USBD_NO_COPY, USBD_NO_TIMEOUT, ucomwritecb); ucom_write_status(sc, ub, usbd_transfer(ub->ub_xfer)); }
static usbd_status start_input_transfer(struct umidi_endpoint *ep) { usbd_setup_xfer(ep->xfer, ep->pipe, (usbd_private_handle)ep, ep->buffer, ep->buffer_size, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, in_intr); return usbd_transfer(ep->xfer); }
/* * Listen INTR pipe */ static void lgue_intrstart(struct ifnet *ifp) { struct lgue_softc *sc; sc = ifp->if_softc; usbd_setup_xfer(sc->lgue_intr_xfer, sc->lgue_ep[LGUE_ENDPT_INTR], sc, sc->lgue_intr_buf, LGUE_BUFSZ, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, lgue_intreof); usbd_transfer(sc->lgue_intr_xfer); }
/* * Start read */ static void lgue_rxstart(struct ifnet *ifp) { struct lgue_softc *sc; sc = ifp->if_softc; if (sc->lgue_dying) return; usbd_setup_xfer(sc->lgue_rx_xfer, sc->lgue_ep[LGUE_ENDPT_RX], sc, sc->lgue_rx_buf, LGUE_BUFSZ, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, lgue_rxeof); usbd_transfer(sc->lgue_rx_xfer); }
static usbd_status start_input_transfer(struct umidi_endpoint *ep) { usbd_status err; usbd_setup_xfer(ep->xfer, ep->pipe, (void *)ep, ep->buffer, ep->packetsize, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, in_intr); err = usbd_transfer(ep->xfer); if (err != USBD_NORMAL_COMPLETION && err != USBD_IN_PROGRESS) { DPRINTF(("%s: %s: usbd_transfer() failed err=%s\n", ep->sc->sc_dev.dv_xname, __func__, usbd_errstr(err))); return err; } return USBD_NORMAL_COMPLETION; }
Static int url_send(struct url_softc *sc, struct mbuf *m, int idx) { int total_len; struct url_chain *c; usbd_status err; DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev),__func__)); c = &sc->sc_cdata.url_tx_chain[idx]; /* Copy the mbuf data into a contiguous buffer */ m_copydata(m, 0, m->m_pkthdr.len, c->url_buf); c->url_mbuf = m; total_len = m->m_pkthdr.len; if (total_len < URL_MIN_FRAME_LEN) { memset(c->url_buf + total_len, 0, URL_MIN_FRAME_LEN - total_len); total_len = URL_MIN_FRAME_LEN; } usbd_setup_xfer(c->url_xfer, sc->sc_pipe_tx, c, c->url_buf, total_len, USBD_FORCE_SHORT_XFER | USBD_NO_COPY, URL_TX_TIMEOUT, url_txeof); /* Transmit */ sc->sc_refcnt++; err = usbd_transfer(c->url_xfer); if (--sc->sc_refcnt < 0) usb_detach_wakeupold(sc->sc_dev); if (err != USBD_IN_PROGRESS) { printf("%s: url_send error=%s\n", device_xname(sc->sc_dev), usbd_errstr(err)); /* Stop the interface */ usb_add_task(sc->sc_udev, &sc->sc_stop_task, USB_TASKQ_DRIVER); return (EIO); } DPRINTF(("%s: %s: send %d bytes\n", device_xname(sc->sc_dev), __func__, total_len)); sc->sc_cdata.url_tx_cnt++; return (0); }
int ugl_openpipes(struct ugl_softc *sc) { struct ugl_chain *c; usbd_status err; int i; /* Open RX and TX pipes. */ err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[UGL_ENDPT_RX], USBD_EXCLUSIVE_USE, &sc->sc_ep[UGL_ENDPT_RX]); if (err) { printf("%s: open rx pipe failed: %s\n", sc->sc_dev.dv_xname, usbd_errstr(err)); return (EIO); } err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[UGL_ENDPT_TX], USBD_EXCLUSIVE_USE, &sc->sc_ep[UGL_ENDPT_TX]); if (err) { printf("%s: open tx pipe failed: %s\n", sc->sc_dev.dv_xname, usbd_errstr(err)); return (EIO); } err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_ed[UGL_ENDPT_INTR], USBD_EXCLUSIVE_USE, &sc->sc_ep[UGL_ENDPT_INTR], sc, sc->sc_ibuf, UGL_INTR_PKTLEN, ugl_intr, UGL_INTR_INTERVAL); if (err) { printf("%s: open intr pipe failed: %s\n", sc->sc_dev.dv_xname, usbd_errstr(err)); return (EIO); } /* Start up the receive pipe. */ for (i = 0; i < UGL_RX_LIST_CNT; i++) { c = &sc->sc_cdata.ugl_rx_chain[i]; usbd_setup_xfer(c->ugl_xfer, sc->sc_ep[UGL_ENDPT_RX], c, c->ugl_buf, UGL_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, ugl_rxeof); usbd_transfer(c->ugl_xfer); } return (0); }
static usbd_status ucomsubmitread(struct ucom_softc *sc, struct ucom_buffer *ub) { usbd_status err; usbd_setup_xfer(ub->ub_xfer, sc->sc_bulkin_pipe, (usbd_private_handle)sc, ub->ub_data, sc->sc_ibufsize, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, ucomreadcb); if ((err = usbd_transfer(ub->ub_xfer)) != USBD_IN_PROGRESS) { /* XXX: Recover from this, please! */ printf("ucomsubmitread: err=%s\n", usbd_errstr(err)); return (err); } SIMPLEQ_INSERT_TAIL(&sc->sc_ibuff_empty, ub, ub_link); return (USBD_NORMAL_COMPLETION); }
int kue_send(struct kue_softc *sc, struct mbuf *m, int idx) { int total_len; struct kue_chain *c; usbd_status err; DPRINTFN(10,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__)); c = &sc->kue_cdata.kue_tx_chain[idx]; /* * Copy the mbuf data into a contiguous buffer, leaving two * bytes at the beginning to hold the frame length. */ m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2); c->kue_mbuf = m; total_len = m->m_pkthdr.len + 2; /* XXX what's this? */ total_len += 64 - (total_len % 64); /* Frame length is specified in the first 2 bytes of the buffer. */ c->kue_buf[0] = (u_int8_t)m->m_pkthdr.len; c->kue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8); usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX], c, c->kue_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT, kue_txeof); /* Transmit */ err = usbd_transfer(c->kue_xfer); if (err != USBD_IN_PROGRESS) { printf("%s: kue_send error=%s\n", sc->kue_dev.dv_xname, usbd_errstr(err)); kue_stop(sc); return (EIO); } sc->kue_cdata.kue_tx_cnt++; return (0); }
/* * Generic USB transfer routines */ static usbd_status atausb_start(struct atausb_softc *sc, usbd_pipe_handle pipe, void *buffer, int buflen, int flags, usbd_xfer_handle xfer) { usbd_status err; if (sc->state == ATAUSB_S_DETACH) return USBD_NOT_STARTED; usbd_setup_xfer(xfer, pipe, (void *)sc, buffer, buflen, flags, sc->timeout, atausb_bbb_finish); err = usbd_transfer(xfer); if (err && (err != USBD_IN_PROGRESS)) { if (atausbdebug) device_printf(sc->dev, "failed to setup transfer, %s\n", usbd_errstr(err)); return err; } return USBD_NORMAL_COMPLETION; }
usbd_status usbd_bulk_transfer(struct usbd_xfer *xfer, struct usbd_pipe *pipe, uint16_t flags, uint32_t timeout, void *buf, uint32_t *size) { usbd_status err; USBHIST_FUNC(); USBHIST_CALLED(usbdebug); usbd_setup_xfer(xfer, 0, buf, *size, flags, timeout, NULL); DPRINTFN(1, "start transfer %d bytes", *size, 0, 0, 0); err = usbd_sync_transfer_sig(xfer); usbd_get_xfer_status(xfer, NULL, NULL, size, NULL); DPRINTFN(1, "transferred %d", *size, 0, 0, 0); if (err) { usbd_clear_endpoint_stall(pipe); } USBHIST_LOG(usbdebug, "<- done xfer %p err %d", xfer, err, 0, 0); return err; }
int ugl_send(struct ugl_softc *sc, struct mbuf *m, int idx) { int total_len; struct ugl_chain *c; usbd_status err; c = &sc->sc_cdata.ugl_tx_chain[idx]; /* * Copy the mbuf data into a contiguous buffer, leaving two * bytes at the beginning to hold the frame length. */ USETDW(c->ugl_buf->pkt_count, UGL_TX_FRAMES); USETDW(c->ugl_buf->pkt_length, m->m_pkthdr.len); m_copydata(m, 0, m->m_pkthdr.len, c->ugl_buf->pkt_data); c->ugl_mbuf = m; total_len = offsetof(struct ugl_packet, pkt_data[m->m_pkthdr.len]); DPRINTFN(10,("%s: %s: total_len=%d\n", sc->sc_dev.dv_xname, __func__, total_len)); usbd_setup_xfer(c->ugl_xfer, sc->sc_ep[UGL_ENDPT_TX], c, c->ugl_buf, total_len, USBD_FORCE_SHORT_XFER | USBD_NO_COPY, USBD_DEFAULT_TIMEOUT, ugl_txeof); /* Transmit */ err = usbd_transfer(c->ugl_xfer); if (err != USBD_IN_PROGRESS) { printf("%s: ugl_send error=%s\n", sc->sc_dev.dv_xname, usbd_errstr(err)); ugl_stop(sc); return (EIO); } sc->sc_cdata.ugl_tx_cnt++; return (0); }
static usbd_status udsir_start_read(struct udsir_softc *sc) { usbd_status err; DPRINTFN(60, ("%s: sc=%p, size=%d\n", __func__, sc, sc->sc_rd_maxpsz)); if (sc->sc_dying) return USBD_IOERROR; if (UDSIR_BLOCK_RX_DATA(sc) || deframe_rd_ur(sc)) { /* * Can't start reading just yet. Since we aren't * going to start a read, have to switch direction to * idle. */ sc->sc_direction = udir_idle; return USBD_NORMAL_COMPLETION; } /* Starting a read... */ sc->sc_rd_readinprogress = 1; sc->sc_direction = udir_input; if (sc->sc_rd_err) { sc->sc_rd_err = 0; DPRINTFN(0, ("%s: clear stall\n", __func__)); usbd_clear_endpoint_stall(sc->sc_rd_pipe); } usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, sc->sc_rd_maxpsz, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, udsir_rd_cb); err = usbd_transfer(sc->sc_rd_xfer); if (err != USBD_IN_PROGRESS) { DPRINTFN(0, ("%s: err=%d\n", __func__, (int)err)); return err; } return USBD_NORMAL_COMPLETION; }
int kue_open_pipes(struct kue_softc *sc) { usbd_status err; struct kue_chain *c; int i; DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__)); /* Open RX and TX pipes. */ err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_RX], USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_RX]); if (err) { printf("%s: open rx pipe failed: %s\n", sc->kue_dev.dv_xname, usbd_errstr(err)); return (EIO); } err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX], USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_TX]); if (err) { printf("%s: open tx pipe failed: %s\n", sc->kue_dev.dv_xname, usbd_errstr(err)); return (EIO); } /* Start up the receive pipe. */ for (i = 0; i < KUE_RX_LIST_CNT; i++) { c = &sc->kue_cdata.kue_rx_chain[i]; usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX], c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, kue_rxeof); DPRINTFN(5,("%s: %s: start read\n", sc->kue_dev.dv_xname, __func__)); usbd_transfer(c->kue_xfer); } return (0); }
static int kue_send(struct kue_softc *sc, struct mbuf *m, int idx) { int total_len; struct kue_chain *c; usbd_status err; DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__)); c = &sc->kue_cdata.kue_tx_chain[idx]; /* Frame length is specified in the first 2 bytes of the buffer. */ le16enc(c->kue_buf, (uint16_t)m->m_pkthdr.len); /* * Copy the mbuf data into a contiguous buffer, leaving two * bytes at the beginning to hold the frame length. */ m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2); total_len = 2 + m->m_pkthdr.len; total_len = roundup2(total_len, 64); usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX], c, c->kue_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT, kue_txeof); /* Transmit */ err = usbd_transfer(c->kue_xfer); if (err != USBD_IN_PROGRESS) { printf("%s: kue_send error=%s\n", device_xname(sc->kue_dev), usbd_errstr(err)); kue_stop(sc); return (EIO); } sc->kue_cdata.kue_tx_cnt++; return (0); }
void ubt_recv_acl_start(struct ubt_softc *sc) { usbd_status status; DPRINTFN(15, "sc=%p\n", sc); if (sc->sc_aclrd_busy || sc->sc_dying) { DPRINTF("sc_aclrd_busy=%d, sc_dying=%d\n", sc->sc_aclrd_busy, sc->sc_dying); return; } sc->sc_refcnt++; sc->sc_aclrd_busy = 1; usbd_setup_xfer(sc->sc_aclrd_xfer, sc->sc_aclrd_pipe, sc, sc->sc_aclrd_buf, UBT_BUFSIZ_ACL, USBD_NO_COPY | USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, ubt_recv_acl_complete); status = usbd_transfer(sc->sc_aclrd_xfer); KKASSERT(status != USBD_NORMAL_COMPLETION); if (status != USBD_IN_PROGRESS) { DPRINTF("usbd_transfer status=%s (%d)\n", usbd_errstr(status), status); sc->sc_refcnt--; sc->sc_aclrd_busy = 0; } }
/* General CDC asynchronous transfer function */ static jresult_t cdc_async_transfer(cdc_cmd_priv_t *priv, usbd_pipe_handle pipe, void *membuf, juint32_t size, usbd_xfer_handle xfer) { jresult_t rc; usbd_status status; juint16_t flags = USBD_SHORT_XFER_OK | USBD_FORCE_SHORT_XFER; DECLARE_FNAME("cdc_async_transfer"); DBG_X(DHOST_CDC_GENERAL, ("%s: Entered\n", fname)); /* Allocate a transfer request object and set up a xfer */ xfer = usbd_alloc_xfer(priv->sc->device); if (!xfer) { DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate xfer\n", fname)); rc = JENOMEM; goto Error; } usbd_setup_xfer(xfer, pipe, (void *)priv, membuf, size, flags, CDC_DATA_XFER_TIMEOUT, cdc_data_xfer_complete); /* Execute xfer */ status = usbd_transfer(xfer); if (status && status != USBD_IN_PROGRESS) { DBG_W(DHOST_CDC_GENERAL, ("%s: failed to setup transfer, %s\n", fname, usbd_errstr(status))); rc = status_to_result(status); goto Error; } return 0; Error: if (xfer) usbd_free_xfer(xfer); return rc; }
/* * Start transfer from internal queue */ static int lgue_start_transfer(struct lgue_softc *sc) { usbd_status err; struct lgue_queue_entry *entry; struct ifnet *ifp; if (STAILQ_EMPTY(&sc->lgue_tx_queue)) return(0); ifp = &sc->lgue_arpcom.ac_if; entry = STAILQ_FIRST(&sc->lgue_tx_queue); STAILQ_REMOVE_HEAD(&sc->lgue_tx_queue, entry_next); m_copydata(entry->entry_mbuf, 0, entry->entry_mbuf->m_pkthdr.len, sc->lgue_tx_buf); /* Transmit */ usbd_setup_xfer(sc->lgue_tx_xfer, sc->lgue_ep[LGUE_ENDPT_TX], sc, sc->lgue_tx_buf, entry->entry_mbuf->m_pkthdr.len, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, lgue_txeof); err = usbd_transfer(sc->lgue_tx_xfer); if (err != USBD_IN_PROGRESS) { m_freem(entry->entry_mbuf); kfree(entry, M_USBDEV); lgue_stop(sc); ifq_clr_oactive(&ifp->if_snd); return(EIO); } m_freem(entry->entry_mbuf); kfree(entry, M_USBDEV); sc->lgue_tx_cnt++; ifq_set_oactive(&ifp->if_snd); ifp->if_timer = 5; return(0); }