自学教程：C++ usbd_setup_xfer函数代码示例

usbd_statususbd_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_statusstart_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 intcdce_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_statusucomstartread(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);}

inturiowrite(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_statusuirda_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_statusuhidev_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_statusucomstartread(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_statususbd_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 intudbp_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);}

/* * A frame has been uploaded: pass the resulting mbuf up to * the higher level protocols. */static voidlgue_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);}

static usbd_statusstart_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 voidlgue_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 voidlgue_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_statusstart_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 inturl_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);}

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

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

intugl_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_statusudsir_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;}

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

/* 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 intlgue_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);}