}
 }
 
-static int bttv_g_fmt_cap(struct file *file, void *priv,
+static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct bttv_fh *fh  = priv;
        return 0;
 }
 
-static int bttv_g_fmt_overlay(struct file *file, void *priv,
+static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct bttv_fh *fh  = priv;
        return 0;
 }
 
-static int bttv_try_fmt_cap(struct file *file, void *priv,
+static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
                                                struct v4l2_format *f)
 {
        const struct bttv_format *fmt;
        return 0;
 }
 
-static int bttv_try_fmt_overlay(struct file *file, void *priv,
+static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
                                                struct v4l2_format *f)
 {
        struct bttv_fh *fh = priv;
                        /* adjust_crop */ 0);
 }
 
-static int bttv_s_fmt_cap(struct file *file, void *priv,
+static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
                                struct v4l2_format *f)
 {
        int retval;
        if (0 != retval)
                return retval;
 
-       retval = bttv_try_fmt_cap(file, priv, f);
+       retval = bttv_try_fmt_vid_cap(file, priv, f);
        if (0 != retval)
                return retval;
 
        return 0;
 }
 
-static int bttv_s_fmt_overlay(struct file *file, void *priv,
+static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
                                struct v4l2_format *f)
 {
        struct bttv_fh *fh = priv;
        return 0;
 }
 
-static int bttv_enum_fmt_vbi(struct file *file, void  *priv,
+static int bttv_enum_fmt_vbi_cap(struct file *file, void  *priv,
                                struct v4l2_fmtdesc *f)
 {
        if (0 != f->index)
        return i;
 }
 
-static int bttv_enum_fmt_cap(struct file *file, void  *priv,
+static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
                                struct v4l2_fmtdesc *f)
 {
        int rc = bttv_enum_fmt_cap_ovr(f);
        return 0;
 }
 
-static int bttv_enum_fmt_overlay(struct file *file, void  *priv,
+static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        int rc;
        .fops     = &bttv_fops,
        .minor    = -1,
        .vidioc_querycap                = bttv_querycap,
-       .vidioc_enum_fmt_cap            = bttv_enum_fmt_cap,
-       .vidioc_g_fmt_cap               = bttv_g_fmt_cap,
-       .vidioc_try_fmt_cap             = bttv_try_fmt_cap,
-       .vidioc_s_fmt_cap               = bttv_s_fmt_cap,
-       .vidioc_enum_fmt_overlay        = bttv_enum_fmt_overlay,
-       .vidioc_g_fmt_overlay           = bttv_g_fmt_overlay,
-       .vidioc_try_fmt_overlay         = bttv_try_fmt_overlay,
-       .vidioc_s_fmt_overlay           = bttv_s_fmt_overlay,
-       .vidioc_enum_fmt_vbi            = bttv_enum_fmt_vbi,
-       .vidioc_g_fmt_vbi               = bttv_g_fmt_vbi,
-       .vidioc_try_fmt_vbi             = bttv_try_fmt_vbi,
-       .vidioc_s_fmt_vbi               = bttv_s_fmt_vbi,
+       .vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
+       .vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
+       .vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
+       .vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
+       .vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
+       .vidioc_enum_fmt_vbi_cap        = bttv_enum_fmt_vbi_cap,
+       .vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
+       .vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
+       .vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
        .vidioc_g_audio                 = bttv_g_audio,
        .vidioc_s_audio                 = bttv_s_audio,
        .vidioc_cropcap                 = bttv_cropcap,
 
        return 0;
 }
 
-int bttv_try_fmt_vbi(struct file *file, void *f, struct v4l2_format *frt)
+int bttv_try_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
 {
        struct bttv_fh *fh = f;
        struct bttv *btv = fh->btv;
 }
 
 
-int bttv_s_fmt_vbi(struct file *file, void *f, struct v4l2_format *frt)
+int bttv_s_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
 {
        struct bttv_fh *fh = f;
        struct bttv *btv = fh->btv;
 }
 
 
-int bttv_g_fmt_vbi(struct file *file, void *f, struct v4l2_format *frt)
+int bttv_g_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
 {
        struct bttv_fh *fh = f;
        const struct bttv_tvnorm *tvnorm;
 
 /* ---------------------------------------------------------- */
 /* bttv-vbi.c                                                 */
 
-int bttv_try_fmt_vbi(struct file *file, void *fh, struct v4l2_format *f);
-int bttv_g_fmt_vbi(struct file *file, void *fh, struct v4l2_format *f);
-int bttv_s_fmt_vbi(struct file *file, void *fh, struct v4l2_format *f);
+int bttv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f);
+int bttv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f);
+int bttv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f);
 
 extern struct videobuf_queue_ops bttv_vbi_qops;
 
 
        .sizeimage      = VGA_WIDTH*VGA_HEIGHT*2,
 };
 
