V4L/DVB (4065): Several improvements at videodev.c
Mauro Carvalho Chehab [Sun, 4 Jun 2006 13:06:18 +0000 (10:06 -0300)]
Videodev now is capable of better handling V4L2 api, by
processing V4L2 ioctls and using callbacks to the driver.
The drivers should be migrated to the newer way and the older
one will be obsoleted soon.

Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

drivers/media/video/cx88/cx88.h
drivers/media/video/saa7134/saa7134.h
drivers/media/video/v4l2-common.c
drivers/media/video/videodev.c
include/linux/videodev.h
include/linux/videodev2.h
include/media/v4l2-common.h
include/media/v4l2-dev.h [new file with mode: 0644]
include/media/video-buf.h

index 46a21f8..b950129 100644 (file)
@@ -25,6 +25,7 @@
 #include <linux/videodev2.h>
 #include <linux/kdev_t.h>
 
+#include <media/v4l2-common.h>
 #include <media/tuner.h>
 #include <media/tveeprom.h>
 #include <media/video-buf.h>
index 9048d2c..6cba6c1 100644 (file)
@@ -33,6 +33,7 @@
 
 #include <asm/io.h>
 
+#include <media/v4l2-common.h>
 #include <media/tuner.h>
 #include <media/ir-common.h>
 #include <media/ir-kbd-i2c.h>
index ad92e07..bffe482 100644 (file)
@@ -59,6 +59,7 @@
 #include <asm/io.h>
 #include <asm/div64.h>
 #include <linux/video_decoder.h>
+#define __OLD_VIDIOC_ /* To allow fixing old calls*/
 #include <media/v4l2-common.h>
 
 #ifdef CONFIG_KMOD
@@ -424,7 +425,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
        case TUNER_SET_TYPE_ADDR:
        case TUNER_SET_STANDBY:
        case TDA9887_SET_CONFIG:
+#ifdef __OLD_VIDIOC_
        case VIDIOC_OVERLAY_OLD:
+#endif
        case VIDIOC_STREAMOFF:
        case VIDIOC_G_OUTPUT:
        case VIDIOC_S_OUTPUT:
@@ -440,7 +443,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
        case VIDIOC_G_AUDIO:
        case VIDIOC_S_AUDIO:
        case VIDIOC_ENUMAUDIO:
+#ifdef __OLD_VIDIOC_
        case VIDIOC_G_AUDIO_OLD:
