2008-07-01 01:04:50 +07:00
|
|
|
/*
|
|
|
|
* uvc_v4l2.c -- USB Video Class driver - V4L2 API
|
|
|
|
*
|
2010-09-20 16:10:10 +07:00
|
|
|
* Copyright (C) 2005-2010
|
|
|
|
* Laurent Pinchart (laurent.pinchart@ideasonboard.com)
|
2008-07-01 01:04:50 +07:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/version.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2008-07-01 01:04:50 +07:00
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/videodev2.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
|
|
|
|
#include <media/v4l2-common.h>
|
2008-07-20 18:12:02 +07:00
|
|
|
#include <media/v4l2-ioctl.h>
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
#include "uvcvideo.h"
|
|
|
|
|
2010-02-19 02:38:52 +07:00
|
|
|
/* ------------------------------------------------------------------------
|
|
|
|
* UVC ioctls
|
|
|
|
*/
|
2010-09-20 15:53:21 +07:00
|
|
|
static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
|
|
|
|
struct uvc_xu_control_mapping *xmap, int old)
|
2010-02-19 02:38:52 +07:00
|
|
|
{
|
|
|
|
struct uvc_control_mapping *map;
|
|
|
|
unsigned int size;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
map = kzalloc(sizeof *map, GFP_KERNEL);
|
|
|
|
if (map == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
map->id = xmap->id;
|
|
|
|
memcpy(map->name, xmap->name, sizeof map->name);
|
|
|
|
memcpy(map->entity, xmap->entity, sizeof map->entity);
|
|
|
|
map->selector = xmap->selector;
|
|
|
|
map->size = xmap->size;
|
|
|
|
map->offset = xmap->offset;
|
|
|
|
map->v4l2_type = xmap->v4l2_type;
|
|
|
|
map->data_type = xmap->data_type;
|
|
|
|
|
|
|
|
switch (xmap->v4l2_type) {
|
|
|
|
case V4L2_CTRL_TYPE_INTEGER:
|
|
|
|
case V4L2_CTRL_TYPE_BOOLEAN:
|
|
|
|
case V4L2_CTRL_TYPE_BUTTON:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case V4L2_CTRL_TYPE_MENU:
|
|
|
|
if (old) {
|
2010-09-20 15:53:21 +07:00
|
|
|
uvc_trace(UVC_TRACE_CONTROL, "V4L2_CTRL_TYPE_MENU not "
|
|
|
|
"supported for UVCIOC_CTRL_MAP_OLD.\n");
|
2010-02-19 02:38:52 +07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = xmap->menu_count * sizeof(*map->menu_info);
|
|
|
|
map->menu_info = kmalloc(size, GFP_KERNEL);
|
|
|
|
if (map->menu_info == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (copy_from_user(map->menu_info, xmap->menu_info, size)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
map->menu_count = xmap->menu_count;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-09-20 15:53:21 +07:00
|
|
|
uvc_trace(UVC_TRACE_CONTROL, "Unsupported V4L2 control type "
|
|
|
|
"%u.\n", xmap->v4l2_type);
|
2010-02-19 02:38:52 +07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2010-09-20 15:53:21 +07:00
|
|
|
ret = uvc_ctrl_add_mapping(chain, map);
|
2010-02-19 02:38:52 +07:00
|
|
|
|
|
|
|
done:
|
2010-09-20 15:53:21 +07:00
|
|
|
kfree(map->menu_info);
|
|
|
|
kfree(map);
|
2010-02-19 02:38:52 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-01 01:04:50 +07:00
|
|
|
/* ------------------------------------------------------------------------
|
|
|
|
* V4L2 interface
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the frame interval closest to the requested frame interval for the
|
|
|
|
* given frame format and size. This should be done by the device as part of
|
|
|
|
* the Video Probe and Commit negotiation, but some hardware don't implement
|
|
|
|
* that feature.
|
|
|
|
*/
|
|
|
|
static __u32 uvc_try_frame_interval(struct uvc_frame *frame, __u32 interval)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (frame->bFrameIntervalType) {
|
|
|
|
__u32 best = -1, dist;
|
|
|
|
|
|
|
|
for (i = 0; i < frame->bFrameIntervalType; ++i) {
|
|
|
|
dist = interval > frame->dwFrameInterval[i]
|
|
|
|
? interval - frame->dwFrameInterval[i]
|
|
|
|
: frame->dwFrameInterval[i] - interval;
|
|
|
|
|
|
|
|
if (dist > best)
|
|
|
|
break;
|
|
|
|
|
|
|
|
best = dist;
|
|
|
|
}
|
|
|
|
|
|
|
|
interval = frame->dwFrameInterval[i-1];
|
|
|
|
} else {
|
|
|
|
const __u32 min = frame->dwFrameInterval[0];
|
|
|
|
const __u32 max = frame->dwFrameInterval[1];
|
|
|
|
const __u32 step = frame->dwFrameInterval[2];
|
|
|
|
|
|
|
|
interval = min + (interval - min + step/2) / step * step;
|
|
|
|
if (interval > max)
|
|
|
|
interval = max;
|
|
|
|
}
|
|
|
|
|
|
|
|
return interval;
|
|
|
|
}
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
static int uvc_v4l2_try_format(struct uvc_streaming *stream,
|
2008-07-01 01:04:50 +07:00
|
|
|
struct v4l2_format *fmt, struct uvc_streaming_control *probe,
|
|
|
|
struct uvc_format **uvc_format, struct uvc_frame **uvc_frame)
|
|
|
|
{
|
|
|
|
struct uvc_format *format = NULL;
|
|
|
|
struct uvc_frame *frame = NULL;
|
|
|
|
__u16 rw, rh;
|
|
|
|
unsigned int d, maxd;
|
|
|
|
unsigned int i;
|
|
|
|
__u32 interval;
|
|
|
|
int ret = 0;
|
|
|
|
__u8 *fcc;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (fmt->type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
fcc = (__u8 *)&fmt->fmt.pix.pixelformat;
|
|
|
|
uvc_trace(UVC_TRACE_FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
|
|
|
|
fmt->fmt.pix.pixelformat,
|
|
|
|
fcc[0], fcc[1], fcc[2], fcc[3],
|
|
|
|
fmt->fmt.pix.width, fmt->fmt.pix.height);
|
|
|
|
|
|
|
|
/* Check if the hardware supports the requested format. */
|
2009-06-28 18:37:50 +07:00
|
|
|
for (i = 0; i < stream->nformats; ++i) {
|
|
|
|
format = &stream->format[i];
|
2008-07-01 01:04:50 +07:00
|
|
|
if (format->fcc == fmt->fmt.pix.pixelformat)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (format == NULL || format->fcc != fmt->fmt.pix.pixelformat) {
|
|
|
|
uvc_trace(UVC_TRACE_FORMAT, "Unsupported format 0x%08x.\n",
|
|
|
|
fmt->fmt.pix.pixelformat);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the closest image size. The distance between image sizes is
|
|
|
|
* the size in pixels of the non-overlapping regions between the
|
|
|
|
* requested size and the frame-specified size.
|
|
|
|
*/
|
|
|
|
rw = fmt->fmt.pix.width;
|
|
|
|
rh = fmt->fmt.pix.height;
|
|
|
|
maxd = (unsigned int)-1;
|
|
|
|
|
|
|
|
for (i = 0; i < format->nframes; ++i) {
|
|
|
|
__u16 w = format->frame[i].wWidth;
|
|
|
|
__u16 h = format->frame[i].wHeight;
|
|
|
|
|
|
|
|
d = min(w, rw) * min(h, rh);
|
|
|
|
d = w*h + rw*rh - 2*d;
|
|
|
|
if (d < maxd) {
|
|
|
|
maxd = d;
|
|
|
|
frame = &format->frame[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (maxd == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (frame == NULL) {
|
|
|
|
uvc_trace(UVC_TRACE_FORMAT, "Unsupported size %ux%u.\n",
|
|
|
|
fmt->fmt.pix.width, fmt->fmt.pix.height);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Use the default frame interval. */
|
|
|
|
interval = frame->dwDefaultFrameInterval;
|
|
|
|
uvc_trace(UVC_TRACE_FORMAT, "Using default frame interval %u.%u us "
|
|
|
|
"(%u.%u fps).\n", interval/10, interval%10, 10000000/interval,
|
|
|
|
(100000000/interval)%10);
|
|
|
|
|
|
|
|
/* Set the format index, frame index and frame interval. */
|
|
|
|
memset(probe, 0, sizeof *probe);
|
|
|
|
probe->bmHint = 1; /* dwFrameInterval */
|
|
|
|
probe->bFormatIndex = format->index;
|
|
|
|
probe->bFrameIndex = frame->bFrameIndex;
|
|
|
|
probe->dwFrameInterval = uvc_try_frame_interval(frame, interval);
|
|
|
|
/* Some webcams stall the probe control set request when the
|
|
|
|
* dwMaxVideoFrameSize field is set to zero. The UVC specification
|
|
|
|
* clearly states that the field is read-only from the host, so this
|
|
|
|
* is a webcam bug. Set dwMaxVideoFrameSize to the value reported by
|
|
|
|
* the webcam to work around the problem.
|
|
|
|
*
|
|
|
|
* The workaround could probably be enabled for all webcams, so the
|
|
|
|
* quirk can be removed if needed. It's currently useful to detect
|
|
|
|
* webcam bugs and fix them before they hit the market (providing
|
|
|
|
* developers test their webcams with the Linux driver as well as with
|
|
|
|
* the Windows driver).
|
|
|
|
*/
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_lock(&stream->mutex);
|
2009-06-28 18:37:50 +07:00
|
|
|
if (stream->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS)
|
2008-07-01 01:04:50 +07:00
|
|
|
probe->dwMaxVideoFrameSize =
|
2009-06-28 18:37:50 +07:00
|
|
|
stream->ctrl.dwMaxVideoFrameSize;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2009-01-04 05:12:40 +07:00
|
|
|
/* Probe the device. */
|
2009-06-28 18:37:50 +07:00
|
|
|
ret = uvc_probe_video(stream, probe);
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_unlock(&stream->mutex);
|
2009-06-28 18:37:50 +07:00
|
|
|
if (ret < 0)
|
2008-07-01 01:04:50 +07:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
fmt->fmt.pix.width = frame->wWidth;
|
|
|
|
fmt->fmt.pix.height = frame->wHeight;
|
|
|
|
fmt->fmt.pix.field = V4L2_FIELD_NONE;
|
|
|
|
fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
|
|
|
|
fmt->fmt.pix.sizeimage = probe->dwMaxVideoFrameSize;
|
|
|
|
fmt->fmt.pix.colorspace = format->colorspace;
|
|
|
|
fmt->fmt.pix.priv = 0;
|
|
|
|
|
|
|
|
if (uvc_format != NULL)
|
|
|
|
*uvc_format = format;
|
|
|
|
if (uvc_frame != NULL)
|
|
|
|
*uvc_frame = frame;
|
|
|
|
|
|
|
|
done:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
static int uvc_v4l2_get_format(struct uvc_streaming *stream,
|
2008-07-01 01:04:50 +07:00
|
|
|
struct v4l2_format *fmt)
|
|
|
|
{
|
2010-11-21 23:36:34 +07:00
|
|
|
struct uvc_format *format;
|
|
|
|
struct uvc_frame *frame;
|
|
|
|
int ret = 0;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (fmt->type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_lock(&stream->mutex);
|
|
|
|
format = stream->cur_format;
|
|
|
|
frame = stream->cur_frame;
|
|
|
|
|
|
|
|
if (format == NULL || frame == NULL) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
fmt->fmt.pix.pixelformat = format->fcc;
|
|
|
|
fmt->fmt.pix.width = frame->wWidth;
|
|
|
|
fmt->fmt.pix.height = frame->wHeight;
|
|
|
|
fmt->fmt.pix.field = V4L2_FIELD_NONE;
|
|
|
|
fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
|
2009-06-28 18:37:50 +07:00
|
|
|
fmt->fmt.pix.sizeimage = stream->ctrl.dwMaxVideoFrameSize;
|
2008-07-01 01:04:50 +07:00
|
|
|
fmt->fmt.pix.colorspace = format->colorspace;
|
|
|
|
fmt->fmt.pix.priv = 0;
|
|
|
|
|
2010-11-21 23:36:34 +07:00
|
|
|
done:
|
|
|
|
mutex_unlock(&stream->mutex);
|
|
|
|
return ret;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
static int uvc_v4l2_set_format(struct uvc_streaming *stream,
|
2008-07-01 01:04:50 +07:00
|
|
|
struct v4l2_format *fmt)
|
|
|
|
{
|
|
|
|
struct uvc_streaming_control probe;
|
|
|
|
struct uvc_format *format;
|
|
|
|
struct uvc_frame *frame;
|
|
|
|
int ret;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (fmt->type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
ret = uvc_v4l2_try_format(stream, fmt, &probe, &format, &frame);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_lock(&stream->mutex);
|
|
|
|
|
|
|
|
if (uvc_queue_allocated(&stream->queue)) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
memcpy(&stream->ctrl, &probe, sizeof probe);
|
|
|
|
stream->cur_format = format;
|
|
|
|
stream->cur_frame = frame;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2010-11-21 23:36:34 +07:00
|
|
|
done:
|
|
|
|
mutex_unlock(&stream->mutex);
|
|
|
|
return ret;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
|
2008-07-01 01:04:50 +07:00
|
|
|
struct v4l2_streamparm *parm)
|
|
|
|
{
|
|
|
|
uint32_t numerator, denominator;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (parm->type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_lock(&stream->mutex);
|
2009-06-28 18:37:50 +07:00
|
|
|
numerator = stream->ctrl.dwFrameInterval;
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_unlock(&stream->mutex);
|
|
|
|
|
2008-07-01 01:04:50 +07:00
|
|
|
denominator = 10000000;
|
|
|
|
uvc_simplify_fraction(&numerator, &denominator, 8, 333);
|
|
|
|
|
|
|
|
memset(parm, 0, sizeof *parm);
|
2009-06-28 18:37:50 +07:00
|
|
|
parm->type = stream->type;
|
2008-12-29 08:32:29 +07:00
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
|
2008-12-29 08:32:29 +07:00
|
|
|
parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
|
|
|
|
parm->parm.capture.capturemode = 0;
|
|
|
|
parm->parm.capture.timeperframe.numerator = numerator;
|
|
|
|
parm->parm.capture.timeperframe.denominator = denominator;
|
|
|
|
parm->parm.capture.extendedmode = 0;
|
|
|
|
parm->parm.capture.readbuffers = 0;
|
|
|
|
} else {
|
|
|
|
parm->parm.output.capability = V4L2_CAP_TIMEPERFRAME;
|
|
|
|
parm->parm.output.outputmode = 0;
|
|
|
|
parm->parm.output.timeperframe.numerator = numerator;
|
|
|
|
parm->parm.output.timeperframe.denominator = denominator;
|
|
|
|
}
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
|
2008-07-01 01:04:50 +07:00
|
|
|
struct v4l2_streamparm *parm)
|
|
|
|
{
|
|
|
|
struct uvc_streaming_control probe;
|
2008-12-29 08:32:29 +07:00
|
|
|
struct v4l2_fract timeperframe;
|
2008-07-01 01:04:50 +07:00
|
|
|
uint32_t interval;
|
|
|
|
int ret;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (parm->type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-12-29 08:32:29 +07:00
|
|
|
if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
|
|
|
|
timeperframe = parm->parm.capture.timeperframe;
|
|
|
|
else
|
|
|
|
timeperframe = parm->parm.output.timeperframe;
|
|
|
|
|
|
|
|
interval = uvc_fraction_to_interval(timeperframe.numerator,
|
|
|
|
timeperframe.denominator);
|
2008-07-01 01:04:50 +07:00
|
|
|
uvc_trace(UVC_TRACE_FORMAT, "Setting frame interval to %u/%u (%u).\n",
|
2008-12-29 08:32:29 +07:00
|
|
|
timeperframe.numerator, timeperframe.denominator, interval);
|
2010-11-21 23:36:34 +07:00
|
|
|
|
|
|
|
mutex_lock(&stream->mutex);
|
|
|
|
|
|
|
|
if (uvc_queue_streaming(&stream->queue)) {
|
|
|
|
mutex_unlock(&stream->mutex);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(&probe, &stream->ctrl, sizeof probe);
|
|
|
|
probe.dwFrameInterval =
|
|
|
|
uvc_try_frame_interval(stream->cur_frame, interval);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
/* Probe the device with the new settings. */
|
2009-06-28 18:37:50 +07:00
|
|
|
ret = uvc_probe_video(stream, &probe);
|
2010-11-21 23:36:34 +07:00
|
|
|
if (ret < 0) {
|
|
|
|
mutex_unlock(&stream->mutex);
|
2008-07-01 01:04:50 +07:00
|
|
|
return ret;
|
2010-11-21 23:36:34 +07:00
|
|
|
}
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
memcpy(&stream->ctrl, &probe, sizeof probe);
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_unlock(&stream->mutex);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
/* Return the actual frame period. */
|
2008-12-29 08:32:29 +07:00
|
|
|
timeperframe.numerator = probe.dwFrameInterval;
|
|
|
|
timeperframe.denominator = 10000000;
|
|
|
|
uvc_simplify_fraction(&timeperframe.numerator,
|
|
|
|
&timeperframe.denominator, 8, 333);
|
|
|
|
|
|
|
|
if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
|
|
|
|
parm->parm.capture.timeperframe = timeperframe;
|
|
|
|
else
|
|
|
|
parm->parm.output.timeperframe = timeperframe;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------
|
|
|
|
* Privilege management
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Privilege management is the multiple-open implementation basis. The current
|
|
|
|
* implementation is completely transparent for the end-user and doesn't
|
|
|
|
* require explicit use of the VIDIOC_G_PRIORITY and VIDIOC_S_PRIORITY ioctls.
|
|
|
|
* Those ioctls enable finer control on the device (by making possible for a
|
|
|
|
* user to request exclusive access to a device), but are not mature yet.
|
|
|
|
* Switching to the V4L2 priority mechanism might be considered in the future
|
|
|
|
* if this situation changes.
|
|
|
|
*
|
|
|
|
* Each open instance of a UVC device can either be in a privileged or
|
|
|
|
* unprivileged state. Only a single instance can be in a privileged state at
|
2009-01-04 05:12:40 +07:00
|
|
|
* a given time. Trying to perform an operation that requires privileges will
|
2008-07-01 01:04:50 +07:00
|
|
|
* automatically acquire the required privileges if possible, or return -EBUSY
|
2009-09-02 13:12:26 +07:00
|
|
|
* otherwise. Privileges are dismissed when closing the instance or when
|
|
|
|
* freeing the video buffers using VIDIOC_REQBUFS.
|
2008-07-01 01:04:50 +07:00
|
|
|
*
|
2009-01-04 05:12:40 +07:00
|
|
|
* Operations that require privileges are:
|
2008-07-01 01:04:50 +07:00
|
|
|
*
|
|
|
|
* - VIDIOC_S_INPUT
|
|
|
|
* - VIDIOC_S_PARM
|
|
|
|
* - VIDIOC_S_FMT
|
|
|
|
* - VIDIOC_REQBUFS
|
|
|
|
*/
|
|
|
|
static int uvc_acquire_privileges(struct uvc_fh *handle)
|
|
|
|
{
|
|
|
|
/* Always succeed if the handle is already privileged. */
|
|
|
|
if (handle->state == UVC_HANDLE_ACTIVE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Check if the device already has a privileged handle. */
|
2009-06-28 18:37:50 +07:00
|
|
|
if (atomic_inc_return(&handle->stream->active) != 1) {
|
|
|
|
atomic_dec(&handle->stream->active);
|
2009-09-30 07:07:19 +07:00
|
|
|
return -EBUSY;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
handle->state = UVC_HANDLE_ACTIVE;
|
2009-09-30 07:07:19 +07:00
|
|
|
return 0;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void uvc_dismiss_privileges(struct uvc_fh *handle)
|
|
|
|
{
|
|
|
|
if (handle->state == UVC_HANDLE_ACTIVE)
|
2009-06-28 18:37:50 +07:00
|
|
|
atomic_dec(&handle->stream->active);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
handle->state = UVC_HANDLE_PASSIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uvc_has_privileges(struct uvc_fh *handle)
|
|
|
|
{
|
|
|
|
return handle->state == UVC_HANDLE_ACTIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------
|
|
|
|
* V4L2 file operations
|
|
|
|
*/
|
|
|
|
|
2008-12-30 16:58:20 +07:00
|
|
|
static int uvc_v4l2_open(struct file *file)
|
2008-07-01 01:04:50 +07:00
|
|
|
{
|
2009-06-28 18:37:50 +07:00
|
|
|
struct uvc_streaming *stream;
|
2008-07-01 01:04:50 +07:00
|
|
|
struct uvc_fh *handle;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open\n");
|
2009-06-28 18:37:50 +07:00
|
|
|
stream = video_drvdata(file);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2009-09-30 07:07:19 +07:00
|
|
|
if (stream->dev->state & UVC_DEV_DISCONNECTED)
|
|
|
|
return -ENODEV;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
ret = usb_autopm_get_interface(stream->dev->intf);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0)
|
2009-09-30 07:07:19 +07:00
|
|
|
return ret;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
/* Create the device handle. */
|
|
|
|
handle = kzalloc(sizeof *handle, GFP_KERNEL);
|
|
|
|
if (handle == NULL) {
|
2009-06-28 18:37:50 +07:00
|
|
|
usb_autopm_put_interface(stream->dev->intf);
|
2009-09-30 07:07:19 +07:00
|
|
|
return -ENOMEM;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (atomic_inc_return(&stream->dev->users) == 1) {
|
|
|
|
ret = uvc_status_start(stream->dev);
|
|
|
|
if (ret < 0) {
|
|
|
|
usb_autopm_put_interface(stream->dev->intf);
|
|
|
|
atomic_dec(&stream->dev->users);
|
2009-05-19 20:08:03 +07:00
|
|
|
kfree(handle);
|
2009-09-30 07:07:19 +07:00
|
|
|
return ret;
|
2009-05-19 20:08:03 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
handle->chain = stream->chain;
|
2009-06-28 18:37:50 +07:00
|
|
|
handle->stream = stream;
|
2008-07-01 01:04:50 +07:00
|
|
|
handle->state = UVC_HANDLE_PASSIVE;
|
|
|
|
file->private_data = handle;
|
|
|
|
|
2009-09-30 07:07:19 +07:00
|
|
|
return 0;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
2008-12-30 16:58:20 +07:00
|
|
|
static int uvc_v4l2_release(struct file *file)
|
2008-07-01 01:04:50 +07:00
|
|
|
{
|
2010-07-13 03:50:03 +07:00
|
|
|
struct uvc_fh *handle = file->private_data;
|
2009-06-28 18:37:50 +07:00
|
|
|
struct uvc_streaming *stream = handle->stream;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_release\n");
|
|
|
|
|
|
|
|
/* Only free resources if this is a privileged handle. */
|
|
|
|
if (uvc_has_privileges(handle)) {
|
2009-06-28 18:37:50 +07:00
|
|
|
uvc_video_enable(stream, 0);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (uvc_free_buffers(&stream->queue) < 0)
|
2008-07-01 01:04:50 +07:00
|
|
|
uvc_printk(KERN_ERR, "uvc_v4l2_release: Unable to "
|
|
|
|
"free buffers.\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Release the file handle. */
|
|
|
|
uvc_dismiss_privileges(handle);
|
|
|
|
kfree(handle);
|
|
|
|
file->private_data = NULL;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (atomic_dec_return(&stream->dev->users) == 0)
|
|
|
|
uvc_status_stop(stream->dev);
|
2009-05-19 20:08:03 +07:00
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
usb_autopm_put_interface(stream->dev->intf);
|
2008-07-01 01:04:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-12 22:11:30 +07:00
|
|
|
static void uvc_v4l2_ioctl_warn(void)
|
|
|
|
{
|
|
|
|
static int warned;
|
|
|
|
|
|
|
|
if (warned)
|
|
|
|
return;
|
|
|
|
|
|
|
|
uvc_printk(KERN_INFO, "Deprecated UVCIOC_CTRL_{ADD,MAP_OLD,GET,SET} "
|
|
|
|
"ioctls will be removed in 2.6.42.\n");
|
|
|
|
uvc_printk(KERN_INFO, "See http://www.ideasonboard.org/uvc/upgrade/ "
|
|
|
|
"for upgrade instructions.\n");
|
|
|
|
warned = 1;
|
|
|
|
}
|
|
|
|
|
2008-12-30 17:04:34 +07:00
|
|
|
static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
|
2008-07-01 01:04:50 +07:00
|
|
|
{
|
|
|
|
struct video_device *vdev = video_devdata(file);
|
2010-07-13 03:50:03 +07:00
|
|
|
struct uvc_fh *handle = file->private_data;
|
2009-07-02 06:24:47 +07:00
|
|
|
struct uvc_video_chain *chain = handle->chain;
|
2009-06-28 18:37:50 +07:00
|
|
|
struct uvc_streaming *stream = handle->stream;
|
2008-12-30 17:04:34 +07:00
|
|
|
long ret = 0;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
/* Query capabilities */
|
|
|
|
case VIDIOC_QUERYCAP:
|
|
|
|
{
|
|
|
|
struct v4l2_capability *cap = arg;
|
|
|
|
|
|
|
|
memset(cap, 0, sizeof *cap);
|
2009-01-09 00:05:11 +07:00
|
|
|
strlcpy(cap->driver, "uvcvideo", sizeof cap->driver);
|
|
|
|
strlcpy(cap->card, vdev->name, sizeof cap->card);
|
2009-06-28 18:37:50 +07:00
|
|
|
usb_make_path(stream->dev->udev,
|
2009-01-28 02:53:23 +07:00
|
|
|
cap->bus_info, sizeof(cap->bus_info));
|
2008-07-01 01:04:50 +07:00
|
|
|
cap->version = DRIVER_VERSION_NUMBER;
|
2009-06-28 18:37:50 +07:00
|
|
|
if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
|
2008-12-29 08:32:29 +07:00
|
|
|
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE
|
|
|
|
| V4L2_CAP_STREAMING;
|
|
|
|
else
|
|
|
|
cap->capabilities = V4L2_CAP_VIDEO_OUTPUT
|
|
|
|
| V4L2_CAP_STREAMING;
|
2008-07-01 01:04:50 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get, Set & Query control */
|
|
|
|
case VIDIOC_QUERYCTRL:
|
2009-07-02 06:24:47 +07:00
|
|
|
return uvc_query_v4l2_ctrl(chain, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
case VIDIOC_G_CTRL:
|
|
|
|
{
|
|
|
|
struct v4l2_control *ctrl = arg;
|
|
|
|
struct v4l2_ext_control xctrl;
|
|
|
|
|
|
|
|
memset(&xctrl, 0, sizeof xctrl);
|
|
|
|
xctrl.id = ctrl->id;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_begin(chain);
|
|
|
|
if (ret < 0)
|
2009-06-12 23:51:03 +07:00
|
|
|
return ret;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_get(chain, &xctrl);
|
|
|
|
uvc_ctrl_rollback(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret >= 0)
|
|
|
|
ctrl->value = xctrl.value;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_S_CTRL:
|
|
|
|
{
|
|
|
|
struct v4l2_control *ctrl = arg;
|
|
|
|
struct v4l2_ext_control xctrl;
|
|
|
|
|
|
|
|
memset(&xctrl, 0, sizeof xctrl);
|
|
|
|
xctrl.id = ctrl->id;
|
|
|
|
xctrl.value = ctrl->value;
|
|
|
|
|
2010-02-05 07:43:37 +07:00
|
|
|
ret = uvc_ctrl_begin(chain);
|
2009-07-02 06:24:47 +07:00
|
|
|
if (ret < 0)
|
2009-06-12 23:51:03 +07:00
|
|
|
return ret;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_set(chain, &xctrl);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0) {
|
2009-07-02 06:24:47 +07:00
|
|
|
uvc_ctrl_rollback(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_commit(chain);
|
2010-01-23 17:07:53 +07:00
|
|
|
if (ret == 0)
|
|
|
|
ctrl->value = xctrl.value;
|
2008-07-01 01:04:50 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_QUERYMENU:
|
2010-11-21 17:58:54 +07:00
|
|
|
return uvc_query_v4l2_menu(chain, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
case VIDIOC_G_EXT_CTRLS:
|
|
|
|
{
|
|
|
|
struct v4l2_ext_controls *ctrls = arg;
|
|
|
|
struct v4l2_ext_control *ctrl = ctrls->controls;
|
|
|
|
unsigned int i;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_begin(chain);
|
|
|
|
if (ret < 0)
|
2009-06-12 23:51:03 +07:00
|
|
|
return ret;
|
|
|
|
|
2008-07-01 01:04:50 +07:00
|
|
|
for (i = 0; i < ctrls->count; ++ctrl, ++i) {
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_get(chain, ctrl);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0) {
|
2009-07-02 06:24:47 +07:00
|
|
|
uvc_ctrl_rollback(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
ctrls->error_idx = i;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ctrls->error_idx = 0;
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_rollback(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_S_EXT_CTRLS:
|
|
|
|
case VIDIOC_TRY_EXT_CTRLS:
|
|
|
|
{
|
|
|
|
struct v4l2_ext_controls *ctrls = arg;
|
|
|
|
struct v4l2_ext_control *ctrl = ctrls->controls;
|
|
|
|
unsigned int i;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_begin(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
for (i = 0; i < ctrls->count; ++ctrl, ++i) {
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_set(chain, ctrl);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0) {
|
2009-07-02 06:24:47 +07:00
|
|
|
uvc_ctrl_rollback(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
ctrls->error_idx = i;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ctrls->error_idx = 0;
|
|
|
|
|
|
|
|
if (cmd == VIDIOC_S_EXT_CTRLS)
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_commit(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
else
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_ctrl_rollback(chain);
|
2008-07-01 01:04:50 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get, Set & Enum input */
|
|
|
|
case VIDIOC_ENUMINPUT:
|
|
|
|
{
|
2009-07-02 06:24:47 +07:00
|
|
|
const struct uvc_entity *selector = chain->selector;
|
2008-07-01 01:04:50 +07:00
|
|
|
struct v4l2_input *input = arg;
|
|
|
|
struct uvc_entity *iterm = NULL;
|
|
|
|
u32 index = input->index;
|
|
|
|
int pin = 0;
|
|
|
|
|
|
|
|
if (selector == NULL ||
|
2009-07-02 06:24:47 +07:00
|
|
|
(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
|
2008-07-01 01:04:50 +07:00
|
|
|
if (index != 0)
|
|
|
|
return -EINVAL;
|
2009-11-25 22:00:22 +07:00
|
|
|
list_for_each_entry(iterm, &chain->entities, chain) {
|
|
|
|
if (UVC_ENTITY_IS_ITERM(iterm))
|
|
|
|
break;
|
|
|
|
}
|
2008-07-01 01:04:50 +07:00
|
|
|
pin = iterm->id;
|
2009-11-25 22:00:30 +07:00
|
|
|
} else if (pin < selector->bNrInPins) {
|
|
|
|
pin = selector->baSourceID[index];
|
2009-11-25 22:00:22 +07:00
|
|
|
list_for_each_entry(iterm, &chain->entities, chain) {
|
|
|
|
if (!UVC_ENTITY_IS_ITERM(iterm))
|
|
|
|
continue;
|
2008-07-01 01:04:50 +07:00
|
|
|
if (iterm->id == pin)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (iterm == NULL || iterm->id != pin)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
memset(input, 0, sizeof *input);
|
|
|
|
input->index = index;
|
2009-01-09 00:05:11 +07:00
|
|
|
strlcpy(input->name, iterm->name, sizeof input->name);
|
2009-06-26 21:39:42 +07:00
|
|
|
if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA)
|
2008-07-01 01:04:50 +07:00
|
|
|
input->type = V4L2_INPUT_TYPE_CAMERA;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_G_INPUT:
|
|
|
|
{
|
|
|
|
u8 input;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
if (chain->selector == NULL ||
|
|
|
|
(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
|
2008-07-01 01:04:50 +07:00
|
|
|
*(int *)arg = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,
|
|
|
|
chain->selector->id, chain->dev->intfnum,
|
2009-06-26 21:39:42 +07:00
|
|
|
UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
*(int *)arg = input - 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_S_INPUT:
|
|
|
|
{
|
2009-04-15 19:01:58 +07:00
|
|
|
u32 input = *(u32 *)arg + 1;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
if ((ret = uvc_acquire_privileges(handle)) < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
if (chain->selector == NULL ||
|
|
|
|
(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
|
2008-07-01 01:04:50 +07:00
|
|
|
if (input != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-11-25 22:00:30 +07:00
|
|
|
if (input == 0 || input > chain->selector->bNrInPins)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-07-02 06:24:47 +07:00
|
|
|
return uvc_query_ctrl(chain->dev, UVC_SET_CUR,
|
|
|
|
chain->selector->id, chain->dev->intfnum,
|
2009-06-26 21:39:42 +07:00
|
|
|
UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Try, Get, Set & Enum format */
|
|
|
|
case VIDIOC_ENUM_FMT:
|
|
|
|
{
|
|
|
|
struct v4l2_fmtdesc *fmt = arg;
|
|
|
|
struct uvc_format *format;
|
2009-03-27 21:13:57 +07:00
|
|
|
enum v4l2_buf_type type = fmt->type;
|
|
|
|
__u32 index = fmt->index;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (fmt->type != stream->type ||
|
|
|
|
fmt->index >= stream->nformats)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-03-27 21:13:57 +07:00
|
|
|
memset(fmt, 0, sizeof(*fmt));
|
|
|
|
fmt->index = index;
|
|
|
|
fmt->type = type;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
format = &stream->format[fmt->index];
|
2008-07-01 01:04:50 +07:00
|
|
|
fmt->flags = 0;
|
|
|
|
if (format->flags & UVC_FMT_FLAG_COMPRESSED)
|
|
|
|
fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
|
2009-01-09 00:05:11 +07:00
|
|
|
strlcpy(fmt->description, format->name,
|
2008-07-01 01:04:50 +07:00
|
|
|
sizeof fmt->description);
|
|
|
|
fmt->description[sizeof fmt->description - 1] = 0;
|
|
|
|
fmt->pixelformat = format->fcc;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_TRY_FMT:
|
|
|
|
{
|
|
|
|
struct uvc_streaming_control probe;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_v4l2_try_format(stream, arg, &probe, NULL, NULL);
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_S_FMT:
|
|
|
|
if ((ret = uvc_acquire_privileges(handle)) < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_v4l2_set_format(stream, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
case VIDIOC_G_FMT:
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_v4l2_get_format(stream, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
/* Frame size enumeration */
|
|
|
|
case VIDIOC_ENUM_FRAMESIZES:
|
|
|
|
{
|
|
|
|
struct v4l2_frmsizeenum *fsize = arg;
|
|
|
|
struct uvc_format *format = NULL;
|
|
|
|
struct uvc_frame *frame;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Look for the given pixel format */
|
2009-06-28 18:37:50 +07:00
|
|
|
for (i = 0; i < stream->nformats; i++) {
|
|
|
|
if (stream->format[i].fcc ==
|
2008-07-01 01:04:50 +07:00
|
|
|
fsize->pixel_format) {
|
2009-06-28 18:37:50 +07:00
|
|
|
format = &stream->format[i];
|
2008-07-01 01:04:50 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (format == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (fsize->index >= format->nframes)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
frame = &format->frame[fsize->index];
|
|
|
|
fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
|
|
|
|
fsize->discrete.width = frame->wWidth;
|
|
|
|
fsize->discrete.height = frame->wHeight;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Frame interval enumeration */
|
|
|
|
case VIDIOC_ENUM_FRAMEINTERVALS:
|
|
|
|
{
|
|
|
|
struct v4l2_frmivalenum *fival = arg;
|
|
|
|
struct uvc_format *format = NULL;
|
|
|
|
struct uvc_frame *frame = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Look for the given pixel format and frame size */
|
2009-06-28 18:37:50 +07:00
|
|
|
for (i = 0; i < stream->nformats; i++) {
|
|
|
|
if (stream->format[i].fcc ==
|
2008-07-01 01:04:50 +07:00
|
|
|
fival->pixel_format) {
|
2009-06-28 18:37:50 +07:00
|
|
|
format = &stream->format[i];
|
2008-07-01 01:04:50 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (format == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
for (i = 0; i < format->nframes; i++) {
|
|
|
|
if (format->frame[i].wWidth == fival->width &&
|
|
|
|
format->frame[i].wHeight == fival->height) {
|
|
|
|
frame = &format->frame[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (frame == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (frame->bFrameIntervalType) {
|
|
|
|
if (fival->index >= frame->bFrameIntervalType)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
|
|
|
|
fival->discrete.numerator =
|
|
|
|
frame->dwFrameInterval[fival->index];
|
|
|
|
fival->discrete.denominator = 10000000;
|
|
|
|
uvc_simplify_fraction(&fival->discrete.numerator,
|
|
|
|
&fival->discrete.denominator, 8, 333);
|
|
|
|
} else {
|
|
|
|
fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
|
|
|
|
fival->stepwise.min.numerator =
|
|
|
|
frame->dwFrameInterval[0];
|
|
|
|
fival->stepwise.min.denominator = 10000000;
|
|
|
|
fival->stepwise.max.numerator =
|
|
|
|
frame->dwFrameInterval[1];
|
|
|
|
fival->stepwise.max.denominator = 10000000;
|
|
|
|
fival->stepwise.step.numerator =
|
|
|
|
frame->dwFrameInterval[2];
|
|
|
|
fival->stepwise.step.denominator = 10000000;
|
|
|
|
uvc_simplify_fraction(&fival->stepwise.min.numerator,
|
|
|
|
&fival->stepwise.min.denominator, 8, 333);
|
|
|
|
uvc_simplify_fraction(&fival->stepwise.max.numerator,
|
|
|
|
&fival->stepwise.max.denominator, 8, 333);
|
|
|
|
uvc_simplify_fraction(&fival->stepwise.step.numerator,
|
|
|
|
&fival->stepwise.step.denominator, 8, 333);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get & Set streaming parameters */
|
|
|
|
case VIDIOC_G_PARM:
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_v4l2_get_streamparm(stream, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
case VIDIOC_S_PARM:
|
|
|
|
if ((ret = uvc_acquire_privileges(handle)) < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_v4l2_set_streamparm(stream, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
/* Cropping and scaling */
|
|
|
|
case VIDIOC_CROPCAP:
|
|
|
|
{
|
|
|
|
struct v4l2_cropcap *ccap = arg;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (ccap->type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ccap->bounds.left = 0;
|
|
|
|
ccap->bounds.top = 0;
|
2010-11-21 23:36:34 +07:00
|
|
|
|
|
|
|
mutex_lock(&stream->mutex);
|
|
|
|
ccap->bounds.width = stream->cur_frame->wWidth;
|
|
|
|
ccap->bounds.height = stream->cur_frame->wHeight;
|
|
|
|
mutex_unlock(&stream->mutex);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
ccap->defrect = ccap->bounds;
|
|
|
|
|
|
|
|
ccap->pixelaspect.numerator = 1;
|
|
|
|
ccap->pixelaspect.denominator = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_G_CROP:
|
|
|
|
case VIDIOC_S_CROP:
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Buffers & streaming */
|
|
|
|
case VIDIOC_REQBUFS:
|
|
|
|
{
|
|
|
|
struct v4l2_requestbuffers *rb = arg;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (rb->type != stream->type ||
|
2008-07-01 01:04:50 +07:00
|
|
|
rb->memory != V4L2_MEMORY_MMAP)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if ((ret = uvc_acquire_privileges(handle)) < 0)
|
|
|
|
return ret;
|
|
|
|
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_lock(&stream->mutex);
|
|
|
|
ret = uvc_alloc_buffers(&stream->queue, rb->count,
|
|
|
|
stream->ctrl.dwMaxVideoFrameSize);
|
|
|
|
mutex_unlock(&stream->mutex);
|
2008-07-01 01:04:50 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-09-02 13:12:26 +07:00
|
|
|
if (ret == 0)
|
|
|
|
uvc_dismiss_privileges(handle);
|
|
|
|
|
2008-07-01 01:04:50 +07:00
|
|
|
rb->count = ret;
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_QUERYBUF:
|
|
|
|
{
|
|
|
|
struct v4l2_buffer *buf = arg;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (buf->type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!uvc_has_privileges(handle))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_query_buffer(&stream->queue, buf);
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_QBUF:
|
|
|
|
if (!uvc_has_privileges(handle))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_queue_buffer(&stream->queue, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
case VIDIOC_DQBUF:
|
|
|
|
if (!uvc_has_privileges(handle))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_dequeue_buffer(&stream->queue, arg,
|
2008-07-01 01:04:50 +07:00
|
|
|
file->f_flags & O_NONBLOCK);
|
|
|
|
|
|
|
|
case VIDIOC_STREAMON:
|
|
|
|
{
|
|
|
|
int *type = arg;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (*type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!uvc_has_privileges(handle))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_lock(&stream->mutex);
|
2009-06-28 18:37:50 +07:00
|
|
|
ret = uvc_video_enable(stream, 1);
|
2010-11-21 23:36:34 +07:00
|
|
|
mutex_unlock(&stream->mutex);
|
2009-06-28 18:37:50 +07:00
|
|
|
if (ret < 0)
|
2008-07-01 01:04:50 +07:00
|
|
|
return ret;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case VIDIOC_STREAMOFF:
|
|
|
|
{
|
|
|
|
int *type = arg;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
if (*type != stream->type)
|
2008-07-01 01:04:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!uvc_has_privileges(handle))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_video_enable(stream, 0);
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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:
|
|
|
|
uvc_trace(UVC_TRACE_IOCTL, "Unsupported ioctl 0x%08x\n", cmd);
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-10-12 22:11:30 +07:00
|
|
|
/* Dynamic controls. UVCIOC_CTRL_ADD, UVCIOC_CTRL_MAP_OLD,
|
|
|
|
* UVCIOC_CTRL_GET and UVCIOC_CTRL_SET are deprecated and scheduled for
|
|
|
|
* removal in 2.6.42.
|
|
|
|
*/
|
2010-11-22 03:15:44 +07:00
|
|
|
case __UVCIOC_CTRL_ADD:
|
2010-10-12 22:11:30 +07:00
|
|
|
uvc_v4l2_ioctl_warn();
|
2010-09-20 15:53:21 +07:00
|
|
|
return -EEXIST;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2010-11-22 03:15:44 +07:00
|
|
|
case __UVCIOC_CTRL_MAP_OLD:
|
2010-10-12 22:11:30 +07:00
|
|
|
uvc_v4l2_ioctl_warn();
|
2010-11-22 03:15:44 +07:00
|
|
|
case __UVCIOC_CTRL_MAP:
|
2008-07-01 01:04:50 +07:00
|
|
|
case UVCIOC_CTRL_MAP:
|
2010-09-20 15:53:21 +07:00
|
|
|
return uvc_ioctl_ctrl_map(chain, arg,
|
2010-11-22 03:15:44 +07:00
|
|
|
cmd == __UVCIOC_CTRL_MAP_OLD);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
2010-11-22 03:15:44 +07:00
|
|
|
case __UVCIOC_CTRL_GET:
|
|
|
|
case __UVCIOC_CTRL_SET:
|
2010-10-03 05:10:16 +07:00
|
|
|
{
|
|
|
|
struct uvc_xu_control *xctrl = arg;
|
|
|
|
struct uvc_xu_control_query xqry = {
|
|
|
|
.unit = xctrl->unit,
|
|
|
|
.selector = xctrl->selector,
|
2010-11-22 03:15:44 +07:00
|
|
|
.query = cmd == __UVCIOC_CTRL_GET
|
2010-10-03 05:10:16 +07:00
|
|
|
? UVC_GET_CUR : UVC_SET_CUR,
|
|
|
|
.size = xctrl->size,
|
|
|
|
.data = xctrl->data,
|
|
|
|
};
|
|
|
|
|
2010-10-12 22:11:30 +07:00
|
|
|
uvc_v4l2_ioctl_warn();
|
2010-10-03 05:10:16 +07:00
|
|
|
return uvc_xu_ctrl_query(chain, &xqry);
|
|
|
|
}
|
|
|
|
|
|
|
|
case UVCIOC_CTRL_QUERY:
|
|
|
|
return uvc_xu_ctrl_query(chain, arg);
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
default:
|
2010-12-24 20:33:19 +07:00
|
|
|
uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n", cmd);
|
|
|
|
return -EINVAL;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-30 17:04:34 +07:00
|
|
|
static long uvc_v4l2_ioctl(struct file *file,
|
2008-07-01 01:04:50 +07:00
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
2008-11-18 04:32:11 +07:00
|
|
|
if (uvc_trace_param & UVC_TRACE_IOCTL) {
|
|
|
|
uvc_printk(KERN_DEBUG, "uvc_v4l2_ioctl(");
|
|
|
|
v4l_printk_ioctl(cmd);
|
|
|
|
printk(")\n");
|
|
|
|
}
|
|
|
|
|
2008-11-01 18:25:11 +07:00
|
|
|
return video_usercopy(file, cmd, arg, uvc_v4l2_do_ioctl);
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_read: not implemented.\n");
|
2009-11-04 21:53:49 +07:00
|
|
|
return -EINVAL;
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
|
|
|
|
{
|
2010-07-13 03:50:03 +07:00
|
|
|
struct uvc_fh *handle = file->private_data;
|
2009-06-28 18:37:50 +07:00
|
|
|
struct uvc_streaming *stream = handle->stream;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_mmap\n");
|
|
|
|
|
2010-11-22 01:18:08 +07:00
|
|
|
return uvc_queue_mmap(&stream->queue, vma);
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait)
|
|
|
|
{
|
2010-07-13 03:50:03 +07:00
|
|
|
struct uvc_fh *handle = file->private_data;
|
2009-06-28 18:37:50 +07:00
|
|
|
struct uvc_streaming *stream = handle->stream;
|
2008-07-01 01:04:50 +07:00
|
|
|
|
|
|
|
uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_poll\n");
|
|
|
|
|
2009-06-28 18:37:50 +07:00
|
|
|
return uvc_queue_poll(&stream->queue, file, wait);
|
2008-07-01 01:04:50 +07:00
|
|
|
}
|
|
|
|
|
2011-04-29 17:11:35 +07:00
|
|
|
#ifndef CONFIG_MMU
|
|
|
|
static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
|
|
|
|
unsigned long addr, unsigned long len, unsigned long pgoff,
|
|
|
|
unsigned long flags)
|
|
|
|
{
|
|
|
|
struct uvc_fh *handle = file->private_data;
|
|
|
|
struct uvc_streaming *stream = handle->stream;
|
|
|
|
|
|
|
|
uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_get_unmapped_area\n");
|
|
|
|
|
|
|
|
return uvc_queue_get_unmapped_area(&stream->queue, pgoff);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-12-30 16:58:20 +07:00
|
|
|
const struct v4l2_file_operations uvc_fops = {
|
2008-07-01 01:04:50 +07:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = uvc_v4l2_open,
|
|
|
|
.release = uvc_v4l2_release,
|
2010-11-22 02:54:56 +07:00
|
|
|
.unlocked_ioctl = uvc_v4l2_ioctl,
|
2008-07-01 01:04:50 +07:00
|
|
|
.read = uvc_v4l2_read,
|
|
|
|
.mmap = uvc_v4l2_mmap,
|
|
|
|
.poll = uvc_v4l2_poll,
|
2011-04-29 17:11:35 +07:00
|
|
|
#ifndef CONFIG_MMU
|
|
|
|
.get_unmapped_area = uvc_v4l2_get_unmapped_area,
|
|
|
|
#endif
|
2008-07-01 01:04:50 +07:00
|
|
|
};
|
2008-07-18 10:50:58 +07:00
|
|
|
|