AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity
724b62b5f7
kernel_optimize_test/drivers/media/video/pwc/pwc-v4l.c
Tejun Heo 5a0e3ad6af 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-30 22:02:32 +09:00

1261 lines
32 KiB
C
Raw Blame History

/* Linux driver for Philips webcam
USB and Video4Linux interface part.
(C) 1999-2004 Nemosoft Unv.
(C) 2004-2006 Luc Saillard (luc@saillard.org)
NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
driver and thus may have bugs that are not present in the original version.
Please send bug reports and support requests to <luc@saillard.org>.
The decompression routines have been implemented by reverse-engineering the
Nemosoft binary pwcx module. Caveat emptor.
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.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/vmalloc.h>
#include <asm/io.h>
#include "pwc.h"
static struct v4l2_queryctrl pwc_controls[] = {
{
.id = V4L2_CID_BRIGHTNESS,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Brightness",
.minimum = 0,
.maximum = 128,
.step = 1,
.default_value = 64,
},
{
.id = V4L2_CID_CONTRAST,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Contrast",
.minimum = 0,
.maximum = 64,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_SATURATION,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Saturation",
.minimum = -100,
.maximum = 100,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_GAMMA,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Gamma",
.minimum = 0,
.maximum = 32,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_RED_BALANCE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Red Gain",
.minimum = 0,
.maximum = 256,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_BLUE_BALANCE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Blue Gain",
.minimum = 0,
.maximum = 256,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_AUTO_WHITE_BALANCE,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Auto White Balance",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_EXPOSURE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Shutter Speed (Exposure)",
.minimum = 0,
.maximum = 256,
.step = 1,
.default_value = 200,
},
{
.id = V4L2_CID_AUTOGAIN,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Auto Gain Enabled",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 1,
},
{
.id = V4L2_CID_GAIN,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Gain Level",
.minimum = 0,
.maximum = 256,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_SAVE_USER,
.type = V4L2_CTRL_TYPE_BUTTON,
.name = "Save User Settings",
.minimum = 0,
.maximum = 0,
.step = 0,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_RESTORE_USER,
.type = V4L2_CTRL_TYPE_BUTTON,
.name = "Restore User Settings",
.minimum = 0,
.maximum = 0,
.step = 0,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_RESTORE_FACTORY,
.type = V4L2_CTRL_TYPE_BUTTON,
.name = "Restore Factory Settings",
.minimum = 0,
.maximum = 0,
.step = 0,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_COLOUR_MODE,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Colour mode",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_AUTOCONTOUR,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Auto contour",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_CONTOUR,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Contour",
.minimum = 0,
.maximum = 63,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_BACKLIGHT,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Backlight compensation",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_FLICKERLESS,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Flickerless",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 0,
},
{
.id = V4L2_CID_PRIVATE_NOISE_REDUCTION,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Noise reduction",
.minimum = 0,
.maximum = 3,
.step = 1,
.default_value = 0,
},
};
static void pwc_vidioc_fill_fmt(const struct pwc_device *pdev, struct v4l2_format *f)
{
memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
f->fmt.pix.width = pdev->view.x;
f->fmt.pix.height = pdev->view.y;
f->fmt.pix.field = V4L2_FIELD_NONE;
if (pdev->vpalette == VIDEO_PALETTE_YUV420P) {
f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
f->fmt.pix.bytesperline = (f->fmt.pix.width * 3)/2;
f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
} else {
/* vbandlength contains 4 lines ... */
f->fmt.pix.bytesperline = pdev->vbandlength/4;
f->fmt.pix.sizeimage = pdev->frame_size + sizeof(struct pwc_raw_frame);
if (DEVICE_USE_CODEC1(pdev->type))
f->fmt.pix.pixelformat = V4L2_PIX_FMT_PWC1;
else
f->fmt.pix.pixelformat = V4L2_PIX_FMT_PWC2;
}
PWC_DEBUG_IOCTL("pwc_vidioc_fill_fmt() "
"width=%d, height=%d, bytesperline=%d, sizeimage=%d, pixelformat=%c%c%c%c\n",
f->fmt.pix.width,
f->fmt.pix.height,
f->fmt.pix.bytesperline,
f->fmt.pix.sizeimage,
(f->fmt.pix.pixelformat)&255,
(f->fmt.pix.pixelformat>>8)&255,
(f->fmt.pix.pixelformat>>16)&255,
(f->fmt.pix.pixelformat>>24)&255);
}
/* ioctl(VIDIOC_TRY_FMT) */
static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
{
if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
PWC_DEBUG_IOCTL("Bad video type must be V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
return -EINVAL;
}
switch (f->fmt.pix.pixelformat) {
case V4L2_PIX_FMT_YUV420:
break;
case V4L2_PIX_FMT_PWC1:
if (DEVICE_USE_CODEC23(pdev->type)) {
PWC_DEBUG_IOCTL("codec1 is only supported for old pwc webcam\n");
return -EINVAL;
}
break;
case V4L2_PIX_FMT_PWC2:
if (DEVICE_USE_CODEC1(pdev->type)) {
PWC_DEBUG_IOCTL("codec23 is only supported for new pwc webcam\n");
return -EINVAL;
}
break;
default:
PWC_DEBUG_IOCTL("Unsupported pixel format\n");
return -EINVAL;
}
if (f->fmt.pix.width > pdev->view_max.x)
f->fmt.pix.width = pdev->view_max.x;
else if (f->fmt.pix.width < pdev->view_min.x)
f->fmt.pix.width = pdev->view_min.x;
if (f->fmt.pix.height > pdev->view_max.y)
f->fmt.pix.height = pdev->view_max.y;
else if (f->fmt.pix.height < pdev->view_min.y)
f->fmt.pix.height = pdev->view_min.y;
return 0;
}
/* ioctl(VIDIOC_SET_FMT) */
static int pwc_vidioc_set_fmt(struct pwc_device *pdev, struct v4l2_format *f)
{
int ret, fps, snapshot, compression, pixelformat;
ret = pwc_vidioc_try_fmt(pdev, f);
if (ret<0)
return ret;
pixelformat = f->fmt.pix.pixelformat;
compression = pdev->vcompression;
snapshot = 0;
fps = pdev->vframes;
if (f->fmt.pix.priv) {
compression = (f->fmt.pix.priv & PWC_QLT_MASK) >> PWC_QLT_SHIFT;
snapshot = !!(f->fmt.pix.priv & PWC_FPS_SNAPSHOT);
fps = (f->fmt.pix.priv & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
if (fps == 0)
fps = pdev->vframes;
}
if (pixelformat == V4L2_PIX_FMT_YUV420)
pdev->vpalette = VIDEO_PALETTE_YUV420P;
else
pdev->vpalette = VIDEO_PALETTE_RAW;
PWC_DEBUG_IOCTL("Try to change format to: width=%d height=%d fps=%d "
"compression=%d snapshot=%d format=%c%c%c%c\n",
f->fmt.pix.width, f->fmt.pix.height, fps,
compression, snapshot,
(pixelformat)&255,
(pixelformat>>8)&255,
(pixelformat>>16)&255,
(pixelformat>>24)&255);
ret = pwc_try_video_mode(pdev,
f->fmt.pix.width,
f->fmt.pix.height,
fps,
compression,
snapshot);
PWC_DEBUG_IOCTL("pwc_try_video_mode(), return=%d\n", ret);
if (ret)
return ret;
pwc_vidioc_fill_fmt(pdev, f);
return 0;
}
long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
{
struct video_device *vdev = video_devdata(file);
struct pwc_device *pdev;
DECLARE_WAITQUEUE(wait, current);
if (vdev == NULL)
return -EFAULT;
pdev = video_get_drvdata(vdev);
if (pdev == NULL)
return -EFAULT;
#ifdef CONFIG_USB_PWC_DEBUG
if (PWC_DEBUG_LEVEL_IOCTL & pwc_trace) {
v4l_printk_ioctl(cmd);
printk("\n");
}
#endif
switch (cmd) {
/* Query cabapilities */
case VIDIOCGCAP:
{
struct video_capability *caps = arg;
strcpy(caps->name, vdev->name);
caps->type = VID_TYPE_CAPTURE;
caps->channels = 1;
caps->audios = 1;
caps->minwidth = pdev->view_min.x;
caps->minheight = pdev->view_min.y;
caps->maxwidth = pdev->view_max.x;
caps->maxheight = pdev->view_max.y;
break;
}
/* Channel functions (simulate 1 channel) */
case VIDIOCGCHAN:
{
struct video_channel *v = arg;
if (v->channel != 0)
return -EINVAL;
v->flags = 0;
v->tuners = 0;
v->type = VIDEO_TYPE_CAMERA;
strcpy(v->name, "Webcam");
return 0;
}
case VIDIOCSCHAN:
{
/* The spec says the argument is an integer, but
the bttv driver uses a video_channel arg, which
makes sense becasue it also has the norm flag.
*/
struct video_channel *v = arg;
if (v->channel != 0)
return -EINVAL;
return 0;
}
/* Picture functions; contrast etc. */
case VIDIOCGPICT:
{
struct video_picture *p = arg;
int val;
val = pwc_get_brightness(pdev);
if (val >= 0)
p->brightness = (val<<9);
else
p->brightness = 0xffff;
val = pwc_get_contrast(pdev);
if (val >= 0)
p->contrast = (val<<10);
else
p->contrast = 0xffff;
/* Gamma, Whiteness, what's the difference? :) */
val = pwc_get_gamma(pdev);
if (val >= 0)
p->whiteness = (val<<11);
else
p->whiteness = 0xffff;
if (pwc_get_saturation(pdev, &val)<0)
p->colour = 0xffff;
else
p->colour = 32768 + val * 327;
p->depth = 24;
p->palette = pdev->vpalette;
p->hue = 0xFFFF; /* N/A */
break;
}
case VIDIOCSPICT:
{
struct video_picture *p = arg;
/*
* FIXME: Suppose we are mid read
ANSWER: No problem: the firmware of the camera
can handle brightness/contrast/etc
changes at _any_ time, and the palette
is used exactly once in the uncompress
routine.
*/
pwc_set_brightness(pdev, p->brightness);
pwc_set_contrast(pdev, p->contrast);
pwc_set_gamma(pdev, p->whiteness);
pwc_set_saturation(pdev, (p->colour-32768)/327);
if (p->palette && p->palette != pdev->vpalette) {
switch (p->palette) {
case VIDEO_PALETTE_YUV420P:
case VIDEO_PALETTE_RAW:
pdev->vpalette = p->palette;
return pwc_try_video_mode(pdev, pdev->image.x, pdev->image.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
break;
default:
return -EINVAL;
break;
}
}
break;
}
/* Window/size parameters */
case VIDIOCGWIN:
{
struct video_window *vw = arg;
vw->x = 0;
vw->y = 0;
vw->width = pdev->view.x;
vw->height = pdev->view.y;
vw->chromakey = 0;
vw->flags = (pdev->vframes << PWC_FPS_SHIFT) |
(pdev->vsnapshot ? PWC_FPS_SNAPSHOT : 0);
break;
}
case VIDIOCSWIN:
{
struct video_window *vw = arg;
int fps, snapshot, ret;
fps = (vw->flags & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
snapshot = vw->flags & PWC_FPS_SNAPSHOT;
if (fps == 0)
fps = pdev->vframes;
if (pdev->view.x == vw->width && pdev->view.y && fps == pdev->vframes && snapshot == pdev->vsnapshot)
return 0;
ret = pwc_try_video_mode(pdev, vw->width, vw->height, fps, pdev->vcompression, snapshot);
if (ret)
return ret;
break;
}
/* We don't have overlay support (yet) */
case VIDIOCGFBUF:
{
struct video_buffer *vb = arg;
memset(vb,0,sizeof(*vb));
break;
}
/* mmap() functions */
case VIDIOCGMBUF:
{
/* Tell the user program how much memory is needed for a mmap() */
struct video_mbuf *vm = arg;
int i;
memset(vm, 0, sizeof(*vm));
vm->size = pwc_mbufs * pdev->len_per_image;
vm->frames = pwc_mbufs; /* double buffering should be enough for most applications */
for (i = 0; i < pwc_mbufs; i++)
vm->offsets[i] = i * pdev->len_per_image;
break;
}
case VIDIOCMCAPTURE:
{
/* Start capture into a given image buffer (called 'frame' in video_mmap structure) */
struct video_mmap *vm = arg;
PWC_DEBUG_READ("VIDIOCMCAPTURE: %dx%d, frame %d, format %d\n", vm->width, vm->height, vm->frame, vm->format);
if (vm->frame < 0 || vm->frame >= pwc_mbufs)
return -EINVAL;
/* xawtv is nasty. It probes the available palettes
by setting a very small image size and trying
various palettes... The driver doesn't support
such small images, so I'm working around it.
*/
if (vm->format)
{
switch (vm->format)
{
case VIDEO_PALETTE_YUV420P:
case VIDEO_PALETTE_RAW:
break;
default:
return -EINVAL;
break;
}
}
if ((vm->width != pdev->view.x || vm->height != pdev->view.y) &&
(vm->width >= pdev->view_min.x && vm->height >= pdev->view_min.y)) {
int ret;
PWC_DEBUG_OPEN("VIDIOCMCAPTURE: changing size to please xawtv :-(.\n");
ret = pwc_try_video_mode(pdev, vm->width, vm->height, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
if (ret)
return ret;
} /* ... size mismatch */
/* FIXME: should we lock here? */
if (pdev->image_used[vm->frame])
return -EBUSY; /* buffer wasn't available. Bummer */
pdev->image_used[vm->frame] = 1;
/* Okay, we're done here. In the SYNC call we wait until a
frame comes available, then expand image into the given
buffer.
In contrast to the CPiA cam the Philips cams deliver a
constant stream, almost like a grabber card. Also,
we have separate buffers for the rawdata and the image,
meaning we can nearly always expand into the requested buffer.
*/
PWC_DEBUG_READ("VIDIOCMCAPTURE done.\n");
break;
}
case VIDIOCSYNC:
{
/* The doc says: "Whenever a buffer is used it should
call VIDIOCSYNC to free this frame up and continue."
The only odd thing about this whole procedure is
that MCAPTURE flags the buffer as "in use", and
SYNC immediately unmarks it, while it isn't
after SYNC that you know that the buffer actually
got filled! So you better not start a CAPTURE in
the same frame immediately (use double buffering).
This is not a problem for this cam, since it has
extra intermediate buffers, but a hardware
grabber card will then overwrite the buffer
you're working on.
*/
int *mbuf = arg;
int ret;
PWC_DEBUG_READ("VIDIOCSYNC called (%d).\n", *mbuf);
/* bounds check */
if (*mbuf < 0 || *mbuf >= pwc_mbufs)
return -EINVAL;
/* check if this buffer was requested anyway */
if (pdev->image_used[*mbuf] == 0)
return -EINVAL;
/* Add ourselves to the frame wait-queue.
FIXME: needs auditing for safety.
QUESTION: In what respect? I think that using the
frameq is safe now.
*/
add_wait_queue(&pdev->frameq, &wait);
while (pdev->full_frames == NULL) {
/* Check for unplugged/etc. here */
if (pdev->error_status) {
remove_wait_queue(&pdev->frameq, &wait);
set_current_state(TASK_RUNNING);
return -pdev->error_status;
}
if (signal_pending(current)) {
remove_wait_queue(&pdev->frameq, &wait);
set_current_state(TASK_RUNNING);
return -ERESTARTSYS;
}
schedule();
set_current_state(TASK_INTERRUPTIBLE);
}
remove_wait_queue(&pdev->frameq, &wait);
set_current_state(TASK_RUNNING);
/* The frame is ready. Expand in the image buffer
requested by the user. I don't care if you
mmap() 5 buffers and request data in this order:
buffer 4 2 3 0 1 2 3 0 4 3 1 . . .
Grabber hardware may not be so forgiving.
*/
PWC_DEBUG_READ("VIDIOCSYNC: frame ready.\n");
pdev->fill_image = *mbuf; /* tell in which buffer we want the image to be expanded */
/* Decompress, etc */
ret = pwc_handle_frame(pdev);
pdev->image_used[*mbuf] = 0;
if (ret)
return -EFAULT;
break;
}
case VIDIOCGAUDIO:
{
struct video_audio *v = arg;
strcpy(v->name, "Microphone");
v->audio = -1; /* unknown audio minor */
v->flags = 0;
v->mode = VIDEO_SOUND_MONO;
v->volume = 0;
v->bass = 0;
v->treble = 0;
v->balance = 0x8000;
v->step = 1;
break;
}
case VIDIOCSAUDIO:
{
/* Dummy: nothing can be set */
break;
}
case VIDIOCGUNIT:
{
struct video_unit *vu = arg;
vu->video = pdev->vdev->minor & 0x3F;
vu->audio = -1; /* not known yet */
vu->vbi = -1;
vu->radio = -1;
vu->teletext = -1;
break;
}
/* V4L2 Layer */
case VIDIOC_QUERYCAP:
{
struct v4l2_capability *cap = arg;
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCAP) This application "\
"try to use the v4l2 layer\n");
strcpy(cap->driver,PWC_NAME);
strlcpy(cap->card, vdev->name, sizeof(cap->card));
usb_make_path(pdev->udev,cap->bus_info,sizeof(cap->bus_info));
cap->version = PWC_VERSION_CODE;
cap->capabilities =
V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_STREAMING |
V4L2_CAP_READWRITE;
return 0;
}
case VIDIOC_ENUMINPUT:
{
struct v4l2_input *i = arg;
if ( i->index ) /* Only one INPUT is supported */
return -EINVAL;
memset(i, 0, sizeof(struct v4l2_input));
strcpy(i->name, "usb");
return 0;
}
case VIDIOC_G_INPUT:
{
int *i = arg;
*i = 0; /* Only one INPUT is supported */
return 0;
}
case VIDIOC_S_INPUT:
{
int *i = arg;
if ( *i ) { /* Only one INPUT is supported */
PWC_DEBUG_IOCTL("Only one input source is"\
" supported with this webcam.\n");
return -EINVAL;
}
return 0;
}
/* TODO: */
case VIDIOC_QUERYCTRL:
{
struct v4l2_queryctrl *c = arg;
int i;
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) query id=%d\n", c->id);
for (i=0; i<sizeof(pwc_controls)/sizeof(struct v4l2_queryctrl); i++) {
if (pwc_controls[i].id == c->id) {
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) found\n");
memcpy(c,&pwc_controls[i],sizeof(struct v4l2_queryctrl));
return 0;
}
}
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) not found\n");
return -EINVAL;
}
case VIDIOC_G_CTRL:
{
struct v4l2_control *c = arg;
int ret;
switch (c->id)
{
case V4L2_CID_BRIGHTNESS:
c->value = pwc_get_brightness(pdev);
if (c->value<0)
return -EINVAL;
return 0;
case V4L2_CID_CONTRAST:
c->value = pwc_get_contrast(pdev);
if (c->value<0)
return -EINVAL;
return 0;
case V4L2_CID_SATURATION:
ret = pwc_get_saturation(pdev, &c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_GAMMA:
c->value = pwc_get_gamma(pdev);
if (c->value<0)
return -EINVAL;
return 0;
case V4L2_CID_RED_BALANCE:
ret = pwc_get_red_gain(pdev, &c->value);
if (ret<0)
return -EINVAL;
c->value >>= 8;
return 0;
case V4L2_CID_BLUE_BALANCE:
ret = pwc_get_blue_gain(pdev, &c->value);
if (ret<0)
return -EINVAL;
c->value >>= 8;
return 0;
case V4L2_CID_AUTO_WHITE_BALANCE:
ret = pwc_get_awb(pdev);
if (ret<0)
return -EINVAL;
c->value = (ret == PWC_WB_MANUAL)?0:1;
return 0;
case V4L2_CID_GAIN:
ret = pwc_get_agc(pdev, &c->value);
if (ret<0)
return -EINVAL;
c->value >>= 8;
return 0;
case V4L2_CID_AUTOGAIN:
ret = pwc_get_agc(pdev, &c->value);
if (ret<0)
return -EINVAL;
c->value = (c->value < 0)?1:0;
return 0;
case V4L2_CID_EXPOSURE:
ret = pwc_get_shutter_speed(pdev, &c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_COLOUR_MODE:
ret = pwc_get_colour_mode(pdev, &c->value);
if (ret < 0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_AUTOCONTOUR:
ret = pwc_get_contour(pdev, &c->value);
if (ret < 0)
return -EINVAL;
c->value=(c->value == -1?1:0);
return 0;
case V4L2_CID_PRIVATE_CONTOUR:
ret = pwc_get_contour(pdev, &c->value);
if (ret < 0)
return -EINVAL;
c->value >>= 10;
return 0;
case V4L2_CID_PRIVATE_BACKLIGHT:
ret = pwc_get_backlight(pdev, &c->value);
if (ret < 0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_FLICKERLESS:
ret = pwc_get_flicker(pdev, &c->value);
if (ret < 0)
return -EINVAL;
c->value=(c->value?1:0);
return 0;
case V4L2_CID_PRIVATE_NOISE_REDUCTION:
ret = pwc_get_dynamic_noise(pdev, &c->value);
if (ret < 0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_SAVE_USER:
case V4L2_CID_PRIVATE_RESTORE_USER:
case V4L2_CID_PRIVATE_RESTORE_FACTORY:
return -EINVAL;
}
return -EINVAL;
}
case VIDIOC_S_CTRL:
{
struct v4l2_control *c = arg;
int ret;
switch (c->id)
{
case V4L2_CID_BRIGHTNESS:
c->value <<= 9;
ret = pwc_set_brightness(pdev, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_CONTRAST:
c->value <<= 10;
ret = pwc_set_contrast(pdev, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_SATURATION:
ret = pwc_set_saturation(pdev, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_GAMMA:
c->value <<= 11;
ret = pwc_set_gamma(pdev, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_RED_BALANCE:
c->value <<= 8;
ret = pwc_set_red_gain(pdev, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_BLUE_BALANCE:
c->value <<= 8;
ret = pwc_set_blue_gain(pdev, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_AUTO_WHITE_BALANCE:
c->value = (c->value == 0)?PWC_WB_MANUAL:PWC_WB_AUTO;
ret = pwc_set_awb(pdev, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_EXPOSURE:
c->value <<= 8;
ret = pwc_set_shutter_speed(pdev, c->value?0:1, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_AUTOGAIN:
/* autogain off means nothing without a gain */
if (c->value == 0)
return 0;
ret = pwc_set_agc(pdev, c->value, 0);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_GAIN:
c->value <<= 8;
ret = pwc_set_agc(pdev, 0, c->value);
if (ret<0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_SAVE_USER:
if (pwc_save_user(pdev))
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_RESTORE_USER:
if (pwc_restore_user(pdev))
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_RESTORE_FACTORY:
if (pwc_restore_factory(pdev))
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_COLOUR_MODE:
ret = pwc_set_colour_mode(pdev, c->value);
if (ret < 0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_AUTOCONTOUR:
c->value=(c->value == 1)?-1:0;
ret = pwc_set_contour(pdev, c->value);
if (ret < 0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_CONTOUR:
c->value <<= 10;
ret = pwc_set_contour(pdev, c->value);
if (ret < 0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_BACKLIGHT:
ret = pwc_set_backlight(pdev, c->value);
if (ret < 0)
return -EINVAL;
return 0;
case V4L2_CID_PRIVATE_FLICKERLESS:
ret = pwc_set_flicker(pdev, c->value);
if (ret < 0)
return -EINVAL;
case V4L2_CID_PRIVATE_NOISE_REDUCTION:
ret = pwc_set_dynamic_noise(pdev, c->value);
if (ret < 0)
return -EINVAL;
return 0;
}
return -EINVAL;
}
case VIDIOC_ENUM_FMT:
{
struct v4l2_fmtdesc *f = arg;
int index;
if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
/* We only support two format: the raw format, and YUV */
index = f->index;
memset(f,0,sizeof(struct v4l2_fmtdesc));
f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
f->index = index;
switch(index)
{
case 0:
/* RAW format */
f->pixelformat = pdev->type<=646?V4L2_PIX_FMT_PWC1:V4L2_PIX_FMT_PWC2;
f->flags = V4L2_FMT_FLAG_COMPRESSED;
strlcpy(f->description,"Raw Philips Webcam",sizeof(f->description));
break;
case 1:
f->pixelformat = V4L2_PIX_FMT_YUV420;
strlcpy(f->description,"4:2:0, planar, Y-Cb-Cr",sizeof(f->description));
break;
default:
return -EINVAL;
}
return 0;
}
case VIDIOC_G_FMT:
{
struct v4l2_format *f = arg;
PWC_DEBUG_IOCTL("ioctl(VIDIOC_G_FMT) return size %dx%d\n",pdev->image.x,pdev->image.y);
if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
pwc_vidioc_fill_fmt(pdev, f);
return 0;
}
case VIDIOC_TRY_FMT:
return pwc_vidioc_try_fmt(pdev, arg);
case VIDIOC_S_FMT:
return pwc_vidioc_set_fmt(pdev, arg);
case VIDIOC_G_STD:
{
v4l2_std_id *std = arg;
*std = V4L2_STD_UNKNOWN;
return 0;
}
case VIDIOC_S_STD:
{
v4l2_std_id *std = arg;
if (*std != V4L2_STD_UNKNOWN)
return -EINVAL;
return 0;
}
case VIDIOC_ENUMSTD:
{
struct v4l2_standard *std = arg;
if (std->index != 0)
return -EINVAL;
std->id = V4L2_STD_UNKNOWN;
strlcpy(std->name, "webcam", sizeof(std->name));
return 0;
}
case VIDIOC_REQBUFS:
{
struct v4l2_requestbuffers *rb = arg;
int nbuffers;
PWC_DEBUG_IOCTL("ioctl(VIDIOC_REQBUFS) count=%d\n",rb->count);
if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
if (rb->memory != V4L2_MEMORY_MMAP)
return -EINVAL;
nbuffers = rb->count;
if (nbuffers < 2)
nbuffers = 2;
else if (nbuffers > pwc_mbufs)
nbuffers = pwc_mbufs;
/* Force to use our # of buffers */
rb->count = pwc_mbufs;
return 0;
}
case VIDIOC_QUERYBUF:
{
struct v4l2_buffer *buf = arg;
int index;
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) index=%d\n",buf->index);
if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad type\n");
return -EINVAL;
}
if (buf->memory != V4L2_MEMORY_MMAP) {
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad memory type\n");
return -EINVAL;
}
index = buf->index;
if (index < 0 || index >= pwc_mbufs) {
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad index %d\n", buf->index);
return -EINVAL;
}
memset(buf, 0, sizeof(struct v4l2_buffer));
buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf->index = index;
buf->m.offset = index * pdev->len_per_image;
if (pdev->vpalette == VIDEO_PALETTE_RAW)
buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
else
buf->bytesused = pdev->view.size;
buf->field = V4L2_FIELD_NONE;
buf->memory = V4L2_MEMORY_MMAP;
//buf->flags = V4L2_BUF_FLAG_MAPPED;
buf->length = pdev->len_per_image;
PWC_DEBUG_READ("VIDIOC_QUERYBUF: index=%d\n",buf->index);
PWC_DEBUG_READ("VIDIOC_QUERYBUF: m.offset=%d\n",buf->m.offset);
PWC_DEBUG_READ("VIDIOC_QUERYBUF: bytesused=%d\n",buf->bytesused);
return 0;
}
case VIDIOC_QBUF:
{
struct v4l2_buffer *buf = arg;
PWC_DEBUG_IOCTL("ioctl(VIDIOC_QBUF) index=%d\n",buf->index);
if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
if (buf->memory != V4L2_MEMORY_MMAP)
return -EINVAL;
if (buf->index >= pwc_mbufs)
return -EINVAL;
buf->flags |= V4L2_BUF_FLAG_QUEUED;
buf->flags &= ~V4L2_BUF_FLAG_DONE;
return 0;
}
case VIDIOC_DQBUF:
{
struct v4l2_buffer *buf = arg;
int ret;
PWC_DEBUG_IOCTL("ioctl(VIDIOC_DQBUF)\n");
if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
/* Add ourselves to the frame wait-queue.
FIXME: needs auditing for safety.
QUESTION: In what respect? I think that using the
frameq is safe now.
*/
add_wait_queue(&pdev->frameq, &wait);
while (pdev->full_frames == NULL) {
if (pdev->error_status) {
remove_wait_queue(&pdev->frameq, &wait);
set_current_state(TASK_RUNNING);
return -pdev->error_status;
}
if (signal_pending(current)) {
remove_wait_queue(&pdev->frameq, &wait);
set_current_state(TASK_RUNNING);
return -ERESTARTSYS;
}
schedule();
set_current_state(TASK_INTERRUPTIBLE);
}
remove_wait_queue(&pdev->frameq, &wait);
set_current_state(TASK_RUNNING);
PWC_DEBUG_IOCTL("VIDIOC_DQBUF: frame ready.\n");
/* Decompress data in pdev->images[pdev->fill_image] */
ret = pwc_handle_frame(pdev);
if (ret)
return -EFAULT;
PWC_DEBUG_IOCTL("VIDIOC_DQBUF: after pwc_handle_frame\n");
buf->index = pdev->fill_image;
if (pdev->vpalette == VIDEO_PALETTE_RAW)
buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
else
buf->bytesused = pdev->view.size;
buf->flags = V4L2_BUF_FLAG_MAPPED;
buf->field = V4L2_FIELD_NONE;
do_gettimeofday(&buf->timestamp);
buf->sequence = 0;
buf->memory = V4L2_MEMORY_MMAP;
buf->m.offset = pdev->fill_image * pdev->len_per_image;
buf->length = pdev->len_per_image;
pwc_next_image(pdev);
PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->index=%d\n",buf->index);
PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->length=%d\n",buf->length);
PWC_DEBUG_IOCTL("VIDIOC_DQBUF: m.offset=%d\n",buf->m.offset);
PWC_DEBUG_IOCTL("VIDIOC_DQBUF: bytesused=%d\n",buf->bytesused);
PWC_DEBUG_IOCTL("VIDIOC_DQBUF: leaving\n");
return 0;
}
case VIDIOC_STREAMON:
{
/* WARNING: pwc_try_video_mode() called pwc_isoc_init */
pwc_isoc_init(pdev);
return 0;
}
case VIDIOC_STREAMOFF:
{
pwc_isoc_cleanup(pdev);
return 0;
}
case VIDIOC_ENUM_FRAMESIZES:
{
struct v4l2_frmsizeenum *fsize = arg;
unsigned int i = 0, index = fsize->index;
if (fsize->pixel_format == V4L2_PIX_FMT_YUV420) {
for (i = 0; i < PSZ_MAX; i++) {
if (pdev->image_mask & (1UL << i)) {
if (!index--) {
fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
fsize->discrete.width = pwc_image_sizes[i].x;
fsize->discrete.height = pwc_image_sizes[i].y;
return 0;
}
}
}
} else if (fsize->index == 0 &&
((fsize->pixel_format == V4L2_PIX_FMT_PWC1 && DEVICE_USE_CODEC1(pdev->type)) ||
(fsize->pixel_format == V4L2_PIX_FMT_PWC2 && DEVICE_USE_CODEC23(pdev->type)))) {
fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
fsize->discrete.width = pdev->abs_max.x;
fsize->discrete.height = pdev->abs_max.y;
return 0;
}
return -EINVAL;
}
case VIDIOC_ENUM_FRAMEINTERVALS:
{
struct v4l2_frmivalenum *fival = arg;
int size = -1;
unsigned int i;
for (i = 0; i < PSZ_MAX; i++) {
if (pwc_image_sizes[i].x == fival->width &&
pwc_image_sizes[i].y == fival->height) {
size = i;
break;
}
}
/* TODO: Support raw format */
if (size < 0 || fival->pixel_format != V4L2_PIX_FMT_YUV420) {
return -EINVAL;
}
i = pwc_get_fps(pdev, fival->index, size);
if (!i)
return -EINVAL;
fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
fival->discrete.numerator = 1;
fival->discrete.denominator = i;
return 0;
}
default:
return pwc_ioctl(pdev, cmd, arg);
} /* ..switch */
return 0;
}
/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
View Git Blame Copy Permalink