xref: /linux/drivers/media/pci/ivtv/ivtv-streams.c (revision 17cfcb68af3bc7d5e8ae08779b1853310a2949f3)
1 /*
2     init/start/stop/exit stream functions
3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
6 
7     This program is free software; you can redistribute it and/or modify
8     it under the terms of the GNU General Public License as published by
9     the Free Software Foundation; either version 2 of the License, or
10     (at your option) any later version.
11 
12     This program is distributed in the hope that it will be useful,
13     but WITHOUT ANY WARRANTY; without even the implied warranty of
14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15     GNU General Public License for more details.
16 
17     You should have received a copy of the GNU General Public License
18     along with this program; if not, write to the Free Software
19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21 
22 /* License: GPL
23  * Author: Kevin Thayer <nufan_wfk at yahoo dot com>
24  *
25  * This file will hold API related functions, both internal (firmware api)
26  * and external (v4l2, etc)
27  *
28  * -----
29  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
30  *                      and Takeru KOMORIYA<komoriya@paken.org>
31  *
32  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
33  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
34  */
35 
36 #include "ivtv-driver.h"
37 #include "ivtv-fileops.h"
38 #include "ivtv-queue.h"
39 #include "ivtv-mailbox.h"
40 #include "ivtv-ioctl.h"
41 #include "ivtv-irq.h"
42 #include "ivtv-yuv.h"
43 #include "ivtv-cards.h"
44 #include "ivtv-streams.h"
45 #include "ivtv-firmware.h"
46 #include <media/v4l2-event.h>
47 
48 static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
49 	.owner = THIS_MODULE,
50 	.read = ivtv_v4l2_read,
51 	.write = ivtv_v4l2_write,
52 	.open = ivtv_v4l2_open,
53 	.unlocked_ioctl = video_ioctl2,
54 #ifdef CONFIG_COMPAT
55 	.compat_ioctl32 = video_ioctl2, /* for ivtv_default() */
56 #endif
57 	.release = ivtv_v4l2_close,
58 	.poll = ivtv_v4l2_enc_poll,
59 };
60 
61 static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
62 	.owner = THIS_MODULE,
63 	.read = ivtv_v4l2_read,
64 	.write = ivtv_v4l2_write,
65 	.open = ivtv_v4l2_open,
66 	.unlocked_ioctl = video_ioctl2,
67 #ifdef CONFIG_COMPAT
68 	.compat_ioctl32 = video_ioctl2, /* for ivtv_default() */
69 #endif
70 	.release = ivtv_v4l2_close,
71 	.poll = ivtv_v4l2_dec_poll,
72 };
73 
74 static const struct v4l2_file_operations ivtv_v4l2_radio_fops = {
75 	.owner = THIS_MODULE,
76 	.open = ivtv_v4l2_open,
77 	.unlocked_ioctl = video_ioctl2,
78 #ifdef CONFIG_COMPAT
79 	.compat_ioctl32 = video_ioctl2, /* for ivtv_default() */
80 #endif
81 	.release = ivtv_v4l2_close,
82 	.poll = ivtv_v4l2_enc_poll,
83 };
84 
85 #define IVTV_V4L2_DEC_MPG_OFFSET  16	/* offset from 0 to register decoder mpg v4l2 minors on */
86 #define IVTV_V4L2_ENC_PCM_OFFSET  24	/* offset from 0 to register pcm v4l2 minors on */
87 #define IVTV_V4L2_ENC_YUV_OFFSET  32	/* offset from 0 to register yuv v4l2 minors on */
88 #define IVTV_V4L2_DEC_YUV_OFFSET  48	/* offset from 0 to register decoder yuv v4l2 minors on */
89 #define IVTV_V4L2_DEC_VBI_OFFSET   8	/* offset from 0 to register decoder vbi input v4l2 minors on */
90 #define IVTV_V4L2_DEC_VOUT_OFFSET 16	/* offset from 0 to register vbi output v4l2 minors on */
91 
92 static struct {
93 	const char *name;
94 	int vfl_type;
95 	int num_offset;
96 	int dma, pio;
97 	u32 v4l2_caps;
98 	const struct v4l2_file_operations *fops;
99 } ivtv_stream_info[] = {
100 	{	/* IVTV_ENC_STREAM_TYPE_MPG */
101 		"encoder MPG",
102 		VFL_TYPE_GRABBER, 0,
103 		PCI_DMA_FROMDEVICE, 0,
104 		V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
105 			V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
106 		&ivtv_v4l2_enc_fops
107 	},
108 	{	/* IVTV_ENC_STREAM_TYPE_YUV */
109 		"encoder YUV",
110 		VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
111 		PCI_DMA_FROMDEVICE, 0,
112 		V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
113 			V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
114 		&ivtv_v4l2_enc_fops
115 	},
116 	{	/* IVTV_ENC_STREAM_TYPE_VBI */
117 		"encoder VBI",
118 		VFL_TYPE_VBI, 0,
119 		PCI_DMA_FROMDEVICE, 0,
120 		V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_TUNER |
121 			V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
122 		&ivtv_v4l2_enc_fops
123 	},
124 	{	/* IVTV_ENC_STREAM_TYPE_PCM */
125 		"encoder PCM",
126 		VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
127 		PCI_DMA_FROMDEVICE, 0,
128 		V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
129 		&ivtv_v4l2_enc_fops
130 	},
131 	{	/* IVTV_ENC_STREAM_TYPE_RAD */
132 		"encoder radio",
133 		VFL_TYPE_RADIO, 0,
134 		PCI_DMA_NONE, 1,
135 		V4L2_CAP_RADIO | V4L2_CAP_TUNER,
136 		&ivtv_v4l2_radio_fops
137 	},
138 	{	/* IVTV_DEC_STREAM_TYPE_MPG */
139 		"decoder MPG",
140 		VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
141 		PCI_DMA_TODEVICE, 0,
142 		V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
143 		&ivtv_v4l2_dec_fops
144 	},
145 	{	/* IVTV_DEC_STREAM_TYPE_VBI */
146 		"decoder VBI",
147 		VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
148 		PCI_DMA_NONE, 1,
149 		V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_READWRITE,
150 		&ivtv_v4l2_enc_fops
151 	},
152 	{	/* IVTV_DEC_STREAM_TYPE_VOUT */
153 		"decoder VOUT",
154 		VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
155 		PCI_DMA_NONE, 1,
156 		V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
157 		&ivtv_v4l2_dec_fops
158 	},
159 	{	/* IVTV_DEC_STREAM_TYPE_YUV */
160 		"decoder YUV",
161 		VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
162 		PCI_DMA_TODEVICE, 0,
163 		V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
164 		&ivtv_v4l2_dec_fops
165 	}
166 };
167 
168 static void ivtv_stream_init(struct ivtv *itv, int type)
169 {
170 	struct ivtv_stream *s = &itv->streams[type];
171 
172 	/* we need to keep vdev, so restore it afterwards */
173 	memset(s, 0, sizeof(*s));
174 
175 	/* initialize ivtv_stream fields */
176 	s->itv = itv;
177 	s->type = type;
178 	s->name = ivtv_stream_info[type].name;
179 	s->caps = ivtv_stream_info[type].v4l2_caps;
180 
181 	if (ivtv_stream_info[type].pio)
182 		s->dma = PCI_DMA_NONE;
183 	else
184 		s->dma = ivtv_stream_info[type].dma;
185 	s->buf_size = itv->stream_buf_size[type];
186 	if (s->buf_size)
187 		s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
188 	spin_lock_init(&s->qlock);
189 	init_waitqueue_head(&s->waitq);
190 	s->sg_handle = IVTV_DMA_UNMAPPED;
191 	ivtv_queue_init(&s->q_free);
192 	ivtv_queue_init(&s->q_full);
193 	ivtv_queue_init(&s->q_dma);
194 	ivtv_queue_init(&s->q_predma);
195 	ivtv_queue_init(&s->q_io);
196 }
197 
198 static int ivtv_prep_dev(struct ivtv *itv, int type)
199 {
200 	struct ivtv_stream *s = &itv->streams[type];
201 	int num_offset = ivtv_stream_info[type].num_offset;
202 	int num = itv->instance + ivtv_first_minor + num_offset;
203 
204 	/* These four fields are always initialized. If vdev.v4l2_dev == NULL, then
205 	   this stream is not in use. In that case no other fields but these
206 	   four can be used. */
207 	s->vdev.v4l2_dev = NULL;
208 	s->itv = itv;
209 	s->type = type;
210 	s->name = ivtv_stream_info[type].name;
211 
212 	/* Check whether the radio is supported */
213 	if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
214 		return 0;
215 	if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
216 		return 0;
217 
218 	/* User explicitly selected 0 buffers for these streams, so don't
219 	   create them. */
220 	if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
221 	    itv->options.kilobytes[type] == 0) {
222 		IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
223 		return 0;
224 	}
225 
226 	ivtv_stream_init(itv, type);
227 
228 	snprintf(s->vdev.name, sizeof(s->vdev.name), "%s %s",
229 			itv->v4l2_dev.name, s->name);
230 
231 	s->vdev.num = num;
232 	s->vdev.v4l2_dev = &itv->v4l2_dev;
233 	if (ivtv_stream_info[type].v4l2_caps &
234 			(V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_SLICED_VBI_OUTPUT))
235 		s->vdev.vfl_dir = VFL_DIR_TX;
236 	s->vdev.fops = ivtv_stream_info[type].fops;
237 	s->vdev.ctrl_handler = itv->v4l2_dev.ctrl_handler;
238 	s->vdev.release = video_device_release_empty;
239 	s->vdev.tvnorms = V4L2_STD_ALL;
240 	s->vdev.lock = &itv->serialize_lock;
241 	if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {
242 		v4l2_disable_ioctl(&s->vdev, VIDIOC_S_AUDIO);
243 		v4l2_disable_ioctl(&s->vdev, VIDIOC_G_AUDIO);
244 		v4l2_disable_ioctl(&s->vdev, VIDIOC_ENUMAUDIO);
245 		v4l2_disable_ioctl(&s->vdev, VIDIOC_ENUMINPUT);
246 		v4l2_disable_ioctl(&s->vdev, VIDIOC_S_INPUT);
247 		v4l2_disable_ioctl(&s->vdev, VIDIOC_G_INPUT);
248 		v4l2_disable_ioctl(&s->vdev, VIDIOC_S_FREQUENCY);
249 		v4l2_disable_ioctl(&s->vdev, VIDIOC_G_FREQUENCY);
250 		v4l2_disable_ioctl(&s->vdev, VIDIOC_S_TUNER);
251 		v4l2_disable_ioctl(&s->vdev, VIDIOC_G_TUNER);
252 		v4l2_disable_ioctl(&s->vdev, VIDIOC_S_STD);
253 	}
254 	ivtv_set_funcs(&s->vdev);
255 	return 0;
256 }
257 
258 /* Initialize v4l2 variables and prepare v4l2 devices */
259 int ivtv_streams_setup(struct ivtv *itv)
260 {
261 	int type;
262 
263 	/* Setup V4L2 Devices */
264 	for (type = 0; type < IVTV_MAX_STREAMS; type++) {
265 		/* Prepare device */
266 		if (ivtv_prep_dev(itv, type))
267 			break;
268 
269 		if (itv->streams[type].vdev.v4l2_dev == NULL)
270 			continue;
271 
272 		/* Allocate Stream */
273 		if (ivtv_stream_alloc(&itv->streams[type]))
274 			break;
275 	}
276 	if (type == IVTV_MAX_STREAMS)
277 		return 0;
278 
279 	/* One or more streams could not be initialized. Clean 'em all up. */
280 	ivtv_streams_cleanup(itv);
281 	return -ENOMEM;
282 }
283 
284 static int ivtv_reg_dev(struct ivtv *itv, int type)
285 {
286 	struct ivtv_stream *s = &itv->streams[type];
287 	int vfl_type = ivtv_stream_info[type].vfl_type;
288 	const char *name;
289 	int num;
290 
291 	if (s->vdev.v4l2_dev == NULL)
292 		return 0;
293 
294 	num = s->vdev.num;
295 	/* card number + user defined offset + device offset */
296 	if (type != IVTV_ENC_STREAM_TYPE_MPG) {
297 		struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
298 
299 		if (s_mpg->vdev.v4l2_dev)
300 			num = s_mpg->vdev.num + ivtv_stream_info[type].num_offset;
301 	}
302 	s->vdev.device_caps = s->caps;
303 	if (itv->osd_video_pbase) {
304 		itv->streams[IVTV_DEC_STREAM_TYPE_YUV].vdev.device_caps |=
305 			V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
306 		itv->streams[IVTV_DEC_STREAM_TYPE_MPG].vdev.device_caps |=
307 			V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
308 		itv->v4l2_cap |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
309 	}
310 	video_set_drvdata(&s->vdev, s);
311 
312 	/* Register device. First try the desired minor, then any free one. */
313 	if (video_register_device_no_warn(&s->vdev, vfl_type, num)) {
314 		IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
315 				s->name, num);
316 		return -ENOMEM;
317 	}
318 	name = video_device_node_name(&s->vdev);
319 
320 	switch (vfl_type) {
321 	case VFL_TYPE_GRABBER:
322 		IVTV_INFO("Registered device %s for %s (%d kB)\n",
323 			name, s->name, itv->options.kilobytes[type]);
324 		break;
325 	case VFL_TYPE_RADIO:
326 		IVTV_INFO("Registered device %s for %s\n",
327 			name, s->name);
328 		break;
329 	case VFL_TYPE_VBI:
330 		if (itv->options.kilobytes[type])
331 			IVTV_INFO("Registered device %s for %s (%d kB)\n",
332 				name, s->name, itv->options.kilobytes[type]);
333 		else
334 			IVTV_INFO("Registered device %s for %s\n",
335 				name, s->name);
336 		break;
337 	}
338 	return 0;
339 }
340 
341 /* Register v4l2 devices */
342 int ivtv_streams_register(struct ivtv *itv)
343 {
344 	int type;
345 	int err = 0;
346 
347 	/* Register V4L2 devices */
348 	for (type = 0; type < IVTV_MAX_STREAMS; type++)
349 		err |= ivtv_reg_dev(itv, type);
350 
351 	if (err == 0)
352 		return 0;
353 
354 	/* One or more streams could not be initialized. Clean 'em all up. */
355 	ivtv_streams_cleanup(itv);
356 	return -ENOMEM;
357 }
358 
359 /* Unregister v4l2 devices */
360 void ivtv_streams_cleanup(struct ivtv *itv)
361 {
362 	int type;
363 
364 	/* Teardown all streams */
365 	for (type = 0; type < IVTV_MAX_STREAMS; type++) {
366 		struct video_device *vdev = &itv->streams[type].vdev;
367 
368 		if (vdev->v4l2_dev == NULL)
369 			continue;
370 
371 		video_unregister_device(vdev);
372 		ivtv_stream_free(&itv->streams[type]);
373 		itv->streams[type].vdev.v4l2_dev = NULL;
374 	}
375 }
376 
377 static void ivtv_vbi_setup(struct ivtv *itv)
378 {
379 	int raw = ivtv_raw_vbi(itv);
380 	u32 data[CX2341X_MBOX_MAX_DATA];
381 	int lines;
382 	int i;
383 
384 	/* Reset VBI */
385 	ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
386 
387 	/* setup VBI registers */
388 	if (raw)
389 		v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
390 	else
391 		v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
392 
393 	/* determine number of lines and total number of VBI bytes.
394 	   A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
395 	   The '- 1' byte is probably an unused U or V byte. Or something...
396 	   A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
397 	   header, 42 data bytes + checksum (to be confirmed) */
398 	if (raw) {
399 		lines = itv->vbi.count * 2;
400 	} else {
401 		lines = itv->is_60hz ? 24 : 38;
402 		if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
403 			lines += 2;
404 	}
405 
406 	itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
407 
408 	/* Note: sliced vs raw flag doesn't seem to have any effect
409 	   TODO: check mode (0x02) value with older ivtv versions. */
410 	data[0] = raw | 0x02 | (0xbd << 8);
411 
412 	/* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
413 	data[1] = 1;
414 	/* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
415 	data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
416 	/* The start/stop codes determine which VBI lines end up in the raw VBI data area.
417 	   The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
418 	   is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
419 	   code. These values for raw VBI are obtained from a driver disassembly. The sliced
420 	   start/stop codes was deduced from this, but they do not appear in the driver.
421 	   Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
422 	   However, I have no idea what these values are for. */
423 	if (itv->hw_flags & IVTV_HW_CX25840) {
424 		/* Setup VBI for the cx25840 digitizer */
425 		if (raw) {
426 			data[3] = 0x20602060;
427 			data[4] = 0x30703070;
428 		} else {
429 			data[3] = 0xB0F0B0F0;
430 			data[4] = 0xA0E0A0E0;
431 		}
432 		/* Lines per frame */
433 		data[5] = lines;
434 		/* bytes per line */
435 		data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
436 	} else {
437 		/* Setup VBI for the saa7115 digitizer */
438 		if (raw) {
439 			data[3] = 0x25256262;
440 			data[4] = 0x387F7F7F;
441 		} else {
442 			data[3] = 0xABABECEC;
443 			data[4] = 0xB6F1F1F1;
444 		}
445 		/* Lines per frame */
446 		data[5] = lines;
447 		/* bytes per line */
448 		data[6] = itv->vbi.enc_size / lines;
449 	}
450 
451 	IVTV_DEBUG_INFO(
452 		"Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
453 			data[0], data[1], data[2], data[5], data[6]);
454 
455 	ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
456 
457 	/* returns the VBI encoder memory area. */
458 	itv->vbi.enc_start = data[2];
459 	itv->vbi.fpi = data[0];
460 	if (!itv->vbi.fpi)
461 		itv->vbi.fpi = 1;
462 
463 	IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
464 		itv->vbi.enc_start, data[1], itv->vbi.fpi);
465 
466 	/* select VBI lines.
467 	   Note that the sliced argument seems to have no effect. */
468 	for (i = 2; i <= 24; i++) {
469 		int valid;
470 
471 		if (itv->is_60hz) {
472 			valid = i >= 10 && i < 22;
473 		} else {
474 			valid = i >= 6 && i < 24;
475 		}
476 		ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
477 				valid, 0 , 0, 0);
478 		ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
479 				valid, 0, 0, 0);
480 	}
481 
482 	/* Remaining VBI questions:
483 	   - Is it possible to select particular VBI lines only for inclusion in the MPEG
484 	   stream? Currently you can only get the first X lines.
485 	   - Is mixed raw and sliced VBI possible?
486 	   - What's the meaning of the raw/sliced flag?
487 	   - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
488 }
489 
490 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
491 {
492 	u32 data[CX2341X_MBOX_MAX_DATA];
493 	struct ivtv *itv = s->itv;
494 	int captype = 0, subtype = 0;
495 	int enable_passthrough = 0;
496 
497 	if (s->vdev.v4l2_dev == NULL)
498 		return -EINVAL;
499 
500 	IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
501 
502 	switch (s->type) {
503 	case IVTV_ENC_STREAM_TYPE_MPG:
504 		captype = 0;
505 		subtype = 3;
506 
507 		/* Stop Passthrough */
508 		if (itv->output_mode == OUT_PASSTHROUGH) {
509 			ivtv_passthrough_mode(itv, 0);
510 			enable_passthrough = 1;
511 		}
512 		itv->mpg_data_received = itv->vbi_data_inserted = 0;
513 		itv->dualwatch_jiffies = jiffies;
514 		itv->dualwatch_stereo_mode = v4l2_ctrl_g_ctrl(itv->cxhdl.audio_mode);
515 		itv->search_pack_header = 0;
516 		break;
517 
518 	case IVTV_ENC_STREAM_TYPE_YUV:
519 		if (itv->output_mode == OUT_PASSTHROUGH) {
520 			captype = 2;
521 			subtype = 11;	/* video+audio+decoder */
522 			break;
523 		}
524 		captype = 1;
525 		subtype = 1;
526 		break;
527 	case IVTV_ENC_STREAM_TYPE_PCM:
528 		captype = 1;
529 		subtype = 2;
530 		break;
531 	case IVTV_ENC_STREAM_TYPE_VBI:
532 		captype = 1;
533 		subtype = 4;
534 
535 		itv->vbi.frame = 0;
536 		itv->vbi.inserted_frame = 0;
537 		memset(itv->vbi.sliced_mpeg_size,
538 			0, sizeof(itv->vbi.sliced_mpeg_size));
539 		break;
540 	default:
541 		return -EINVAL;
542 	}
543 	s->subtype = subtype;
544 	s->buffers_stolen = 0;
545 
546 	/* Clear Streamoff flags in case left from last capture */
547 	clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
548 
549 	if (atomic_read(&itv->capturing) == 0) {
550 		int digitizer;
551 
552 		/* Always use frame based mode. Experiments have demonstrated that byte
553 		   stream based mode results in dropped frames and corruption. Not often,
554 		   but occasionally. Many thanks go to Leonard Orb who spent a lot of
555 		   effort and time trying to trace the cause of the drop outs. */
556 		/* 1 frame per DMA */
557 		/*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
558 		ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
559 
560 		/* Stuff from Windows, we don't know what it is */
561 		ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
562 		/* According to the docs, this should be correct. However, this is
563 		   untested. I don't dare enable this without having tested it.
564 		   Only very few old cards actually have this hardware combination.
565 		ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
566 			((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
567 		*/
568 		ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
569 		ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
570 		ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
571 		ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
572 
573 		/* assign placeholder */
574 		ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
575 			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
576 
577 		if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
578 		    digitizer = 0xF1;
579 		else if (itv->card->hw_all & IVTV_HW_SAA7114)
580 		    digitizer = 0xEF;
581 		else /* cx25840 */
582 		    digitizer = 0x140;
583 
584 		ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
585 
586 		/* Setup VBI */
587 		if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
588 			ivtv_vbi_setup(itv);
589 		}
590 
591 		/* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
592 		ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
593 		itv->pgm_info_offset = data[0];
594 		itv->pgm_info_num = data[1];
595 		itv->pgm_info_write_idx = 0;
596 		itv->pgm_info_read_idx = 0;
597 
598 		IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
599 				itv->pgm_info_offset, itv->pgm_info_num);
600 
601 		/* Setup API for Stream */
602 		cx2341x_handler_setup(&itv->cxhdl);
603 
604 		/* mute if capturing radio */
605 		if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
606 			ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
607 				1 | (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
608 	}
609 
610 	/* Vsync Setup */
611 	if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
612 		/* event notification (on) */
613 		ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
614 		ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
615 	}
616 
617 	if (atomic_read(&itv->capturing) == 0) {
618 		/* Clear all Pending Interrupts */
619 		ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
620 
621 		clear_bit(IVTV_F_I_EOS, &itv->i_flags);
622 
623 		cx2341x_handler_set_busy(&itv->cxhdl, 1);
624 
625 		/* Initialize Digitizer for Capture */
626 		/* Avoid tinny audio problem - ensure audio clocks are going */
627 		v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
628 		/* Avoid unpredictable PCI bus hang - disable video clocks */
629 		v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
630 		ivtv_msleep_timeout(300, 0);
631 		ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
632 		v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
633 	}
634 
635 	/* begin_capture */
636 	if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
637 	{
638 		IVTV_DEBUG_WARN( "Error starting capture!\n");
639 		return -EINVAL;
640 	}
641 
642 	/* Start Passthrough */
643 	if (enable_passthrough) {
644 		ivtv_passthrough_mode(itv, 1);
645 	}
646 
647 	if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
648 		ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
649 	else
650 		ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
651 
652 	/* you're live! sit back and await interrupts :) */
653 	atomic_inc(&itv->capturing);
654 	return 0;
655 }
656 EXPORT_SYMBOL(ivtv_start_v4l2_encode_stream);
657 
658 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
659 {
660 	u32 data[CX2341X_MBOX_MAX_DATA];
661 	struct ivtv *itv = s->itv;
662 	int datatype;
663 	u16 width;
664 	u16 height;
665 
666 	if (s->vdev.v4l2_dev == NULL)
667 		return -EINVAL;
668 
669 	IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
670 
671 	width = itv->cxhdl.width;
672 	height = itv->cxhdl.height;
673 
674 	/* set audio mode to left/stereo  for dual/stereo mode. */
675 	ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
676 
677 	/* set number of internal decoder buffers */
678 	ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
679 
680 	/* prebuffering */
681 	ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
682 
683 	/* extract from user packets */
684 	ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
685 	itv->vbi.dec_start = data[0];
686 
687 	IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
688 		itv->vbi.dec_start, data[1]);
689 
690 	/* set decoder source settings */
691 	/* Data type: 0 = mpeg from host,
692 	   1 = yuv from encoder,
693 	   2 = yuv_from_host */
694 	switch (s->type) {
695 	case IVTV_DEC_STREAM_TYPE_YUV:
696 		if (itv->output_mode == OUT_PASSTHROUGH) {
697 			datatype = 1;
698 		} else {
699 			/* Fake size to avoid switching video standard */
700 			datatype = 2;
701 			width = 720;
702 			height = itv->is_out_50hz ? 576 : 480;
703 		}
704 		IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
705 		break;
706 	case IVTV_DEC_STREAM_TYPE_MPG:
707 	default:
708 		datatype = 0;
709 		break;
710 	}
711 	if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
712 			width, height, itv->cxhdl.audio_properties)) {
713 		IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
714 	}
715 
716 	/* Decoder sometimes dies here, so wait a moment */
717 	ivtv_msleep_timeout(10, 0);
718 
719 	/* Known failure point for firmware, so check */
720 	return ivtv_firmware_check(itv, "ivtv_setup_v4l2_decode_stream");
721 }
722 
723 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
724 {
725 	struct ivtv *itv = s->itv;
726 	int rc;
727 
728 	if (s->vdev.v4l2_dev == NULL)
729 		return -EINVAL;
730 
731 	if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
732 		return 0;	/* already started */
733 
734 	IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
735 
736 	rc = ivtv_setup_v4l2_decode_stream(s);
737 	if (rc < 0) {
738 		clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
739 		return rc;
740 	}
741 
742 	/* set dma size to 65536 bytes */
743 	ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
744 
745 	/* Clear Streamoff */
746 	clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
747 
748 	/* Zero out decoder counters */
749 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
750 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
751 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
752 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
753 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
754 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
755 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
756 	writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
757 
758 	/* turn on notification of dual/stereo mode change */
759 	ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
760 
761 	/* start playback */
762 	ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
763 
764 	/* Let things settle before we actually start */
765 	ivtv_msleep_timeout(10, 0);
766 
767 	/* Clear the following Interrupt mask bits for decoding */
768 	ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
769 	IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
770 
771 	/* you're live! sit back and await interrupts :) */
772 	atomic_inc(&itv->decoding);
773 	return 0;
774 }
775 
776 void ivtv_stop_all_captures(struct ivtv *itv)
777 {
778 	int i;
779 
780 	for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
781 		struct ivtv_stream *s = &itv->streams[i];
782 
783 		if (s->vdev.v4l2_dev == NULL)
784 			continue;
785 		if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
786 			ivtv_stop_v4l2_encode_stream(s, 0);
787 		}
788 	}
789 }
790 
791 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
792 {
793 	struct ivtv *itv = s->itv;
794 	DECLARE_WAITQUEUE(wait, current);
795 	int cap_type;
796 	int stopmode;
797 
798 	if (s->vdev.v4l2_dev == NULL)
799 		return -EINVAL;
800 
801 	/* This function assumes that you are allowed to stop the capture
802 	   and that we are actually capturing */
803 
804 	IVTV_DEBUG_INFO("Stop Capture\n");
805 
806 	if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
807 		return 0;
808 	if (atomic_read(&itv->capturing) == 0)
809 		return 0;
810 
811 	switch (s->type) {
812 	case IVTV_ENC_STREAM_TYPE_YUV:
813 		cap_type = 1;
814 		break;
815 	case IVTV_ENC_STREAM_TYPE_PCM:
816 		cap_type = 1;
817 		break;
818 	case IVTV_ENC_STREAM_TYPE_VBI:
819 		cap_type = 1;
820 		break;
821 	case IVTV_ENC_STREAM_TYPE_MPG:
822 	default:
823 		cap_type = 0;
824 		break;
825 	}
826 
827 	/* Stop Capture Mode */
828 	if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
829 		stopmode = 0;
830 	} else {
831 		stopmode = 1;
832 	}
833 
834 	/* end_capture */
835 	/* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
836 	ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
837 
838 	if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
839 		if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
840 			/* only run these if we're shutting down the last cap */
841 			unsigned long duration;
842 			unsigned long then = jiffies;
843 
844 			add_wait_queue(&itv->eos_waitq, &wait);
845 
846 			set_current_state(TASK_INTERRUPTIBLE);
847 
848 			/* wait 2s for EOS interrupt */
849 			while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
850 				time_before(jiffies,
851 					    then + msecs_to_jiffies(2000))) {
852 				schedule_timeout(msecs_to_jiffies(10));
853 			}
854 
855 			/* To convert jiffies to ms, we must multiply by 1000
856 			 * and divide by HZ.  To avoid runtime division, we
857 			 * convert this to multiplication by 1000/HZ.
858 			 * Since integer division truncates, we get the best
859 			 * accuracy if we do a rounding calculation of the constant.
860 			 * Think of the case where HZ is 1024.
861 			 */
862 			duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
863 
864 			if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
865 				IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
866 				IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
867 			} else {
868 				IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
869 			}
870 			set_current_state(TASK_RUNNING);
871 			remove_wait_queue(&itv->eos_waitq, &wait);
872 			set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
873 		}
874 
875 		/* Handle any pending interrupts */
876 		ivtv_msleep_timeout(100, 0);
877 	}
878 
879 	atomic_dec(&itv->capturing);
880 
881 	/* Clear capture and no-read bits */
882 	clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
883 
884 	if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
885 		ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
886 
887 	if (atomic_read(&itv->capturing) > 0) {
888 		return 0;
889 	}
890 
891 	cx2341x_handler_set_busy(&itv->cxhdl, 0);
892 
893 	/* Set the following Interrupt mask bits for capture */
894 	ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
895 	del_timer(&itv->dma_timer);
896 
897 	/* event notification (off) */
898 	if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
899 		/* type: 0 = refresh */
900 		/* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
901 		ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
902 		ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
903 	}
904 
905 	/* Raw-passthrough is implied on start. Make sure it's stopped so
906 	   the encoder will re-initialize when next started */
907 	ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
908 
909 	wake_up(&s->waitq);
910 
911 	return 0;
912 }
913 EXPORT_SYMBOL(ivtv_stop_v4l2_encode_stream);
914 
915 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
916 {
917 	static const struct v4l2_event ev = {
918 		.type = V4L2_EVENT_EOS,
919 	};
920 	struct ivtv *itv = s->itv;
921 
922 	if (s->vdev.v4l2_dev == NULL)
923 		return -EINVAL;
924 
925 	if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
926 		return -EINVAL;
927 
928 	if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
929 		return 0;
930 
931 	IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
932 
933 	/* Stop Decoder */
934 	if (!(flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) || pts) {
935 		u32 tmp = 0;
936 
937 		/* Wait until the decoder is no longer running */
938 		if (pts) {
939 			ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
940 				0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
941 		}
942 		while (1) {
943 			u32 data[CX2341X_MBOX_MAX_DATA];
944 			ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
945 			if (s->q_full.buffers + s->q_dma.buffers == 0) {
946 				if (tmp == data[3])
947 					break;
948 				tmp = data[3];
949 			}
950 			if (ivtv_msleep_timeout(100, 1))
951 				break;
952 		}
953 	}
954 	ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & V4L2_DEC_CMD_STOP_TO_BLACK, 0, 0);
955 
956 	/* turn off notification of dual/stereo mode change */
957 	ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
958 
959 	ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
960 	del_timer(&itv->dma_timer);
961 
962 	clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
963 	clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
964 	ivtv_flush_queues(s);
965 
966 	/* decoder needs time to settle */
967 	ivtv_msleep_timeout(40, 0);
968 
969 	/* decrement decoding */
970 	atomic_dec(&itv->decoding);
971 
972 	set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
973 	wake_up(&itv->event_waitq);
974 	v4l2_event_queue(&s->vdev, &ev);
975 
976 	/* wake up wait queues */
977 	wake_up(&s->waitq);
978 
979 	return 0;
980 }
981 
982 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
983 {
984 	struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
985 	struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
986 
987 	if (yuv_stream->vdev.v4l2_dev == NULL || dec_stream->vdev.v4l2_dev == NULL)
988 		return -EINVAL;
989 
990 	IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
991 
992 	/* Prevent others from starting/stopping streams while we
993 	   initiate/terminate passthrough mode */
994 	if (enable) {
995 		if (itv->output_mode == OUT_PASSTHROUGH) {
996 			return 0;
997 		}
998 		if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
999 			return -EBUSY;
1000 
1001 		/* Fully initialize stream, and then unflag init */
1002 		set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1003 		set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1004 
1005 		/* Setup YUV Decoder */
1006 		ivtv_setup_v4l2_decode_stream(dec_stream);
1007 
1008 		/* Start Decoder */
1009 		ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
1010 		atomic_inc(&itv->decoding);
1011 
1012 		/* Setup capture if not already done */
1013 		if (atomic_read(&itv->capturing) == 0) {
1014 			cx2341x_handler_setup(&itv->cxhdl);
1015 			cx2341x_handler_set_busy(&itv->cxhdl, 1);
1016 		}
1017 
1018 		/* Start Passthrough Mode */
1019 		ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
1020 		atomic_inc(&itv->capturing);
1021 		return 0;
1022 	}
1023 
1024 	if (itv->output_mode != OUT_PASSTHROUGH)
1025 		return 0;
1026 
1027 	/* Stop Passthrough Mode */
1028 	ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
1029 	ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
1030 
1031 	atomic_dec(&itv->capturing);
1032 	atomic_dec(&itv->decoding);
1033 	clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1034 	clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1035 	itv->output_mode = OUT_NONE;
1036 	if (atomic_read(&itv->capturing) == 0)
1037 		cx2341x_handler_set_busy(&itv->cxhdl, 0);
1038 
1039 	return 0;
1040 }
1041