ssize_t cx18_v4l2_read(struct file *filp, char __user *buf, size_t count,
                loff_t *pos)
 {
-       struct cx18_open_id *id = filp->private_data;
+       struct cx18_open_id *id = file2id(filp);
        struct cx18 *cx = id->cx;
        struct cx18_stream *s = &cx->streams[id->type];
        int rc;
 
 unsigned int cx18_v4l2_enc_poll(struct file *filp, poll_table *wait)
 {
-       struct cx18_open_id *id = filp->private_data;
+       struct cx18_open_id *id = file2id(filp);
        struct cx18 *cx = id->cx;
        struct cx18_stream *s = &cx->streams[id->type];
        int eof = test_bit(CX18_F_S_STREAMOFF, &s->s_flags);
 
 int cx18_v4l2_close(struct file *filp)
 {
-       struct cx18_open_id *id = filp->private_data;
+       struct v4l2_fh *fh = filp->private_data;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        struct cx18_stream *s = &cx->streams[id->type];
 
        CX18_DEBUG_IOCTL("close() of %s\n", s->name);
 
        v4l2_prio_close(&cx->prio, id->prio);
+       v4l2_fh_del(fh);
+       v4l2_fh_exit(fh);
 
        /* Easy case first: this stream was never claimed by us */
        if (s->id != id->open_id) {
        CX18_DEBUG_FILE("open %s\n", s->name);
 
        /* Allocate memory */
-       item = kmalloc(sizeof(struct cx18_open_id), GFP_KERNEL);
+       item = kzalloc(sizeof(struct cx18_open_id), GFP_KERNEL);
        if (NULL == item) {
                CX18_DEBUG_WARN("nomem on v4l2 open\n");
                return -ENOMEM;
        }
+       v4l2_fh_init(&item->fh, s->video_dev);
+
        item->cx = cx;
        item->type = s->type;
        v4l2_prio_open(&cx->prio, &item->prio);
 
        item->open_id = cx->open_id++;
-       filp->private_data = item;
+       filp->private_data = &item->fh;
 
        if (item->type == CX18_ENC_STREAM_TYPE_RAD) {
                /* Try to claim this stream */
                if (cx18_claim_stream(item, item->type)) {
                        /* No, it's already in use */
+                       v4l2_fh_exit(&item->fh);
                        kfree(item);
                        return -EBUSY;
                }
                                /* switching to radio while capture is
                                   in progress is not polite */
                                cx18_release_stream(s);
+                               v4l2_fh_exit(&item->fh);
                                kfree(item);
                                return -EBUSY;
                        }
                /* Done! Unmute and continue. */
                cx18_unmute(cx);
        }
+       v4l2_fh_add(&item->fh);
        return 0;
 }
 
 
 static int cx18_g_fmt_vid_cap(struct file *file, void *fh,
                                struct v4l2_format *fmt)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 
 static int cx18_g_fmt_vbi_cap(struct file *file, void *fh,
                                struct v4l2_format *fmt)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
        struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
 
        vbifmt->sampling_rate = 27000000;
 static int cx18_g_fmt_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_format *fmt)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
        struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 
        /* sane, V4L2 spec compliant, defaults */
 static int cx18_try_fmt_vid_cap(struct file *file, void *fh,
                                struct v4l2_format *fmt)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int w = fmt->fmt.pix.width;
        int h = fmt->fmt.pix.height;
 static int cx18_try_fmt_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_format *fmt)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
        struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 
        vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 static int cx18_s_fmt_vid_cap(struct file *file, void *fh,
                                struct v4l2_format *fmt)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        struct v4l2_mbus_framefmt mbus_fmt;
        int ret;
 static int cx18_s_fmt_vbi_cap(struct file *file, void *fh,
                                struct v4l2_format *fmt)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int ret;
 
 static int cx18_s_fmt_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_format *fmt)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int ret;
        struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 static int cx18_g_chip_ident(struct file *file, void *fh,
                                struct v4l2_dbg_chip_ident *chip)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
        int err = 0;
 
        chip->ident = V4L2_IDENT_NONE;
 static int cx18_g_register(struct file *file, void *fh,
                                struct v4l2_dbg_register *reg)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        if (v4l2_chip_match_host(®->match))
                return cx18_cxc(cx, VIDIOC_DBG_G_REGISTER, reg);
 static int cx18_s_register(struct file *file, void *fh,
                                struct v4l2_dbg_register *reg)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        if (v4l2_chip_match_host(®->match))
                return cx18_cxc(cx, VIDIOC_DBG_S_REGISTER, reg);
 
 static int cx18_g_priority(struct file *file, void *fh, enum v4l2_priority *p)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = file2id(file)->cx;
 
        *p = v4l2_prio_max(&cx->prio);
        return 0;
 
 static int cx18_s_priority(struct file *file, void *fh, enum v4l2_priority prio)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = file2id(file);
        struct cx18 *cx = id->cx;
 
        return v4l2_prio_change(&cx->prio, &id->prio, prio);
 static int cx18_querycap(struct file *file, void *fh,
                                struct v4l2_capability *vcap)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        strlcpy(vcap->driver, CX18_DRIVER_NAME, sizeof(vcap->driver));
        strlcpy(vcap->card, cx->card_name, sizeof(vcap->card));
 
 static int cx18_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        return cx18_get_audio_input(cx, vin->index, vin);
 }
 
 static int cx18_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        vin->index = cx->audio_input;
        return cx18_get_audio_input(cx, vin->index, vin);
 
 static int cx18_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        if (vout->index >= cx->nof_audio_inputs)
                return -EINVAL;
 
 static int cx18_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        /* set it to defaults from our table */
        return cx18_get_input(cx, vin->index, vin);
 static int cx18_cropcap(struct file *file, void *fh,
                        struct v4l2_cropcap *cropcap)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
 
 static int cx18_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int ret;
 
 
 static int cx18_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
 
 static int cx18_g_input(struct file *file, void *fh, unsigned int *i)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        *i = cx->active_input;
        return 0;
 
 int cx18_s_input(struct file *file, void *fh, unsigned int inp)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int ret;
 
 static int cx18_g_frequency(struct file *file, void *fh,
                                struct v4l2_frequency *vf)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        if (vf->tuner != 0)
                return -EINVAL;
 
 int cx18_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int ret;
 
 
 static int cx18_g_std(struct file *file, void *fh, v4l2_std_id *std)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        *std = cx->std;
        return 0;
 
 int cx18_s_std(struct file *file, void *fh, v4l2_std_id *std)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int ret;
 
 
 static int cx18_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        int ret;
 
 
 static int cx18_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        if (vt->index != 0)
                return -EINVAL;
 static int cx18_g_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_sliced_vbi_cap *cap)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
        int set = cx->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
        int f, l;
 
 static int cx18_g_enc_index(struct file *file, void *fh,
                                struct v4l2_enc_idx *idx)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
        struct cx18_stream *s = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
        s32 tmp;
        struct cx18_mdl *mdl;
 static int cx18_encoder_cmd(struct file *file, void *fh,
                                struct v4l2_encoder_cmd *enc)
 {
-       struct cx18_open_id *id = fh;
+       struct cx18_open_id *id = fh2id(fh);
        struct cx18 *cx = id->cx;
        u32 h;
 
 static int cx18_try_encoder_cmd(struct file *file, void *fh,
                                struct v4l2_encoder_cmd *enc)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        switch (enc->cmd) {
        case V4L2_ENC_CMD_START:
 
 static int cx18_log_status(struct file *file, void *fh)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
        struct v4l2_input vidin;
        struct v4l2_audio audin;
        int i;
 static long cx18_default(struct file *file, void *fh, bool valid_prio,
                                                        int cmd, void *arg)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct cx18 *cx = fh2id(fh)->cx;
 
        switch (cmd) {
        case VIDIOC_INT_RESET: {
                    unsigned long arg)
 {
        struct video_device *vfd = video_devdata(filp);
-       struct cx18_open_id *id = filp->private_data;
+       struct cx18_open_id *id = file2id(filp);
        struct cx18 *cx = id->cx;
        long res;