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);
}