Commit d5e90b7a authored by Laurent Pinchart's avatar Laurent Pinchart Committed by Mauro Carvalho Chehab

[media] uvcvideo: Move to video_ioctl2

Simplify ioctl handling by using video_ioctl2.
Signed-off-by: default avatarLaurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@osg.samsung.com>
parent 59b702ea
...@@ -1760,6 +1760,7 @@ static int uvc_register_video(struct uvc_device *dev, ...@@ -1760,6 +1760,7 @@ static int uvc_register_video(struct uvc_device *dev,
*/ */
vdev->v4l2_dev = &dev->vdev; vdev->v4l2_dev = &dev->vdev;
vdev->fops = &uvc_fops; vdev->fops = &uvc_fops;
vdev->ioctl_ops = &uvc_ioctl_ops;
vdev->release = uvc_release; vdev->release = uvc_release;
vdev->prio = &stream->chain->prio; vdev->prio = &stream->chain->prio;
if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
......
...@@ -551,167 +551,253 @@ static int uvc_v4l2_release(struct file *file) ...@@ -551,167 +551,253 @@ static int uvc_v4l2_release(struct file *file)
return 0; return 0;
} }
static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg) static int uvc_ioctl_querycap(struct file *file, void *fh,
struct v4l2_capability *cap)
{ {
struct video_device *vdev = video_devdata(file); struct video_device *vdev = video_devdata(file);
struct uvc_fh *handle = file->private_data; struct uvc_fh *handle = file->private_data;
struct uvc_video_chain *chain = handle->chain; struct uvc_video_chain *chain = handle->chain;
struct uvc_streaming *stream = handle->stream; struct uvc_streaming *stream = handle->stream;
long ret = 0;
switch (cmd) { strlcpy(cap->driver, "uvcvideo", sizeof(cap->driver));
/* Query capabilities */ strlcpy(cap->card, vdev->name, sizeof(cap->card));
case VIDIOC_QUERYCAP: usb_make_path(stream->dev->udev, cap->bus_info, sizeof(cap->bus_info));
{
struct v4l2_capability *cap = arg;
memset(cap, 0, sizeof *cap);
strlcpy(cap->driver, "uvcvideo", sizeof cap->driver);
strlcpy(cap->card, vdev->name, sizeof cap->card);
usb_make_path(stream->dev->udev,
cap->bus_info, sizeof(cap->bus_info));
cap->version = LINUX_VERSION_CODE;
cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING
| chain->caps; | chain->caps;
if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
cap->device_caps = V4L2_CAP_VIDEO_CAPTURE cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
| V4L2_CAP_STREAMING;
else else
cap->device_caps = V4L2_CAP_VIDEO_OUTPUT cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
| V4L2_CAP_STREAMING;
break;
}
/* Priority */ return 0;
case VIDIOC_G_PRIORITY: }
*(u32 *)arg = v4l2_prio_max(vdev->prio);
break;
case VIDIOC_S_PRIORITY: static int uvc_ioctl_enum_fmt(struct uvc_streaming *stream,
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio); struct v4l2_fmtdesc *fmt)
if (ret < 0) {
return ret; struct uvc_format *format;
enum v4l2_buf_type type = fmt->type;
__u32 index = fmt->index;
return v4l2_prio_change(vdev->prio, &handle->vfh.prio, if (fmt->type != stream->type || fmt->index >= stream->nformats)
*(u32 *)arg); return -EINVAL;
/* Get, Set & Query control */ memset(fmt, 0, sizeof(*fmt));
case VIDIOC_QUERYCTRL: fmt->index = index;
return uvc_query_v4l2_ctrl(chain, arg); fmt->type = type;
case VIDIOC_G_CTRL: format = &stream->format[fmt->index];
{ fmt->flags = 0;
struct v4l2_control *ctrl = arg; if (format->flags & UVC_FMT_FLAG_COMPRESSED)
struct v4l2_ext_control xctrl; fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
strlcpy(fmt->description, format->name, sizeof(fmt->description));
fmt->description[sizeof(fmt->description) - 1] = 0;
fmt->pixelformat = format->fcc;
return 0;
}
memset(&xctrl, 0, sizeof xctrl); static int uvc_ioctl_enum_fmt_vid_cap(struct file *file, void *fh,
xctrl.id = ctrl->id; struct v4l2_fmtdesc *fmt)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
ret = uvc_ctrl_begin(chain); return uvc_ioctl_enum_fmt(stream, fmt);
}
static int uvc_ioctl_enum_fmt_vid_out(struct file *file, void *fh,
struct v4l2_fmtdesc *fmt)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
return uvc_ioctl_enum_fmt(stream, fmt);
}
static int uvc_ioctl_g_fmt_vid_cap(struct file *file, void *fh,
struct v4l2_format *fmt)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
return uvc_v4l2_get_format(stream, fmt);
}
static int uvc_ioctl_g_fmt_vid_out(struct file *file, void *fh,
struct v4l2_format *fmt)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
return uvc_v4l2_get_format(stream, fmt);
}
static int uvc_ioctl_s_fmt_vid_cap(struct file *file, void *fh,
struct v4l2_format *fmt)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
int ret;
ret = uvc_acquire_privileges(handle);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = uvc_ctrl_get(chain, &xctrl); return uvc_v4l2_set_format(stream, fmt);
uvc_ctrl_rollback(handle); }
if (ret >= 0)
ctrl->value = xctrl.value;
break;
}
case VIDIOC_S_CTRL: static int uvc_ioctl_s_fmt_vid_out(struct file *file, void *fh,
{ struct v4l2_format *fmt)
struct v4l2_control *ctrl = arg; {
struct v4l2_ext_control xctrl; struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
int ret;
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio); ret = uvc_acquire_privileges(handle);
if (ret < 0) if (ret < 0)
return ret; return ret;
memset(&xctrl, 0, sizeof xctrl); return uvc_v4l2_set_format(stream, fmt);
xctrl.id = ctrl->id; }
xctrl.value = ctrl->value;
ret = uvc_ctrl_begin(chain); static int uvc_ioctl_try_fmt_vid_cap(struct file *file, void *fh,
struct v4l2_format *fmt)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
struct uvc_streaming_control probe;
return uvc_v4l2_try_format(stream, fmt, &probe, NULL, NULL);
}
static int uvc_ioctl_try_fmt_vid_out(struct file *file, void *fh,
struct v4l2_format *fmt)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
struct uvc_streaming_control probe;
return uvc_v4l2_try_format(stream, fmt, &probe, NULL, NULL);
}
static int uvc_ioctl_reqbufs(struct file *file, void *fh,
struct v4l2_requestbuffers *rb)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
int ret;
ret = uvc_acquire_privileges(handle);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = uvc_ctrl_set(chain, &xctrl); mutex_lock(&stream->mutex);
if (ret < 0) { ret = uvc_alloc_buffers(&stream->queue, rb);
uvc_ctrl_rollback(handle); mutex_unlock(&stream->mutex);
if (ret < 0)
return ret; return ret;
}
ret = uvc_ctrl_commit(handle, &xctrl, 1);
if (ret == 0) if (ret == 0)
ctrl->value = xctrl.value; uvc_dismiss_privileges(handle);
break;
}
case VIDIOC_QUERYMENU: return 0;
return uvc_query_v4l2_menu(chain, arg); }
case VIDIOC_G_EXT_CTRLS: static int uvc_ioctl_querybuf(struct file *file, void *fh,
{ struct v4l2_buffer *buf)
struct v4l2_ext_controls *ctrls = arg; {
struct v4l2_ext_control *ctrl = ctrls->controls; struct uvc_fh *handle = fh;
unsigned int i; struct uvc_streaming *stream = handle->stream;
ret = uvc_ctrl_begin(chain); if (!uvc_has_privileges(handle))
if (ret < 0) return -EBUSY;
return ret;
for (i = 0; i < ctrls->count; ++ctrl, ++i) { return uvc_query_buffer(&stream->queue, buf);
ret = uvc_ctrl_get(chain, ctrl); }
if (ret < 0) {
uvc_ctrl_rollback(handle);
ctrls->error_idx = i;
return ret;
}
}
ctrls->error_idx = 0;
ret = uvc_ctrl_rollback(handle);
break;
}
case VIDIOC_S_EXT_CTRLS: static int uvc_ioctl_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio); {
if (ret < 0) struct uvc_fh *handle = fh;
return ret; struct uvc_streaming *stream = handle->stream;
/* Fall through */
case VIDIOC_TRY_EXT_CTRLS:
{
struct v4l2_ext_controls *ctrls = arg;
struct v4l2_ext_control *ctrl = ctrls->controls;
unsigned int i;
ret = uvc_ctrl_begin(chain); if (!uvc_has_privileges(handle))
return -EBUSY;
return uvc_queue_buffer(&stream->queue, buf);
}
static int uvc_ioctl_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
if (!uvc_has_privileges(handle))
return -EBUSY;
return uvc_dequeue_buffer(&stream->queue, buf,
file->f_flags & O_NONBLOCK);
}
static int uvc_ioctl_create_bufs(struct file *file, void *fh,
struct v4l2_create_buffers *cb)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
int ret;
ret = uvc_acquire_privileges(handle);
if (ret < 0) if (ret < 0)
return ret; return ret;
for (i = 0; i < ctrls->count; ++ctrl, ++i) { return uvc_create_buffers(&stream->queue, cb);
ret = uvc_ctrl_set(chain, ctrl); }
if (ret < 0) {
uvc_ctrl_rollback(handle); static int uvc_ioctl_streamon(struct file *file, void *fh,
ctrls->error_idx = cmd == VIDIOC_S_EXT_CTRLS enum v4l2_buf_type type)
? ctrls->count : i; {
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
int ret;
if (type != stream->type)
return -EINVAL;
if (!uvc_has_privileges(handle))
return -EBUSY;
mutex_lock(&stream->mutex);
ret = uvc_video_enable(stream, 1);
mutex_unlock(&stream->mutex);
return ret; return ret;
} }
}
ctrls->error_idx = 0; static int uvc_ioctl_streamoff(struct file *file, void *fh,
enum v4l2_buf_type type)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
int ret;
if (cmd == VIDIOC_S_EXT_CTRLS) if (type != stream->type)
ret = uvc_ctrl_commit(handle, return -EINVAL;
ctrls->controls, ctrls->count);
else
ret = uvc_ctrl_rollback(handle);
break;
}
/* Get, Set & Enum input */ if (!uvc_has_privileges(handle))
case VIDIOC_ENUMINPUT: return -EBUSY;
{
mutex_lock(&stream->mutex);
ret = uvc_video_enable(stream, 0);
mutex_unlock(&stream->mutex);
return ret;
}
static int uvc_ioctl_enum_input(struct file *file, void *fh,
struct v4l2_input *input)
{
struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
const struct uvc_entity *selector = chain->selector; const struct uvc_entity *selector = chain->selector;
struct v4l2_input *input = arg;
struct uvc_entity *iterm = NULL; struct uvc_entity *iterm = NULL;
u32 index = input->index; u32 index = input->index;
int pin = 0; int pin = 0;
...@@ -738,119 +824,268 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg) ...@@ -738,119 +824,268 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
if (iterm == NULL || iterm->id != pin) if (iterm == NULL || iterm->id != pin)
return -EINVAL; return -EINVAL;
memset(input, 0, sizeof *input); memset(input, 0, sizeof(*input));
input->index = index; input->index = index;
strlcpy(input->name, iterm->name, sizeof input->name); strlcpy(input->name, iterm->name, sizeof(input->name));
if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA) if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA)
input->type = V4L2_INPUT_TYPE_CAMERA; input->type = V4L2_INPUT_TYPE_CAMERA;
break;
}
case VIDIOC_G_INPUT: return 0;
{ }
u8 input;
static int uvc_ioctl_g_input(struct file *file, void *fh, unsigned int *input)
{
struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
int ret;
u8 i;
if (chain->selector == NULL || if (chain->selector == NULL ||
(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) { (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
*(int *)arg = 0; *input = 0;
break; return 0;
} }
ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, chain->selector->id,
chain->selector->id, chain->dev->intfnum, chain->dev->intfnum, UVC_SU_INPUT_SELECT_CONTROL,
UVC_SU_INPUT_SELECT_CONTROL, &input, 1); &i, 1);
if (ret < 0) if (ret < 0)
return ret; return ret;
*(int *)arg = input - 1; *input = i - 1;
break; return 0;
} }
case VIDIOC_S_INPUT: static int uvc_ioctl_s_input(struct file *file, void *fh, unsigned int input)
{ {
u32 input = *(u32 *)arg + 1; struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
int ret;
u32 i;
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio); ret = uvc_acquire_privileges(handle);
if (ret < 0) if (ret < 0)
return ret; return ret;
if ((ret = uvc_acquire_privileges(handle)) < 0)
return ret;
if (chain->selector == NULL || if (chain->selector == NULL ||
(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) { (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
if (input != 1) if (input)
return -EINVAL; return -EINVAL;
break; return 0;
} }
if (input == 0 || input > chain->selector->bNrInPins) if (input >= chain->selector->bNrInPins)
return -EINVAL; return -EINVAL;
return uvc_query_ctrl(chain->dev, UVC_SET_CUR, i = input + 1;
chain->selector->id, chain->dev->intfnum, return uvc_query_ctrl(chain->dev, UVC_SET_CUR, chain->selector->id,
UVC_SU_INPUT_SELECT_CONTROL, &input, 1); chain->dev->intfnum, UVC_SU_INPUT_SELECT_CONTROL,
} &i, 1);
}
/* Try, Get, Set & Enum format */ static int uvc_ioctl_queryctrl(struct file *file, void *fh,
case VIDIOC_ENUM_FMT: struct v4l2_queryctrl *qc)
{ {
struct v4l2_fmtdesc *fmt = arg; struct uvc_fh *handle = fh;
struct uvc_format *format; struct uvc_video_chain *chain = handle->chain;
enum v4l2_buf_type type = fmt->type;
__u32 index = fmt->index;
if (fmt->type != stream->type || return uvc_query_v4l2_ctrl(chain, qc);
fmt->index >= stream->nformats) }
return -EINVAL;
memset(fmt, 0, sizeof(*fmt)); static int uvc_ioctl_g_ctrl(struct file *file, void *fh,
fmt->index = index; struct v4l2_control *ctrl)
fmt->type = type; {
struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
struct v4l2_ext_control xctrl;
int ret;
format = &stream->format[fmt->index]; memset(&xctrl, 0, sizeof(xctrl));
fmt->flags = 0; xctrl.id = ctrl->id;
if (format->flags & UVC_FMT_FLAG_COMPRESSED)
fmt->flags |= V4L2_FMT_FLAG_COMPRESSED; ret = uvc_ctrl_begin(chain);
strlcpy(fmt->description, format->name, if (ret < 0)
sizeof fmt->description); return ret;
fmt->description[sizeof fmt->description - 1] = 0;
fmt->pixelformat = format->fcc; ret = uvc_ctrl_get(chain, &xctrl);
break; uvc_ctrl_rollback(handle);
if (ret < 0)
return ret;
ctrl->value = xctrl.value;
return 0;
}
static int uvc_ioctl_s_ctrl(struct file *file, void *fh,
struct v4l2_control *ctrl)
{
struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
struct v4l2_ext_control xctrl;
int ret;
memset(&xctrl, 0, sizeof(xctrl));
xctrl.id = ctrl->id;
xctrl.value = ctrl->value;
ret = uvc_ctrl_begin(chain);
if (ret < 0)
return ret;
ret = uvc_ctrl_set(chain, &xctrl);
if (ret < 0) {
uvc_ctrl_rollback(handle);
return ret;
} }
case VIDIOC_TRY_FMT: ret = uvc_ctrl_commit(handle, &xctrl, 1);
{ if (ret < 0)
struct uvc_streaming_control probe; return ret;
ctrl->value = xctrl.value;
return 0;
}
static int uvc_ioctl_g_ext_ctrls(struct file *file, void *fh,
struct v4l2_ext_controls *ctrls)
{
struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
struct v4l2_ext_control *ctrl = ctrls->controls;
unsigned int i;
int ret;
ret = uvc_ctrl_begin(chain);
if (ret < 0)
return ret;
return uvc_v4l2_try_format(stream, arg, &probe, NULL, NULL); for (i = 0; i < ctrls->count; ++ctrl, ++i) {
ret = uvc_ctrl_get(chain, ctrl);
if (ret < 0) {
uvc_ctrl_rollback(handle);
ctrls->error_idx = i;
return ret;
}
} }
case VIDIOC_S_FMT: ctrls->error_idx = 0;
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
return uvc_ctrl_rollback(handle);
}
static int uvc_ioctl_s_try_ext_ctrls(struct uvc_fh *handle,
struct v4l2_ext_controls *ctrls,
bool commit)
{
struct v4l2_ext_control *ctrl = ctrls->controls;
struct uvc_video_chain *chain = handle->chain;
unsigned int i;
int ret;
ret = uvc_ctrl_begin(chain);
if (ret < 0) if (ret < 0)
return ret; return ret;
if ((ret = uvc_acquire_privileges(handle)) < 0) for (i = 0; i < ctrls->count; ++ctrl, ++i) {
ret = uvc_ctrl_set(chain, ctrl);
if (ret < 0) {
uvc_ctrl_rollback(handle);
ctrls->error_idx = commit ? ctrls->count : i;
return ret; return ret;
}
}
ctrls->error_idx = 0;
if (commit)
return uvc_ctrl_commit(handle, ctrls->controls, ctrls->count);
else
return uvc_ctrl_rollback(handle);
}
static int uvc_ioctl_s_ext_ctrls(struct file *file, void *fh,
struct v4l2_ext_controls *ctrls)
{
struct uvc_fh *handle = fh;
return uvc_v4l2_set_format(stream, arg); return uvc_ioctl_s_try_ext_ctrls(handle, ctrls, true);
}
static int uvc_ioctl_try_ext_ctrls(struct file *file, void *fh,
struct v4l2_ext_controls *ctrls)
{
struct uvc_fh *handle = fh;
return uvc_ioctl_s_try_ext_ctrls(handle, ctrls, false);
}
case VIDIOC_G_FMT: static int uvc_ioctl_querymenu(struct file *file, void *fh,
return uvc_v4l2_get_format(stream, arg); struct v4l2_querymenu *qm)
{
struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
/* Frame size enumeration */ return uvc_query_v4l2_menu(chain, qm);
case VIDIOC_ENUM_FRAMESIZES: }
{
struct v4l2_frmsizeenum *fsize = arg; static int uvc_ioctl_cropcap(struct file *file, void *fh,
struct v4l2_cropcap *ccap)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
if (ccap->type != stream->type)
return -EINVAL;
ccap->bounds.left = 0;
ccap->bounds.top = 0;
mutex_lock(&stream->mutex);
ccap->bounds.width = stream->cur_frame->wWidth;
ccap->bounds.height = stream->cur_frame->wHeight;
mutex_unlock(&stream->mutex);
ccap->defrect = ccap->bounds;
ccap->pixelaspect.numerator = 1;
ccap->pixelaspect.denominator = 1;
return 0;
}
static int uvc_ioctl_g_parm(struct file *file, void *fh,
struct v4l2_streamparm *parm)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
return uvc_v4l2_get_streamparm(stream, parm);
}
static int uvc_ioctl_s_parm(struct file *file, void *fh,
struct v4l2_streamparm *parm)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
int ret;
ret = uvc_acquire_privileges(handle);
if (ret < 0)
return ret;
return uvc_v4l2_set_streamparm(stream, parm);
}
static int uvc_ioctl_enum_framesizes(struct file *file, void *fh,
struct v4l2_frmsizeenum *fsize)
{
struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
struct uvc_format *format = NULL; struct uvc_format *format = NULL;
struct uvc_frame *frame; struct uvc_frame *frame;
int i; int i;
/* Look for the given pixel format */ /* Look for the given pixel format */
for (i = 0; i < stream->nformats; i++) { for (i = 0; i < stream->nformats; i++) {
if (stream->format[i].fcc == if (stream->format[i].fcc == fsize->pixel_format) {
fsize->pixel_format) {
format = &stream->format[i]; format = &stream->format[i];
break; break;
} }
...@@ -865,21 +1100,21 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg) ...@@ -865,21 +1100,21 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
fsize->discrete.width = frame->wWidth; fsize->discrete.width = frame->wWidth;
fsize->discrete.height = frame->wHeight; fsize->discrete.height = frame->wHeight;
break; return 0;
} }
/* Frame interval enumeration */ static int uvc_ioctl_enum_frameintervals(struct file *file, void *fh,
case VIDIOC_ENUM_FRAMEINTERVALS: struct v4l2_frmivalenum *fival)
{ {
struct v4l2_frmivalenum *fival = arg; struct uvc_fh *handle = fh;
struct uvc_streaming *stream = handle->stream;
struct uvc_format *format = NULL; struct uvc_format *format = NULL;
struct uvc_frame *frame = NULL; struct uvc_frame *frame = NULL;
int i; int i;
/* Look for the given pixel format and frame size */ /* Look for the given pixel format and frame size */
for (i = 0; i < stream->nformats; i++) { for (i = 0; i < stream->nformats; i++) {
if (stream->format[i].fcc == if (stream->format[i].fcc == fival->pixel_format) {
fival->pixel_format) {
format = &stream->format[i]; format = &stream->format[i];
break; break;
} }
...@@ -909,14 +1144,11 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg) ...@@ -909,14 +1144,11 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
&fival->discrete.denominator, 8, 333); &fival->discrete.denominator, 8, 333);
} else { } else {
fival->type = V4L2_FRMIVAL_TYPE_STEPWISE; fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
fival->stepwise.min.numerator = fival->stepwise.min.numerator = frame->dwFrameInterval[0];
frame->dwFrameInterval[0];
fival->stepwise.min.denominator = 10000000; fival->stepwise.min.denominator = 10000000;
fival->stepwise.max.numerator = fival->stepwise.max.numerator = frame->dwFrameInterval[1];
frame->dwFrameInterval[1];
fival->stepwise.max.denominator = 10000000; fival->stepwise.max.denominator = 10000000;
fival->stepwise.step.numerator = fival->stepwise.step.numerator = frame->dwFrameInterval[2];
frame->dwFrameInterval[2];
fival->stepwise.step.denominator = 10000000; fival->stepwise.step.denominator = 10000000;
uvc_simplify_fraction(&fival->stepwise.min.numerator, uvc_simplify_fraction(&fival->stepwise.min.numerator,
&fival->stepwise.min.denominator, 8, 333); &fival->stepwise.min.denominator, 8, 333);
...@@ -925,179 +1157,29 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg) ...@@ -925,179 +1157,29 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
uvc_simplify_fraction(&fival->stepwise.step.numerator, uvc_simplify_fraction(&fival->stepwise.step.numerator,
&fival->stepwise.step.denominator, 8, 333); &fival->stepwise.step.denominator, 8, 333);
} }
break;
}
/* Get & Set streaming parameters */
case VIDIOC_G_PARM:
return uvc_v4l2_get_streamparm(stream, arg);
case VIDIOC_S_PARM:
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
if (ret < 0)
return ret;
if ((ret = uvc_acquire_privileges(handle)) < 0)
return ret;
return uvc_v4l2_set_streamparm(stream, arg);
/* Cropping and scaling */
case VIDIOC_CROPCAP:
{
struct v4l2_cropcap *ccap = arg;
if (ccap->type != stream->type)
return -EINVAL;
ccap->bounds.left = 0;
ccap->bounds.top = 0;
mutex_lock(&stream->mutex);
ccap->bounds.width = stream->cur_frame->wWidth;
ccap->bounds.height = stream->cur_frame->wHeight;
mutex_unlock(&stream->mutex);
ccap->defrect = ccap->bounds;
ccap->pixelaspect.numerator = 1;
ccap->pixelaspect.denominator = 1;
break;
}
case VIDIOC_G_CROP:
case VIDIOC_S_CROP:
return -ENOTTY;
/* Buffers & streaming */
case VIDIOC_REQBUFS:
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
if (ret < 0)
return ret;
if ((ret = uvc_acquire_privileges(handle)) < 0)
return ret;
mutex_lock(&stream->mutex);
ret = uvc_alloc_buffers(&stream->queue, arg);
mutex_unlock(&stream->mutex);
if (ret < 0)
return ret;
if (ret == 0)
uvc_dismiss_privileges(handle);
ret = 0;
break;
case VIDIOC_QUERYBUF:
{
struct v4l2_buffer *buf = arg;
if (!uvc_has_privileges(handle))
return -EBUSY;
return uvc_query_buffer(&stream->queue, buf);
}
case VIDIOC_CREATE_BUFS: return 0;
{ }
struct v4l2_create_buffers *cb = arg;
ret = uvc_acquire_privileges(handle);
if (ret < 0)
return ret;
return uvc_create_buffers(&stream->queue, cb);
}
case VIDIOC_QBUF:
if (!uvc_has_privileges(handle))
return -EBUSY;
return uvc_queue_buffer(&stream->queue, arg);
case VIDIOC_DQBUF:
if (!uvc_has_privileges(handle))
return -EBUSY;
return uvc_dequeue_buffer(&stream->queue, arg,
file->f_flags & O_NONBLOCK);
case VIDIOC_STREAMON:
{
int *type = arg;
if (*type != stream->type)
return -EINVAL;
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
if (ret < 0)
return ret;
if (!uvc_has_privileges(handle))
return -EBUSY;
mutex_lock(&stream->mutex);
ret = uvc_video_enable(stream, 1);
mutex_unlock(&stream->mutex);
if (ret < 0)
return ret;
break;
}
case VIDIOC_STREAMOFF:
{
int *type = arg;
if (*type != stream->type)
return -EINVAL;
ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
if (ret < 0)
return ret;
if (!uvc_has_privileges(handle))
return -EBUSY;
return uvc_video_enable(stream, 0);
}
case VIDIOC_SUBSCRIBE_EVENT:
{
struct v4l2_event_subscription *sub = arg;
static int uvc_ioctl_subscribe_event(struct v4l2_fh *fh,
const struct v4l2_event_subscription *sub)
{
switch (sub->type) { switch (sub->type) {
case V4L2_EVENT_CTRL: case V4L2_EVENT_CTRL:
return v4l2_event_subscribe(&handle->vfh, sub, 0, return v4l2_event_subscribe(fh, sub, 0, &uvc_ctrl_sub_ev_ops);
&uvc_ctrl_sub_ev_ops);
default: default:
return -EINVAL; return -EINVAL;
} }
} }
case VIDIOC_UNSUBSCRIBE_EVENT:
return v4l2_event_unsubscribe(&handle->vfh, arg);
case VIDIOC_DQEVENT:
return v4l2_event_dequeue(&handle->vfh, arg,
file->f_flags & O_NONBLOCK);
/* Analog video standards make no sense for digital cameras. */
case VIDIOC_ENUMSTD:
case VIDIOC_QUERYSTD:
case VIDIOC_G_STD:
case VIDIOC_S_STD:
case VIDIOC_OVERLAY:
case VIDIOC_ENUMAUDIO:
case VIDIOC_ENUMAUDOUT:
case VIDIOC_ENUMOUTPUT: static long uvc_ioctl_default(struct file *file, void *fh, bool valid_prio,
uvc_trace(UVC_TRACE_IOCTL, "Unsupported ioctl 0x%08x\n", cmd); unsigned int cmd, void *arg)
return -ENOTTY; {
struct uvc_fh *handle = fh;
struct uvc_video_chain *chain = handle->chain;
switch (cmd) {
/* Dynamic controls. */
case UVCIOC_CTRL_MAP: case UVCIOC_CTRL_MAP:
return uvc_ioctl_ctrl_map(chain, arg); return uvc_ioctl_ctrl_map(chain, arg);
...@@ -1105,23 +1187,8 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg) ...@@ -1105,23 +1187,8 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
return uvc_xu_ctrl_query(chain, arg); return uvc_xu_ctrl_query(chain, arg);
default: default:
uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n", cmd);
return -ENOTTY; return -ENOTTY;
} }
return ret;
}
static long uvc_v4l2_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
if (uvc_trace_param & UVC_TRACE_IOCTL) {
uvc_printk(KERN_DEBUG, "uvc_v4l2_ioctl(");
v4l_printk_ioctl(NULL, cmd);
printk(")\n");
}
return video_usercopy(file, cmd, arg, uvc_v4l2_do_ioctl);
} }
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
...@@ -1304,7 +1371,7 @@ static long uvc_v4l2_compat_ioctl32(struct file *file, ...@@ -1304,7 +1371,7 @@ static long uvc_v4l2_compat_ioctl32(struct file *file,
old_fs = get_fs(); old_fs = get_fs();
set_fs(KERNEL_DS); set_fs(KERNEL_DS);
ret = uvc_v4l2_ioctl(file, cmd, (unsigned long)&karg); ret = video_ioctl2(file, cmd, (unsigned long)&karg);
set_fs(old_fs); set_fs(old_fs);
if (ret < 0) if (ret < 0)
...@@ -1365,11 +1432,48 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file, ...@@ -1365,11 +1432,48 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
} }
#endif #endif
const struct v4l2_ioctl_ops uvc_ioctl_ops = {
.vidioc_querycap = uvc_ioctl_querycap,
.vidioc_enum_fmt_vid_cap = uvc_ioctl_enum_fmt_vid_cap,
.vidioc_enum_fmt_vid_out = uvc_ioctl_enum_fmt_vid_out,
.vidioc_g_fmt_vid_cap = uvc_ioctl_g_fmt_vid_cap,
.vidioc_g_fmt_vid_out = uvc_ioctl_g_fmt_vid_out,
.vidioc_s_fmt_vid_cap = uvc_ioctl_s_fmt_vid_cap,
.vidioc_s_fmt_vid_out = uvc_ioctl_s_fmt_vid_out,
.vidioc_try_fmt_vid_cap = uvc_ioctl_try_fmt_vid_cap,
.vidioc_try_fmt_vid_out = uvc_ioctl_try_fmt_vid_out,
.vidioc_reqbufs = uvc_ioctl_reqbufs,
.vidioc_querybuf = uvc_ioctl_querybuf,
.vidioc_qbuf = uvc_ioctl_qbuf,
.vidioc_dqbuf = uvc_ioctl_dqbuf,
.vidioc_create_bufs = uvc_ioctl_create_bufs,
.vidioc_streamon = uvc_ioctl_streamon,
.vidioc_streamoff = uvc_ioctl_streamoff,
.vidioc_enum_input = uvc_ioctl_enum_input,
.vidioc_g_input = uvc_ioctl_g_input,
.vidioc_s_input = uvc_ioctl_s_input,
.vidioc_queryctrl = uvc_ioctl_queryctrl,
.vidioc_g_ctrl = uvc_ioctl_g_ctrl,
.vidioc_s_ctrl = uvc_ioctl_s_ctrl,
.vidioc_g_ext_ctrls = uvc_ioctl_g_ext_ctrls,
.vidioc_s_ext_ctrls = uvc_ioctl_s_ext_ctrls,
.vidioc_try_ext_ctrls = uvc_ioctl_try_ext_ctrls,
.vidioc_querymenu = uvc_ioctl_querymenu,
.vidioc_cropcap = uvc_ioctl_cropcap,
.vidioc_g_parm = uvc_ioctl_g_parm,
.vidioc_s_parm = uvc_ioctl_s_parm,
.vidioc_enum_framesizes = uvc_ioctl_enum_framesizes,
.vidioc_enum_frameintervals = uvc_ioctl_enum_frameintervals,
.vidioc_subscribe_event = uvc_ioctl_subscribe_event,
.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
.vidioc_default = uvc_ioctl_default,
};
const struct v4l2_file_operations uvc_fops = { const struct v4l2_file_operations uvc_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.open = uvc_v4l2_open, .open = uvc_v4l2_open,
.release = uvc_v4l2_release, .release = uvc_v4l2_release,
.unlocked_ioctl = uvc_v4l2_ioctl, .unlocked_ioctl = video_ioctl2,
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
.compat_ioctl32 = uvc_v4l2_compat_ioctl32, .compat_ioctl32 = uvc_v4l2_compat_ioctl32,
#endif #endif
......
...@@ -580,7 +580,6 @@ struct uvc_driver { ...@@ -580,7 +580,6 @@ struct uvc_driver {
#define UVC_TRACE_FORMAT (1 << 3) #define UVC_TRACE_FORMAT (1 << 3)
#define UVC_TRACE_CAPTURE (1 << 4) #define UVC_TRACE_CAPTURE (1 << 4)
#define UVC_TRACE_CALLS (1 << 5) #define UVC_TRACE_CALLS (1 << 5)
#define UVC_TRACE_IOCTL (1 << 6)
#define UVC_TRACE_FRAME (1 << 7) #define UVC_TRACE_FRAME (1 << 7)
#define UVC_TRACE_SUSPEND (1 << 8) #define UVC_TRACE_SUSPEND (1 << 8)
#define UVC_TRACE_STATUS (1 << 9) #define UVC_TRACE_STATUS (1 << 9)
...@@ -654,6 +653,7 @@ static inline int uvc_queue_streaming(struct uvc_video_queue *queue) ...@@ -654,6 +653,7 @@ static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
} }
/* V4L2 interface */ /* V4L2 interface */
extern const struct v4l2_ioctl_ops uvc_ioctl_ops;
extern const struct v4l2_file_operations uvc_fops; extern const struct v4l2_file_operations uvc_fops;
/* Media controller */ /* Media controller */
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment