/*
        DEB_EE(("inode:%p, file:%p, cmd:%d, arg:%li\n",inode, file, cmd, arg));
 */
-       return video_usercopy(inode, file, cmd, arg, saa7146_video_do_ioctl);
+       return video_usercopy(file, cmd, arg, saa7146_video_do_ioctl);
 }
 
 static int fops_mmap(struct file *file, struct vm_area_struct * vma)
 
  * copying is done already, arg is a kernel pointer.
  */
 
-static int __saa7146_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+int saa7146_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct saa7146_fh *fh  = file->private_data;
        struct saa7146_dev *dev = fh->dev;
 #endif
        default:
                return v4l_compat_translate_ioctl(file, cmd, arg,
-                                                 __saa7146_video_do_ioctl);
+                                                 saa7146_video_do_ioctl);
        }
        return 0;
 }
 
-int saa7146_video_do_ioctl(struct inode *inode, struct file *file,
-                                   unsigned int cmd, void *arg)
-{
-       return __saa7146_video_do_ioctl(file, cmd, arg);
-}
-
 /*********************************************************************************/
 /* buffer handling functions                                                  */
 
 
        return ret;
 }
 
-static int ar_do_ioctl(struct inode *inode, struct file *file,
-                      unsigned int cmd, void *arg)
+static int ar_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *dev = video_devdata(file);
        struct ar_device *ar = video_get_drvdata(dev);
 static int ar_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                    unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, ar_do_ioctl);
+       return video_usercopy(file, cmd, arg, ar_do_ioctl);
 }
 
 #if USE_INT
 
  *     Video4linux interfacing
  */
 
-static int qcam_do_ioctl(struct inode *inode, struct file *file,
-                        unsigned int cmd, void *arg)
+static int qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *dev = video_devdata(file);
        struct qcam_device *qcam=(struct qcam_device *)dev;
 static int qcam_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, qcam_do_ioctl);
+       return video_usercopy(file, cmd, arg, qcam_do_ioctl);
 }
 
 static ssize_t qcam_read(struct file *file, char __user *buf,
 
  *     Video4linux interfacing
  */
 
-static int qcam_do_ioctl(struct inode *inode, struct file *file,
-                        unsigned int cmd, void *arg)
+static int qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *dev = video_devdata(file);
        struct qcam_device *qcam=(struct qcam_device *)dev;
 }
 
 static int qcam_ioctl(struct inode *inode, struct file *file,
-                    unsigned int cmd, unsigned long arg)
+                     unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, qcam_do_ioctl);
+       return video_usercopy(file, cmd, arg, qcam_do_ioctl);
 }
 
 static ssize_t qcam_read(struct file *file, char __user *buf,
 
        return cam->decompressed_frame.count;
 }
 
-static int cpia_do_ioctl(struct inode *inode, struct file *file,
-                        unsigned int ioctlnr, void *arg)
+static int cpia_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *dev = file->private_data;
        struct cam_data *cam = video_get_drvdata(dev);
        if (mutex_lock_interruptible(&cam->busy_lock))
                return -EINTR;
 
-       //DBG("cpia_ioctl: %u\n", ioctlnr);
+       /* DBG("cpia_ioctl: %u\n", cmd); */
 
-       switch (ioctlnr) {
+       switch (cmd) {
        /* query capabilities */
        case VIDIOCGCAP:
        {
 static int cpia_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, cpia_do_ioctl);
+       return video_usercopy(file, cmd, arg, cpia_do_ioctl);
 }
 
 
 
  *  cpia2_ioctl
  *
  *****************************************************************************/
-static int cpia2_do_ioctl(struct inode *inode, struct file *file,
-                         unsigned int ioctl_nr, void *arg)
+static int cpia2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct camera_data *cam = video_drvdata(file);
        int retval = 0;
        }
 
        /* Priority check */
-       switch (ioctl_nr) {
+       switch (cmd) {
        case VIDIOCSWIN:
        case VIDIOCMCAPTURE:
        case VIDIOC_S_FMT:
                break;
        }
 
-       switch (ioctl_nr) {
+       switch (cmd) {
        case VIDIOCGCAP:        /* query capabilities */
                retval = ioctl_cap_query(arg, cam);
                break;
        case VIDIOC_ENUMINPUT:
        case VIDIOC_G_INPUT:
        case VIDIOC_S_INPUT:
-               retval = ioctl_input(ioctl_nr, arg,cam);
+               retval = ioctl_input(cmd, arg, cam);
                break;
 
        case VIDIOC_ENUM_FMT:
 }
 
 static int cpia2_ioctl(struct inode *inode, struct file *file,
-                      unsigned int ioctl_nr, unsigned long iarg)
+                      unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, ioctl_nr, iarg, cpia2_do_ioctl);
+       return video_usercopy(file, cmd, arg, cpia2_do_ioctl);
 }
 
 /******************************************************************************
 
 
 /* Do not call this function directly! */
 static int
-ov51x_v4l1_ioctl_internal(struct inode *inode, struct file *file,
-                         unsigned int cmd, void *arg)
+ov51x_v4l1_ioctl_internal(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *vdev = file->private_data;
        struct usb_ov511 *ov = video_get_drvdata(vdev);
        if (mutex_lock_interruptible(&ov->lock))
                return -EINTR;
 
-       rc = video_usercopy(inode, file, cmd, arg, ov51x_v4l1_ioctl_internal);
+       rc = video_usercopy(file, cmd, arg, ov51x_v4l1_ioctl_internal);
 
        mutex_unlock(&ov->lock);
        return rc;
 
  *     Video4linux interfacing
  */
 
-static int pms_do_ioctl(struct inode *inode, struct file *file,
-                       unsigned int cmd, void *arg)
+static int pms_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *dev = video_devdata(file);
        struct pms_device *pd=(struct pms_device *)dev;
 static int pms_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, pms_do_ioctl);
+       return video_usercopy(file, cmd, arg, pms_do_ioctl);
 }
 
 static ssize_t pms_read(struct file *file, char __user *buf,
 
  * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
  *
  */
-static int __pvr2_v4l2_do_ioctl(struct file *file,
-                             unsigned int cmd, void *arg)
+static int pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct pvr2_v4l2_fh *fh = file->private_data;
        struct pvr2_v4l2 *vp = fh->vhead;
 
        default :
                ret = v4l_compat_translate_ioctl(file, cmd,
-                                                arg, __pvr2_v4l2_do_ioctl);
+                                                arg, pvr2_v4l2_do_ioctl);
        }
 
        pvr2_hdw_commit_ctl(hdw);
        return ret;
 }
 
-static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
-                             unsigned int cmd, void *arg)
-{
-       return __pvr2_v4l2_do_ioctl(file, cmd, arg);
-}
-
 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
 {
        int num = dip->devbase.num;
 #define IVTV_IOC_G_CODEC        0xFFEE7703
 #define IVTV_IOC_S_CODEC        0xFFEE7704
        if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
-       return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
+       return video_usercopy(file, cmd, arg, pvr2_v4l2_do_ioctl);
 }
 
 
 
 
        mutex_lock(&pdev->modlock);
        if (!pdev->unplugged)
-               r = video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
+               r = video_usercopy(file, cmd, arg, pwc_video_do_ioctl);
        mutex_unlock(&pdev->modlock);
 out:
        return r;
 
 
 }
 
-int pwc_video_do_ioctl(struct inode *inode, struct file *file,
-                      unsigned int cmd, void *arg)
+int pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *vdev = video_devdata(file);
        struct pwc_device *pdev;
 
 extern int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg);
 
 /** Functions in pwc-v4l.c */
-extern int pwc_video_do_ioctl(struct inode *inode, struct file *file,
-                             unsigned int cmd, void *arg);
+extern int pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg);
 
 /** pwc-uncompress.c */
 /* Expand frame to image, possibly including decompression. Uses read_frame and fill_image */
 
  *
  *  Returns 0 if successful
  */
-static int do_saa5246a_ioctl(struct inode *inode, struct file *file,
-                           unsigned int cmd, void *arg)
+static int do_saa5246a_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct saa5246a_device *t = video_drvdata(file);
 
 
        cmd = vtx_fix_command(cmd);
        mutex_lock(&t->lock);
-       err = video_usercopy(inode, file, cmd, arg, do_saa5246a_ioctl);
+       err = video_usercopy(file, cmd, arg, do_saa5246a_ioctl);
        mutex_unlock(&t->lock);
        return err;
 }
 
  *     Standard character-device-driver functions
  */
 
-static int do_saa5249_ioctl(struct inode *inode, struct file *file,
-                           unsigned int cmd, void *arg)
+static int do_saa5249_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        static int virtual_mode = false;
        struct saa5249_device *t = video_drvdata(file);
 
        cmd = vtx_fix_command(cmd);
        mutex_lock(&t->lock);
-       err = video_usercopy(inode,file,cmd,arg,do_saa5249_ioctl);
+       err = video_usercopy(file, cmd, arg, do_saa5249_ioctl);
        mutex_unlock(&t->lock);
        return err;
 }
 
        return 0;
 }
 
-static int se401_do_ioctl(struct inode *inode, struct file *file,
-                         unsigned int cmd, void *arg)
+static int se401_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *vdev = file->private_data;
        struct usb_se401 *se401 = (struct usb_se401 *)vdev;
 static int se401_ioctl(struct inode *inode, struct file *file,
                       unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, se401_do_ioctl);
+       return video_usercopy(file, cmd, arg, se401_do_ioctl);
 }
 
 static ssize_t se401_read(struct file *file, char __user *buf,
 
        return 0;
 }
 
-static int stv680_do_ioctl (struct inode *inode, struct file *file,
-                           unsigned int cmd, void *arg)
+static int stv680_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *vdev = file->private_data;
        struct usb_stv *stv680 = video_get_drvdata(vdev);
 static int stv680_ioctl(struct inode *inode, struct file *file,
                        unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, stv680_do_ioctl);
+       return video_usercopy(file, cmd, arg, stv680_do_ioctl);
 }
 
 static int stv680_mmap (struct file *file, struct vm_area_struct *vma)
 
  * History:
  * 22-Jan-2000 Corrected VIDIOCSPICT to reject unsupported settings.
  */
-static int usbvideo_v4l_do_ioctl(struct inode *inode, struct file *file,
-                                unsigned int cmd, void *arg)
+static int usbvideo_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct uvd *uvd = file->private_data;
 
 static int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
                       unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, usbvideo_v4l_do_ioctl);
+       return video_usercopy(file, cmd, arg, usbvideo_v4l_do_ioctl);
 }
 
 /*
 
        return -ENODEV;
 }
 
-static int usbvision_do_vbi_ioctl(struct inode *inode, struct file *file,
+static int usbvision_do_vbi_ioctl(struct file *file,
                                 unsigned int cmd, void *arg)
 {
        /* TODO */
 static int usbvision_vbi_ioctl(struct inode *inode, struct file *file,
                       unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, usbvision_do_vbi_ioctl);
+       return video_usercopy(file, cmd, arg, usbvision_do_vbi_ioctl);
 }
 
 
 
        return 0;
 }
 
-static int __uvc_v4l2_do_ioctl(struct file *file,
-                    unsigned int cmd, void *arg)
+static int uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct video_device *vdev = video_devdata(file);
        struct uvc_video_device *video = video_get_drvdata(vdev);
 
        default:
                if ((ret = v4l_compat_translate_ioctl(file, cmd, arg,
-                       __uvc_v4l2_do_ioctl)) == -ENOIOCTLCMD)
+                       uvc_v4l2_do_ioctl)) == -ENOIOCTLCMD)
                        uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n",
                                  cmd);
                return ret;
        return ret;
 }
 
-static int uvc_v4l2_do_ioctl(struct inode *inode, struct file *file,
-                             unsigned int cmd, void *arg)
-{
-       return __uvc_v4l2_do_ioctl(file, cmd, arg);
-}
-
 static int uvc_v4l2_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, unsigned long arg)
 {
        uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_ioctl\n");
-       return video_usercopy(inode, file, cmd, arg, uvc_v4l2_do_ioctl);
+       return video_usercopy(file, cmd, arg, uvc_v4l2_do_ioctl);
 }
 
 static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
 
  * Obsolete usercopy function - Should be removed soon
  */
 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))
+video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
+               v4l2_kioctl func)
 {
        char    sbuf[128];
        void    *mbuf = NULL;
        }
 
        /* call driver */
-       err = func(inode, file, cmd, parg);
+       err = func(file, cmd, parg);
        if (err == -ENOIOCTLCMD)
                err = -EINVAL;
        if (is_ext_ctrl) {
 
        return ret;
 }
 
-static int vino_do_ioctl(struct inode *inode, struct file *file,
-                     unsigned int cmd, void *arg)
+static int vino_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct vino_channel_settings *vcs = video_drvdata(file);
 
        if (mutex_lock_interruptible(&vcs->mutex))
                return -EINTR;
 
-       ret = video_usercopy(inode, file, cmd, arg, vino_do_ioctl);
+       ret = video_usercopy(file, cmd, arg, vino_do_ioctl);
 
        mutex_unlock(&vcs->mutex);
 
 
  *     Video4linux interfacing
  */
 
-static int w9966_v4l_do_ioctl(struct inode *inode, struct file *file,
-                             unsigned int cmd, void *arg)
+static int w9966_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct w9966_dev *cam = video_drvdata(file);
 
 static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
                           unsigned int cmd, unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, w9966_v4l_do_ioctl);
+       return video_usercopy(file, cmd, arg, w9966_v4l_do_ioctl);
 }
 
 // Capture data
 
  *   ioctl routine
  */
 
-static int
-zoran_do_ioctl (struct inode *inode,
-               struct file  *file,
-               unsigned int  cmd,
-               void         *arg)
+static int zoran_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
        struct zoran_fh *fh = file->private_data;
        struct zoran *zr = fh->zr;
             unsigned int  cmd,
             unsigned long arg)
 {
-       return video_usercopy(inode, file, cmd, arg, zoran_do_ioctl);
+       return video_usercopy(file, cmd, arg, zoran_do_ioctl);
 }
 
 static unsigned int
 
 extern struct saa7146_use_ops saa7146_video_uops;
 int saa7146_start_preview(struct saa7146_fh *fh);
 int saa7146_stop_preview(struct saa7146_fh *fh);
-int saa7146_video_do_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, void *arg);
+int saa7146_video_do_ioctl(struct file *file, unsigned int cmd, void *arg);
 
 /* from saa7146_vbi.c */
 extern struct saa7146_use_ops saa7146_vbi_uops;
 
                                unsigned long arg);
 
 /* 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));
+extern int video_usercopy(struct file *file, unsigned int cmd,
+                               unsigned long arg, v4l2_kioctl func);
 
 /* Standard handlers for V4L ioctl's */