static void
cdce_intr_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
int actlen;
usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
DPRINTF("Received %d bytes\n", actlen);
/* TODO: decode some indications */
/* FALLTHROUGH */
case USB_ST_SETUP:
tr_setup:
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default: /* Error */
if (error != USB_ERR_CANCELLED) {
/* start clear stall */
usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
}
}
static void
uhso_bs_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct uhso_softc *sc = usbd_xfer_softc(xfer);
struct usb_page_cache *pc;
int actlen;
usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
UHSO_DPRINTF(3, "status %d, actlen=%d\n", USB_GET_STATE(xfer), actlen);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
pc = usbd_xfer_get_frame(xfer, 0);
ucom_put_data(&sc->sc_ucom[0], pc, 0, actlen);
/* FALLTHROUGH */
case USB_ST_SETUP:
tr_setup:
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default:
UHSO_DPRINTF(0, "error: %s\n", usbd_errstr(error));
if (error == USB_ERR_CANCELLED)
break;
usbd_xfer_set_stall(xfer);
goto tr_setup;
}
}
static void
usie_uc_status_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct usb_page_cache *pc;
struct {
struct usb_device_request req;
uint16_t param;
} st;
uint32_t actlen;
uint16_t param;
usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
DPRINTFN(4, "info received, actlen=%u\n", actlen);
if (actlen < sizeof(st)) {
DPRINTF("data too short actlen=%u\n", actlen);
goto tr_setup;
}
pc = usbd_xfer_get_frame(xfer, 0);
usbd_copy_out(pc, 0, &st, sizeof(st));
if (st.req.bmRequestType == 0xa1 && st.req.bRequest == 0x20) {
struct ucom_softc *ucom = usbd_xfer_softc(xfer);
struct usie_softc *sc = ucom->sc_parent;
param = le16toh(st.param);
DPRINTF("param=%x\n", param);
sc->sc_msr = sc->sc_lsr = 0;
sc->sc_msr |= (param & USIE_DCD) ? SER_DCD : 0;
sc->sc_msr |= (param & USIE_DSR) ? SER_DSR : 0;
sc->sc_msr |= (param & USIE_RI) ? SER_RI : 0;
sc->sc_msr |= (param & USIE_CTS) ? 0 : SER_CTS;
sc->sc_msr |= (param & USIE_RTS) ? SER_RTS : 0;
sc->sc_msr |= (param & USIE_DTR) ? SER_DTR : 0;
}
/* fall though */
case USB_ST_SETUP:
tr_setup:
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default: /* Error */
DPRINTF("USB transfer error, %s\n",
usbd_errstr(error));
if (error != USB_ERR_CANCELLED) {
usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
}
}
static void
usie_uc_rx_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct ucom_softc *ucom = usbd_xfer_softc(xfer);
struct usie_softc *sc = ucom->sc_parent;
struct usb_page_cache *pc;
uint32_t actlen;
usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
pc = usbd_xfer_get_frame(xfer, 0);
/* handle CnS response */
if (ucom == sc->sc_ucom && actlen >= USIE_HIPCNS_MIN) {
DPRINTF("transferred=%u\n", actlen);
/* check if it is really CnS reply */
usbd_copy_out(pc, 0, sc->sc_resp_temp, 1);
if (sc->sc_resp_temp[0] == USIE_HIP_FRM_CHR) {
/* verify actlen */
if (actlen > USIE_BUFSIZE)
actlen = USIE_BUFSIZE;
/* get complete message */
usbd_copy_out(pc, 0, sc->sc_resp_temp, actlen);
usie_hip_rsp(sc, sc->sc_resp_temp, actlen);
/* need to fall though */
goto tr_setup;
}
/* else call ucom_put_data() */
}
/* standard ucom transfer */
ucom_put_data(ucom, pc, 0, actlen);
/* fall though */
case USB_ST_SETUP:
tr_setup:
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default: /* Error */
if (error != USB_ERR_CANCELLED) {
usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
}
}
static void
ugen_default_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct usb_fifo *f = usbd_xfer_softc(xfer);
struct usb_mbuf *m;
DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
if (xfer->actlen == 0) {
if (f->fifo_zlp != 4) {
f->fifo_zlp++;
} else {
/*
* Throttle a little bit we have multiple ZLPs
* in a row!
*/
xfer->interval = 64; /* ms */
}
} else {
/* clear throttle */
xfer->interval = 0;
f->fifo_zlp = 0;
}
usb_fifo_put_data(f, xfer->frbuffers, 0,
xfer->actlen, 1);
case USB_ST_SETUP:
if (f->flag_stall) {
usbd_transfer_start(f->xfer[1]);
break;
}
USB_IF_POLL(&f->free_q, m);
if (m) {
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
}
break;
default: /* Error */
if (xfer->error != USB_ERR_CANCELLED) {
/* send a zero length packet to userland */
usb_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
f->flag_stall = 1;
f->fifo_zlp = 0;
usbd_transfer_start(f->xfer[1]);
}
break;
}
}
/*
* Interrupt callback for the multiplexed serial port. Indicates
* which serial port has data waiting.
*/
static void
uhso_mux_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct usb_page_cache *pc;
struct usb_page_search res;
struct uhso_softc *sc = usbd_xfer_softc(xfer);
unsigned int i, mux;
UHSO_DPRINTF(3, "status %d\n", USB_GET_STATE(xfer));
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
/*
* The multiplexed port number can be found at the first byte.
* It contains a bit mask, we transform this in to an integer.
*/
pc = usbd_xfer_get_frame(xfer, 0);
usbd_get_page(pc, 0, &res);
i = *((unsigned char *)res.buffer);
mux = 0;
while (i >>= 1) {
mux++;
}
UHSO_DPRINTF(3, "mux port %d (%d)\n", mux, i);
if (mux > UHSO_MPORT_TYPE_NOMAX)
break;
/* Issue a read for this serial port */
usbd_xfer_set_priv(
sc->sc_tty[mux].ht_xfer[UHSO_CTRL_READ],
&sc->sc_tty[mux]);
usbd_transfer_start(sc->sc_tty[mux].ht_xfer[UHSO_CTRL_READ]);
break;
case USB_ST_SETUP:
tr_setup:
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default:
UHSO_DPRINTF(0, "error: %s\n", usbd_errstr(error));
if (error == USB_ERR_CANCELLED)
break;
usbd_xfer_set_stall(xfer);
goto tr_setup;
}
}
static void
usie_if_status_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct usie_softc *sc = usbd_xfer_softc(xfer);
struct usb_page_cache *pc;
struct usb_cdc_notification cdc;
uint32_t actlen;
usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
DPRINTFN(4, "info received, actlen=%d\n", actlen);
/* usb_cdc_notification - .data[16] */
if (actlen < (sizeof(cdc) - 16)) {
DPRINTF("data too short %d\n", actlen);
goto tr_setup;
}
pc = usbd_xfer_get_frame(xfer, 0);
usbd_copy_out(pc, 0, &cdc, (sizeof(cdc) - 16));
DPRINTFN(4, "bNotification=%x\n", cdc.bNotification);
if (cdc.bNotification & UCDC_N_RESPONSE_AVAILABLE) {
taskqueue_enqueue(taskqueue_thread,
&sc->sc_if_status_task);
}
/* fall though */
case USB_ST_SETUP:
tr_setup:
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default: /* Error */
DPRINTF("USB transfer error, %s\n",
usbd_errstr(error));
if (error != USB_ERR_CANCELLED) {
usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
}
}
static void
uhso_ifnet_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct uhso_softc *sc = usbd_xfer_softc(xfer);
struct mbuf *m;
struct usb_page_cache *pc;
int actlen;
usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
UHSO_DPRINTF(3, "status=%d, actlen=%d\n", USB_GET_STATE(xfer), actlen);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
if (actlen > 0 && (sc->sc_ifp->if_drv_flags & IFF_DRV_RUNNING)) {
pc = usbd_xfer_get_frame(xfer, 0);
m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
usbd_copy_out(pc, 0, mtod(m, uint8_t *), actlen);
m->m_pkthdr.len = m->m_len = actlen;
/* Enqueue frame for further processing */
_IF_ENQUEUE(&sc->sc_rxq, m);
if (!callout_pending(&sc->sc_c) ||
!callout_active(&sc->sc_c)) {
callout_schedule(&sc->sc_c, 1);
}
}
/* FALLTHROUGH */
case USB_ST_SETUP:
tr_setup:
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default:
UHSO_DPRINTF(0, "error: %s\n", usbd_errstr(error));
if (error == USB_ERR_CANCELLED)
break;
usbd_xfer_set_stall(xfer);
goto tr_setup;
}
static int
ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index)
{
struct usb_device_request *req;
struct usb_xfer *xfer;
struct usb_fs_endpoint fs_ep;
struct usb_fs_endpoint *fs_ep_uptr; /* userland ptr */
void *uaddr; /* userland ptr */
void *kaddr;
usb_frlength_t offset;
usb_frlength_t rem;
usb_frcount_t n;
uint32_t length;
uint32_t temp;
int error;
uint8_t isread;
if (ep_index >= f->fs_ep_max)
return (EINVAL);
xfer = f->fs_xfer[ep_index];
if (xfer == NULL)
return (EINVAL);
mtx_lock(f->priv_mtx);
if (usbd_transfer_pending(xfer)) {
mtx_unlock(f->priv_mtx);
return (EBUSY); /* should not happen */
}
mtx_unlock(f->priv_mtx);
fs_ep_uptr = f->fs_ep_ptr + ep_index;
error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
if (error) {
return (error);
}
fs_ep.status = xfer->error;
fs_ep.aFrames = xfer->aframes;
fs_ep.isoc_time_complete = xfer->isoc_time_complete;
if (xfer->error) {
goto complete;
}
if (xfer->flags_int.control_xfr) {
req = xfer->frbuffers[0].buffer;
/* Host mode only ! */
if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
isread = 1;
} else {
isread = 0;
}
if (xfer->nframes == 0)
n = 0; /* should never happen */
else
n = 1;
} else {
/* Device and Host mode */
if (USB_GET_DATA_ISREAD(xfer)) {
isread = 1;
} else {
isread = 0;
}
n = 0;
}
/* Update lengths and copy out data */
rem = usbd_xfer_max_len(xfer);
offset = 0;
for (; n != xfer->nframes; n++) {
/* get initial length into "temp" */
error = copyin(fs_ep.pLength + n,
&temp, sizeof(temp));
if (error) {
return (error);
}
if (temp > rem) {
/* the userland length has been corrupted */
DPRINTF("corrupt userland length "
"%u > %u\n", temp, rem);
fs_ep.status = USB_ERR_INVAL;
goto complete;
}
rem -= temp;
/* get actual transfer length */
length = xfer->frlengths[n];
if (length > temp) {
/* data overflow */
fs_ep.status = USB_ERR_INVAL;
DPRINTF("data overflow %u > %u\n",
length, temp);
goto complete;
}
if (isread) {
/* we need to know the destination buffer */
error = copyin(fs_ep.ppBuffer + n,
&uaddr, sizeof(uaddr));
if (error) {
return (error);
}
if (xfer->flags_int.isochronous_xfr) {
/* only one frame buffer */
kaddr = USB_ADD_BYTES(
xfer->frbuffers[0].buffer, offset);
} else {
/* multiple frame buffers */
kaddr = xfer->frbuffers[n].buffer;
}
/* move data */
error = copyout(kaddr, uaddr, length);
if (error) {
return (error);
}
}
/*
* Update offset according to initial length, which is
* needed by isochronous transfers!
*/
offset += temp;
/* update length */
error = copyout(&length,
fs_ep.pLength + n, sizeof(length));
if (error) {
return (error);
}
}
complete:
/* update "aFrames" */
error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames,
sizeof(fs_ep.aFrames));
if (error)
goto done;
/* update "isoc_time_complete" */
error = copyout(&fs_ep.isoc_time_complete,
&fs_ep_uptr->isoc_time_complete,
sizeof(fs_ep.isoc_time_complete));
if (error)
goto done;
/* update "status" */
error = copyout(&fs_ep.status, &fs_ep_uptr->status,
sizeof(fs_ep.status));
done:
return (error);
}
static int
ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
{
struct usb_device_request *req;
struct usb_xfer *xfer;
struct usb_fs_endpoint fs_ep;
void *uaddr; /* userland pointer */
void *kaddr;
usb_frlength_t offset;
usb_frlength_t rem;
usb_frcount_t n;
uint32_t length;
int error;
uint8_t isread;
if (ep_index >= f->fs_ep_max) {
return (EINVAL);
}
xfer = f->fs_xfer[ep_index];
if (xfer == NULL) {
return (EINVAL);
}
mtx_lock(f->priv_mtx);
if (usbd_transfer_pending(xfer)) {
mtx_unlock(f->priv_mtx);
return (EBUSY); /* should not happen */
}
mtx_unlock(f->priv_mtx);
error = copyin(f->fs_ep_ptr +
ep_index, &fs_ep, sizeof(fs_ep));
if (error) {
return (error);
}
/* security checks */
if (fs_ep.nFrames > xfer->max_frame_count) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
if (fs_ep.nFrames == 0) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
error = copyin(fs_ep.ppBuffer,
&uaddr, sizeof(uaddr));
if (error) {
return (error);
}
/* reset first frame */
usbd_xfer_set_frame_offset(xfer, 0, 0);
if (xfer->flags_int.control_xfr) {
req = xfer->frbuffers[0].buffer;
error = copyin(fs_ep.pLength,
&length, sizeof(length));
if (error) {
return (error);
}
if (length != sizeof(*req)) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
if (length != 0) {
error = copyin(uaddr, req, length);
if (error) {
return (error);
}
}
if (ugen_check_request(f->udev, req)) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
usbd_xfer_set_frame_len(xfer, 0, length);
/* Host mode only ! */
if ((req->bmRequestType &
(UT_READ | UT_WRITE)) == UT_READ) {
isread = 1;
} else {
isread = 0;
}
n = 1;
offset = sizeof(*req);
} else {
/* Device and Host mode */
if (USB_GET_DATA_ISREAD(xfer)) {
isread = 1;
} else {
isread = 0;
}
n = 0;
offset = 0;
}
rem = usbd_xfer_max_len(xfer);
xfer->nframes = fs_ep.nFrames;
xfer->timeout = fs_ep.timeout;
if (xfer->timeout > 65535) {
xfer->timeout = 65535;
}
if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
xfer->flags.short_xfer_ok = 1;
else
xfer->flags.short_xfer_ok = 0;
if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
xfer->flags.short_frames_ok = 1;
else
xfer->flags.short_frames_ok = 0;
if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
xfer->flags.force_short_xfer = 1;
else
xfer->flags.force_short_xfer = 0;
if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
usbd_xfer_set_stall(xfer);
else
xfer->flags.stall_pipe = 0;
for (; n != xfer->nframes; n++) {
error = copyin(fs_ep.pLength + n,
&length, sizeof(length));
if (error) {
break;
}
usbd_xfer_set_frame_len(xfer, n, length);
if (length > rem) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
rem -= length;
if (!isread) {
/* we need to know the source buffer */
error = copyin(fs_ep.ppBuffer + n,
&uaddr, sizeof(uaddr));
if (error) {
break;
}
if (xfer->flags_int.isochronous_xfr) {
/* get kernel buffer address */
kaddr = xfer->frbuffers[0].buffer;
kaddr = USB_ADD_BYTES(kaddr, offset);
} else {
/* set current frame offset */
usbd_xfer_set_frame_offset(xfer, offset, n);
/* get kernel buffer address */
kaddr = xfer->frbuffers[n].buffer;
}
/* move data */
error = copyin(uaddr, kaddr, length);
if (error) {
break;
}
}
offset += length;
}
return (error);
complete:
mtx_lock(f->priv_mtx);
ugen_fs_set_complete(f, ep_index);
mtx_unlock(f->priv_mtx);
return (0);
}
/*------------------------------------------------------------------------*
* usb_handle_request
*
* Internal state sequence:
*
* USB_HR_NOT_COMPLETE -> USB_HR_COMPLETE_OK v USB_HR_COMPLETE_ERR
*
* Returns:
* 0: Ready to start hardware
* Else: Stall current transfer, if any
*------------------------------------------------------------------------*/
static usb_error_t
usb_handle_request(struct usb_xfer *xfer)
{
struct usb_device_request req;
struct usb_device *udev;
const void *src_zcopy; /* zero-copy source pointer */
const void *src_mcopy; /* non zero-copy source pointer */
uint16_t off; /* data offset */
uint16_t rem; /* data remainder */
uint16_t max_len; /* max fragment length */
uint16_t wValue;
uint16_t wIndex;
uint8_t state;
uint8_t is_complete = 1;
usb_error_t err;
union {
uWord wStatus;
uint8_t buf[2];
} temp;
/*
* Filter the USB transfer state into
* something which we understand:
*/
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
state = USB_HR_NOT_COMPLETE;
if (!xfer->flags_int.control_act) {
/* nothing to do */
goto tr_stalled;
}
break;
case USB_ST_TRANSFERRED:
if (!xfer->flags_int.control_act) {
state = USB_HR_COMPLETE_OK;
} else {
state = USB_HR_NOT_COMPLETE;
}
break;
default:
state = USB_HR_COMPLETE_ERR;
break;
}
/* reset frame stuff */
usbd_xfer_set_frame_len(xfer, 0, 0);
usbd_xfer_set_frame_offset(xfer, 0, 0);
usbd_xfer_set_frame_offset(xfer, sizeof(req), 1);
/* get the current request, if any */
usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
if (xfer->flags_int.control_rem == 0xFFFF) {
/* first time - not initialised */
rem = UGETW(req.wLength);
off = 0;
} else {
/* not first time - initialised */
rem = xfer->flags_int.control_rem;
off = UGETW(req.wLength) - rem;
}
/* set some defaults */
max_len = 0;
src_zcopy = NULL;
src_mcopy = NULL;
udev = xfer->xroot->udev;
/* get some request fields decoded */
wValue = UGETW(req.wValue);
wIndex = UGETW(req.wIndex);
DPRINTF("req 0x%02x 0x%02x 0x%04x 0x%04x "
"off=0x%x rem=0x%x, state=%d\n", req.bmRequestType,
req.bRequest, wValue, wIndex, off, rem, state);
/* demultiplex the control request */
switch (req.bmRequestType) {
case UT_READ_DEVICE:
if (state != USB_HR_NOT_COMPLETE) {
break;
}
switch (req.bRequest) {
case UR_GET_DESCRIPTOR:
goto tr_handle_get_descriptor;
case UR_GET_CONFIG:
goto tr_handle_get_config;
case UR_GET_STATUS:
goto tr_handle_get_status;
default:
goto tr_stalled;
}
break;
case UT_WRITE_DEVICE:
switch (req.bRequest) {
case UR_SET_ADDRESS:
goto tr_handle_set_address;
case UR_SET_CONFIG:
goto tr_handle_set_config;
case UR_CLEAR_FEATURE:
switch (wValue) {
case UF_DEVICE_REMOTE_WAKEUP:
goto tr_handle_clear_wakeup;
default:
goto tr_stalled;
}
break;
case UR_SET_FEATURE:
switch (wValue) {
case UF_DEVICE_REMOTE_WAKEUP:
goto tr_handle_set_wakeup;
default:
goto tr_stalled;
}
break;
default:
goto tr_stalled;
}
break;
case UT_WRITE_ENDPOINT:
switch (req.bRequest) {
case UR_CLEAR_FEATURE:
switch (wValue) {
case UF_ENDPOINT_HALT:
goto tr_handle_clear_halt;
default:
goto tr_stalled;
}
break;
case UR_SET_FEATURE:
switch (wValue) {
case UF_ENDPOINT_HALT:
goto tr_handle_set_halt;
default:
goto tr_stalled;
}
break;
default:
goto tr_stalled;
}
break;
case UT_READ_ENDPOINT:
switch (req.bRequest) {
case UR_GET_STATUS:
goto tr_handle_get_ep_status;
default:
goto tr_stalled;
}
break;
default:
/* we use "USB_ADD_BYTES" to de-const the src_zcopy */
err = usb_handle_iface_request(xfer,
USB_ADD_BYTES(&src_zcopy, 0),
&max_len, req, off, state);
if (err == 0) {
is_complete = 0;
goto tr_valid;
} else if (err == USB_ERR_SHORT_XFER) {
goto tr_valid;
}
/*
* Reset zero-copy pointer and max length
* variable in case they were unintentionally
* set:
*/
src_zcopy = NULL;
max_len = 0;
/*
* Check if we have a vendor specific
* descriptor:
*/
goto tr_handle_get_descriptor;
}
goto tr_valid;
tr_handle_get_descriptor:
err = (usb_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len);
if (err)
goto tr_stalled;
if (src_zcopy == NULL)
goto tr_stalled;
goto tr_valid;
tr_handle_get_config:
temp.buf[0] = udev->curr_config_no;
src_mcopy = temp.buf;
max_len = 1;
goto tr_valid;
tr_handle_get_status:
wValue = 0;
USB_BUS_LOCK(udev->bus);
if (udev->flags.remote_wakeup) {
wValue |= UDS_REMOTE_WAKEUP;
}
if (udev->flags.self_powered) {
wValue |= UDS_SELF_POWERED;
}
USB_BUS_UNLOCK(udev->bus);
USETW(temp.wStatus, wValue);
src_mcopy = temp.wStatus;
max_len = sizeof(temp.wStatus);
goto tr_valid;
tr_handle_set_address:
if (state == USB_HR_NOT_COMPLETE) {
if (wValue >= 0x80) {
/* invalid value */
goto tr_stalled;
} else if (udev->curr_config_no != 0) {
/* we are configured ! */
goto tr_stalled;
}
} else if (state != USB_HR_NOT_COMPLETE) {
udev->address = (wValue & 0x7F);
goto tr_bad_context;
}
goto tr_valid;
tr_handle_set_config:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_set_config(xfer, req.wValue[0])) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_clear_halt:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_set_stall(xfer, req.wIndex[0], 0)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_clear_wakeup:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_remote_wakeup(xfer, 0)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_set_halt:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_set_stall(xfer, req.wIndex[0], 1)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_set_wakeup:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_remote_wakeup(xfer, 1)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_get_ep_status:
if (state == USB_HR_NOT_COMPLETE) {
temp.wStatus[0] =
usb_handle_get_stall(udev, req.wIndex[0]);
temp.wStatus[1] = 0;
src_mcopy = temp.wStatus;
max_len = sizeof(temp.wStatus);
}
goto tr_valid;
tr_valid:
if (state != USB_HR_NOT_COMPLETE) {
goto tr_stalled;
}
/* subtract offset from length */
max_len -= off;
/* Compute the real maximum data length */
if (max_len > xfer->max_data_length) {
max_len = usbd_xfer_max_len(xfer);
}
if (max_len > rem) {
max_len = rem;
}
/*
* If the remainder is greater than the maximum data length,
* we need to truncate the value for the sake of the
* comparison below:
*/
if (rem > xfer->max_data_length) {
rem = usbd_xfer_max_len(xfer);
}
if ((rem != max_len) && (is_complete != 0)) {
/*
* If we don't transfer the data we can transfer, then
* the transfer is short !
*/
xfer->flags.force_short_xfer = 1;
xfer->nframes = 2;
} else {
/*
* Default case
*/
xfer->flags.force_short_xfer = 0;
xfer->nframes = max_len ? 2 : 1;
}
if (max_len > 0) {
if (src_mcopy) {
src_mcopy = USB_ADD_BYTES(src_mcopy, off);
usbd_copy_in(xfer->frbuffers + 1, 0,
src_mcopy, max_len);
usbd_xfer_set_frame_len(xfer, 1, max_len);
} else {
usbd_xfer_set_frame_data(xfer, 1,
USB_ADD_BYTES(src_zcopy, off), max_len);
}
} else {
/* the end is reached, send status */
xfer->flags.manual_status = 0;
usbd_xfer_set_frame_len(xfer, 1, 0);
}
DPRINTF("success\n");
return (0); /* success */
tr_stalled:
DPRINTF("%s\n", (state != USB_HR_NOT_COMPLETE) ?
"complete" : "stalled");
return (USB_ERR_STALLED);
tr_bad_context:
DPRINTF("bad context\n");
return (USB_ERR_BAD_CONTEXT);
}
static void
usbd_ctrl_callback(struct usb_xfer *xfer, usb_error_t error)
{
irp *ip;
struct ndis_softc *sc = usbd_xfer_softc(xfer);
struct ndisusb_ep *ne = usbd_xfer_get_priv(xfer);
struct ndisusb_xfer *nx;
uint8_t irql;
union usbd_urb *urb;
struct usbd_urb_vendor_or_class_request *vcreq;
struct usb_page_cache *pc;
uint8_t type = 0;
struct usb_device_request req;
int len;
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
nx = usbd_aq_getfirst(sc, ne);
if (nx == NULL)
return;
ip = nx->nx_priv;
urb = usbd_geturb(ip);
vcreq = &urb->uu_vcreq;
if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) {
pc = usbd_xfer_get_frame(xfer, 1);
len = usbd_xfer_frame_len(xfer, 1);
usbd_copy_out(pc, 0, vcreq->uvc_trans_buf, len);
nx->nx_urbactlen += len;
}
usbd_xfer_complete(sc, ne, nx, USB_ERR_NORMAL_COMPLETION);
/* fall through */
case USB_ST_SETUP:
next:
/* get next transfer */
KeAcquireSpinLock(&ne->ne_lock, &irql);
if (IsListEmpty(&ne->ne_pending)) {
KeReleaseSpinLock(&ne->ne_lock, irql);
return;
}
nx = CONTAINING_RECORD(ne->ne_pending.nle_flink,
struct ndisusb_xfer, nx_next);
RemoveEntryList(&nx->nx_next);
/* add a entry to the active queue's tail. */
InsertTailList((&ne->ne_active), (&nx->nx_next));
KeReleaseSpinLock(&ne->ne_lock, irql);
ip = nx->nx_priv;
urb = usbd_geturb(ip);
vcreq = &urb->uu_vcreq;
switch (urb->uu_hdr.uuh_func) {
case URB_FUNCTION_CLASS_DEVICE:
type = UT_CLASS | UT_DEVICE;
break;
case URB_FUNCTION_CLASS_INTERFACE:
type = UT_CLASS | UT_INTERFACE;
break;
case URB_FUNCTION_CLASS_OTHER:
type = UT_CLASS | UT_OTHER;
break;
case URB_FUNCTION_CLASS_ENDPOINT:
type = UT_CLASS | UT_ENDPOINT;
break;
case URB_FUNCTION_VENDOR_DEVICE:
type = UT_VENDOR | UT_DEVICE;
break;
case URB_FUNCTION_VENDOR_INTERFACE:
type = UT_VENDOR | UT_INTERFACE;
break;
case URB_FUNCTION_VENDOR_OTHER:
type = UT_VENDOR | UT_OTHER;
break;
case URB_FUNCTION_VENDOR_ENDPOINT:
type = UT_VENDOR | UT_ENDPOINT;
break;
default:
/* never reached. */
break;
}
type |= (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) ?
UT_READ : UT_WRITE;
type |= vcreq->uvc_reserved1;
req.bmRequestType = type;
req.bRequest = vcreq->uvc_req;
USETW(req.wIndex, vcreq->uvc_idx);
USETW(req.wValue, vcreq->uvc_value);
USETW(req.wLength, vcreq->uvc_trans_buflen);
nx->nx_urbbuf = vcreq->uvc_trans_buf;
nx->nx_urblen = vcreq->uvc_trans_buflen;
nx->nx_urbactlen = 0;
pc = usbd_xfer_get_frame(xfer, 0);
usbd_copy_in(pc, 0, &req, sizeof(req));
usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
usbd_xfer_set_frames(xfer, 1);
if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) {
if (vcreq->uvc_trans_buflen >= USBD_CTRL_READ_BUFFER_SP)
device_printf(sc->ndis_dev,
"warning: not enough buffer space (%d).\n",
vcreq->uvc_trans_buflen);
usbd_xfer_set_frame_len(xfer, 1,
MIN(usbd_xfer_max_len(xfer),
vcreq->uvc_trans_buflen));
usbd_xfer_set_frames(xfer, 2);
} else {
if (nx->nx_urblen > USBD_CTRL_WRITE_BUFFER_SP)
device_printf(sc->ndis_dev,
"warning: not enough write buffer space"
" (%d).\n", nx->nx_urblen);
/*
* XXX with my local tests there was no cases to require
* a extra buffer until now but it'd need to update in
* the future if it needs to be.
*/
if (nx->nx_urblen > 0) {
pc = usbd_xfer_get_frame(xfer, 1);
usbd_copy_in(pc, 0, nx->nx_urbbuf,
nx->nx_urblen);
usbd_xfer_set_frame_len(xfer, 1, nx->nx_urblen);
usbd_xfer_set_frames(xfer, 2);
}
}
usbd_transfer_submit(xfer);
break;
default:
nx = usbd_aq_getfirst(sc, ne);
if (nx == NULL)
return;
if (error != USB_ERR_CANCELLED) {
usbd_xfer_set_stall(xfer);
device_printf(sc->ndis_dev, "usb xfer warning (%s)\n",
usbd_errstr(error));
}
usbd_xfer_complete(sc, ne, nx, error);
if (error != USB_ERR_CANCELLED)
goto next;
break;
}
}
static void
usbd_non_isoc_callback(struct usb_xfer *xfer, usb_error_t error)
{
irp *ip;
struct ndis_softc *sc = usbd_xfer_softc(xfer);
struct ndisusb_ep *ne = usbd_xfer_get_priv(xfer);
struct ndisusb_xfer *nx;
struct usbd_urb_bulk_or_intr_transfer *ubi;
struct usb_page_cache *pc;
uint8_t irql;
uint32_t len;
union usbd_urb *urb;
usb_endpoint_descriptor_t *ep;
int actlen, sumlen;
usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
nx = usbd_aq_getfirst(sc, ne);
pc = usbd_xfer_get_frame(xfer, 0);
if (nx == NULL)
return;
/* copy in data with regard to the URB */
if (ne->ne_dirin != 0)
usbd_copy_out(pc, 0, nx->nx_urbbuf, actlen);
nx->nx_urbbuf += actlen;
nx->nx_urbactlen += actlen;
nx->nx_urblen -= actlen;
/* check for short transfer */
if (actlen < sumlen)
nx->nx_urblen = 0;
else {
/* check remainder */
if (nx->nx_urblen > 0) {
KeAcquireSpinLock(&ne->ne_lock, &irql);
InsertHeadList((&ne->ne_active), (&nx->nx_next));
KeReleaseSpinLock(&ne->ne_lock, irql);
ip = nx->nx_priv;
urb = usbd_geturb(ip);
ubi = &urb->uu_bulkintr;
ep = ubi->ubi_epdesc;
goto extra;
}
}
usbd_xfer_complete(sc, ne, nx,
((actlen < sumlen) && (nx->nx_shortxfer == 0)) ?
USB_ERR_SHORT_XFER : USB_ERR_NORMAL_COMPLETION);
/* fall through */
case USB_ST_SETUP:
next:
/* get next transfer */
KeAcquireSpinLock(&ne->ne_lock, &irql);
if (IsListEmpty(&ne->ne_pending)) {
KeReleaseSpinLock(&ne->ne_lock, irql);
return;
}
nx = CONTAINING_RECORD(ne->ne_pending.nle_flink,
struct ndisusb_xfer, nx_next);
RemoveEntryList(&nx->nx_next);
/* add a entry to the active queue's tail. */
InsertTailList((&ne->ne_active), (&nx->nx_next));
KeReleaseSpinLock(&ne->ne_lock, irql);
ip = nx->nx_priv;
urb = usbd_geturb(ip);
ubi = &urb->uu_bulkintr;
ep = ubi->ubi_epdesc;
nx->nx_urbbuf = ubi->ubi_trans_buf;
nx->nx_urbactlen = 0;
nx->nx_urblen = ubi->ubi_trans_buflen;
nx->nx_shortxfer = (ubi->ubi_trans_flags &
USBD_SHORT_TRANSFER_OK) ? 1 : 0;
extra:
len = MIN(usbd_xfer_max_len(xfer), nx->nx_urblen);
pc = usbd_xfer_get_frame(xfer, 0);
if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_OUT)
usbd_copy_in(pc, 0, nx->nx_urbbuf, len);
usbd_xfer_set_frame_len(xfer, 0, len);
usbd_xfer_set_frames(xfer, 1);
usbd_transfer_submit(xfer);
break;
default:
nx = usbd_aq_getfirst(sc, ne);
if (nx == NULL)
return;
if (error != USB_ERR_CANCELLED) {
usbd_xfer_set_stall(xfer);
device_printf(sc->ndis_dev, "usb xfer warning (%s)\n",
usbd_errstr(error));
}
usbd_xfer_complete(sc, ne, nx, error);
if (error != USB_ERR_CANCELLED)
goto next;
break;
}
}
static void
ubt_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct ubt_softc *sc = usbd_xfer_softc(xfer);
struct mbuf *m;
ng_hci_acldata_pkt_t *hdr;
struct usb_page_cache *pc;
int len;
int actlen;
usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
m = NULL;
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
/* Allocate new mbuf */
MGETHDR(m, M_NOWAIT, MT_DATA);
if (m == NULL) {
UBT_STAT_IERROR(sc);
goto submit_next;
}
if (!(MCLGET(m, M_NOWAIT))) {
UBT_STAT_IERROR(sc);
goto submit_next;
}
/* Add HCI packet type */
*mtod(m, uint8_t *)= NG_HCI_ACL_DATA_PKT;
m->m_pkthdr.len = m->m_len = 1;
if (actlen > MCLBYTES - 1)
actlen = MCLBYTES - 1;
pc = usbd_xfer_get_frame(xfer, 0);
usbd_copy_out(pc, 0, mtod(m, uint8_t *) + 1, actlen);
m->m_pkthdr.len += actlen;
m->m_len += actlen;
UBT_INFO(sc, "got %d bytes from bulk-in pipe\n",
actlen);
/* Validate packet and send it up the stack */
if (m->m_pkthdr.len < (int)sizeof(*hdr)) {
UBT_INFO(sc, "HCI ACL packet is too short\n");
UBT_STAT_IERROR(sc);
goto submit_next;
}
hdr = mtod(m, ng_hci_acldata_pkt_t *);
len = le16toh(hdr->length);
if (len != (int)(m->m_pkthdr.len - sizeof(*hdr))) {
UBT_ERR(sc, "Invalid ACL packet size, length=%d, " \
"pktlen=%d\n", len, m->m_pkthdr.len);
UBT_STAT_IERROR(sc);
goto submit_next;
}
UBT_INFO(sc, "got complete ACL data packet, pktlen=%d, " \
"length=%d\n", m->m_pkthdr.len, len);
UBT_STAT_PCKTS_RECV(sc);
UBT_STAT_BYTES_RECV(sc, m->m_pkthdr.len);
ubt_fwd_mbuf_up(sc, &m);
/* m == NULL at this point */
/* FALLTHOUGH */
case USB_ST_SETUP:
submit_next:
NG_FREE_M(m); /* checks for m != NULL */
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default: /* Error */
if (error != USB_ERR_CANCELLED) {
UBT_WARN(sc, "bulk-in transfer failed: %s\n",
usbd_errstr(error));
/* Try to clear stall first */
usbd_xfer_set_stall(xfer);
goto submit_next;
}
/* transfer cancelled */
break;
}
} /* ubt_bulk_read_callback */
void
rtwn_bulk_rx_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct rtwn_usb_softc *uc = usbd_xfer_softc(xfer);
struct rtwn_softc *sc = &uc->uc_sc;
struct ieee80211com *ic = &sc->sc_ic;
struct ieee80211_node *ni;
struct mbuf *m = NULL, *next;
struct rtwn_data *data;
int8_t nf, rssi;
RTWN_ASSERT_LOCKED(sc);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
data = STAILQ_FIRST(&uc->uc_rx_active);
if (data == NULL)
goto tr_setup;
STAILQ_REMOVE_HEAD(&uc->uc_rx_active, next);
m = rtwn_report_intr(uc, xfer, data);
STAILQ_INSERT_TAIL(&uc->uc_rx_inactive, data, next);
/* FALLTHROUGH */
case USB_ST_SETUP:
tr_setup:
data = STAILQ_FIRST(&uc->uc_rx_inactive);
if (data == NULL) {
KASSERT(m == NULL, ("mbuf isn't NULL"));
goto finish;
}
STAILQ_REMOVE_HEAD(&uc->uc_rx_inactive, next);
STAILQ_INSERT_TAIL(&uc->uc_rx_active, data, next);
usbd_xfer_set_frame_data(xfer, 0, data->buf,
usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
/*
* To avoid LOR we should unlock our private mutex here to call
* ieee80211_input() because here is at the end of a USB
* callback and safe to unlock.
*/
while (m != NULL) {
next = m->m_next;
m->m_next = NULL;
ni = rtwn_rx_frame(sc, m, &rssi);
RTWN_UNLOCK(sc);
nf = RTWN_NOISE_FLOOR;
if (ni != NULL) {
if (ni->ni_flags & IEEE80211_NODE_HT)
m->m_flags |= M_AMPDU;
(void)ieee80211_input(ni, m, rssi - nf, nf);
ieee80211_free_node(ni);
} else {
(void)ieee80211_input_all(ic, m,
rssi - nf, nf);
}
RTWN_LOCK(sc);
m = next;
}
break;
default:
/* needs it to the inactive queue due to a error. */
data = STAILQ_FIRST(&uc->uc_rx_active);
if (data != NULL) {
STAILQ_REMOVE_HEAD(&uc->uc_rx_active, next);
STAILQ_INSERT_TAIL(&uc->uc_rx_inactive, data, next);
}
if (error != USB_ERR_CANCELLED) {
usbd_xfer_set_stall(xfer);
counter_u64_add(ic->ic_ierrors, 1);
goto tr_setup;
}
break;
}
finish:
/* Finished receive; age anything left on the FF queue by a little bump */
/*
* XXX TODO: just make this a callout timer schedule so we can
* flush the FF staging queue if we're approaching idle.
*/
#ifdef IEEE80211_SUPPORT_SUPERG
if (!(sc->sc_flags & RTWN_FW_LOADED) ||
sc->sc_ratectl != RTWN_RATECTL_NET80211)
rtwn_cmd_sleepable(sc, NULL, 0, rtwn_ff_flush_all);
#endif
/* Kick-start more transmit in case we stalled */
rtwn_start(sc);
}
/*------------------------------------------------------------------------*
* usbd_do_request_flags and usbd_do_request
*
* Description of arguments passed to these functions:
*
* "udev" - this is the "usb_device" structure pointer on which the
* request should be performed. It is possible to call this function
* in both Host Side mode and Device Side mode.
*
* "mtx" - if this argument is non-NULL the mutex pointed to by it
* will get dropped and picked up during the execution of this
* function, hence this function sometimes needs to sleep. If this
* argument is NULL it has no effect.
*
* "req" - this argument must always be non-NULL and points to an
* 8-byte structure holding the USB request to be done. The USB
* request structure has a bit telling the direction of the USB
* request, if it is a read or a write.
*
* "data" - if the "wLength" part of the structure pointed to by "req"
* is non-zero this argument must point to a valid kernel buffer which
* can hold at least "wLength" bytes. If "wLength" is zero "data" can
* be NULL.
*
* "flags" - here is a list of valid flags:
*
* o USB_SHORT_XFER_OK: allows the data transfer to be shorter than
* specified
*
* o USB_DELAY_STATUS_STAGE: allows the status stage to be performed
* at a later point in time. This is tunable by the "hw.usb.ss_delay"
* sysctl. This flag is mostly useful for debugging.
*
* o USB_USER_DATA_PTR: treat the "data" pointer like a userland
* pointer.
*
* "actlen" - if non-NULL the actual transfer length will be stored in
* the 16-bit unsigned integer pointed to by "actlen". This
* information is mostly useful when the "USB_SHORT_XFER_OK" flag is
* used.
*
* "timeout" - gives the timeout for the control transfer in
* milliseconds. A "timeout" value less than 50 milliseconds is
* treated like a 50 millisecond timeout. A "timeout" value greater
* than 30 seconds is treated like a 30 second timeout. This USB stack
* does not allow control requests without a timeout.
*
* NOTE: This function is thread safe. All calls to
* "usbd_do_request_flags" will be serialised by the use of an
* internal "sx_lock".
*
* Returns:
* 0: Success
* Else: Failure
*------------------------------------------------------------------------*/
usb_error_t
usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx,
struct usb_device_request *req, void *data, uint16_t flags,
uint16_t *actlen, usb_timeout_t timeout)
{
usb_handle_req_t *hr_func;
struct usb_xfer *xfer;
const void *desc;
int err = 0;
usb_ticks_t start_ticks;
usb_ticks_t delta_ticks;
usb_ticks_t max_ticks;
uint16_t length;
uint16_t temp;
if (timeout < 50) {
/* timeout is too small */
timeout = 50;
}
if (timeout > 30000) {
/* timeout is too big */
timeout = 30000;
}
length = UGETW(req->wLength);
DPRINTFN(5, "udev=%p bmRequestType=0x%02x bRequest=0x%02x "
"wValue=0x%02x%02x wIndex=0x%02x%02x wLength=0x%02x%02x\n",
udev, req->bmRequestType, req->bRequest,
req->wValue[1], req->wValue[0],
req->wIndex[1], req->wIndex[0],
req->wLength[1], req->wLength[0]);
/* Check if the device is still alive */
if (udev->state < USB_STATE_POWERED) {
DPRINTF("usb device has gone\n");
return (USB_ERR_NOT_CONFIGURED);
}
/*
* Set "actlen" to a known value in case the caller does not
* check the return value:
*/
if (actlen)
*actlen = 0;
#if (USB_HAVE_USER_IO == 0)
if (flags & USB_USER_DATA_PTR)
return (USB_ERR_INVAL);
#endif
if (mtx) {
mtx_unlock(mtx);
if (mtx != &Giant) {
mtx_assert(mtx, MA_NOTOWNED);
}
}
/*
* Grab the default sx-lock so that serialisation
* is achieved when multiple threads are involved:
*/
sx_xlock(udev->default_sx);
hr_func = usbd_get_hr_func(udev);
if (hr_func != NULL) {
DPRINTF("Handle Request function is set\n");
desc = NULL;
temp = 0;
if (!(req->bmRequestType & UT_READ)) {
if (length != 0) {
DPRINTFN(1, "The handle request function "
"does not support writing data!\n");
err = USB_ERR_INVAL;
goto done;
}
}
/* The root HUB code needs the BUS lock locked */
USB_BUS_LOCK(udev->bus);
err = (hr_func) (udev, req, &desc, &temp);
USB_BUS_UNLOCK(udev->bus);
if (err)
goto done;
if (length > temp) {
if (!(flags & USB_SHORT_XFER_OK)) {
err = USB_ERR_SHORT_XFER;
goto done;
}
length = temp;
}
if (actlen)
*actlen = length;
if (length > 0) {
#if USB_HAVE_USER_IO
if (flags & USB_USER_DATA_PTR) {
if (copyout(desc, data, length)) {
err = USB_ERR_INVAL;
goto done;
}
} else
#endif
bcopy(desc, data, length);
}
goto done; /* success */
}
/*
* Setup a new USB transfer or use the existing one, if any:
*/
usbd_default_transfer_setup(udev);
xfer = udev->default_xfer[0];
if (xfer == NULL) {
/* most likely out of memory */
err = USB_ERR_NOMEM;
goto done;
}
USB_XFER_LOCK(xfer);
if (flags & USB_DELAY_STATUS_STAGE)
xfer->flags.manual_status = 1;
else
xfer->flags.manual_status = 0;
if (flags & USB_SHORT_XFER_OK)
xfer->flags.short_xfer_ok = 1;
else
xfer->flags.short_xfer_ok = 0;
xfer->timeout = timeout;
start_ticks = ticks;
max_ticks = USB_MS_TO_TICKS(timeout);
usbd_copy_in(xfer->frbuffers, 0, req, sizeof(*req));
usbd_xfer_set_frame_len(xfer, 0, sizeof(*req));
xfer->nframes = 2;
while (1) {
temp = length;
if (temp > xfer->max_data_length) {
temp = usbd_xfer_max_len(xfer);
}
usbd_xfer_set_frame_len(xfer, 1, temp);
if (temp > 0) {
if (!(req->bmRequestType & UT_READ)) {
#if USB_HAVE_USER_IO
if (flags & USB_USER_DATA_PTR) {
USB_XFER_UNLOCK(xfer);
err = usbd_copy_in_user(xfer->frbuffers + 1,
0, data, temp);
USB_XFER_LOCK(xfer);
if (err) {
err = USB_ERR_INVAL;
break;
}
} else
#endif
usbd_copy_in(xfer->frbuffers + 1,
0, data, temp);
}
xfer->nframes = 2;
} else {
if (xfer->frlengths[0] == 0) {
if (xfer->flags.manual_status) {
#if USB_DEBUG
int temp;
temp = usb_ss_delay;
if (temp > 5000) {
temp = 5000;
}
if (temp > 0) {
usb_pause_mtx(
xfer->xroot->xfer_mtx,
USB_MS_TO_TICKS(temp));
}
#endif
xfer->flags.manual_status = 0;
} else {
break;
}
}
xfer->nframes = 1;
}
usbd_transfer_start(xfer);
while (usbd_transfer_pending(xfer)) {
cv_wait(udev->default_cv,
xfer->xroot->xfer_mtx);
}
err = xfer->error;
if (err) {
break;
}
/* subtract length of SETUP packet, if any */
if (xfer->aframes > 0) {
xfer->actlen -= xfer->frlengths[0];
} else {
xfer->actlen = 0;
}
/* check for short packet */
if (temp > xfer->actlen) {
temp = xfer->actlen;
length = temp;
}
if (temp > 0) {
if (req->bmRequestType & UT_READ) {
#if USB_HAVE_USER_IO
if (flags & USB_USER_DATA_PTR) {
USB_XFER_UNLOCK(xfer);
err = usbd_copy_out_user(xfer->frbuffers + 1,
0, data, temp);
USB_XFER_LOCK(xfer);
if (err) {
err = USB_ERR_INVAL;
break;
}
} else
#endif
usbd_copy_out(xfer->frbuffers + 1,
0, data, temp);
}
}
/*
* Clear "frlengths[0]" so that we don't send the setup
* packet again:
*/
usbd_xfer_set_frame_len(xfer, 0, 0);
/* update length and data pointer */
length -= temp;
data = USB_ADD_BYTES(data, temp);
if (actlen) {
(*actlen) += temp;
}
/* check for timeout */
delta_ticks = ticks - start_ticks;
if (delta_ticks > max_ticks) {
if (!err) {
err = USB_ERR_TIMEOUT;
}
}
if (err) {
break;
}
}
if (err) {
/*
* Make sure that the control endpoint is no longer
* blocked in case of a non-transfer related error:
*/
usbd_transfer_stop(xfer);
}
USB_XFER_UNLOCK(xfer);
done:
sx_xunlock(udev->default_sx);
if (mtx) {
mtx_lock(mtx);
}
return ((usb_error_t)err);
}