+#endif
        {
                struct v4l2_audio *p=arg;
 
@@ -451,7 +456,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
        case VIDIOC_G_AUDOUT:
        case VIDIOC_S_AUDOUT:
        case VIDIOC_ENUMAUDOUT:
+#ifdef __OLD_VIDIOC_
        case VIDIOC_G_AUDOUT_OLD:
+#endif
        {
                struct v4l2_audioout *p=arg;
                printk ("%s: index=%d, name=%s, capability=%d, mode=%d\n", s,
@@ -496,7 +503,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
        }
        case VIDIOC_G_CTRL:
        case VIDIOC_S_CTRL:
+#ifdef __OLD_VIDIOC_
        case VIDIOC_S_CTRL_OLD:
+#endif
        {
                struct v4l2_control *p=arg;
                printk ("%s: id=%d, value=%d\n", s, p->id, p->value);
@@ -511,7 +520,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
                break;
        }
        case VIDIOC_CROPCAP:
+#ifdef __OLD_VIDIOC_
        case VIDIOC_CROPCAP_OLD:
+#endif
        {
                struct v4l2_cropcap *p=arg;
                /*FIXME: Should also show rect structs */
@@ -703,7 +714,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
        }
        case VIDIOC_G_PARM:
        case VIDIOC_S_PARM:
+#ifdef __OLD_VIDIOC_
        case VIDIOC_S_PARM_OLD:
+#endif
        {
                struct v4l2_streamparm *p=arg;
                printk ("%s: type=%d\n", s, p->type);
index 5f87dd5..3f7a94b 100644 (file)
@@ -1,20 +1,31 @@
 /*
- * Video capture interface for Linux
+ * Video capture interface for Linux version 2
  *
- *             A generic video device interface for the LINUX operating system
- *             using a set of device structures/vectors for low level operations.
+ *     A generic video device interface for the LINUX operating system
+ *     using a set of device structures/vectors for low level operations.
  *
- *             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 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.
  *
- * Author:     Alan Cox, <alan@redhat.com>
+ * Authors:    Alan Cox, <alan@redhat.com> (version 1)
+ *              Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
  *
  * Fixes:      20000516  Claudio Matsuoka <claudio@conectiva.com>
  *             - Added procfs support
  */
 
+#define dbgarg(cmd, fmt, arg...) \
+               if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)                  \
+                       printk (KERN_DEBUG "%s: ",  vfd->name);         \
+                       v4l_printk_ioctl(cmd);                          \
+                       printk (KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
+
+#define dbgarg2(fmt, arg...) \
+               if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)                  \
+                       printk (KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
+
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 
+#define __OLD_VIDIOC_ /* To allow fixing old calls*/
+#include <linux/videodev2.h>
+
+#ifdef CONFIG_VIDEO_V4L1
 #include <linux/videodev.h>
+#endif
+#include <media/v4l2-common.h>
 
 #define VIDEO_NUM_DEVICES      256
 #define VIDEO_NAME              "video4linux"
@@ -41,7 +58,8 @@
 
 static ssize_t show_name(struct class_device *cd, char *buf)
 {
-       struct video_device *vfd = container_of(cd, struct video_device, class_dev);
+       struct video_device *vfd = container_of(cd, struct video_device,
+                                                               class_dev);
        return sprintf(buf,"%.*s\n",(int)sizeof(vfd->name),vfd->name);
 }
 
@@ -62,7 +80,8 @@ void video_device_release(struct video_device *vfd)
 
 static void video_release(struct class_device *cd)
 {
-       struct video_device *vfd = container_of(cd, struct video_device, class_dev);
+       struct video_device *vfd = container_of(cd, struct video_device,
+                                                               class_dev);
 
 #if 1
        /* needed until all drivers are fixed */
@@ -90,7 +109,7 @@ struct video_device* video_devdata(struct file *file)
 }
 
 /*
- *     Open a video device.
+ *     Open a video device - FIXME: Obsoleted
  */
 static int video_open(struct inode *inode, struct file *file)
 {
@@ -130,6 +149,7 @@ static int video_open(struct inode *inode, struct file *file)
  * helper function -- handles userspace copying for ioctl arguments
  */
 
+#ifdef __OLD_VIDIOC_
 static unsigned int
 video_fix_command(unsigned int cmd)
 {
@@ -155,7 +175,11 @@ video_fix_command(unsigned int cmd)
        }
        return cmd;
 }
+#endif
 
+/*
+ * Obsolete usercopy function - Should be removed soon
+ */
 int
 video_usercopy(struct inode *inode, struct file *file,
               unsigned int cmd, unsigned long arg,
@@ -167,7 +191,9 @@ video_usercopy(struct inode *inode, struct file *file,
        void    *parg = NULL;
        int     err  = -EINVAL;
 
+#ifdef __OLD_VIDIOC_
        cmd = video_fix_command(cmd);
+#endif
 
        /*  Copy arguments into temp kernel buffer  */
        switch (_IOC_DIR(cmd)) {
@@ -189,7 +215,8 @@ video_usercopy(struct inode *inode, struct file *file,
 
                err = -EFAULT;
                if (_IOC_DIR(cmd) & _IOC_WRITE)
-                       if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
+                       if (copy_from_user(parg, (void __user *)arg,
+                                                       _IOC_SIZE(cmd)))
                                goto out;
                break;
        }
@@ -218,6 +245,7 @@ out:
 
 /*
  * open/release helper functions -- handle exclusive opens
+ * Should be removed soon
  */
 int video_exclusive_open(struct inode *inode, struct file *file)
 {
@@ -242,6 +270,1115 @@ int video_exclusive_release(struct inode *inode, struct file *file)
        return 0;
 }
 
+static char *v4l2_memory_names[] = {
+       [V4L2_MEMORY_MMAP]    = "mmap",
+       [V4L2_MEMORY_USERPTR] = "userptr",
+       [V4L2_MEMORY_OVERLAY] = "overlay",
+};
+
+
+/* FIXME: Those stuff are replicated also on v4l2-common.c */
+static char *v4l2_type_names_FIXME[] = {
+       [V4L2_BUF_TYPE_VIDEO_CAPTURE]      = "video-cap",
+       [V4L2_BUF_TYPE_VIDEO_OVERLAY]      = "video-over",
+       [V4L2_BUF_TYPE_VIDEO_OUTPUT]       = "video-out",
+       [V4L2_BUF_TYPE_VBI_CAPTURE]        = "vbi-cap",
+       [V4L2_BUF_TYPE_VBI_OUTPUT]         = "vbi-out",
+       [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT]  = "sliced-vbi-out",
+       [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-capture",
+       [V4L2_BUF_TYPE_PRIVATE]            = "private",
+};
+
+static char *v4l2_field_names_FIXME[] = {
+       [V4L2_FIELD_ANY]        = "any",
+       [V4L2_FIELD_NONE]       = "none",
+       [V4L2_FIELD_TOP]        = "top",
+       [V4L2_FIELD_BOTTOM]     = "bottom",
+       [V4L2_FIELD_INTERLACED] = "interlaced",
+       [V4L2_FIELD_SEQ_TB]     = "seq-tb",
+       [V4L2_FIELD_SEQ_BT]     = "seq-bt",
+       [V4L2_FIELD_ALTERNATE]  = "alternate",
+};
+
+#define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
+
+static void dbgbuf(unsigned int cmd, struct video_device *vfd,
+                                       struct v4l2_buffer *p)
+{
+       struct v4l2_timecode *tc=&p->timecode;
+
+       dbgarg (cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
+               "bytesused=%d, flags=0x%08d, "
+               "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx\n",
+                       (p->timestamp.tv_sec/3600),
+                       (int)(p->timestamp.tv_sec/60)%60,
+                       (int)(p->timestamp.tv_sec%60),
+                       p->timestamp.tv_usec,
+                       p->index,
+                       prt_names(p->type,v4l2_type_names_FIXME),
+                       p->bytesused,p->flags,
+                       p->field,p->sequence,
+                       prt_names(p->memory,v4l2_memory_names),
+                       p->m.userptr);
+       dbgarg2 ("timecode= %02d:%02d:%02d type=%d, "
+               "flags=0x%08d, frames=%d, userbits=0x%08x\n",
+                       tc->hours,tc->minutes,tc->seconds,
+                       tc->type, tc->flags, tc->frames, (__u32) tc->userbits);
+}
+
+static inline void dbgrect(struct video_device *vfd, char *s,
+                                                       struct v4l2_rect *r)
+{
+       dbgarg2 ("%sRect start at %dx%d, size= %dx%d\n", s, r->left, r->top,
+                                               r->width, r->height);
+};
+
+static inline void v4l_print_pix_fmt (struct video_device *vfd,
+                                               struct v4l2_pix_format *fmt)
+{
+       dbgarg2 ("width=%d, height=%d, format=0x%08x, field=%s, "
+               "bytesperline=%d sizeimage=%d, colorspace=%d\n",
+               fmt->width,fmt->height,fmt->pixelformat,
+               prt_names(fmt->field,v4l2_field_names_FIXME),
+               fmt->bytesperline,fmt->sizeimage,fmt->colorspace);
+};
+
+
+static int check_fmt (struct video_device *vfd, enum v4l2_buf_type type)
+{
+       switch (type) {
+       case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+               if (vfd->vidioc_try_fmt_cap)
+                       return (0);
+               break;
+       case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+               if (vfd->vidioc_try_fmt_overlay)
+                       return (0);
+               break;
+       case V4L2_BUF_TYPE_VBI_CAPTURE:
+               if (vfd->vidioc_try_fmt_vbi)
+                       return (0);
+               break;
+       case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+               if (vfd->vidioc_try_fmt_vbi_output)
+                       return (0);
+               break;
+       case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+               if (vfd->vidioc_try_fmt_vbi_capture)
+                       return (0);
+               break;
+       case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+               if (vfd->vidioc_try_fmt_video_output)
+                       return (0);
+               break;
+       case V4L2_BUF_TYPE_VBI_OUTPUT:
+               if (vfd->vidioc_try_fmt_vbi_output)
+                       return (0);
+               break;
+       case V4L2_BUF_TYPE_PRIVATE:
+               if (vfd->vidioc_try_fmt_type_private)
+                       return (0);
+               break;
+       }
+       return (-EINVAL);
+}
+
+static int __video_do_ioctl(struct inode *inode, struct file *file,
+               unsigned int cmd, void *arg)
+{
+       struct video_device *vfd = video_devdata(file);
+       void                 *fh = file->private_data;
+       int                  ret = -EINVAL;
+
+       if ( (vfd->debug & V4L2_DEBUG_IOCTL) &&
+                               !(vfd->debug | V4L2_DEBUG_IOCTL_ARG)) {
+               v4l_print_ioctl(vfd->name, cmd);
+       }
+
+       switch(cmd) {
+       /* --- capabilities ------------------------------------------ */
+       case VIDIOC_QUERYCAP:
+       {
+               struct v4l2_capability *cap = (struct v4l2_capability*)arg;
+               memset(cap, 0, sizeof(*cap));
+
+               if (!vfd->vidioc_querycap)
+                       break;
+
+               ret=vfd->vidioc_querycap(file, fh, cap);
+               if (!ret)
+                       dbgarg (cmd, "driver=%s, card=%s, bus=%s, "
+                                       "version=0x%08x, "
+                                       "capabilities=0x%08x\n",
+                                       cap->driver,cap->card,cap->bus_info,
+                                       cap->version,
+                                       cap->capabilities);
+               break;
+       }
+
+       /* --- priority ------------------------------------------ */
+       case VIDIOC_G_PRIORITY:
+       {
+               enum v4l2_priority *p=arg;
+
+               if (!vfd->vidioc_g_priority)
+                       break;
+               ret=vfd->vidioc_g_priority(file, fh, p);
+               if (!ret)
+                       dbgarg(cmd, "priority is %d\n", *p);
+               break;
+       }
+       case VIDIOC_S_PRIORITY:
+       {
+               enum v4l2_priority *p=arg;
+
+               if (!vfd->vidioc_s_priority)
+                       break;
+               dbgarg(cmd, "setting priority to %d\n", *p);
+               ret=vfd->vidioc_s_priority(file, fh, *p);
+               break;
+       }
+
+       /* --- capture ioctls ---------------------------------------- */
+       case VIDIOC_ENUM_FMT:
+       {
+               struct v4l2_fmtdesc *f = arg;
+               enum v4l2_buf_type type;
+               unsigned int index;
+
+               index = f->index;
+               type  = f->type;
+               memset(f,0,sizeof(*f));
+               f->index = index;
+               f->type  = type;
+
+               switch (type) {
+               case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                       if (vfd->vidioc_enum_fmt_cap)
+                               ret=vfd->vidioc_enum_fmt_cap(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                       if (vfd->vidioc_enum_fmt_overlay)
+                               ret=vfd->vidioc_enum_fmt_overlay(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       if (vfd->vidioc_enum_fmt_vbi)
+                               ret=vfd->vidioc_enum_fmt_vbi(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       if (vfd->vidioc_enum_fmt_vbi_output)
+                               ret=vfd->vidioc_enum_fmt_vbi_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       if (vfd->vidioc_enum_fmt_vbi_capture)
+                               ret=vfd->vidioc_enum_fmt_vbi_capture(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                       if (vfd->vidioc_enum_fmt_video_output)
+                               ret=vfd->vidioc_enum_fmt_video_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_OUTPUT:
+                       if (vfd->vidioc_enum_fmt_vbi_output)
+                               ret=vfd->vidioc_enum_fmt_vbi_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_PRIVATE:
+                       if (vfd->vidioc_enum_fmt_type_private)
+                               ret=vfd->vidioc_enum_fmt_type_private(file,
+                                                               fh, f);
+                       break;
+               }
+               if (!ret)
+                       dbgarg (cmd, "index=%d, type=%d, flags=%d, "
+                                       "description=%s,"
+                                       " pixelformat=0x%8x\n",
+                                       f->index, f->type, f->flags,
+                                       f->description,
+                                       f->pixelformat);
+
+               break;
+       }
+       case VIDIOC_G_FMT:
+       {
+               struct v4l2_format *f = (struct v4l2_format *)arg;
+               enum v4l2_buf_type type=f->type;
+
+               memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
+               f->type=type;
+
+               /* FIXME: Should be one dump per type */
+               dbgarg (cmd, "type=%s\n", prt_names(type,
+                                       v4l2_type_names_FIXME));
+
+               switch (type) {
+               case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                       if (vfd->vidioc_g_fmt_cap)
+                               ret=vfd->vidioc_g_fmt_cap(file, fh, f);
+                       if (!ret)
+                               v4l_print_pix_fmt(vfd,&f->fmt.pix);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                       if (vfd->vidioc_g_fmt_overlay)
+                               ret=vfd->vidioc_g_fmt_overlay(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       if (vfd->vidioc_g_fmt_vbi)
+                               ret=vfd->vidioc_g_fmt_vbi(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       if (vfd->vidioc_g_fmt_vbi_output)
+                               ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       if (vfd->vidioc_g_fmt_vbi_capture)
+                               ret=vfd->vidioc_g_fmt_vbi_capture(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                       if (vfd->vidioc_g_fmt_video_output)
+                               ret=vfd->vidioc_g_fmt_video_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_OUTPUT:
+                       if (vfd->vidioc_g_fmt_vbi_output)
+                               ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_PRIVATE:
+                       if (vfd->vidioc_g_fmt_type_private)
+                               ret=vfd->vidioc_g_fmt_type_private(file,
+                                                               fh, f);
+                       break;
+               }
+
+               break;
+       }
+       case VIDIOC_S_FMT:
+       {
+               struct v4l2_format *f = (struct v4l2_format *)arg;
+
+               /* FIXME: Should be one dump per type */
+               dbgarg (cmd, "type=%s\n", prt_names(f->type,
+                                       v4l2_type_names_FIXME));
+
+               switch (f->type) {
+               case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                       v4l_print_pix_fmt(vfd,&f->fmt.pix);
+                       if (vfd->vidioc_s_fmt_cap)
+                               ret=vfd->vidioc_s_fmt_cap(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                       if (vfd->vidioc_s_fmt_overlay)
+                               ret=vfd->vidioc_s_fmt_overlay(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       if (vfd->vidioc_s_fmt_vbi)
+                               ret=vfd->vidioc_s_fmt_vbi(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       if (vfd->vidioc_s_fmt_vbi_output)
+                               ret=vfd->vidioc_s_fmt_vbi_output(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       if (vfd->vidioc_s_fmt_vbi_capture)
+                               ret=vfd->vidioc_s_fmt_vbi_capture(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                       if (vfd->vidioc_s_fmt_video_output)
+                               ret=vfd->vidioc_s_fmt_video_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_OUTPUT:
+                       if (vfd->vidioc_s_fmt_vbi_output)
+                               ret=vfd->vidioc_s_fmt_vbi_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_PRIVATE:
+                       if (vfd->vidioc_s_fmt_type_private)
+                               ret=vfd->vidioc_s_fmt_type_private(file,
+                                                               fh, f);
+                       break;
+               }
+               break;
+       }
+       case VIDIOC_TRY_FMT:
+       {
+               struct v4l2_format *f = (struct v4l2_format *)arg;
+
+               /* FIXME: Should be one dump per type */
+               dbgarg (cmd, "type=%s\n", prt_names(f->type,
+                                               v4l2_type_names_FIXME));
+               switch (f->type) {
+               case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                       if (vfd->vidioc_try_fmt_cap)
+                               ret=vfd->vidioc_try_fmt_cap(file, fh, f);
+                       if (!ret)
+                               v4l_print_pix_fmt(vfd,&f->fmt.pix);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                       if (vfd->vidioc_try_fmt_overlay)
+                               ret=vfd->vidioc_try_fmt_overlay(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       if (vfd->vidioc_try_fmt_vbi)
+                               ret=vfd->vidioc_try_fmt_vbi(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       if (vfd->vidioc_try_fmt_vbi_output)
+                               ret=vfd->vidioc_try_fmt_vbi_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       if (vfd->vidioc_try_fmt_vbi_capture)
+                               ret=vfd->vidioc_try_fmt_vbi_capture(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                       if (vfd->vidioc_try_fmt_video_output)
+                               ret=vfd->vidioc_try_fmt_video_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_OUTPUT:
+                       if (vfd->vidioc_try_fmt_vbi_output)
+                               ret=vfd->vidioc_try_fmt_vbi_output(file,
+                                                               fh, f);
+                       break;
+               case V4L2_BUF_TYPE_PRIVATE:
+                       if (vfd->vidioc_try_fmt_type_private)
+                               ret=vfd->vidioc_try_fmt_type_private(file,
+                                                               fh, f);
+                       break;
+               }
+
+               break;
+       }
+       /* FIXME: Those buf reqs could be handled here,
+          with some changes on videobuf to allow its header to be included at
+          videodev2.h or being merged at videodev2.
+        */
+       case VIDIOC_REQBUFS:
+       {
+               struct v4l2_requestbuffers *p=arg;
+
+               if (!vfd->vidioc_reqbufs)
+                       break;
+               ret = check_fmt (vfd, p->type);
+               if (ret)
+                       break;
+
+               ret=vfd->vidioc_reqbufs(file, fh, p);
+               dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
+                               p->count,
+                               prt_names(p->type,v4l2_type_names_FIXME),
+                               prt_names(p->memory,v4l2_memory_names));
+               break;
+       }
+       case VIDIOC_QUERYBUF:
+       {
+               struct v4l2_buffer *p=arg;
+
+               if (!vfd->vidioc_querybuf)
+                       break;
+               ret = check_fmt (vfd, p->type);
+               if (ret)
+                       break;
+
+               ret=vfd->vidioc_querybuf(file, fh, p);
+               if (!ret)
+                       dbgbuf(cmd,vfd,p);
+               break;
+       }
+       case VIDIOC_QBUF:
+       {
+               struct v4l2_buffer *p=arg;
+
+               if (!vfd->vidioc_qbuf)
+                       break;
+               ret = check_fmt (vfd, p->type);
+               if (ret)
+                       break;
+
+               ret=vfd->vidioc_qbuf(file, fh, p);
+               if (!ret)
+                       dbgbuf(cmd,vfd,p);
+               break;
+       }
+       case VIDIOC_DQBUF:
+       {
+               struct v4l2_buffer *p=arg;
+               if (!vfd->vidioc_qbuf)
+                       break;
+               ret = check_fmt (vfd, p->type);
+               if (ret)
+                       break;
+
+               ret=vfd->vidioc_qbuf(file, fh, p);
+               if (!ret)
+                       dbgbuf(cmd,vfd,p);
+               break;
+       }
+       case VIDIOC_OVERLAY:
+       {
+               int *i = arg;
+
+               if (!vfd->vidioc_overlay)
+                       break;
+               dbgarg (cmd, "value=%d\n",*i);
+               ret=vfd->vidioc_overlay(file, fh, *i);
+               break;
+       }
+#ifdef HAVE_V4L1
+       /* --- streaming capture ------------------------------------- */
+       case VIDIOCGMBUF:
+       {
+               struct video_mbuf *p=arg;
+
+               memset(&p,0,sizeof(p));
+
+               if (!vfd->vidiocgmbuf)
+                       break;
+               ret=vfd->vidiocgmbuf(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
+                                               p->size, p->frames,
+                                               (unsigned long)p->offsets);
+               break;
+       }
+#endif
+       case VIDIOC_G_FBUF:
+       {
+               struct v4l2_framebuffer *p=arg;
+               if (!vfd->vidioc_g_fbuf)
+                       break;
+               ret=vfd->vidioc_g_fbuf(file, fh, arg);
+               if (!ret) {
+                       dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
+                                       p->capability,p->flags,
+                                       (unsigned long)p->base);
+                       v4l_print_pix_fmt (vfd, &p->fmt);
+               }
+               break;
+       }
+       case VIDIOC_S_FBUF:
+       {
+               struct v4l2_framebuffer *p=arg;
+               if (!vfd->vidioc_s_fbuf)
+                       break;
+
+               dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
+                               p->capability,p->flags,(unsigned long)p->base);
+               v4l_print_pix_fmt (vfd, &p->fmt);
+               ret=vfd->vidioc_s_fbuf(file, fh, arg);
+
+               break;
+       }
+       case VIDIOC_STREAMON:
+       {
+               enum v4l2_buf_type i = *(int *)arg;
+               if (!vfd->vidioc_streamon)
+                       break;
+               dbgarg (cmd, "type=%s\n", prt_names(i,v4l2_type_names_FIXME));
+               ret=vfd->vidioc_streamon(file, fh,i);
+               break;
+       }
+       case VIDIOC_STREAMOFF:
+       {
+               enum v4l2_buf_type i = *(int *)arg;
+
+               if (!vfd->vidioc_streamoff)
+                       break;
+               dbgarg (cmd, "type=%s\n", prt_names(i,v4l2_type_names_FIXME));
+               ret=vfd->vidioc_streamoff(file, fh, i);
+               break;
+       }
+       /* ---------- tv norms ---------- */
+       case VIDIOC_ENUMSTD:
+       {
+               struct v4l2_standard *p = arg;
+               unsigned int index = p->index;
+
+               if (!vfd->tvnormsize) {
+                       printk (KERN_WARNING "%s: no TV norms defined!\n",
+                                               vfd->name);
+                       break;
+               }
+
+               if (index<=0 || index >= vfd->tvnormsize) {
+                       ret=-EINVAL;
+                       break;
+               }
+               v4l2_video_std_construct(p, vfd->tvnorms[p->index].id,
+                                        vfd->tvnorms[p->index].name);
+               p->index = index;
+
+               dbgarg (cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
+                               "framelines=%d\n", p->index,
+                               (unsigned long long)p->id, p->name,
+                               p->frameperiod.numerator,
+                               p->frameperiod.denominator,
+                               p->framelines);
+
+               ret=0;
+               break;
+       }
+       case VIDIOC_G_STD:
+       {
+               v4l2_std_id *id = arg;
+
+               *id = vfd->current_norm;
+
+               dbgarg (cmd, "value=%Lu\n", (long long unsigned) *id);
+
+               ret=0;
+               break;
+       }
+       case VIDIOC_S_STD:
+       {
+               v4l2_std_id *id = arg;
+               unsigned int i;
+
+               if (!vfd->tvnormsize) {
+                       printk (KERN_WARNING "%s: no TV norms defined!\n",
+                                               vfd->name);
+                       break;
+               }
+
+               dbgarg (cmd, "value=%Lu\n", (long long unsigned) *id);
+
+               /* First search for exact match */
+               for (i = 0; i < vfd->tvnormsize; i++)
+                       if (*id == vfd->tvnorms[i].id)
+                               break;
+               /* Then for a generic video std that contains desired std */
+               if (i == vfd->tvnormsize)
+                       for (i = 0; i < vfd->tvnormsize; i++)
+                               if (*id & vfd->tvnorms[i].id)
+                                       break;
+               if (i == vfd->tvnormsize) {
+                       break;
+               }
+
+               /* Calls the specific handler */
+               if (vfd->vidioc_s_std)
+                       ret=vfd->vidioc_s_std(file, fh, i);
+               else
+                       ret=-EINVAL;
+
+               /* Updates standard information */
+               if (!ret)
+                       vfd->current_norm=*id;
+
+               break;
+       }
+       case VIDIOC_QUERYSTD:
+       {
+               v4l2_std_id *p=arg;
+
+               if (!vfd->vidioc_querystd)
+                       break;
+               ret=vfd->vidioc_querystd(file, fh, arg);
+               if (!ret)
+                       dbgarg (cmd, "detected std=%Lu\n",
+                                               (unsigned long long)*p);
+               break;
+       }
+       /* ------ input switching ---------- */
+       /* FIXME: Inputs can be handled inside videodev2 */
+       case VIDIOC_ENUMINPUT:
+       {
+               struct v4l2_input *p=arg;
+               int i=p->index;
+
+               if (!vfd->vidioc_enum_input)
+                       break;
+               memset(p, 0, sizeof(*p));
+               p->index=i;
+
+               ret=vfd->vidioc_enum_input(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "index=%d, name=%s, type=%d, "
+                                       "audioset=%d, "
+                                       "tuner=%d, std=%Ld, status=%d\n",
+                                       p->index,p->name,p->type,p->audioset,
+                                       p->tuner,
+                                       (unsigned long long)p->std,
+                                       p->status);
+               break;
+       }
+       case VIDIOC_G_INPUT:
+       {
+               unsigned int *i = arg;
+
+               if (!vfd->vidioc_g_input)
+                       break;
+               ret=vfd->vidioc_g_input(file, fh, i);
+               if (!ret)
+                       dbgarg (cmd, "value=%d\n",*i);
+               break;
+       }
+       case VIDIOC_S_INPUT:
+       {
+               unsigned int *i = arg;
+
+               if (!vfd->vidioc_s_input)
+                       break;
+               dbgarg (cmd, "value=%d\n",*i);
+               ret=vfd->vidioc_s_input(file, fh, *i);
+               break;
+       }
+
+       /* ------ output switching ---------- */
+       case VIDIOC_G_OUTPUT:
+       {
+               unsigned int *i = arg;
+
+               if (!vfd->vidioc_g_output)
+                       break;
+               ret=vfd->vidioc_g_output(file, fh, i);
+               if (!ret)
+                       dbgarg (cmd, "value=%d\n",*i);
+               break;
+       }
+       case VIDIOC_S_OUTPUT:
+       {
+               unsigned int *i = arg;
+
+               if (!vfd->vidioc_s_output)
+                       break;
+               dbgarg (cmd, "value=%d\n",*i);
+               ret=vfd->vidioc_s_output(file, fh, *i);
+               break;
+       }
+
+       /* --- controls ---------------------------------------------- */
+       case VIDIOC_QUERYCTRL:
+       {
+               struct v4l2_queryctrl *p=arg;
+
+               if (!vfd->vidioc_queryctrl)
+                       break;
+               ret=vfd->vidioc_queryctrl(file, fh, p);
+
+               if (!ret)
+                       dbgarg (cmd, "id=%d, type=%d, name=%s, "
+                                       "min/max=%d/%d,"
+                                       " step=%d, default=%d, flags=0x%08x\n",
+                                       p->id,p->type,p->name,p->minimum,
+                                       p->maximum,p->step,p->default_value,
+                                       p->flags);
+               break;
+       }
+       case VIDIOC_G_CTRL:
+       {
+               struct v4l2_control *p = arg;
+
+               if (!vfd->vidioc_g_ctrl)
+                       break;
+               dbgarg(cmd, "Enum for index=%d\n", p->id);
+
+               ret=vfd->vidioc_g_ctrl(file, fh, p);
+               if (!ret)
+                       dbgarg2 ( "id=%d, value=%d\n", p->id, p->value);
+               break;
+       }
+       case VIDIOC_S_CTRL:
+       {
+               struct v4l2_control *p = arg;
+
+               if (!vfd->vidioc_s_ctrl)
+                       break;
+               dbgarg (cmd, "id=%d, value=%d\n", p->id, p->value);
+
+               ret=vfd->vidioc_s_ctrl(file, fh, p);
+               break;
+       }
+       case VIDIOC_QUERYMENU:
+       {
+               struct v4l2_querymenu *p=arg;
+               if (!vfd->vidioc_querymenu)
+                       break;
+               ret=vfd->vidioc_querymenu(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "id=%d, index=%d, name=%s\n",
+                                               p->id,p->index,p->name);
+               break;
+       }
+       /* --- audio ---------------------------------------------- */
+       case VIDIOC_ENUMAUDIO:
+       {
+               struct v4l2_audio *p=arg;
+
+               if (!vfd->vidioc_enumaudio)
+                       break;
+               dbgarg(cmd, "Enum for index=%d\n", p->index);
+               ret=vfd->vidioc_enumaudio(file, fh, p);
+               if (!ret)
+                       dbgarg2("index=%d, name=%s, capability=%d, "
+                                       "mode=%d\n",p->index,p->name,
+                                       p->capability, p->mode);
+               break;
+       }
+       case VIDIOC_G_AUDIO:
+       {
+               struct v4l2_audio *p=arg;
+
+               if (!vfd->vidioc_g_audio)
+                       break;
+               dbgarg(cmd, "Get for index=%d\n", p->index);
+               ret=vfd->vidioc_g_audio(file, fh, p);
+               if (!ret)
+                       dbgarg2("index=%d, name=%s, capability=%d, "
+                                       "mode=%d\n",p->index,
+                                       p->name,p->capability, p->mode);
+               break;
+       }
+       case VIDIOC_S_AUDIO:
+       {
+               struct v4l2_audio *p=arg;
+
+               if (!vfd->vidioc_s_audio)
+                       break;
+               dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+                                       "mode=%d\n", p->index, p->name,
+                                       p->capability, p->mode);
+               ret=vfd->vidioc_s_audio(file, fh, p);
+               break;
+       }
+       case VIDIOC_ENUMAUDOUT:
+       {
+               struct v4l2_audioout *p=arg;
+
+               if (!vfd->vidioc_enumaudout)
+                       break;
+               dbgarg(cmd, "Enum for index=%d\n", p->index);
+               ret=vfd->vidioc_enumaudout(file, fh, p);
+               if (!ret)
+                       dbgarg2("index=%d, name=%s, capability=%d, "
+                                       "mode=%d\n", p->index, p->name,
+                                       p->capability,p->mode);
+               break;
+       }
+       case VIDIOC_G_AUDOUT:
+       {
+               struct v4l2_audioout *p=arg;
+
+               if (!vfd->vidioc_g_audout)
+                       break;
+               dbgarg(cmd, "Enum for index=%d\n", p->index);
+               ret=vfd->vidioc_g_audout(file, fh, p);
+               if (!ret)
+                       dbgarg2("index=%d, name=%s, capability=%d, "
+                                       "mode=%d\n", p->index, p->name,
+                                       p->capability,p->mode);
+               break;
+       }
+       case VIDIOC_S_AUDOUT:
+       {
+               struct v4l2_audioout *p=arg;
+
+               if (!vfd->vidioc_s_audout)
+                       break;
+               dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+                                       "mode=%d\n", p->index, p->name,
+                                       p->capability,p->mode);
+
+               ret=vfd->vidioc_s_audout(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_MODULATOR:
+       {
+               struct v4l2_modulator *p=arg;
+               if (!vfd->vidioc_g_modulator)
+                       break;
+               ret=vfd->vidioc_g_modulator(file, fh, p);
+               if (!ret)
+                       dbgarg(cmd, "index=%d, name=%s, "
+                                       "capability=%d, rangelow=%d,"
+                                       " rangehigh=%d, txsubchans=%d\n",
+                                       p->index, p->name,p->capability,
+                                       p->rangelow, p->rangehigh,
+                                       p->txsubchans);
+               break;
+       }
+       case VIDIOC_S_MODULATOR:
+       {
+               struct v4l2_modulator *p=arg;
+               if (!vfd->vidioc_s_modulator)
+                       break;
+               dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+                               "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
+                               p->index, p->name,p->capability,p->rangelow,
+                               p->rangehigh,p->txsubchans);
+                       ret=vfd->vidioc_s_modulator(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_CROP:
+       {
+               struct v4l2_crop *p=arg;
+               if (!vfd->vidioc_g_crop)
+                       break;
+               ret=vfd->vidioc_g_crop(file, fh, p);
+               if (!ret) {
+                       dbgarg(cmd, "type=%d\n", p->type);
+                       dbgrect(vfd, "", &p->c);
+               }
+               break;
+       }
+       case VIDIOC_S_CROP:
+       {
+               struct v4l2_crop *p=arg;
+               if (!vfd->vidioc_s_crop)
+                       break;
+               dbgarg(cmd, "type=%d\n", p->type);
+               dbgrect(vfd, "", &p->c);
+               ret=vfd->vidioc_s_crop(file, fh, p);
+               break;
+       }
+       case VIDIOC_CROPCAP:
+       {
+               struct v4l2_cropcap *p=arg;
+               /*FIXME: Should also show v4l2_fract pixelaspect */
+               if (!vfd->vidioc_cropcap)
+                       break;
+               dbgarg(cmd, "type=%d\n", p->type);
+               dbgrect(vfd, "bounds ", &p->bounds);
+               dbgrect(vfd, "defrect ", &p->defrect);
+               ret=vfd->vidioc_cropcap(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_MPEGCOMP:
+       {
+               struct v4l2_mpeg_compression *p=arg;
+               /*FIXME: Several fields not shown */
+               if (!vfd->vidioc_g_mpegcomp)
+                       break;
+               ret=vfd->vidioc_g_mpegcomp(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "ts_pid_pmt=%d, ts_pid_audio=%d,"
+                                       " ts_pid_video=%d, ts_pid_pcr=%d, "
+                                       "ps_size=%d, au_sample_rate=%d, "
+                                       "au_pesid=%c, vi_frame_rate=%d, "
+                                       "vi_frames_per_gop=%d, "
+                                       "vi_bframes_count=%d, vi_pesid=%c\n",
+                                       p->ts_pid_pmt,p->ts_pid_audio,
+                                       p->ts_pid_video,p->ts_pid_pcr,
+                                       p->ps_size, p->au_sample_rate,
+                                       p->au_pesid, p->vi_frame_rate,
+                                       p->vi_frames_per_gop,
+                                       p->vi_bframes_count, p->vi_pesid);
+               break;
+       }
+       case VIDIOC_S_MPEGCOMP:
+       {
+               struct v4l2_mpeg_compression *p=arg;
+               /*FIXME: Several fields not shown */
+               if (!vfd->vidioc_s_mpegcomp)
+                       break;
+               dbgarg (cmd, "ts_pid_pmt=%d, ts_pid_audio=%d, "
+                               "ts_pid_video=%d, ts_pid_pcr=%d, ps_size=%d, "
+                               "au_sample_rate=%d, au_pesid=%c, "
+                               "vi_frame_rate=%d, vi_frames_per_gop=%d, "
+                               "vi_bframes_count=%d, vi_pesid=%c\n",
+                               p->ts_pid_pmt,p->ts_pid_audio, p->ts_pid_video,
+                               p->ts_pid_pcr, p->ps_size, p->au_sample_rate,
+                               p->au_pesid, p->vi_frame_rate,
+                               p->vi_frames_per_gop, p->vi_bframes_count,
+                               p->vi_pesid);
+               ret=vfd->vidioc_s_mpegcomp(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_JPEGCOMP:
+       {
+               struct v4l2_jpegcompression *p=arg;
+               if (!vfd->vidioc_g_jpegcomp)
+                       break;
+               ret=vfd->vidioc_g_jpegcomp(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "quality=%d, APPn=%d, "
+                                               "APP_len=%d, COM_len=%d, "
+                                               "jpeg_markers=%d\n",
+                                               p->quality,p->APPn,p->APP_len,
+                                               p->COM_len,p->jpeg_markers);
+               break;
+       }
+       case VIDIOC_S_JPEGCOMP:
+       {
+               struct v4l2_jpegcompression *p=arg;
+               if (!vfd->vidioc_g_jpegcomp)
+                       break;
+               dbgarg (cmd, "quality=%d, APPn=%d, APP_len=%d, "
+                                       "COM_len=%d, jpeg_markers=%d\n",
+                                       p->quality,p->APPn,p->APP_len,
+                                       p->COM_len,p->jpeg_markers);
+                       ret=vfd->vidioc_s_jpegcomp(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_PARM:
+       {
+               struct v4l2_streamparm *p=arg;
+               if (!vfd->vidioc_g_parm)
+                       break;
+               ret=vfd->vidioc_g_parm(file, fh, p);
+               dbgarg (cmd, "type=%d\n", p->type);
+               break;
+       }
+       case VIDIOC_S_PARM:
+       {
+               struct v4l2_streamparm *p=arg;
+               if (!vfd->vidioc_s_parm)
+                       break;
+               dbgarg (cmd, "type=%d\n", p->type);
+               ret=vfd->vidioc_s_parm(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_TUNER:
+       {
+               struct v4l2_tuner *p=arg;
+               if (!vfd->vidioc_g_tuner)
+                       break;
+               ret=vfd->vidioc_g_tuner(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "index=%d, name=%s, type=%d, "
+                                       "capability=%d, rangelow=%d, "
+                                       "rangehigh=%d, signal=%d, afc=%d, "
+                                       "rxsubchans=%d, audmode=%d\n",
+                                       p->index, p->name, p->type,
+                                       p->capability, p->rangelow,
+                                       p->rangehigh, p->rxsubchans,
+                                       p->audmode, p->signal, p->afc);
+               break;
+       }
+       case VIDIOC_S_TUNER:
+       {
+               struct v4l2_tuner *p=arg;
+               if (!vfd->vidioc_s_tuner)
+                       break;
+               dbgarg (cmd, "index=%d, name=%s, type=%d, "
+                               "capability=%d, rangelow=%d, rangehigh=%d, "
+                               "signal=%d, afc=%d, rxsubchans=%d, "
+                               "audmode=%d\n",p->index, p->name, p->type,
+                               p->capability, p->rangelow,p->rangehigh,
+                               p->rxsubchans, p->audmode, p->signal,
+                               p->afc);
+               ret=vfd->vidioc_s_tuner(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_FREQUENCY:
+       {
+               struct v4l2_frequency *p=arg;
+               if (!vfd->vidioc_g_frequency)
+                       break;
+               ret=vfd->vidioc_g_frequency(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
+                                               p->tuner,p->type,p->frequency);
+               break;
+       }
+       case VIDIOC_S_FREQUENCY:
+       {
+               struct v4l2_frequency *p=arg;
+               if (!vfd->vidioc_s_frequency)
+                       break;
+               dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
+                               p->tuner,p->type,p->frequency);
+               ret=vfd->vidioc_s_frequency(file, fh, p);
+               break;
+       }
+       case VIDIOC_G_SLICED_VBI_CAP:
+       {
+               struct v4l2_sliced_vbi_cap *p=arg;
+               if (!vfd->vidioc_g_sliced_vbi_cap)
+                       break;
+               ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
+               if (!ret)
+                       dbgarg (cmd, "service_set=%d\n", p->service_set);
+               break;
+       }
+       case VIDIOC_LOG_STATUS:
+       {
+               if (!vfd->vidioc_log_status)
+                       break;
+               ret=vfd->vidioc_log_status(file, fh);
+               break;
+       }
+
+       /* --- Others --------------------------------------------- */
+
+       default:
+               ret=v4l_compat_translate_ioctl(inode,file,cmd,arg,__video_do_ioctl);
+       }
+
+       if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
+               if (ret<0) {
+                       printk ("%s: err:\n", vfd->name);
+                       v4l_print_ioctl(vfd->name, cmd);
+               }
+       }
+
+       return ret;
+}
+
+int video_ioctl2 (struct inode *inode, struct file *file,
+              unsigned int cmd, unsigned long arg)
+{
+       char    sbuf[128];
+       void    *mbuf = NULL;
+       void    *parg = NULL;
+       int     err  = -EINVAL;
+
+#ifdef __OLD_VIDIOC_
+       cmd = video_fix_command(cmd);
+#endif
+
+       /*  Copy arguments into temp kernel buffer  */
+       switch (_IOC_DIR(cmd)) {
+       case _IOC_NONE:
+               parg = NULL;
+               break;
+       case _IOC_READ:
+       case _IOC_WRITE:
+       case (_IOC_WRITE | _IOC_READ):
+               if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
+                       parg = sbuf;
+               } else {
+                       /* too big to allocate from stack */
+                       mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
+                       if (NULL == mbuf)
+                               return -ENOMEM;
+                       parg = mbuf;
+               }
+
+               err = -EFAULT;
+               if (_IOC_DIR(cmd) & _IOC_WRITE)
+                       if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
+                               goto out;
+               break;
+       }
+
+       /* Handles IOCTL */
+       err = __video_do_ioctl(inode, file, cmd, parg);
+       if (err == -ENOIOCTLCMD)
+               err = -EINVAL;
+       if (err < 0)
+               goto out;
+
+       /*  Copy results into user buffer  */
+       switch (_IOC_DIR(cmd))
+       {
+       case _IOC_READ:
+       case (_IOC_WRITE | _IOC_READ):
+               if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
+                       err = -EFAULT;
+               break;
+       }
+
+out:
+       kfree(mbuf);
+       return err;
+}
+
+
 static struct file_operations video_fops;
 
 /**
@@ -371,7 +1508,9 @@ void video_unregister_device(struct video_device *vfd)
        mutex_unlock(&videodev_lock);
 }
 
-
+/*
+ * Video fs operations
+ */
 static struct file_operations video_fops=
 {
        .owner          = THIS_MODULE,
@@ -387,7 +1526,7 @@ static int __init videodev_init(void)
 {
        int ret;
 
-       printk(KERN_INFO "Linux video capture interface: v1.00\n");
+       printk(KERN_INFO "Linux video capture interface: v2.00\n");
        if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
                printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
                return -EIO;
@@ -418,11 +1557,12 @@ EXPORT_SYMBOL(video_devdata);
 EXPORT_SYMBOL(video_usercopy);
 EXPORT_SYMBOL(video_exclusive_open);
 EXPORT_SYMBOL(video_exclusive_release);
+EXPORT_SYMBOL(video_ioctl2);
 EXPORT_SYMBOL(video_device_alloc);
 EXPORT_SYMBOL(video_device_release);
 
-MODULE_AUTHOR("Alan Cox");
-MODULE_DESCRIPTION("Device registrar for Video4Linux drivers");
+MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
+MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
 MODULE_LICENSE("GPL");
 
 
index 9114009..5b62055 100644 (file)
@@ -1,49 +1,28 @@
+/*
+ *     Video for Linux version 1 - OBSOLETE
+ *
+ *     Header file for v4l1 drivers and applications, for
+ *     Linux kernels 2.2.x or 2.4.x.
+ *
+ *     Provides header for legacy drivers and applications
+ *
+ *     See http://linuxtv.org for more info
+ *
+ */
 #ifndef __LINUX_VIDEODEV_H
 #define __LINUX_VIDEODEV_H
 
 #include <linux/types.h>
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/mutex.h>
+#include <linux/compiler.h> /* need __user */
 
 #define HAVE_V4L1 1
 
 #include <linux/videodev2.h>
 
-#ifdef __KERNEL__
-
-#include <linux/mm.h>
-
-extern struct video_device* video_devdata(struct file*);
-
-#define to_video_device(cd) container_of(cd, struct video_device, class_dev)
-static inline void
-video_device_create_file(struct video_device *vfd,
-                        struct class_device_attribute *attr)
-{
-       class_device_create_file(&vfd->class_dev, attr);
-}
-static inline void
-video_device_remove_file(struct video_device *vfd,
-                        struct class_device_attribute *attr)
-{
-       class_device_remove_file(&vfd->class_dev, attr);
-}
-
-#if OBSOLETE_OWNER /* to be removed in 2.6.15 */
-/* helper functions to access driver private data. */
-static inline void *video_get_drvdata(struct video_device *dev)
-{
-       return dev->priv;
-}
-
-static inline void video_set_drvdata(struct video_device *dev, void *data)
-{
-       dev->priv = data;
-}
-#endif
-
-extern int video_exclusive_open(struct inode *inode, struct file *file);
-extern int video_exclusive_release(struct inode *inode, struct file *file);
-#endif /* __KERNEL__ */
-
 struct video_capability
 {
        char name[32];
@@ -363,6 +342,11 @@ struct video_code
 #define VID_HARDWARE_SAA7114H   37
 #define VID_HARDWARE_SN9C102   38
 #define VID_HARDWARE_ARV       39
+
+#ifdef __KERNEL__
+#include <media/v4l2-dev.h>
+#endif /* __KERNEL__ */
+
 #endif /* __LINUX_VIDEODEV_H */
 
 /*
index b3a848b..bb58197 100644 (file)
@@ -1,29 +1,23 @@
-#ifndef __LINUX_VIDEODEV2_H
-#define __LINUX_VIDEODEV2_H
 /*
  *     Video for Linux Two
  *
- *     Header file for v4l or V4L2 drivers and applications, for
- *     Linux kernels 2.2.x or 2.4.x.
+ *     Header file for v4l or V4L2 drivers and applications
+ * with public API.
+ * All kernel-specific stuff were moved to media/v4l2-dev.h, so
+ * no #if __KERNEL tests are allowed here
  *
- *     See http://bytesex.org/v4l/ for API specs and other
- *     v4l2 documentation.
+ *     See http://linuxtv.org for more info
  *
  *     Author: Bill Dirks <bdirks@pacbell.net>
  *             Justin Schoeman
  *             et al.
  */
-#ifdef __KERNEL__
+#ifndef __LINUX_VIDEODEV2_H
+#define __LINUX_VIDEODEV2_H
 #include <linux/time.h> /* need struct timeval */
-#include <linux/poll.h>
-#include <linux/device.h>
-#include <linux/mutex.h>
-#endif
 #include <linux/types.h>
 #include <linux/compiler.h> /* need __user */
 
-
-#define OBSOLETE_OWNER 1 /* It will be removed for 2.6.17 */
 #define HAVE_V4L2 1
 
 /*
 #define VID_TYPE_MJPEG_DECODER 4096    /* Can decode MJPEG streams */
 #define VID_TYPE_MJPEG_ENCODER 8192    /* Can encode MJPEG streams */
 
-#ifdef __KERNEL__
-
-/* Minor device allocation */
-#define MINOR_VFL_TYPE_GRABBER_MIN   0
-#define MINOR_VFL_TYPE_GRABBER_MAX  63
-#define MINOR_VFL_TYPE_RADIO_MIN    64
-#define MINOR_VFL_TYPE_RADIO_MAX   127
-#define MINOR_VFL_TYPE_VTX_MIN     192
-#define MINOR_VFL_TYPE_VTX_MAX     223
-#define MINOR_VFL_TYPE_VBI_MIN     224
-#define MINOR_VFL_TYPE_VBI_MAX     255
-
-#define VFL_TYPE_GRABBER       0
-#define VFL_TYPE_VBI           1
-#define VFL_TYPE_RADIO         2
-#define VFL_TYPE_VTX           3
-
-struct video_device
-{
-       /* device info */
-       struct device *dev;
-       char name[32];
-       int type;       /* v4l1 */
-       int type2;      /* v4l2 */
-       int hardware;
-       int minor;
-
-       /* device ops + callbacks */
-       const struct file_operations *fops;
-       void (*release)(struct video_device *vfd);
-
-
-#if OBSOLETE_OWNER /* to be removed in 2.6.15 */
-       /* obsolete -- fops->owner is used instead */
-       struct module *owner;
-       /* dev->driver_data will be used instead some day.
-        * Use the video_{get|set}_drvdata() helper functions,
-        * so the switch over will be transparent for you.
-        * Or use {pci|usb}_{get|set}_drvdata() directly. */
-       void *priv;
-#endif
-
-       /* for videodev.c intenal usage -- please don't touch */
-       int users;                     /* video_exclusive_{open|close} ... */
-       struct mutex lock;             /* ... helper function uses these   */
-       char devfs_name[64];           /* devfs */
-       struct class_device class_dev; /* sysfs */
-};
-
-#define VIDEO_MAJOR    81
-
-extern int video_register_device(struct video_device *, int type, int nr);
-extern void video_unregister_device(struct video_device *);
-extern int video_usercopy(struct inode *inode, struct file *file,
-                         unsigned int cmd, unsigned long arg,
-                         int (*func)(struct inode *inode, struct file *file,
-                                     unsigned int cmd, void *arg));
-
-/* helper functions to alloc / release struct video_device, the
-   later can be used for video_device->release() */
-struct video_device *video_device_alloc(void);
-void video_device_release(struct video_device *vfd);
-
-#endif
-
 /*
  *     M I S C E L L A N E O U S
  */
@@ -1098,6 +1027,7 @@ struct v4l2_streamparm
 #endif
 #define VIDIOC_LOG_STATUS       _IO   ('V', 70)
 
+#ifdef __OLD_VIDIOC_
 /* for compatibility, will go away some day */
 #define VIDIOC_OVERLAY_OLD             _IOWR ('V', 14, int)
 #define VIDIOC_S_PARM_OLD              _IOW  ('V', 22, struct v4l2_streamparm)
@@ -1105,57 +1035,10 @@ struct v4l2_streamparm
 #define VIDIOC_G_AUDIO_OLD             _IOWR ('V', 33, struct v4l2_audio)
 #define VIDIOC_G_AUDOUT_OLD            _IOWR ('V', 49, struct v4l2_audioout)
 #define VIDIOC_CROPCAP_OLD             _IOR  ('V', 58, struct v4l2_cropcap)
-
-#define BASE_VIDIOC_PRIVATE    192             /* 192-255 are private */
-
-
-#ifdef __KERNEL__
-/*
- *
- *     V 4 L 2   D R I V E R   H E L P E R   A P I
- *
- *     Some commonly needed functions for drivers (v4l2-common.o module)
- */
-#include <linux/fs.h>
-
-/*  Video standard functions  */
-extern unsigned int v4l2_video_std_fps(struct v4l2_standard *vs);
-extern int v4l2_video_std_construct(struct v4l2_standard *vs,
-                                   int id, char *name);
-
-/* prority handling */
-struct v4l2_prio_state {
-       atomic_t prios[4];
-};
-int v4l2_prio_init(struct v4l2_prio_state *global);
-int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
-                    enum v4l2_priority new);
-int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local);
-int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local);
-enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global);
-int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local);
-
-/* names for fancy debug output */
-extern char *v4l2_field_names[];
-extern char *v4l2_type_names[];
-
-/*  Compatibility layer interface  --  v4l1-compat module */
-typedef int (*v4l2_kioctl)(struct inode *inode, struct file *file,
-                          unsigned int cmd, void *arg);
-
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-int v4l_compat_translate_ioctl(struct inode *inode, struct file *file,
-                              int cmd, void *arg, v4l2_kioctl driver_ioctl);
-#else
-#define v4l_compat_translate_ioctl(inode,file,cmd,arg,ioctl) -EINVAL
 #endif
 
-/* 32 Bits compatibility layer for 64 bits processors */
-extern long v4l_compat_ioctl32(struct file *file, unsigned int cmd,
-                               unsigned long arg);
-
+#define BASE_VIDIOC_PRIVATE    192             /* 192-255 are private */
 
-#endif /* __KERNEL__ */
 #endif /* __LINUX_VIDEODEV2_H */
 
 /*
index e94aff0..1440d4a 100644 (file)
 #ifndef V4L2_COMMON_H_
 #define V4L2_COMMON_H_
 
+#include <media/v4l2-dev.h>
+
 /* v4l debugging and diagnostics */
 
+/* Debug bitmask flags to be used on V4L2 */
+#define V4L2_DEBUG_IOCTL     0x01
+#define V4L2_DEBUG_IOCTL_ARG 0x02
+
 /* Common printk constucts for v4l-i2c drivers. These macros create a unique
    prefix consisting of the driver name, the adapter number and the i2c
    address. */
diff --git a/include/media/v4l2-dev.h b/include/media/v4l2-dev.h
new file mode 100644 (file)
index 0000000..c2f54d2
--- /dev/null
@@ -0,0 +1,371 @@
+/*
+ *
+ *     V 4 L 2   D R I V E R   H E L P E R   A P I
+ *
+ * Moved from videodev2.h
+ *
+ *     Some commonly needed functions for drivers (v4l2-common.o module)
+ */
+#ifndef _V4L2_DEV_H
+#define _V4L2_DEV_H
+
+#define OBSOLETE_OWNER 1 /* to be removed soon */
+
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/mutex.h>
+#include <linux/compiler.h> /* need __user */
+#ifdef CONFIG_VIDEO_V4L1
+#include <linux/videodev.h>
+#else
+#include <linux/videodev2.h>
+#endif
+
+#include <linux/fs.h>
+
+#define VIDEO_MAJOR    81
+/* Minor device allocation */
+#define MINOR_VFL_TYPE_GRABBER_MIN   0
+#define MINOR_VFL_TYPE_GRABBER_MAX  63
+#define MINOR_VFL_TYPE_RADIO_MIN    64
+#define MINOR_VFL_TYPE_RADIO_MAX   127
+#define MINOR_VFL_TYPE_VTX_MIN     192
+#define MINOR_VFL_TYPE_VTX_MAX     223
+#define MINOR_VFL_TYPE_VBI_MIN     224
+#define MINOR_VFL_TYPE_VBI_MAX     255
+
+#define VFL_TYPE_GRABBER       0
+#define VFL_TYPE_VBI           1
+#define VFL_TYPE_RADIO         2
+#define VFL_TYPE_VTX           3
+
+       const struct file_operations *fops;
+
+/*  Video standard functions  */
+extern unsigned int v4l2_video_std_fps(struct v4l2_standard *vs);
+extern int v4l2_video_std_construct(struct v4l2_standard *vs,
+                                   int id, char *name);
+
+/* prority handling */
+struct v4l2_prio_state {
+       atomic_t prios[4];
+};
+int v4l2_prio_init(struct v4l2_prio_state *global);
+int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
+                    enum v4l2_priority new);
+int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local);
+int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local);
+enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global);
+int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local);
+
+/* names for fancy debug output */
+extern char *v4l2_field_names[];
+extern char *v4l2_type_names[];
+
+/*  Compatibility layer interface  --  v4l1-compat module */
+typedef int (*v4l2_kioctl)(struct inode *inode, struct file *file,
+                          unsigned int cmd, void *arg);
+#ifdef CONFIG_VIDEO_V4L1_COMPAT
+int v4l_compat_translate_ioctl(struct inode *inode, struct file *file,
+                              int cmd, void *arg, v4l2_kioctl driver_ioctl);
+#else
+#define v4l_compat_translate_ioctl(inode,file,cmd,arg,ioctl) -EINVAL
+#endif
+
+/* 32 Bits compatibility layer for 64 bits processors */
+extern long v4l_compat_ioctl32(struct file *file, unsigned int cmd,
+                               unsigned long arg);
+
+/*
+ * Newer version of video_device, handled by videodev2.c
+ *     This version moves redundant code from video device code to
+ *     the common handler
+ */
+struct v4l2_tvnorm {
+       char          *name;
+       v4l2_std_id   id;
+
+       void          *priv_data;
+};
+
+struct video_device
+{
+       /* device ops */
+       struct file_operations *fops;
+
+       /* device info */
+       struct device *dev;
+       char name[32];
+       int type;       /* v4l1 */
+       int type2;      /* v4l2 */
+       int hardware;
+       int minor;
+
+       int debug;      /* Activates debug level*/
+
+       /* Video standard vars */
+       int tvnormsize; /* Size of tvnorm array */
+       v4l2_std_id current_norm; /* Current tvnorm */
+       struct v4l2_tvnorm *tvnorms;
+
+       /* callbacks */
+       void (*release)(struct video_device *vfd);
+
+       /* ioctl callbacks */
+
+       /* VIDIOC_QUERYCAP handler */
+       int (*vidioc_querycap)(struct file *file, void *fh, struct v4l2_capability *cap);
+
+       /* Priority handling */
+       int (*vidioc_g_priority)   (struct file *file, void *fh,
+                                   enum v4l2_priority *p);
+       int (*vidioc_s_priority)   (struct file *file, void *fh,
+                                   enum v4l2_priority p);
+
+       /* VIDIOC_ENUM_FMT handlers */
+       int (*vidioc_enum_fmt_cap)         (struct file *file, void *fh,
+                                           struct v4l2_fmtdesc *f);
+       int (*vidioc_enum_fmt_overlay)     (struct file *file, void *fh,
+                                           struct v4l2_fmtdesc *f);
+       int (*vidioc_enum_fmt_vbi)         (struct file *file, void *fh,
+                                           struct v4l2_fmtdesc *f);
+       int (*vidioc_enum_fmt_vbi_capture) (struct file *file, void *fh,
+                                           struct v4l2_fmtdesc *f);
+       int (*vidioc_enum_fmt_video_output)(struct file *file, void *fh,
+                                           struct v4l2_fmtdesc *f);
+       int (*vidioc_enum_fmt_vbi_output)  (struct file *file, void *fh,
+                                           struct v4l2_fmtdesc *f);
+       int (*vidioc_enum_fmt_type_private)(struct file *file, void *fh,
+                                           struct v4l2_fmtdesc *f);
+
+       /* VIDIOC_G_FMT handlers */
+       int (*vidioc_g_fmt_cap)        (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_g_fmt_overlay)    (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_g_fmt_vbi)        (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_g_fmt_vbi_output) (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_g_fmt_vbi_capture)(struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_g_fmt_video_output)(struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_g_fmt_type_private)(struct file *file, void *fh,
+                                       struct v4l2_format *f);
+
+       /* VIDIOC_S_FMT handlers */
+       int (*vidioc_s_fmt_cap)        (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+
+       int (*vidioc_s_fmt_overlay)    (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_s_fmt_vbi)        (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_s_fmt_vbi_output) (struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_s_fmt_vbi_capture)(struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_s_fmt_video_output)(struct file *file, void *fh,
+                                       struct v4l2_format *f);
+       int (*vidioc_s_fmt_type_private)(struct file *file, void *fh,
+                                       struct v4l2_format *f);
+
+       /* VIDIOC_TRY_FMT handlers */
+       int (*vidioc_try_fmt_cap)        (struct file *file, void *fh,
+                                         struct v4l2_format *f);
+       int (*vidioc_try_fmt_overlay)    (struct file *file, void *fh,
+                                         struct v4l2_format *f);
+       int (*vidioc_try_fmt_vbi)        (struct file *file, void *fh,
+                                         struct v4l2_format *f);
+       int (*vidioc_try_fmt_vbi_output) (struct file *file, void *fh,
+                                         struct v4l2_format *f);
+       int (*vidioc_try_fmt_vbi_capture)(struct file *file, void *fh,
+                                         struct v4l2_format *f);
+       int (*vidioc_try_fmt_video_output)(struct file *file, void *fh,
+                                         struct v4l2_format *f);
+       int (*vidioc_try_fmt_type_private)(struct file *file, void *fh,
+                                         struct v4l2_format *f);
+
+       /* Buffer handlers */
+       int (*vidioc_reqbufs) (struct file *file, void *fh, struct v4l2_requestbuffers *b);
+       int (*vidioc_querybuf)(struct file *file, void *fh, struct v4l2_buffer *b);
+       int (*vidioc_qbuf)    (struct file *file, void *fh, struct v4l2_buffer *b);
+       int (*vidioc_dqbuf)   (struct file *file, void *fh, struct v4l2_buffer *b);
+
+
+       int (*vidioc_overlay) (struct file *file, void *fh, unsigned int i);
+#ifdef HAVE_V4L1
+                       /* buffer type is struct vidio_mbuf * */
+       int (*vidiocgmbuf)  (struct file *file, void *fh, struct video_mbuf *p);
+#endif
+       int (*vidioc_g_fbuf)   (struct file *file, void *fh,
+                               struct v4l2_framebuffer *a);
+       int (*vidioc_s_fbuf)   (struct file *file, void *fh,
+                               struct v4l2_framebuffer *a);
+
+               /* Stream on/off */
+       int (*vidioc_streamon) (struct file *file, void *fh, enum v4l2_buf_type i);
+       int (*vidioc_streamoff)(struct file *file, void *fh, enum v4l2_buf_type i);
+
+               /* Standard handling
+                       G_STD and ENUMSTD are handled by videodev.c
+                */
+       int (*vidioc_s_std)    (struct file *file, void *fh, v4l2_std_id a);
+       int (*vidioc_querystd) (struct file *file, void *fh, v4l2_std_id *a);
+
+               /* Input handling */
+       int (*vidioc_enum_input)(struct file *file, void *fh,
+                                struct v4l2_input *inp);
+       int (*vidioc_g_input)   (struct file *file, void *fh, unsigned int *i);
+       int (*vidioc_s_input)   (struct file *file, void *fh, unsigned int i);
+
+               /* Output handling */
+       int (*vidioc_enumoutput) (struct file *file, void *fh,
+                                 struct v4l2_output *a);
+       int (*vidioc_g_output)   (struct file *file, void *fh, unsigned int *i);
+       int (*vidioc_s_output)   (struct file *file, void *fh, unsigned int i);
+
+               /* Control handling */
+       int (*vidioc_queryctrl)        (struct file *file, void *fh,
+                                       struct v4l2_queryctrl *a);
+       int (*vidioc_g_ctrl)           (struct file *file, void *fh,
+                                       struct v4l2_control *a);
+       int (*vidioc_s_ctrl)           (struct file *file, void *fh,
+                                       struct v4l2_control *a);
+       int (*vidioc_querymenu)        (struct file *file, void *fh,
+                                       struct v4l2_querymenu *a);
+
+       /* Audio ioctls */
+       int (*vidioc_enumaudio)        (struct file *file, void *fh,
+                                       struct v4l2_audio *a);
+       int (*vidioc_g_audio)          (struct file *file, void *fh,
+                                       struct v4l2_audio *a);
+       int (*vidioc_s_audio)          (struct file *file, void *fh,
+                                       struct v4l2_audio *a);
+
+       /* Audio out ioctls */
+       int (*vidioc_enumaudout)       (struct file *file, void *fh,
+                                       struct v4l2_audioout *a);
+       int (*vidioc_g_audout)         (struct file *file, void *fh,
+                                       struct v4l2_audioout *a);
+       int (*vidioc_s_audout)         (struct file *file, void *fh,
+                                       struct v4l2_audioout *a);
+       int (*vidioc_g_modulator)      (struct file *file, void *fh,
+                                       struct v4l2_modulator *a);
+       int (*vidioc_s_modulator)      (struct file *file, void *fh,
+                                       struct v4l2_modulator *a);
+       /* Crop ioctls */
+       int (*vidioc_cropcap)          (struct file *file, void *fh,
+                                       struct v4l2_cropcap *a);
+       int (*vidioc_g_crop)           (struct file *file, void *fh,
+                                       struct v4l2_crop *a);
+       int (*vidioc_s_crop)           (struct file *file, void *fh,
+                                       struct v4l2_crop *a);
+       /* Compression ioctls */
+       int (*vidioc_g_mpegcomp)       (struct file *file, void *fh,
+                                       struct v4l2_mpeg_compression *a);
+       int (*vidioc_s_mpegcomp)       (struct file *file, void *fh,
+                                       struct v4l2_mpeg_compression *a);
+       int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
+                                       struct v4l2_jpegcompression *a);
+       int (*vidioc_s_jpegcomp)       (struct file *file, void *fh,
+                                       struct v4l2_jpegcompression *a);
+
+       /* Stream type-dependent parameter ioctls */
+       int (*vidioc_g_parm)           (struct file *file, void *fh,
+                                       struct v4l2_streamparm *a);
+       int (*vidioc_s_parm)           (struct file *file, void *fh,
+                                       struct v4l2_streamparm *a);
+
+       /* Tuner ioctls */
+       int (*vidioc_g_tuner)          (struct file *file, void *fh,
+                                       struct v4l2_tuner *a);
+       int (*vidioc_s_tuner)          (struct file *file, void *fh,
+                                       struct v4l2_tuner *a);
+       int (*vidioc_g_frequency)      (struct file *file, void *fh,
+                                       struct v4l2_frequency *a);
+       int (*vidioc_s_frequency)      (struct file *file, void *fh,
+                                       struct v4l2_frequency *a);
+
+       /* Sliced VBI cap */
+       int (*vidioc_g_sliced_vbi_cap) (struct file *file, void *fh,
+                                       struct v4l2_sliced_vbi_cap *a);
+
+       /* Log status ioctl */
+       int (*vidioc_log_status)       (struct file *file, void *fh);
+
+
+#if OBSOLETE_OWNER /* to be removed soon */
+/* obsolete -- fops->owner is used instead */
+struct module *owner;
+/* dev->driver_data will be used instead some day.
+       * Use the video_{get|set}_drvdata() helper functions,
+       * so the switch over will be transparent for you.
+       * Or use {pci|usb}_{get|set}_drvdata() directly. */
+void *priv;
+#endif
+
+       /* for videodev.c intenal usage -- please don't touch */
+       int users;                     /* video_exclusive_{open|close} ... */
+       struct mutex lock;             /* ... helper function uses these   */
+       char devfs_name[64];           /* devfs */
+       struct class_device class_dev; /* sysfs */
+};
+
+/* Version 2 functions */
+extern int video_register_device(struct video_device *vfd, int type, int nr);
+void video_unregister_device(struct video_device *);
+extern int video_ioctl2(struct inode *inode, struct file *file,
+                         unsigned int cmd, unsigned long arg);
+
+/* helper functions to alloc / release struct video_device, the
+   later can be used for video_device->release() */
+struct video_device *video_device_alloc(void);
+void video_device_release(struct video_device *vfd);
+
+/* Include support for obsoleted stuff */
+extern int video_usercopy(struct inode *inode, struct file *file,
+                         unsigned int cmd, unsigned long arg,
+                         int (*func)(struct inode *inode, struct file *file,
+                                     unsigned int cmd, void *arg));
+
+
+#ifdef HAVE_V4L1
+#include <linux/mm.h>
+
+extern struct video_device* video_devdata(struct file*);
+
+#define to_video_device(cd) container_of(cd, struct video_device, class_dev)
+static inline void
+video_device_create_file(struct video_device *vfd,
+                        struct class_device_attribute *attr)
+{
+       class_device_create_file(&vfd->class_dev, attr);
+}
+static inline void
+video_device_remove_file(struct video_device *vfd,
+                        struct class_device_attribute *attr)
+{
+       class_device_remove_file(&vfd->class_dev, attr);
+}
+
+#if OBSOLETE_OWNER /* to be removed soon */
+/* helper functions to access driver private data. */
+static inline void *video_get_drvdata(struct video_device *dev)
+{
+       return dev->priv;
+}
+
+static inline void video_set_drvdata(struct video_device *dev, void *data)
+{
+       dev->priv = data;
+}
+#endif
+
+extern int video_exclusive_open(struct inode *inode, struct file *file);
+extern int video_exclusive_release(struct inode *inode, struct file *file);
+#endif /* HAVE_V4L1 */
+
+#endif /* _V4L2_DEV_H */
index fff3fd0..1115a25 100644 (file)
@@ -23,6 +23,7 @@
  */
 
 #include <linux/videodev2.h>
+#include <linux/poll.h>
 
 #define UNSET (-1U)