static void ufoma_msg(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
{
usb_device_request_t req;
struct ufoma_softc *sc = priv;
int actlen,i;
struct ucom_softc *ucom= &sc->sc_ucom;
usbd_get_xfer_status(xfer, NULL, NULL, &actlen ,NULL);
ufoma_setup_msg_req(sc, &req);
mtx_lock(&sc->sc_mtx);
for(i = 0;i < actlen; i++){
if(sc->sc_ucom.sc_tty->t_state & TS_ISOPEN)
ttyld_rint(sc->sc_ucom.sc_tty, sc->sc_resbuffer[i]);
}
sc->sc_nummsg--;
if(sc->sc_nummsg){
usbd_setup_default_xfer(sc->sc_msgxf, ucom->sc_udev,
priv, USBD_DEFAULT_TIMEOUT, &req,
sc->sc_resbuffer,
UFOMA_CMD_BUF_SIZE,
0, ufoma_msg);
usbd_transfer(sc->sc_msgxf);
}
mtx_unlock(&sc->sc_mtx);
}
void
ubt_xmit_cmd_start(struct ubt_softc *sc)
{
usb_device_request_t req;
usbd_status status;
struct mbuf *m;
int len;
if (sc->sc_dying)
return;
if (IF_QEMPTY(&sc->sc_cmd_queue))
return;
IF_DEQUEUE(&sc->sc_cmd_queue, m);
KKASSERT(m != NULL);
DPRINTFN(15, " %s: xmit CMD packet (%d bytes)\n",
device_get_nameunit(sc->sc_dev), m->m_pkthdr.len);
sc->sc_refcnt++;
sc->sc_cmd_busy = 1;
len = m->m_pkthdr.len - 1;
m_copydata(m, 1, len, sc->sc_cmd_buf);
m_freem(m);
memset(&req, 0, sizeof(req));
req.bmRequestType = UT_WRITE_CLASS_DEVICE;
USETW(req.wLength, len);
usbd_setup_default_xfer(sc->sc_cmd_xfer,
sc->sc_udev,
sc,
UBT_CMD_TIMEOUT,
&req,
sc->sc_cmd_buf,
len,
USBD_NO_COPY | USBD_FORCE_SHORT_XFER,
ubt_xmit_cmd_complete);
status = usbd_transfer(sc->sc_cmd_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_cmd_busy = 0;
}
}
/* Build encapsulated cmd / response and transfer it */
static jresult_t encapsulated_transfer(cdc_cmd_priv_t *priv, void *membuf,
juint16_t size)
{
usbd_status status = USBD_NORMAL_COMPLETION;
usbd_xfer_handle xfer = NULL;
jcdc_dev_softc_t *sc = priv->sc;
usb_device_request_t req_t;
jbool_t in_xfer = (priv->req_type == SEND_ENCAP_CMD) ? 0 : 1;
DECLARE_FNAME("encapsulated_transfer");
DBG_X(DHOST_CDC_GENERAL, ("%s: Entered\n", fname));
xfer = usbd_alloc_xfer(sc->device);
if (!xfer)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate xfer\n", fname));
return JENOMEM;
}
/* Build request according to xfer direction */
req_t.bmRequestType = (in_xfer) ? UT_READ_CLASS_INTERFACE :
UT_WRITE_CLASS_INTERFACE;
req_t.bRequest = (in_xfer) ? CDC_GET_ENC_RESPONSE :
CDC_SEND_ENC_COMMAND;
USETW(req_t.wValue, 0);
USETW(req_t.wIndex, (juint16_t)sc->c_iface->index);
USETW(req_t.wLength, size);
/* setup xfer */
usbd_setup_default_xfer(xfer, priv->sc->device, priv,
CDC_CONTROL_XFER_TIMEOUT, &req_t, membuf, size, 0, jcdc_send_encap_cb);
/* Send the request over default pipe (EP0) */
status = usbd_transfer(xfer);
if (status && status != USBD_IN_PROGRESS)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed transferring control request, "
"error %d\n", j_device_get_nameunit(priv->sc->dev), status));
usbd_free_xfer(xfer);
return status_to_result(status);
}
return 0;
}
static usbd_status
atausb_ctl_start(struct atausb_softc *sc, usbd_device_handle udev,
usb_device_request_t *req, 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_default_xfer(xfer, udev, (void *)sc, sc->timeout, req,
buffer, buflen, flags, atausb_bbb_finish);
err = usbd_transfer(xfer);
if (err && (err != USBD_IN_PROGRESS)) {
if (atausbdebug)
device_printf(sc->dev, "failed to setup ctl transfer, %s\n",
usbd_errstr(err));
return err;
}
return USBD_NORMAL_COMPLETION;
}
