Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (57 commits)
  [media] as3645a: Fix compilation by including slab.h
  [media] s5p-fimc: Remove linux/version.h include from fimc-mdevice.c
  [media] s5p-mfc: Remove linux/version.h include from s5p_mfc.c
  [media] ds3000: using logical && instead of bitwise &
  [media] v4l2-ctrls: make control names consistent
  [media] DVB: dib0700, add support for Nova-TD LEDs
  [media] DVB: dib0700, add corrected Nova-TD frontend_attach
  [media] DVB: dib0700, separate stk7070pd initialization
  [media] DVB: dib0700, move Nova-TD Stick to a separate set
  [media] : add MODULE_FIRMWARE to dib0700
  [media] DVB-CORE: remove superfluous DTV_CMDs
  [media] s5p-jpeg: adapt to recent videobuf2 changes
  [media] s5p-g2d: fixed a bug in controls setting function
  [media] s5p-mfc: Fix volatile controls setup
  [media] drivers/media/video/s5p-mfc/s5p_mfc.c: adjust double test
  [media] drivers/media/video/s5p-fimc/fimc-capture.c: adjust double test
  [media] s5p-fimc: Fix incorrect control ID assignment
  [media] dvb_frontend: Don't call get_frontend() if idle
  [media] DocBook/dvbproperty.xml: Remove DTV_MODULATION from ISDB-T
  [media] DocBook/dvbproperty.xml: Fix ISDB-T delivery system parameters
  ...

7 files changed, 72 insertions, 102 deletions

diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index 544af91cbdc1..3949b7dc2368 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -731,9 +731,6 @@ static int __devinit ivtv_init_struct1(struct ivtv *itv)
 
         init_kthread_work(&itv->irq_work, ivtv_irq_work_handler);
 
-        /* start counting open_id at 1 */
-        itv->open_id = 1;
-
         /* Initial settings */
         itv->cxhdl.port = CX2341X_PORT_MEMORY;
         itv->cxhdl.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
