static void
ugen_default_fs_callback(struct usb_xfer *xfer, usb_error_t error)
{
; /* workaround for a bug in "indent" */
DPRINTF("st=%u alen=%u aframes=%u\n",
USB_GET_STATE(xfer), xfer->actlen, xfer->aframes);
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
usbd_transfer_submit(xfer);
break;
default:
ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
break;
}
}
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);
}
static int
ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
{
struct usb_config usb_config[1];
struct usb_device_request req;
union {
struct usb_fs_complete *pcomp;
struct usb_fs_start *pstart;
struct usb_fs_stop *pstop;
struct usb_fs_open *popen;
struct usb_fs_open_stream *popen_stream;
struct usb_fs_close *pclose;
struct usb_fs_clear_stall_sync *pstall;
void *addr;
} u;
struct usb_endpoint *ep;
struct usb_endpoint_descriptor *ed;
struct usb_xfer *xfer;
int error = 0;
uint8_t iface_index;
uint8_t isread;
uint8_t ep_index;
uint8_t pre_scale;
u.addr = addr;
DPRINTFN(6, "cmd=0x%08lx\n", cmd);
switch (cmd) {
case USB_FS_COMPLETE:
mtx_lock(f->priv_mtx);
error = ugen_fs_get_complete(f, &ep_index);
mtx_unlock(f->priv_mtx);
if (error) {
error = EBUSY;
break;
}
u.pcomp->ep_index = ep_index;
error = ugen_fs_copy_out(f, u.pcomp->ep_index);
break;
case USB_FS_START:
error = ugen_fs_copy_in(f, u.pstart->ep_index);
if (error)
break;
mtx_lock(f->priv_mtx);
xfer = f->fs_xfer[u.pstart->ep_index];
usbd_transfer_start(xfer);
mtx_unlock(f->priv_mtx);
break;
case USB_FS_STOP:
if (u.pstop->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
mtx_lock(f->priv_mtx);
xfer = f->fs_xfer[u.pstart->ep_index];
if (usbd_transfer_pending(xfer)) {
usbd_transfer_stop(xfer);
/*
* Check if the USB transfer was stopped
* before it was even started. Else a cancel
* callback will be pending.
*/
if (!xfer->flags_int.transferring) {
ugen_fs_set_complete(xfer->priv_sc,
USB_P2U(xfer->priv_fifo));
}
}
mtx_unlock(f->priv_mtx);
break;
case USB_FS_OPEN:
case USB_FS_OPEN_STREAM:
if (u.popen->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
if (f->fs_xfer[u.popen->ep_index] != NULL) {
error = EBUSY;
break;
}
if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) {
u.popen->max_bufsize = USB_FS_MAX_BUFSIZE;
}
if (u.popen->max_frames & USB_FS_MAX_FRAMES_PRE_SCALE) {
pre_scale = 1;
u.popen->max_frames &= ~USB_FS_MAX_FRAMES_PRE_SCALE;
} else {
pre_scale = 0;
}
if (u.popen->max_frames > USB_FS_MAX_FRAMES) {
u.popen->max_frames = USB_FS_MAX_FRAMES;
break;
}
if (u.popen->max_frames == 0) {
error = EINVAL;
break;
}
ep = usbd_get_ep_by_addr(f->udev, u.popen->ep_no);
if (ep == NULL) {
error = EINVAL;
break;
}
ed = ep->edesc;
if (ed == NULL) {
error = ENXIO;
break;
}
iface_index = ep->iface_index;
memset(usb_config, 0, sizeof(usb_config));
usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
usb_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
usb_config[0].interval = USB_DEFAULT_INTERVAL;
usb_config[0].flags.proxy_buffer = 1;
if (pre_scale != 0)
usb_config[0].flags.pre_scale_frames = 1;
usb_config[0].callback = &ugen_ctrl_fs_callback;
usb_config[0].timeout = 0; /* no timeout */
usb_config[0].frames = u.popen->max_frames;
usb_config[0].bufsize = u.popen->max_bufsize;
usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
if (cmd == USB_FS_OPEN_STREAM)
usb_config[0].stream_id = u.popen_stream->stream_id;
if (usb_config[0].type == UE_CONTROL) {
if (f->udev->flags.usb_mode != USB_MODE_HOST) {
error = EINVAL;
break;
}
} else {
isread = ((usb_config[0].endpoint &
(UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
if (f->udev->flags.usb_mode != USB_MODE_HOST) {
isread = !isread;
}
/* check permissions */
if (isread) {
if (!(fflags & FREAD)) {
error = EPERM;
break;
}
} else {
if (!(fflags & FWRITE)) {
error = EPERM;
break;
}
}
}
error = usbd_transfer_setup(f->udev, &iface_index,
f->fs_xfer + u.popen->ep_index, usb_config, 1,
f, f->priv_mtx);
if (error == 0) {
/* update maximums */
u.popen->max_packet_length =
f->fs_xfer[u.popen->ep_index]->max_frame_size;
u.popen->max_bufsize =
f->fs_xfer[u.popen->ep_index]->max_data_length;
/* update number of frames */
u.popen->max_frames =
f->fs_xfer[u.popen->ep_index]->nframes;
/* store index of endpoint */
f->fs_xfer[u.popen->ep_index]->priv_fifo =
((uint8_t *)0) + u.popen->ep_index;
} else {
error = ENOMEM;
}
break;
case USB_FS_CLOSE:
if (u.pclose->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
if (f->fs_xfer[u.pclose->ep_index] == NULL) {
error = EINVAL;
break;
}
usbd_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
break;
case USB_FS_CLEAR_STALL_SYNC:
if (u.pstall->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
if (f->fs_xfer[u.pstall->ep_index] == NULL) {
error = EINVAL;
break;
}
if (f->udev->flags.usb_mode != USB_MODE_HOST) {
error = EINVAL;
break;
}
mtx_lock(f->priv_mtx);
error = usbd_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
mtx_unlock(f->priv_mtx);
if (error) {
return (EBUSY);
}
ep = f->fs_xfer[u.pstall->ep_index]->endpoint;
/* setup a clear-stall packet */
req.bmRequestType = UT_WRITE_ENDPOINT;
req.bRequest = UR_CLEAR_FEATURE;
USETW(req.wValue, UF_ENDPOINT_HALT);
req.wIndex[0] = ep->edesc->bEndpointAddress;
req.wIndex[1] = 0;
USETW(req.wLength, 0);
error = usbd_do_request(f->udev, NULL, &req, NULL);
if (error == 0) {
usbd_clear_data_toggle(f->udev, ep);
} else {
error = ENXIO;
}
break;
default:
error = ENOIOCTL;
break;
}
DPRINTFN(6, "error=%d\n", error);
return (error);
}