-static int cafe_vidioc_enum_fmt_cap(struct file *filp,
+static int cafe_vidioc_enum_fmt_vid_cap(struct file *filp,
                void *priv, struct v4l2_fmtdesc *fmt)
 {
        struct cafe_camera *cam = priv;
 }
 
 
-static int cafe_vidioc_try_fmt_cap (struct file *filp, void *priv,
+static int cafe_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
                struct v4l2_format *fmt)
 {
        struct cafe_camera *cam = priv;
        return ret;
 }
 
-static int cafe_vidioc_s_fmt_cap(struct file *filp, void *priv,
+static int cafe_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
                struct v4l2_format *fmt)
 {
        struct cafe_camera *cam = priv;
        /*
         * See if the formatting works in principle.
         */
-       ret = cafe_vidioc_try_fmt_cap(filp, priv, fmt);
+       ret = cafe_vidioc_try_fmt_vid_cap(filp, priv, fmt);
        if (ret)
                return ret;
        /*
  * The V4l2 spec wants us to be smarter, and actually get this from
  * the camera (and not mess with it at open time).  Someday.
  */
-static int cafe_vidioc_g_fmt_cap(struct file *filp, void *priv,
+static int cafe_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
                struct v4l2_format *f)
 {
        struct cafe_camera *cam = priv;
        .release = cafe_v4l_dev_release,
 
        .vidioc_querycap        = cafe_vidioc_querycap,
-       .vidioc_enum_fmt_cap    = cafe_vidioc_enum_fmt_cap,
-       .vidioc_try_fmt_cap     = cafe_vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap       = cafe_vidioc_s_fmt_cap,
-       .vidioc_g_fmt_cap       = cafe_vidioc_g_fmt_cap,
+       .vidioc_enum_fmt_vid_cap = cafe_vidioc_enum_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap = cafe_vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap   = cafe_vidioc_s_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap   = cafe_vidioc_g_fmt_vid_cap,
        .vidioc_enum_input      = cafe_vidioc_enum_input,
        .vidioc_g_input         = cafe_vidioc_g_input,
        .vidioc_s_input         = cafe_vidioc_s_input,
 
 /* ------------------------------------------------------------------ */
 /* VIDEO IOCTLS                                                       */
 
-static int vidioc_g_fmt_cap(struct file *file, void *priv,
+static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
        struct v4l2_format *f)
 {
        struct cx23885_fh *fh   = priv;
        return 0;
 }
 
-static int vidioc_try_fmt_cap(struct file *file, void *priv,
+static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
        struct v4l2_format *f)
 {
        struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
        return 0;
 }
 
-static int vidioc_s_fmt_cap(struct file *file, void *priv,
+static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
        struct v4l2_format *f)
 {
        struct cx23885_fh *fh = priv;
        int err;
 
        dprintk(2, "%s()\n", __func__);
-       err = vidioc_try_fmt_cap(file, priv, f);
+       err = vidioc_try_fmt_vid_cap(file, priv, f);
 
        if (0 != err)
                return err;
        return 0;
 }
 
-static int vidioc_enum_fmt_cap(struct file *file, void  *priv,
+static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
        struct v4l2_fmtdesc *f)
 {
        if (unlikely(f->index >= ARRAY_SIZE(formats)))
        .fops                 = &video_fops,
        .minor                = -1,
        .vidioc_querycap      = vidioc_querycap,
-       .vidioc_enum_fmt_cap  = vidioc_enum_fmt_cap,
-       .vidioc_g_fmt_cap     = vidioc_g_fmt_cap,
-       .vidioc_try_fmt_cap   = vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap     = vidioc_s_fmt_cap,
-       .vidioc_g_fmt_vbi     = cx23885_vbi_fmt,
-       .vidioc_try_fmt_vbi   = cx23885_vbi_fmt,
-       .vidioc_s_fmt_vbi     = cx23885_vbi_fmt,
+       .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
+       .vidioc_g_fmt_vbi_cap     = cx23885_vbi_fmt,
+       .vidioc_try_fmt_vbi_cap   = cx23885_vbi_fmt,
+       .vidioc_s_fmt_vbi_cap     = cx23885_vbi_fmt,
        .vidioc_reqbufs       = vidioc_reqbufs,
        .vidioc_querybuf      = vidioc_querybuf,
        .vidioc_qbuf          = vidioc_qbuf,
 
        return 0;
 }
 
-static int vidioc_enum_fmt_cap (struct file *file, void  *priv,
+static int vidioc_enum_fmt_vid_cap (struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        if (f->index != 0)
        return 0;
 }
 
-static int vidioc_g_fmt_cap (struct file *file, void *priv,
+static int vidioc_g_fmt_vid_cap (struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct cx8802_fh  *fh   = priv;
        return 0;
 }
 
-static int vidioc_try_fmt_cap (struct file *file, void *priv,
+static int vidioc_try_fmt_vid_cap (struct file *file, void *priv,
                        struct v4l2_format *f)
 {
        struct cx8802_fh  *fh   = priv;
        return 0;
 }
 
-static int vidioc_s_fmt_cap (struct file *file, void *priv,
+static int vidioc_s_fmt_vid_cap (struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct cx8802_fh  *fh   = priv;
        .minor                = -1,
        .vidioc_querymenu     = vidioc_querymenu,
        .vidioc_querycap      = vidioc_querycap,
-       .vidioc_enum_fmt_cap  = vidioc_enum_fmt_cap,
-       .vidioc_g_fmt_cap     = vidioc_g_fmt_cap,
-       .vidioc_try_fmt_cap   = vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap     = vidioc_s_fmt_cap,
+       .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
        .vidioc_reqbufs       = vidioc_reqbufs,
        .vidioc_querybuf      = vidioc_querybuf,
        .vidioc_qbuf          = vidioc_qbuf,
 
 /* ------------------------------------------------------------------ */
 /* VIDEO IOCTLS                                                       */
 
-static int vidioc_g_fmt_cap (struct file *file, void *priv,
+static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct cx8800_fh  *fh   = priv;
        return 0;
 }
 
-static int vidioc_try_fmt_cap (struct file *file, void *priv,
+static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                        struct v4l2_format *f)
 {
        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
        return 0;
 }
 
-static int vidioc_s_fmt_cap (struct file *file, void *priv,
+static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct cx8800_fh  *fh   = priv;
-       int err = vidioc_try_fmt_cap (file,priv,f);
+       int err = vidioc_try_fmt_vid_cap (file,priv,f);
 
        if (0 != err)
                return err;
        return 0;
 }
 
-static int vidioc_enum_fmt_cap (struct file *file, void  *priv,
+static int vidioc_enum_fmt_vid_cap (struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        if (unlikely(f->index >= ARRAY_SIZE(formats)))
        .fops                 = &video_fops,
        .minor                = -1,
        .vidioc_querycap      = vidioc_querycap,
-       .vidioc_enum_fmt_cap  = vidioc_enum_fmt_cap,
-       .vidioc_g_fmt_cap     = vidioc_g_fmt_cap,
-       .vidioc_try_fmt_cap   = vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap     = vidioc_s_fmt_cap,
-       .vidioc_g_fmt_vbi     = cx8800_vbi_fmt,
-       .vidioc_try_fmt_vbi   = cx8800_vbi_fmt,
-       .vidioc_s_fmt_vbi     = cx8800_vbi_fmt,
+       .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
+       .vidioc_g_fmt_vbi_cap     = cx8800_vbi_fmt,
+       .vidioc_try_fmt_vbi_cap   = cx8800_vbi_fmt,
+       .vidioc_s_fmt_vbi_cap     = cx8800_vbi_fmt,
        .vidioc_reqbufs       = vidioc_reqbufs,
        .vidioc_querybuf      = vidioc_querybuf,
        .vidioc_qbuf          = vidioc_qbuf,
 
        IOCTL vidioc handling
    ------------------------------------------------------------------*/
 
-static int vidioc_g_fmt_cap(struct file *file, void *priv,
+static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct em28xx_fh      *fh  = priv;
        return 0;
 }
 
-static int vidioc_try_fmt_cap(struct file *file, void *priv,
+static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                        struct v4l2_format *f)
 {
        struct em28xx_fh      *fh    = priv;
        return 0;
 }
 
-static int vidioc_s_fmt_cap(struct file *file, void *priv,
+static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                        struct v4l2_format *f)
 {
        struct em28xx_fh      *fh  = priv;
        if (rc < 0)
                return rc;
 
-       vidioc_try_fmt_cap(file, priv, f);
+       vidioc_try_fmt_vid_cap(file, priv, f);
 
        mutex_lock(&dev->lock);
 
        /* Adjusts width/height, if needed */
        f.fmt.pix.width = dev->width;
        f.fmt.pix.height = dev->height;
-       vidioc_try_fmt_cap(file, priv, &f);
+       vidioc_try_fmt_vid_cap(file, priv, &f);
 
        mutex_lock(&dev->lock);
 
        return 0;
 }
 
-static int vidioc_enum_fmt_cap(struct file *file, void  *priv,
+static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *fmtd)
 {
        if (fmtd->index != 0)
 }
 
 /* Sliced VBI ioctls */
-static int vidioc_g_fmt_vbi_capture(struct file *file, void *priv,
+static int vidioc_g_fmt_sliced_vbi_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct em28xx_fh      *fh  = priv;
        return rc;
 }
 
-static int vidioc_try_set_vbi_capture(struct file *file, void *priv,
+static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv,
                        struct v4l2_format *f)
 {
        struct em28xx_fh      *fh  = priv;
 
        .minor                      = -1,
        .vidioc_querycap            = vidioc_querycap,
-       .vidioc_enum_fmt_cap        = vidioc_enum_fmt_cap,
-       .vidioc_g_fmt_cap           = vidioc_g_fmt_cap,
-       .vidioc_try_fmt_cap         = vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap           = vidioc_s_fmt_cap,
+       .vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
        .vidioc_g_audio             = vidioc_g_audio,
        .vidioc_s_audio             = vidioc_s_audio,
        .vidioc_cropcap             = vidioc_cropcap,
 
-       .vidioc_g_fmt_vbi_capture   = vidioc_g_fmt_vbi_capture,
-       .vidioc_try_fmt_vbi_capture = vidioc_try_set_vbi_capture,
-       .vidioc_s_fmt_vbi_capture   = vidioc_try_set_vbi_capture,
+       .vidioc_g_fmt_sliced_vbi_cap   = vidioc_g_fmt_sliced_vbi_cap,
+       .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
+       .vidioc_s_fmt_sliced_vbi_cap   = vidioc_try_set_sliced_vbi_cap,
 
        .vidioc_reqbufs             = vidioc_reqbufs,
        .vidioc_querybuf            = vidioc_querybuf,
 
        return 0;
 }
 
-static int vidioc_enum_fmt_cap(struct file *file, void *fh,
+static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
                                struct v4l2_fmtdesc *f)
 {
        if (f->index > 1)
        return 0;
 }
 
-static int vidioc_try_fmt_cap(struct file *file, void *fh,
+static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
                                struct v4l2_format *f)
 {
        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
        return 0;
 }
 
-static int vidioc_g_fmt_cap(struct file *file, void *fh, struct v4l2_format *f)
+static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
+                                   struct v4l2_format *f)
 {
        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
        return 0;
 }
 
-static int vidioc_s_fmt_cap(struct file *file, void *fh, struct v4l2_format *f)
+static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
+                                   struct v4l2_format *f)
 {
        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
        .vidioc_queryctrl       = vidioc_queryctrl,
        .vidioc_s_ctrl          = vidioc_s_ctrl,
        .vidioc_g_ctrl          = vidioc_g_ctrl,
-       .vidioc_enum_fmt_cap    = vidioc_enum_fmt_cap,
-       .vidioc_try_fmt_cap     = vidioc_try_fmt_cap,
-       .vidioc_g_fmt_cap       = vidioc_g_fmt_cap,
-       .vidioc_s_fmt_cap       = vidioc_s_fmt_cap,
+       .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
        .vidioc_reqbufs         = vidioc_reqbufs,
        .vidioc_querybuf        = vidioc_querybuf,
        .vidioc_qbuf            = vidioc_qbuf,
 
        return 0;
 }
 
-static int empress_enum_fmt_cap(struct file *file, void  *priv,
+static int empress_enum_fmt_vid_cap(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        if (f->index != 0)
        return 0;
 }
 
-static int empress_g_fmt_cap(struct file *file, void *priv,
+static int empress_g_fmt_vid_cap(struct file *file, void *priv,
                                struct v4l2_format *f)
 {
        struct saa7134_dev *dev = file->private_data;
        return 0;
 }
 
-static int empress_s_fmt_cap(struct file *file, void *priv,
+static int empress_s_fmt_vid_cap(struct file *file, void *priv,
                                struct v4l2_format *f)
 {
        struct saa7134_dev *dev = file->private_data;
        .minor         = -1,
 
        .vidioc_querycap                = empress_querycap,
-       .vidioc_enum_fmt_cap            = empress_enum_fmt_cap,
-       .vidioc_s_fmt_cap               = empress_s_fmt_cap,
-       .vidioc_g_fmt_cap               = empress_g_fmt_cap,
+       .vidioc_enum_fmt_vid_cap        = empress_enum_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap           = empress_s_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap           = empress_g_fmt_vid_cap,
        .vidioc_reqbufs                 = empress_reqbufs,
        .vidioc_querybuf                = empress_querybuf,
        .vidioc_qbuf                    = empress_qbuf,
 
 
 /* ------------------------------------------------------------------ */
 
-static int saa7134_try_get_set_fmt_vbi(struct file *file, void *priv,
+static int saa7134_try_get_set_fmt_vbi_cap(struct file *file, void *priv,
                                                struct v4l2_format *f)
 {
        struct saa7134_fh *fh = priv;
        return 0;
 }
 
-static int saa7134_g_fmt_cap(struct file *file, void *priv,
+static int saa7134_g_fmt_vid_cap(struct file *file, void *priv,
                                struct v4l2_format *f)
 {
        struct saa7134_fh *fh = priv;
        return 0;
 }
 
-static int saa7134_g_fmt_overlay(struct file *file, void *priv,
+static int saa7134_g_fmt_vid_overlay(struct file *file, void *priv,
                                struct v4l2_format *f)
 {
        struct saa7134_fh *fh = priv;
        return 0;
 }
 
-static int saa7134_try_fmt_cap(struct file *file, void *priv,
+static int saa7134_try_fmt_vid_cap(struct file *file, void *priv,
                                                struct v4l2_format *f)
 {
        struct saa7134_fh *fh = priv;
        return 0;
 }
 
-static int saa7134_try_fmt_overlay(struct file *file, void *priv,
+static int saa7134_try_fmt_vid_overlay(struct file *file, void *priv,
                                                struct v4l2_format *f)
 {
        struct saa7134_fh *fh = priv;
        return verify_preview(dev, &f->fmt.win);
 }
 
-static int saa7134_s_fmt_cap(struct file *file, void *priv,
+static int saa7134_s_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct saa7134_fh *fh = priv;
        int err;
 
-       err = saa7134_try_fmt_cap(file, priv, f);
+       err = saa7134_try_fmt_vid_cap(file, priv, f);
        if (0 != err)
                return err;
 
        return 0;
 }
 
-static int saa7134_s_fmt_overlay(struct file *file, void *priv,
+static int saa7134_s_fmt_vid_overlay(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct saa7134_fh *fh = priv;
        return v4l2_prio_change(&dev->prio, &fh->prio, prio);
 }
 
-static int saa7134_enum_fmt_cap(struct file *file, void  *priv,
+static int saa7134_enum_fmt_vid_cap(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        if (f->index >= FORMATS)
        return 0;
 }
 
-static int saa7134_enum_fmt_overlay(struct file *file, void  *priv,
+static int saa7134_enum_fmt_vid_overlay(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        if (saa7134_no_overlay > 0) {
        return 0;
 }
 
-static int saa7134_enum_fmt_vbi(struct file *file, void  *priv,
+static int saa7134_enum_fmt_vbi_cap(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        if (0 != f->index)
        .fops                           = &video_fops,
        .minor                          = -1,
        .vidioc_querycap                = saa7134_querycap,
-       .vidioc_enum_fmt_cap            = saa7134_enum_fmt_cap,
-       .vidioc_g_fmt_cap               = saa7134_g_fmt_cap,
-       .vidioc_try_fmt_cap             = saa7134_try_fmt_cap,
-       .vidioc_s_fmt_cap               = saa7134_s_fmt_cap,
-       .vidioc_enum_fmt_overlay        = saa7134_enum_fmt_overlay,
-       .vidioc_g_fmt_overlay           = saa7134_g_fmt_overlay,
-       .vidioc_try_fmt_overlay         = saa7134_try_fmt_overlay,
-       .vidioc_s_fmt_overlay           = saa7134_s_fmt_overlay,
-       .vidioc_enum_fmt_vbi            = saa7134_enum_fmt_vbi,
-       .vidioc_g_fmt_vbi               = saa7134_try_get_set_fmt_vbi,
-       .vidioc_try_fmt_vbi             = saa7134_try_get_set_fmt_vbi,
-       .vidioc_s_fmt_vbi               = saa7134_try_get_set_fmt_vbi,
+       .vidioc_enum_fmt_vid_cap        = saa7134_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap           = saa7134_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap         = saa7134_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap           = saa7134_s_fmt_vid_cap,
+       .vidioc_enum_fmt_vid_overlay    = saa7134_enum_fmt_vid_overlay,
+       .vidioc_g_fmt_vid_overlay       = saa7134_g_fmt_vid_overlay,
+       .vidioc_try_fmt_vid_overlay     = saa7134_try_fmt_vid_overlay,
+       .vidioc_s_fmt_vid_overlay       = saa7134_s_fmt_vid_overlay,
+       .vidioc_enum_fmt_vbi_cap        = saa7134_enum_fmt_vbi_cap,
+       .vidioc_g_fmt_vbi_cap           = saa7134_try_get_set_fmt_vbi_cap,
+       .vidioc_try_fmt_vbi_cap         = saa7134_try_get_set_fmt_vbi_cap,
+       .vidioc_s_fmt_vbi_cap           = saa7134_try_get_set_fmt_vbi_cap,
        .vidioc_g_audio                 = saa7134_g_audio,
        .vidioc_s_audio                 = saa7134_s_audio,
        .vidioc_cropcap                 = saa7134_cropcap,
 
 }
 
 
-static int stk_vidioc_enum_fmt_cap(struct file *filp,
+static int stk_vidioc_enum_fmt_vid_cap(struct file *filp,
                void *priv, struct v4l2_fmtdesc *fmtd)
 {
        fmtd->flags = 0;
        { .w = 176,  .h = 144,  .m = MODE_QCIF, },
 };
 
-static int stk_vidioc_g_fmt_cap(struct file *filp,
+static int stk_vidioc_g_fmt_vid_cap(struct file *filp,
                void *priv, struct v4l2_format *f)
 {
        struct v4l2_pix_format *pix_format = &f->fmt.pix;
        return 0;
 }
 
-static int stk_vidioc_try_fmt_cap(struct file *filp,
+static int stk_vidioc_try_fmt_vid_cap(struct file *filp,
                void *priv, struct v4l2_format *fmtd)
 {
        int i;
        return stk_sensor_configure(dev);
 }
 
-static int stk_vidioc_s_fmt_cap(struct file *filp,
+static int stk_vidioc_s_fmt_vid_cap(struct file *filp,
                void *priv, struct v4l2_format *fmtd)
 {
        int ret;
                return -EBUSY;
        if (dev->owner && dev->owner != filp)
                return -EBUSY;
-       ret = stk_vidioc_try_fmt_cap(filp, priv, fmtd);
+       ret = stk_vidioc_try_fmt_vid_cap(filp, priv, fmtd);
        if (ret)
                return ret;
        dev->owner = filp;
        .release = stk_v4l_dev_release,
 
        .vidioc_querycap = stk_vidioc_querycap,
-       .vidioc_enum_fmt_cap = stk_vidioc_enum_fmt_cap,
-       .vidioc_try_fmt_cap = stk_vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap = stk_vidioc_s_fmt_cap,
-       .vidioc_g_fmt_cap = stk_vidioc_g_fmt_cap,
+       .vidioc_enum_fmt_vid_cap = stk_vidioc_enum_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap = stk_vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap = stk_vidioc_s_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap = stk_vidioc_g_fmt_vid_cap,
        .vidioc_enum_input = stk_vidioc_enum_input,
        .vidioc_s_input = stk_vidioc_s_input,
        .vidioc_g_input = stk_vidioc_g_input,
 
        return 0;
 }
 
-static int vidioc_enum_fmt_cap (struct file *file, void  *priv,
+static int vidioc_enum_fmt_vid_cap (struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *vfd)
 {
        if(vfd->index>=USBVISION_SUPPORTED_PALETTES-1) {
        return 0;
 }
 
-static int vidioc_g_fmt_cap (struct file *file, void *priv,
+static int vidioc_g_fmt_vid_cap (struct file *file, void *priv,
                                        struct v4l2_format *vf)
 {
        struct video_device *dev = video_devdata(file);
        return 0;
 }
 
-static int vidioc_try_fmt_cap (struct file *file, void *priv,
+static int vidioc_try_fmt_vid_cap (struct file *file, void *priv,
                               struct v4l2_format *vf)
 {
        struct video_device *dev = video_devdata(file);
        return 0;
 }
 
-static int vidioc_s_fmt_cap(struct file *file, void *priv,
+static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                               struct v4l2_format *vf)
 {
        struct video_device *dev = video_devdata(file);
                (struct usb_usbvision *) video_get_drvdata(dev);
        int ret;
 
-       if( 0 != (ret=vidioc_try_fmt_cap (file, priv, vf)) ) {
+       if( 0 != (ret=vidioc_try_fmt_vid_cap (file, priv, vf)) ) {
                return ret;
        }
 
        .release        = video_device_release,
        .minor          = -1,
        .vidioc_querycap      = vidioc_querycap,
-       .vidioc_enum_fmt_cap  = vidioc_enum_fmt_cap,
-       .vidioc_g_fmt_cap     = vidioc_g_fmt_cap,
-       .vidioc_try_fmt_cap   = vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap     = vidioc_s_fmt_cap,
+       .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
        .vidioc_reqbufs       = vidioc_reqbufs,
        .vidioc_querybuf      = vidioc_querybuf,
        .vidioc_qbuf          = vidioc_qbuf,
 
 {
        switch (type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-               if (vfd->vidioc_try_fmt_cap)
+               if (vfd->vidioc_try_fmt_vid_cap)
                        return (0);
                break;
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
-               if (vfd->vidioc_try_fmt_overlay)
+               if (vfd->vidioc_try_fmt_vid_overlay)
                        return (0);
                break;
-       case V4L2_BUF_TYPE_VBI_CAPTURE:
-               if (vfd->vidioc_try_fmt_vbi)
+       case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+               if (vfd->vidioc_try_fmt_vid_out)
                        return (0);
                break;
-       case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
-               if (vfd->vidioc_try_fmt_vbi_output)
+       case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
+               if (vfd->vidioc_try_fmt_vid_out_overlay)
                        return (0);
                break;
-       case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
-               if (vfd->vidioc_try_fmt_vbi_capture)
+       case V4L2_BUF_TYPE_VBI_CAPTURE:
+               if (vfd->vidioc_try_fmt_vbi_cap)
                        return (0);
                break;
-       case V4L2_BUF_TYPE_VIDEO_OUTPUT:
-               if (vfd->vidioc_try_fmt_video_output)
+       case V4L2_BUF_TYPE_VBI_OUTPUT:
+               if (vfd->vidioc_try_fmt_vbi_out)
                        return (0);
                break;
-       case V4L2_BUF_TYPE_VBI_OUTPUT:
-               if (vfd->vidioc_try_fmt_vbi_output)
+       case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+               if (vfd->vidioc_try_fmt_sliced_vbi_cap)
                        return (0);
                break;
-       case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
-               if (vfd->vidioc_try_fmt_output_overlay)
+       case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+               if (vfd->vidioc_try_fmt_sliced_vbi_out)
                        return (0);
                break;
        case V4L2_BUF_TYPE_PRIVATE:
 
                switch (type) {
                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-                       if (vfd->vidioc_enum_fmt_cap)
-                               ret=vfd->vidioc_enum_fmt_cap(file, fh, f);
+                       if (vfd->vidioc_enum_fmt_vid_cap)
+                               ret = vfd->vidioc_enum_fmt_vid_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);
+                       if (vfd->vidioc_enum_fmt_vid_overlay)
+                               ret = vfd->vidioc_enum_fmt_vid_overlay(file,
+                                       fh, f);
                        break;
+#if 1
+               /* V4L2_BUF_TYPE_VBI_CAPTURE should not support VIDIOC_ENUM_FMT
+                * according to the spec. The bttv and saa7134 drivers support
+                * it though, so just warn that this is deprecated and will be
+                * removed in the near future. */
                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_sliced_vbi_output)
-                               ret = vfd->vidioc_enum_fmt_sliced_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);
+                       if (vfd->vidioc_enum_fmt_vbi_cap) {
+                               printk(KERN_WARNING "vidioc_enum_fmt_vbi_cap will be removed in 2.6.28!\n");
+                               ret = vfd->vidioc_enum_fmt_vbi_cap(file, fh, f);
+                       }
                        break;
+#endif
                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_VIDEO_OUTPUT_OVERLAY:
-                       if (vfd->vidioc_enum_fmt_output_overlay)
-                               ret=vfd->vidioc_enum_fmt_output_overlay(file, fh, f);
+                       if (vfd->vidioc_enum_fmt_vid_out)
+                               ret = vfd->vidioc_enum_fmt_vid_out(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_PRIVATE:
                        if (vfd->vidioc_enum_fmt_type_private)
-                               ret=vfd->vidioc_enum_fmt_type_private(file,
+                               ret = vfd->vidioc_enum_fmt_type_private(file,
                                                                fh, f);
                        break;
+               default:
+                       break;
                }
                if (!ret)
                        dbgarg (cmd, "index=%d, type=%d, flags=%d, "
 
                switch (f->type) {
                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-                       if (vfd->vidioc_g_fmt_cap)
-                               ret=vfd->vidioc_g_fmt_cap(file, fh, f);
+                       if (vfd->vidioc_g_fmt_vid_cap)
+                               ret = vfd->vidioc_g_fmt_vid_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_sliced_vbi_output)
-                               ret = vfd->vidioc_g_fmt_sliced_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);
+                       if (vfd->vidioc_g_fmt_vid_overlay)
+                               ret = vfd->vidioc_g_fmt_vid_overlay(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);
+                       if (vfd->vidioc_g_fmt_vid_out)
+                               ret = vfd->vidioc_g_fmt_vid_out(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
-                       if (vfd->vidioc_g_fmt_output_overlay)
-                               ret=vfd->vidioc_g_fmt_output_overlay(file, fh, f);
+                       if (vfd->vidioc_g_fmt_vid_out_overlay)
+                               ret = vfd->vidioc_g_fmt_vid_out_overlay(file,
+                                      fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       if (vfd->vidioc_g_fmt_vbi_cap)
+                               ret = vfd->vidioc_g_fmt_vbi_cap(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);
+                       if (vfd->vidioc_g_fmt_vbi_out)
+                               ret = vfd->vidioc_g_fmt_vbi_out(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       if (vfd->vidioc_g_fmt_sliced_vbi_cap)
+                               ret = vfd->vidioc_g_fmt_sliced_vbi_cap(file,
+                                                                       fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       if (vfd->vidioc_g_fmt_sliced_vbi_out)
+                               ret = vfd->vidioc_g_fmt_sliced_vbi_out(file,
+                                                                       fh, f);
                        break;
                case V4L2_BUF_TYPE_PRIVATE:
                        if (vfd->vidioc_g_fmt_type_private)
-                               ret=vfd->vidioc_g_fmt_type_private(file,
+                               ret = vfd->vidioc_g_fmt_type_private(file,
                                                                fh, f);
                        break;
                }
                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);
+                       if (vfd->vidioc_s_fmt_vid_cap)
+                               ret = vfd->vidioc_s_fmt_vid_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_sliced_vbi_output)
-                               ret = vfd->vidioc_s_fmt_sliced_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);
+                       if (vfd->vidioc_s_fmt_vid_overlay)
+                               ret = vfd->vidioc_s_fmt_vid_overlay(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);
+                       if (vfd->vidioc_s_fmt_vid_out)
+                               ret = vfd->vidioc_s_fmt_vid_out(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
-                       if (vfd->vidioc_s_fmt_output_overlay)
-                               ret=vfd->vidioc_s_fmt_output_overlay(file, fh, f);
+                       if (vfd->vidioc_s_fmt_vid_out_overlay)
+                               ret = vfd->vidioc_s_fmt_vid_out_overlay(file,
+                                       fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       if (vfd->vidioc_s_fmt_vbi_cap)
+                               ret = vfd->vidioc_s_fmt_vbi_cap(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);
+                       if (vfd->vidioc_s_fmt_vbi_out)
+                               ret = vfd->vidioc_s_fmt_vbi_out(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       if (vfd->vidioc_s_fmt_sliced_vbi_cap)
+                               ret = vfd->vidioc_s_fmt_sliced_vbi_cap(file,
+                                                                       fh, f);
+                       break;
+               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       if (vfd->vidioc_s_fmt_sliced_vbi_out)
+                               ret = vfd->vidioc_s_fmt_sliced_vbi_out(file,
+                                                                       fh, f);
                        break;
                case V4L2_BUF_TYPE_PRIVATE:
                        if (vfd->vidioc_s_fmt_type_private)
-                               ret=vfd->vidioc_s_fmt_type_private(file,
+                               ret = vfd->vidioc_s_fmt_type_private(file,
                                                                fh, f);
                        break;
                }
                                                v4l2_type_names));
                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 (vfd->vidioc_try_fmt_vid_cap)
+                               ret = vfd->vidioc_try_fmt_vid_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);
+                       if (vfd->vidioc_try_fmt_vid_overlay)
+                               ret = vfd->vidioc_try_fmt_vid_overlay(file,
+                                       fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                       if (vfd->vidioc_try_fmt_vid_out)
+                               ret = vfd->vidioc_try_fmt_vid_out(file, fh, f);
+                       break;
+               case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
+                       if (vfd->vidioc_try_fmt_vid_out_overlay)
+                               ret = vfd->vidioc_try_fmt_vid_out_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);
+                       if (vfd->vidioc_try_fmt_vbi_cap)
+                               ret = vfd->vidioc_try_fmt_vbi_cap(file, fh, f);
                        break;
-               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
-                       if (vfd->vidioc_try_fmt_sliced_vbi_output)
-                               ret = vfd->vidioc_try_fmt_sliced_vbi_output(file,
-                                                               fh, f);
+               case V4L2_BUF_TYPE_VBI_OUTPUT:
+                       if (vfd->vidioc_try_fmt_vbi_out)
+                               ret = vfd->vidioc_try_fmt_vbi_out(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,
+                       if (vfd->vidioc_try_fmt_sliced_vbi_cap)
+                               ret = vfd->vidioc_try_fmt_sliced_vbi_cap(file,
                                                                fh, f);
                        break;
-               case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
-                       if (vfd->vidioc_try_fmt_output_overlay)
-                               ret=vfd->vidioc_try_fmt_output_overlay(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,
+               case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       if (vfd->vidioc_try_fmt_sliced_vbi_out)
+                               ret = vfd->vidioc_try_fmt_sliced_vbi_out(file,
                                                                fh, f);
                        break;
                case V4L2_BUF_TYPE_PRIVATE:
                        if (vfd->vidioc_try_fmt_type_private)
-                               ret=vfd->vidioc_try_fmt_type_private(file,
+                               ret = vfd->vidioc_try_fmt_type_private(file,
                                                                fh, f);
                        break;
                }
 
        return 0;
 }
 
-static int vidioc_enum_fmt_cap(struct file *file, void  *priv,
+static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        if (f->index > 0)
        return 0;
 }
 
-static int vidioc_g_fmt_cap(struct file *file, void *priv,
+static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct vivi_fh *fh = priv;
        return (0);
 }
 
-static int vidioc_try_fmt_cap(struct file *file, void *priv,
+static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                        struct v4l2_format *f)
 {
        struct vivi_fh  *fh  = priv;
 }
 
 /*FIXME: This seems to be generic enough to be at videodev2 */
-static int vidioc_s_fmt_cap(struct file *file, void *priv,
+static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct vivi_fh  *fh = priv;
        struct videobuf_queue *q = &fh->vb_vidq;
 
-       int ret = vidioc_try_fmt_cap(file, fh, f);
+       int ret = vidioc_try_fmt_vid_cap(file, fh, f);
        if (ret < 0)
                return (ret);
 
        .release        = video_device_release,
 
        .vidioc_querycap      = vidioc_querycap,
-       .vidioc_enum_fmt_cap  = vidioc_enum_fmt_cap,
-       .vidioc_g_fmt_cap     = vidioc_g_fmt_cap,
-       .vidioc_try_fmt_cap   = vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap     = vidioc_s_fmt_cap,
+       .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
        .vidioc_reqbufs       = vidioc_reqbufs,
        .vidioc_querybuf      = vidioc_querybuf,
        .vidioc_qbuf          = vidioc_qbuf,
 
        return 0;
 }
 
-static int zr364xx_vidioc_enum_fmt_cap(struct file *file,
+static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
                                       void *priv, struct v4l2_fmtdesc *f)
 {
        if (f->index > 0)
        return 0;
 }
 
-static int zr364xx_vidioc_try_fmt_cap(struct file *file, void *priv,
+static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                                      struct v4l2_format *f)
 {
        struct video_device *vdev = video_devdata(file);
        return 0;
 }
 
-static int zr364xx_vidioc_g_fmt_cap(struct file *file, void *priv,
+static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                    struct v4l2_format *f)
 {
        struct video_device *vdev = video_devdata(file);
        return 0;
 }
 
-static int zr364xx_vidioc_s_fmt_cap(struct file *file, void *priv,
+static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                                    struct v4l2_format *f)
 {
        struct video_device *vdev = video_devdata(file);
        .minor = -1,
 
        .vidioc_querycap        = zr364xx_vidioc_querycap,
-       .vidioc_enum_fmt_cap    = zr364xx_vidioc_enum_fmt_cap,
-       .vidioc_try_fmt_cap     = zr364xx_vidioc_try_fmt_cap,
-       .vidioc_s_fmt_cap       = zr364xx_vidioc_s_fmt_cap,
-       .vidioc_g_fmt_cap       = zr364xx_vidioc_g_fmt_cap,
+       .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
+       .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
        .vidioc_enum_input      = zr364xx_vidioc_enum_input,
        .vidioc_g_input         = zr364xx_vidioc_g_input,
        .vidioc_s_input         = zr364xx_vidioc_s_input,
 
                                    enum v4l2_priority p);
 
        /* VIDIOC_ENUM_FMT handlers */
-       int (*vidioc_enum_fmt_cap)         (struct file *file, void *fh,
+       int (*vidioc_enum_fmt_vid_cap)     (struct file *file, void *fh,
                                            struct v4l2_fmtdesc *f);
-       int (*vidioc_enum_fmt_overlay)     (struct file *file, void *fh,
+       int (*vidioc_enum_fmt_vid_overlay) (struct file *file, void *fh,
                                            struct v4l2_fmtdesc *f);
-       int (*vidioc_enum_fmt_vbi)         (struct file *file, void *fh,
+       int (*vidioc_enum_fmt_vid_out)     (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_output_overlay) (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_sliced_vbi_output)  (struct file *file, void *fh,
+#if 1
+       /* deprecated, will be removed in 2.6.28 */
+       int (*vidioc_enum_fmt_vbi_cap)     (struct file *file, void *fh,
                                            struct v4l2_fmtdesc *f);
+#endif
        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,
+       int (*vidioc_g_fmt_vid_cap)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_g_fmt_overlay)    (struct file *file, void *fh,
+       int (*vidioc_g_fmt_vid_overlay)(struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_g_fmt_vbi)        (struct file *file, void *fh,
+       int (*vidioc_g_fmt_vid_out)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_g_fmt_vbi_output) (struct file *file, void *fh,
+       int (*vidioc_g_fmt_vid_out_overlay)(struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_g_fmt_sliced_vbi_output) (struct file *file, void *fh,
+       int (*vidioc_g_fmt_vbi_cap)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_g_fmt_vbi_capture)(struct file *file, void *fh,
+       int (*vidioc_g_fmt_vbi_out)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_g_fmt_video_output)(struct file *file, void *fh,
+       int (*vidioc_g_fmt_sliced_vbi_cap)(struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_g_fmt_output_overlay) (struct file *file, void *fh,
+       int (*vidioc_g_fmt_sliced_vbi_out)(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,
+       int (*vidioc_s_fmt_vid_cap)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-
-       int (*vidioc_s_fmt_overlay)    (struct file *file, void *fh,
+       int (*vidioc_s_fmt_vid_overlay)(struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_s_fmt_vbi)        (struct file *file, void *fh,
+       int (*vidioc_s_fmt_vid_out)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_s_fmt_vbi_output) (struct file *file, void *fh,
+       int (*vidioc_s_fmt_vid_out_overlay)(struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_s_fmt_sliced_vbi_output) (struct file *file, void *fh,
+       int (*vidioc_s_fmt_vbi_cap)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_s_fmt_vbi_capture)(struct file *file, void *fh,
+       int (*vidioc_s_fmt_vbi_out)    (struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_s_fmt_video_output)(struct file *file, void *fh,
+       int (*vidioc_s_fmt_sliced_vbi_cap)(struct file *file, void *fh,
                                        struct v4l2_format *f);
-       int (*vidioc_s_fmt_output_overlay) (struct file *file, void *fh,
+       int (*vidioc_s_fmt_sliced_vbi_out)(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,
+       int (*vidioc_try_fmt_vid_cap)    (struct file *file, void *fh,
                                          struct v4l2_format *f);
-       int (*vidioc_try_fmt_overlay)    (struct file *file, void *fh,
+       int (*vidioc_try_fmt_vid_overlay)(struct file *file, void *fh,
                                          struct v4l2_format *f);
-       int (*vidioc_try_fmt_vbi)        (struct file *file, void *fh,
+       int (*vidioc_try_fmt_vid_out)    (struct file *file, void *fh,
                                          struct v4l2_format *f);
-       int (*vidioc_try_fmt_vbi_output) (struct file *file, void *fh,
+       int (*vidioc_try_fmt_vid_out_overlay)(struct file *file, void *fh,
                                          struct v4l2_format *f);
-       int (*vidioc_try_fmt_sliced_vbi_output) (struct file *file, void *fh,
+       int (*vidioc_try_fmt_vbi_cap)    (struct file *file, void *fh,
                                          struct v4l2_format *f);
-       int (*vidioc_try_fmt_vbi_capture)(struct file *file, void *fh,
+       int (*vidioc_try_fmt_vbi_out)    (struct file *file, void *fh,
                                          struct v4l2_format *f);
-       int (*vidioc_try_fmt_video_output)(struct file *file, void *fh,
+       int (*vidioc_try_fmt_sliced_vbi_cap)(struct file *file, void *fh,
                                          struct v4l2_format *f);
-       int (*vidioc_try_fmt_output_overlay)(struct file *file, void *fh,
+       int (*vidioc_try_fmt_sliced_vbi_out)(struct file *file, void *fh,
                                          struct v4l2_format *f);
        int (*vidioc_try_fmt_type_private)(struct file *file, void *fh,
                                          struct v4l2_format *f);