diff --git a/drivers/media/video/ivtv/ivtv-driver.h b/drivers/media/video/ivtv/ivtv-driver.h
index 8f9cc17b518e..06f3d78389bf 100644
--- a/drivers/media/video/ivtv/ivtv-driver.h
+++ b/drivers/media/video/ivtv/ivtv-driver.h
@@ -332,7 +332,7 @@ struct ivtv_stream {
         const char *name;               /* name of the stream */
         int type;                       /* stream type */
 
-        u32 id;
+        struct v4l2_fh *fh;             /* pointer to the streaming filehandle */
         spinlock_t qlock;               /* locks access to the queues */
         unsigned long s_flags;          /* status flags, see above */
         int dma;                        /* can be PCI_DMA_TODEVICE, PCI_DMA_FROMDEVICE or PCI_DMA_NONE */
@@ -379,7 +379,6 @@ struct ivtv_stream {
 
 struct ivtv_open_id {
         struct v4l2_fh fh;
-        u32 open_id;                    /* unique ID for this file descriptor */
         int type;                       /* stream type */
         int yuv_frames;                 /* 1: started OUT_UDMA_YUV output mode */
         struct ivtv *itv;
diff --git a/drivers/media/video/ivtv/ivtv-fileops.c b/drivers/media/video/ivtv/ivtv-fileops.c
index 38f052257f46..2cd6c89b7d91 100644
--- a/drivers/media/video/ivtv/ivtv-fileops.c
+++ b/drivers/media/video/ivtv/ivtv-fileops.c
@@ -50,16 +50,16 @@ static int ivtv_claim_stream(struct ivtv_open_id *id, int type)
 
         if (test_and_set_bit(IVTV_F_S_CLAIMED, &s->s_flags)) {
                 /* someone already claimed this stream */
-                if (s->id == id->open_id) {
+                if (s->fh == &id->fh) {
                         /* yes, this file descriptor did. So that's OK. */
                         return 0;
                 }
-                if (s->id == -1 && (type == IVTV_DEC_STREAM_TYPE_VBI ||
+                if (s->fh == NULL && (type == IVTV_DEC_STREAM_TYPE_VBI ||
                                          type == IVTV_ENC_STREAM_TYPE_VBI)) {
                         /* VBI is handled already internally, now also assign
                            the file descriptor to this stream for external
                            reading of the stream. */
-                        s->id = id->open_id;
+                        s->fh = &id->fh;
                         IVTV_DEBUG_INFO("Start Read VBI\n");
                         return 0;
                 }
@@ -67,7 +67,7 @@ static int ivtv_claim_stream(struct ivtv_open_id *id, int type)
                 IVTV_DEBUG_INFO("Stream %d is busy\n", type);
                 return -EBUSY;
         }
-        s->id = id->open_id;
+        s->fh = &id->fh;
         if (type == IVTV_DEC_STREAM_TYPE_VBI) {
                 /* Enable reinsertion interrupt */
                 ivtv_clear_irq_mask(itv, IVTV_IRQ_DEC_VBI_RE_INSERT);
@@ -104,7 +104,7 @@ void ivtv_release_stream(struct ivtv_stream *s)
         struct ivtv *itv = s->itv;
         struct ivtv_stream *s_vbi;
 
-        s->id = -1;
+        s->fh = NULL;
         if ((s->type == IVTV_DEC_STREAM_TYPE_VBI || s->type == IVTV_ENC_STREAM_TYPE_VBI) &&
                 test_bit(IVTV_F_S_INTERNAL_USE, &s->s_flags)) {
                 /* this stream is still in use internally */
@@ -136,7 +136,7 @@ void ivtv_release_stream(struct ivtv_stream *s)
                 /* was already cleared */
                 return;
         }
-        if (s_vbi->id != -1) {
+        if (s_vbi->fh) {
                 /* VBI stream still claimed by a file descriptor */
                 return;
         }
@@ -268,11 +268,13 @@ static struct ivtv_buffer *ivtv_get_buffer(struct ivtv_stream *s, int non_block,
                 }
 
                 /* wait for more data to arrive */
+                mutex_unlock(&itv->serialize_lock);
                 prepare_to_wait(&s->waitq, &wait, TASK_INTERRUPTIBLE);
                 /* New buffers might have become available before we were added to the waitqueue */
                 if (!s->q_full.buffers)
                         schedule();
                 finish_wait(&s->waitq, &wait);
+                mutex_lock(&itv->serialize_lock);
                 if (signal_pending(current)) {
                         /* return if a signal was received */
                         IVTV_DEBUG_INFO("User stopped %s\n", s->name);
@@ -357,7 +359,7 @@ static ssize_t ivtv_read(struct ivtv_stream *s, char __user *ubuf, size_t tot_co
         size_t tot_written = 0;
         int single_frame = 0;
 
-        if (atomic_read(&itv->capturing) == 0 && s->id == -1) {
+        if (atomic_read(&itv->capturing) == 0 && s->fh == NULL) {
                 /* shouldn't happen */
                 IVTV_DEBUG_WARN("Stream %s not initialized before read\n", s->name);
                 return -EIO;
@@ -507,9 +509,7 @@ ssize_t ivtv_v4l2_read(struct file * filp, char __user *buf, size_t count, loff_
 
         IVTV_DEBUG_HI_FILE("read %zd bytes from %s\n", count, s->name);
 
-        mutex_lock(&itv->serialize_lock);
         rc = ivtv_start_capture(id);
-        mutex_unlock(&itv->serialize_lock);
         if (rc)
                 return rc;
         return ivtv_read_pos(s, buf, count, pos, filp->f_flags & O_NONBLOCK);
@@ -584,9 +584,7 @@ ssize_t ivtv_v4l2_write(struct file *filp, const char __user *user_buf, size_t c
         set_bit(IVTV_F_S_APPL_IO, &s->s_flags);
 
         /* Start decoder (returns 0 if already started) */
-        mutex_lock(&itv->serialize_lock);
         rc = ivtv_start_decoding(id, itv->speed);
-        mutex_unlock(&itv->serialize_lock);
         if (rc) {
                 IVTV_DEBUG_WARN("Failed start decode stream %s\n", s->name);
 
@@ -627,11 +625,13 @@ retry:
                         break;
                 if (filp->f_flags & O_NONBLOCK)
                         return -EAGAIN;
+                mutex_unlock(&itv->serialize_lock);
                 prepare_to_wait(&s->waitq, &wait, TASK_INTERRUPTIBLE);
                 /* New buffers might have become free before we were added to the waitqueue */
                 if (!s->q_free.buffers)
                         schedule();
                 finish_wait(&s->waitq, &wait);
+                mutex_lock(&itv->serialize_lock);
                 if (signal_pending(current)) {
                         IVTV_DEBUG_INFO("User stopped %s\n", s->name);
                         return -EINTR;
@@ -686,12 +686,14 @@ retry:
                         if (mode == OUT_YUV)
                                 ivtv_yuv_setup_stream_frame(itv);
 
+                        mutex_unlock(&itv->serialize_lock);
                         prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
                         while (!(got_sig = signal_pending(current)) &&
                                         test_bit(IVTV_F_S_DMA_PENDING, &s->s_flags)) {
                                 schedule();
                         }
                         finish_wait(&itv->dma_waitq, &wait);
+                        mutex_lock(&itv->serialize_lock);
                         if (got_sig) {
                                 IVTV_DEBUG_INFO("User interrupted %s\n", s->name);
                                 return -EINTR;
@@ -756,9 +758,7 @@ unsigned int ivtv_v4l2_enc_poll(struct file *filp, poll_table * wait)
         if (!eof && !test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
                 int rc;
 
-                mutex_lock(&itv->serialize_lock);
                 rc = ivtv_start_capture(id);
-                mutex_unlock(&itv->serialize_lock);
                 if (rc) {
                         IVTV_DEBUG_INFO("Could not start capture for %s (%d)\n",
                                         s->name, rc);
@@ -808,7 +808,7 @@ void ivtv_stop_capture(struct ivtv_open_id *id, int gop_end)
                      id->type == IVTV_ENC_STREAM_TYPE_VBI) &&
                     test_bit(IVTV_F_S_INTERNAL_USE, &s->s_flags)) {
                         /* Also used internally, don't stop capturing */
-                        s->id = -1;
+                        s->fh = NULL;
                 }
                 else {
                         ivtv_stop_v4l2_encode_stream(s, gop_end);
@@ -861,20 +861,9 @@ int ivtv_v4l2_close(struct file *filp)
 
         IVTV_DEBUG_FILE("close %s\n", s->name);
 
-        v4l2_fh_del(fh);
-        v4l2_fh_exit(fh);
-
-        /* Easy case first: this stream was never claimed by us */
-        if (s->id != id->open_id) {
-                kfree(id);
-                return 0;
-        }
-
-        /* 'Unclaim' this stream */
-
         /* Stop radio */
-        mutex_lock(&itv->serialize_lock);
-        if (id->type == IVTV_ENC_STREAM_TYPE_RAD) {
+        if (id->type == IVTV_ENC_STREAM_TYPE_RAD &&
+                        v4l2_fh_is_singular_file(filp)) {
                 /* Closing radio device, return to TV mode */
                 ivtv_mute(itv);
                 /* Mark that the radio is no longer in use */
@@ -890,13 +879,25 @@ int ivtv_v4l2_close(struct file *filp)
                 if (atomic_read(&itv->capturing) > 0) {
                         /* Undo video mute */
                         ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
-                                v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute) |
-                                (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
+                                        v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute) |
+                                        (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
                 }
                 /* Done! Unmute and continue. */
                 ivtv_unmute(itv);
-                ivtv_release_stream(s);
-        } else if (s->type >= IVTV_DEC_STREAM_TYPE_MPG) {
+        }
+
+        v4l2_fh_del(fh);
+        v4l2_fh_exit(fh);
+
+        /* Easy case first: this stream was never claimed by us */
+        if (s->fh != &id->fh) {
+                kfree(id);
+                return 0;
+        }
+
+        /* 'Unclaim' this stream */
+
+        if (s->type >= IVTV_DEC_STREAM_TYPE_MPG) {
                 struct ivtv_stream *s_vout = &itv->streams[IVTV_DEC_STREAM_TYPE_VOUT];
 
                 ivtv_stop_decoding(id, VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
@@ -911,21 +912,25 @@ int ivtv_v4l2_close(struct file *filp)
                 ivtv_stop_capture(id, 0);
         }
         kfree(id);
-        mutex_unlock(&itv->serialize_lock);
         return 0;
 }
 
-static int ivtv_serialized_open(struct ivtv_stream *s, struct file *filp)
+int ivtv_v4l2_open(struct file *filp)
 {
-#ifdef CONFIG_VIDEO_ADV_DEBUG
         struct video_device *vdev = video_devdata(filp);
-#endif
+        struct ivtv_stream *s = video_get_drvdata(vdev);
         struct ivtv *itv = s->itv;
         struct ivtv_open_id *item;
         int res = 0;
 
         IVTV_DEBUG_FILE("open %s\n", s->name);
 
+        if (ivtv_init_on_first_open(itv)) {
+                IVTV_ERR("Failed to initialize on device %s\n",
+                         video_device_node_name(vdev));
+                return -ENXIO;
+        }
+
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         /* Unless ivtv_fw_debug is set, error out if firmware dead. */
         if (ivtv_fw_debug) {
@@ -966,31 +971,19 @@ static int ivtv_serialized_open(struct ivtv_stream *s, struct file *filp)
                 return -ENOMEM;
         }
         v4l2_fh_init(&item->fh, s->vdev);
-        if (res < 0) {
-                v4l2_fh_exit(&item->fh);
-                kfree(item);
-                return res;
-        }
         item->itv = itv;
         item->type = s->type;
 
-        item->open_id = itv->open_id++;
         filp->private_data = &item->fh;
+        v4l2_fh_add(&item->fh);
 
-        if (item->type == IVTV_ENC_STREAM_TYPE_RAD) {
-                /* Try to claim this stream */
-                if (ivtv_claim_stream(item, item->type)) {
-                        /* No, it's already in use */
-                        v4l2_fh_exit(&item->fh);
-                        kfree(item);
-                        return -EBUSY;
-                }
-
+        if (item->type == IVTV_ENC_STREAM_TYPE_RAD &&
+                        v4l2_fh_is_singular_file(filp)) {
                 if (!test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
                         if (atomic_read(&itv->capturing) > 0) {
                                 /* switching to radio while capture is
                                    in progress is not polite */
-                                ivtv_release_stream(s);
+                                v4l2_fh_del(&item->fh);
                                 v4l2_fh_exit(&item->fh);
                                 kfree(item);
                                 return -EBUSY;
@@ -1022,32 +1015,9 @@ static int ivtv_serialized_open(struct ivtv_stream *s, struct file *filp)
                                 1080 * ((itv->yuv_info.v4l2_src_h + 31) & ~31);
                 itv->yuv_info.stream_size = 0;
         }
-        v4l2_fh_add(&item->fh);
         return 0;
 }
 
-int ivtv_v4l2_open(struct file *filp)
-{
-        int res;
-        struct ivtv *itv = NULL;
-        struct ivtv_stream *s = NULL;
-        struct video_device *vdev = video_devdata(filp);
-
-        s = video_get_drvdata(vdev);
-        itv = s->itv;
-
-        mutex_lock(&itv->serialize_lock);
-        if (ivtv_init_on_first_open(itv)) {
-                IVTV_ERR("Failed to initialize on device %s\n",
-                         video_device_node_name(vdev));
-                mutex_unlock(&itv->serialize_lock);
-                return -ENXIO;
-        }
-        res = ivtv_serialized_open(s, filp);
-        mutex_unlock(&itv->serialize_lock);
-        return res;
-}
-
 void ivtv_mute(struct ivtv *itv)
 {
         if (atomic_read(&itv->capturing))
diff --git a/drivers/media/video/ivtv/ivtv-ioctl.c b/drivers/media/video/ivtv/ivtv-ioctl.c
index ecafa697326e..c4bc48143098 100644
--- a/drivers/media/video/ivtv/ivtv-ioctl.c
+++ b/drivers/media/video/ivtv/ivtv-ioctl.c
@@ -179,6 +179,7 @@ int ivtv_set_speed(struct ivtv *itv, int speed)
                 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
 
                 /* Wait for any DMA to finish */
+                mutex_unlock(&itv->serialize_lock);
                 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
                 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
                         got_sig = signal_pending(current);
@@ -188,6 +189,7 @@ int ivtv_set_speed(struct ivtv *itv, int speed)
                         schedule();
                 }
                 finish_wait(&itv->dma_waitq, &wait);
+                mutex_lock(&itv->serialize_lock);
                 if (got_sig)
                         return -EINTR;
 
@@ -1107,6 +1109,7 @@ void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
          * happens within the first 100 lines of the top field.
          * Make 4 attempts to sync to the decoder before giving up.
          */
+        mutex_unlock(&itv->serialize_lock);
         for (f = 0; f < 4; f++) {
                 prepare_to_wait(&itv->vsync_waitq, &wait,
                                 TASK_UNINTERRUPTIBLE);
@@ -1115,6 +1118,7 @@ void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
                 schedule_timeout(msecs_to_jiffies(25));
         }
         finish_wait(&itv->vsync_waitq, &wait);
+        mutex_lock(&itv->serialize_lock);
 
         if (f == 4)
                 IVTV_WARN("Mode change failed to sync to decoder\n");
@@ -1842,8 +1846,7 @@ static long ivtv_default(struct file *file, void *fh, bool valid_prio,
         return 0;
 }
 
-static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
-                unsigned int cmd, unsigned long arg)
+long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
         struct video_device *vfd = video_devdata(filp);
         long ret;
@@ -1855,21 +1858,6 @@ static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
         return ret;
 }
 
-long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-{
-        struct ivtv_open_id *id = fh2id(filp->private_data);
-        struct ivtv *itv = id->itv;
-        long res;
-
-        /* DQEVENT can block, so this should not run with the serialize lock */
-        if (cmd == VIDIOC_DQEVENT)
-                return ivtv_serialized_ioctl(itv, filp, cmd, arg);
-        mutex_lock(&itv->serialize_lock);
-        res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
-        mutex_unlock(&itv->serialize_lock);
-        return res;
-}
-
 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
         .vidioc_querycap                    = ivtv_querycap,
         .vidioc_s_audio                     = ivtv_s_audio,
diff --git a/drivers/media/video/ivtv/ivtv-irq.c b/drivers/media/video/ivtv/ivtv-irq.c
index 9c29e964d400..1b3b9578bf47 100644
--- a/drivers/media/video/ivtv/ivtv-irq.c
+++ b/drivers/media/video/ivtv/ivtv-irq.c
@@ -288,13 +288,13 @@ static void dma_post(struct ivtv_stream *s)
                         ivtv_process_vbi_data(itv, buf, 0, s->type);
                         s->q_dma.bytesused += buf->bytesused;
                 }
-                if (s->id == -1) {
+                if (s->fh == NULL) {
                         ivtv_queue_move(s, &s->q_dma, NULL, &s->q_free, 0);
                         return;
                 }
         }
         ivtv_queue_move(s, &s->q_dma, NULL, &s->q_full, s->q_dma.bytesused);
-        if (s->id != -1)
+        if (s->fh)
                 wake_up(&s->waitq);
 }
 
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index e7794dc1330e..c6e28b4ebbed 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -159,7 +159,6 @@ static void ivtv_stream_init(struct ivtv *itv, int type)
                 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
         spin_lock_init(&s->qlock);
         init_waitqueue_head(&s->waitq);
-        s->id = -1;
         s->sg_handle = IVTV_DMA_UNMAPPED;
         ivtv_queue_init(&s->q_free);
         ivtv_queue_init(&s->q_full);
@@ -214,6 +213,7 @@ static int ivtv_prep_dev(struct ivtv *itv, int type)
         s->vdev->fops = ivtv_stream_info[type].fops;
         s->vdev->release = video_device_release;
         s->vdev->tvnorms = V4L2_STD_ALL;
+        s->vdev->lock = &itv->serialize_lock;
         set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev->flags);
         ivtv_set_funcs(s->vdev);
         return 0;
diff --git a/drivers/media/video/ivtv/ivtv-yuv.c b/drivers/media/video/ivtv/ivtv-yuv.c
index dcbab6ad4c26..2ad65eb29832 100644
--- a/drivers/media/video/ivtv/ivtv-yuv.c
+++ b/drivers/media/video/ivtv/ivtv-yuv.c
@@ -1149,23 +1149,37 @@ int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void __user *src)
 {
         struct yuv_playback_info *yi = &itv->yuv_info;
         struct ivtv_dma_frame dma_args;
+        int res;
 
         ivtv_yuv_setup_stream_frame(itv);
 
         /* We only need to supply source addresses for this */
         dma_args.y_source = src;
         dma_args.uv_source = src + 720 * ((yi->v4l2_src_h + 31) & ~31);
-        return ivtv_yuv_udma_frame(itv, &dma_args);
+        /* Wait for frame DMA. Note that serialize_lock is locked,
+           so to allow other processes to access the driver while
+           we are waiting unlock first and later lock again. */
+        mutex_unlock(&itv->serialize_lock);
+        res = ivtv_yuv_udma_frame(itv, &dma_args);
+        mutex_lock(&itv->serialize_lock);
+        return res;
 }
 
 /* IVTV_IOC_DMA_FRAME ioctl handler */
 int ivtv_yuv_prep_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
 {
-/*      IVTV_DEBUG_INFO("yuv_prep_frame\n"); */
+        int res;
 
+/*      IVTV_DEBUG_INFO("yuv_prep_frame\n"); */
         ivtv_yuv_next_free(itv);
         ivtv_yuv_setup_frame(itv, args);
-        return ivtv_yuv_udma_frame(itv, args);
+        /* Wait for frame DMA. Note that serialize_lock is locked,
+           so to allow other processes to access the driver while
+           we are waiting unlock first and later lock again. */
+        mutex_unlock(&itv->serialize_lock);
+        res = ivtv_yuv_udma_frame(itv, args);
+        mutex_lock(&itv->serialize_lock);
+        return res;
 }
 
 void ivtv_yuv_close(struct ivtv *itv)
@@ -1174,7 +1188,9 @@ void ivtv_yuv_close(struct ivtv *itv)
         int h_filter, v_filter_1, v_filter_2;
 
         IVTV_DEBUG_YUV("ivtv_yuv_close\n");
+        mutex_unlock(&itv->serialize_lock);
         ivtv_waitq(&itv->vsync_waitq);
+        mutex_lock(&itv->serialize_lock);
 
         yi->running = 0;
         atomic_set(&yi->next_dma_frame, -1);