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>
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.
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.
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
23 * Author: Kevin Thayer <nufan_wfk at yahoo dot com>
25 * This file will hold API related functions, both internal (firmware api)
26 * and external (v4l2, etc)
29 * MPG600/MPG160 support by T.Adachi <tadachi@tadachi-net.com>
30 * and Takeru KOMORIYA<komoriya@paken.org>
32 * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
33 * using information provided by Jiun-Kuei Jung @ AVerMedia.
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"
43 #include "ivtv-cards.h"
44 #include "ivtv-streams.h"
45 #include "ivtv-firmware.h"
46 #include <media/v4l2-event.h>
48 static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
50 .read = ivtv_v4l2_read,
51 .write = ivtv_v4l2_write,
52 .open = ivtv_v4l2_open,
53 .unlocked_ioctl = video_ioctl2,
55 .compat_ioctl32 = video_ioctl2, /* for ivtv_default() */
57 .release = ivtv_v4l2_close,
58 .poll = ivtv_v4l2_enc_poll,
61 static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
63 .read = ivtv_v4l2_read,
64 .write = ivtv_v4l2_write,
65 .open = ivtv_v4l2_open,
66 .unlocked_ioctl = video_ioctl2,
68 .compat_ioctl32 = video_ioctl2, /* for ivtv_default() */
70 .release = ivtv_v4l2_close,
71 .poll = ivtv_v4l2_dec_poll,
74 static const struct v4l2_file_operations ivtv_v4l2_radio_fops = {
76 .open = ivtv_v4l2_open,
77 .unlocked_ioctl = video_ioctl2,
79 .compat_ioctl32 = video_ioctl2, /* for ivtv_default() */
81 .release = ivtv_v4l2_close,
82 .poll = ivtv_v4l2_enc_poll,
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 */
98 const struct v4l2_file_operations *fops;
99 } ivtv_stream_info[] = {
100 { /* IVTV_ENC_STREAM_TYPE_MPG */
103 PCI_DMA_FROMDEVICE, 0,
104 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
105 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
108 { /* IVTV_ENC_STREAM_TYPE_YUV */
110 VFL_TYPE_VIDEO, 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,
116 { /* IVTV_ENC_STREAM_TYPE_VBI */
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,
124 { /* IVTV_ENC_STREAM_TYPE_PCM */
126 VFL_TYPE_VIDEO, IVTV_V4L2_ENC_PCM_OFFSET,
127 PCI_DMA_FROMDEVICE, 0,
128 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
131 { /* IVTV_ENC_STREAM_TYPE_RAD */
135 V4L2_CAP_RADIO | V4L2_CAP_TUNER,
136 &ivtv_v4l2_radio_fops
138 { /* IVTV_DEC_STREAM_TYPE_MPG */
140 VFL_TYPE_VIDEO, IVTV_V4L2_DEC_MPG_OFFSET,
142 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
145 { /* IVTV_DEC_STREAM_TYPE_VBI */
147 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
149 V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_READWRITE,
152 { /* IVTV_DEC_STREAM_TYPE_VOUT */
154 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
156 V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
159 { /* IVTV_DEC_STREAM_TYPE_YUV */
161 VFL_TYPE_VIDEO, IVTV_V4L2_DEC_YUV_OFFSET,
163 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
168 static void ivtv_stream_init(struct ivtv *itv, int type)
170 struct ivtv_stream *s = &itv->streams[type];
172 /* we need to keep vdev, so restore it afterwards */
173 memset(s, 0, sizeof(*s));
175 /* initialize ivtv_stream fields */
178 s->name = ivtv_stream_info[type].name;
179 s->vdev.device_caps = ivtv_stream_info[type].v4l2_caps;
181 if (ivtv_stream_info[type].pio)
182 s->dma = PCI_DMA_NONE;
184 s->dma = ivtv_stream_info[type].dma;
185 s->buf_size = itv->stream_buf_size[type];
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);
198 static int ivtv_prep_dev(struct ivtv *itv, int type)
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;
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
207 s->vdev.v4l2_dev = NULL;
210 s->name = ivtv_stream_info[type].name;
212 /* Check whether the radio is supported */
213 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
215 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
218 /* User explicitly selected 0 buffers for these streams, so don't
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);
226 ivtv_stream_init(itv, type);
228 snprintf(s->vdev.name, sizeof(s->vdev.name), "%s %s",
229 itv->v4l2_dev.name, s->name);
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);
254 ivtv_set_funcs(&s->vdev);
258 /* Initialize v4l2 variables and prepare v4l2 devices */
259 int ivtv_streams_setup(struct ivtv *itv)
263 /* Setup V4L2 Devices */
264 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
266 if (ivtv_prep_dev(itv, type))
269 if (itv->streams[type].vdev.v4l2_dev == NULL)
272 /* Allocate Stream */
273 if (ivtv_stream_alloc(&itv->streams[type]))
276 if (type == IVTV_MAX_STREAMS)
279 /* One or more streams could not be initialized. Clean 'em all up. */
280 ivtv_streams_cleanup(itv);
284 static int ivtv_reg_dev(struct ivtv *itv, int type)
286 struct ivtv_stream *s = &itv->streams[type];
287 int vfl_type = ivtv_stream_info[type].vfl_type;
291 if (s->vdev.v4l2_dev == NULL)
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];
299 if (s_mpg->vdev.v4l2_dev)
300 num = s_mpg->vdev.num + ivtv_stream_info[type].num_offset;
302 if (itv->osd_video_pbase && (type == IVTV_DEC_STREAM_TYPE_YUV ||
303 type == IVTV_DEC_STREAM_TYPE_MPG)) {
304 s->vdev.device_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
305 itv->v4l2_cap |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
307 video_set_drvdata(&s->vdev, s);
309 /* Register device. First try the desired minor, then any free one. */
310 if (video_register_device_no_warn(&s->vdev, vfl_type, num)) {
311 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
315 name = video_device_node_name(&s->vdev);
319 IVTV_INFO("Registered device %s for %s (%d kB)\n",
320 name, s->name, itv->options.kilobytes[type]);
323 IVTV_INFO("Registered device %s for %s\n",
327 if (itv->options.kilobytes[type])
328 IVTV_INFO("Registered device %s for %s (%d kB)\n",
329 name, s->name, itv->options.kilobytes[type]);
331 IVTV_INFO("Registered device %s for %s\n",
338 /* Register v4l2 devices */
339 int ivtv_streams_register(struct ivtv *itv)
344 /* Register V4L2 devices */
345 for (type = 0; type < IVTV_MAX_STREAMS; type++)
346 err |= ivtv_reg_dev(itv, type);
351 /* One or more streams could not be initialized. Clean 'em all up. */
352 ivtv_streams_cleanup(itv);
356 /* Unregister v4l2 devices */
357 void ivtv_streams_cleanup(struct ivtv *itv)
361 /* Teardown all streams */
362 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
363 struct video_device *vdev = &itv->streams[type].vdev;
365 if (vdev->v4l2_dev == NULL)
368 video_unregister_device(vdev);
369 ivtv_stream_free(&itv->streams[type]);
370 itv->streams[type].vdev.v4l2_dev = NULL;
374 static void ivtv_vbi_setup(struct ivtv *itv)
376 int raw = ivtv_raw_vbi(itv);
377 u32 data[CX2341X_MBOX_MAX_DATA];
382 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
384 /* setup VBI registers */
386 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
388 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
390 /* determine number of lines and total number of VBI bytes.
391 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
392 The '- 1' byte is probably an unused U or V byte. Or something...
393 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
394 header, 42 data bytes + checksum (to be confirmed) */
396 lines = itv->vbi.count * 2;
398 lines = itv->is_60hz ? 24 : 38;
399 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
403 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
405 /* Note: sliced vs raw flag doesn't seem to have any effect
406 TODO: check mode (0x02) value with older ivtv versions. */
407 data[0] = raw | 0x02 | (0xbd << 8);
409 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
411 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
412 data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
413 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
414 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
415 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
416 code. These values for raw VBI are obtained from a driver disassembly. The sliced
417 start/stop codes was deduced from this, but they do not appear in the driver.
418 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
419 However, I have no idea what these values are for. */
420 if (itv->hw_flags & IVTV_HW_CX25840) {
421 /* Setup VBI for the cx25840 digitizer */
423 data[3] = 0x20602060;
424 data[4] = 0x30703070;
426 data[3] = 0xB0F0B0F0;
427 data[4] = 0xA0E0A0E0;
429 /* Lines per frame */
432 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
434 /* Setup VBI for the saa7115 digitizer */
436 data[3] = 0x25256262;
437 data[4] = 0x387F7F7F;
439 data[3] = 0xABABECEC;
440 data[4] = 0xB6F1F1F1;
442 /* Lines per frame */
445 data[6] = itv->vbi.enc_size / lines;
449 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
450 data[0], data[1], data[2], data[5], data[6]);
452 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
454 /* returns the VBI encoder memory area. */
455 itv->vbi.enc_start = data[2];
456 itv->vbi.fpi = data[0];
460 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
461 itv->vbi.enc_start, data[1], itv->vbi.fpi);
464 Note that the sliced argument seems to have no effect. */
465 for (i = 2; i <= 24; i++) {
469 valid = i >= 10 && i < 22;
471 valid = i >= 6 && i < 24;
473 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
475 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
479 /* Remaining VBI questions:
480 - Is it possible to select particular VBI lines only for inclusion in the MPEG
481 stream? Currently you can only get the first X lines.
482 - Is mixed raw and sliced VBI possible?
483 - What's the meaning of the raw/sliced flag?
484 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
487 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
489 u32 data[CX2341X_MBOX_MAX_DATA];
490 struct ivtv *itv = s->itv;
491 int captype = 0, subtype = 0;
492 int enable_passthrough = 0;
494 if (s->vdev.v4l2_dev == NULL)
497 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
500 case IVTV_ENC_STREAM_TYPE_MPG:
504 /* Stop Passthrough */
505 if (itv->output_mode == OUT_PASSTHROUGH) {
506 ivtv_passthrough_mode(itv, 0);
507 enable_passthrough = 1;
509 itv->mpg_data_received = itv->vbi_data_inserted = 0;
510 itv->dualwatch_jiffies = jiffies;
511 itv->dualwatch_stereo_mode = v4l2_ctrl_g_ctrl(itv->cxhdl.audio_mode);
512 itv->search_pack_header = 0;
515 case IVTV_ENC_STREAM_TYPE_YUV:
516 if (itv->output_mode == OUT_PASSTHROUGH) {
518 subtype = 11; /* video+audio+decoder */
524 case IVTV_ENC_STREAM_TYPE_PCM:
528 case IVTV_ENC_STREAM_TYPE_VBI:
533 itv->vbi.inserted_frame = 0;
534 memset(itv->vbi.sliced_mpeg_size,
535 0, sizeof(itv->vbi.sliced_mpeg_size));
540 s->subtype = subtype;
541 s->buffers_stolen = 0;
543 /* Clear Streamoff flags in case left from last capture */
544 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
546 if (atomic_read(&itv->capturing) == 0) {
549 /* Always use frame based mode. Experiments have demonstrated that byte
550 stream based mode results in dropped frames and corruption. Not often,
551 but occasionally. Many thanks go to Leonard Orb who spent a lot of
552 effort and time trying to trace the cause of the drop outs. */
553 /* 1 frame per DMA */
554 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
555 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
557 /* Stuff from Windows, we don't know what it is */
558 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
559 /* According to the docs, this should be correct. However, this is
560 untested. I don't dare enable this without having tested it.
561 Only very few old cards actually have this hardware combination.
562 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
563 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
565 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
566 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
567 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
568 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
570 /* assign placeholder */
571 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
572 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
574 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
576 else if (itv->card->hw_all & IVTV_HW_SAA7114)
581 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
584 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
588 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
589 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
590 itv->pgm_info_offset = data[0];
591 itv->pgm_info_num = data[1];
592 itv->pgm_info_write_idx = 0;
593 itv->pgm_info_read_idx = 0;
595 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
596 itv->pgm_info_offset, itv->pgm_info_num);
598 /* Setup API for Stream */
599 cx2341x_handler_setup(&itv->cxhdl);
601 /* mute if capturing radio */
602 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
603 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
604 1 | (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
608 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
609 /* event notification (on) */
610 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
611 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
614 if (atomic_read(&itv->capturing) == 0) {
615 /* Clear all Pending Interrupts */
616 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
618 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
620 cx2341x_handler_set_busy(&itv->cxhdl, 1);
622 /* Initialize Digitizer for Capture */
623 /* Avoid tinny audio problem - ensure audio clocks are going */
624 v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
625 /* Avoid unpredictable PCI bus hang - disable video clocks */
626 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
627 ivtv_msleep_timeout(300, 0);
628 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
629 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
633 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
635 IVTV_DEBUG_WARN( "Error starting capture!\n");
639 /* Start Passthrough */
640 if (enable_passthrough) {
641 ivtv_passthrough_mode(itv, 1);
644 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
645 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
647 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
649 /* you're live! sit back and await interrupts :) */
650 atomic_inc(&itv->capturing);
653 EXPORT_SYMBOL(ivtv_start_v4l2_encode_stream);
655 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
657 u32 data[CX2341X_MBOX_MAX_DATA];
658 struct ivtv *itv = s->itv;
663 if (s->vdev.v4l2_dev == NULL)
666 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
668 width = itv->cxhdl.width;
669 height = itv->cxhdl.height;
671 /* set audio mode to left/stereo for dual/stereo mode. */
672 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
674 /* set number of internal decoder buffers */
675 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
678 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
680 /* extract from user packets */
681 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
682 itv->vbi.dec_start = data[0];
684 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
685 itv->vbi.dec_start, data[1]);
687 /* set decoder source settings */
688 /* Data type: 0 = mpeg from host,
689 1 = yuv from encoder,
692 case IVTV_DEC_STREAM_TYPE_YUV:
693 if (itv->output_mode == OUT_PASSTHROUGH) {
696 /* Fake size to avoid switching video standard */
699 height = itv->is_out_50hz ? 576 : 480;
701 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
703 case IVTV_DEC_STREAM_TYPE_MPG:
708 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
709 width, height, itv->cxhdl.audio_properties)) {
710 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
713 /* Decoder sometimes dies here, so wait a moment */
714 ivtv_msleep_timeout(10, 0);
716 /* Known failure point for firmware, so check */
717 return ivtv_firmware_check(itv, "ivtv_setup_v4l2_decode_stream");
720 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
722 struct ivtv *itv = s->itv;
725 if (s->vdev.v4l2_dev == NULL)
728 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
729 return 0; /* already started */
731 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
733 rc = ivtv_setup_v4l2_decode_stream(s);
735 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
739 /* set dma size to 65536 bytes */
740 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
742 /* Clear Streamoff */
743 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
745 /* Zero out decoder counters */
746 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
747 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
748 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
749 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
750 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
751 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
752 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
753 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
755 /* turn on notification of dual/stereo mode change */
756 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
759 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
761 /* Let things settle before we actually start */
762 ivtv_msleep_timeout(10, 0);
764 /* Clear the following Interrupt mask bits for decoding */
765 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
766 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
768 /* you're live! sit back and await interrupts :) */
769 atomic_inc(&itv->decoding);
773 void ivtv_stop_all_captures(struct ivtv *itv)
777 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
778 struct ivtv_stream *s = &itv->streams[i];
780 if (s->vdev.v4l2_dev == NULL)
782 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
783 ivtv_stop_v4l2_encode_stream(s, 0);
788 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
790 struct ivtv *itv = s->itv;
791 DECLARE_WAITQUEUE(wait, current);
795 if (s->vdev.v4l2_dev == NULL)
798 /* This function assumes that you are allowed to stop the capture
799 and that we are actually capturing */
801 IVTV_DEBUG_INFO("Stop Capture\n");
803 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
805 if (atomic_read(&itv->capturing) == 0)
809 case IVTV_ENC_STREAM_TYPE_YUV:
812 case IVTV_ENC_STREAM_TYPE_PCM:
815 case IVTV_ENC_STREAM_TYPE_VBI:
818 case IVTV_ENC_STREAM_TYPE_MPG:
824 /* Stop Capture Mode */
825 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
832 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
833 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
835 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
836 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
837 /* only run these if we're shutting down the last cap */
838 unsigned long duration;
839 unsigned long then = jiffies;
841 add_wait_queue(&itv->eos_waitq, &wait);
843 set_current_state(TASK_INTERRUPTIBLE);
845 /* wait 2s for EOS interrupt */
846 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
848 then + msecs_to_jiffies(2000))) {
849 schedule_timeout(msecs_to_jiffies(10));
852 /* To convert jiffies to ms, we must multiply by 1000
853 * and divide by HZ. To avoid runtime division, we
854 * convert this to multiplication by 1000/HZ.
855 * Since integer division truncates, we get the best
856 * accuracy if we do a rounding calculation of the constant.
857 * Think of the case where HZ is 1024.
859 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
861 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
862 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
863 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
865 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
867 set_current_state(TASK_RUNNING);
868 remove_wait_queue(&itv->eos_waitq, &wait);
869 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
872 /* Handle any pending interrupts */
873 ivtv_msleep_timeout(100, 0);
876 atomic_dec(&itv->capturing);
878 /* Clear capture and no-read bits */
879 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
881 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
882 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
884 if (atomic_read(&itv->capturing) > 0) {
888 cx2341x_handler_set_busy(&itv->cxhdl, 0);
890 /* Set the following Interrupt mask bits for capture */
891 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
892 del_timer(&itv->dma_timer);
894 /* event notification (off) */
895 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
896 /* type: 0 = refresh */
897 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
898 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
899 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
902 /* Raw-passthrough is implied on start. Make sure it's stopped so
903 the encoder will re-initialize when next started */
904 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
910 EXPORT_SYMBOL(ivtv_stop_v4l2_encode_stream);
912 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
914 static const struct v4l2_event ev = {
915 .type = V4L2_EVENT_EOS,
917 struct ivtv *itv = s->itv;
919 if (s->vdev.v4l2_dev == NULL)
922 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
925 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
928 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
931 if (!(flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) || pts) {
934 /* Wait until the decoder is no longer running */
936 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
937 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
940 u32 data[CX2341X_MBOX_MAX_DATA];
941 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
942 if (s->q_full.buffers + s->q_dma.buffers == 0) {
947 if (ivtv_msleep_timeout(100, 1))
951 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & V4L2_DEC_CMD_STOP_TO_BLACK, 0, 0);
953 /* turn off notification of dual/stereo mode change */
954 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
956 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
957 del_timer(&itv->dma_timer);
959 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
960 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
961 ivtv_flush_queues(s);
963 /* decoder needs time to settle */
964 ivtv_msleep_timeout(40, 0);
966 /* decrement decoding */
967 atomic_dec(&itv->decoding);
969 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
970 wake_up(&itv->event_waitq);
971 v4l2_event_queue(&s->vdev, &ev);
973 /* wake up wait queues */
979 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
981 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
982 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
984 if (yuv_stream->vdev.v4l2_dev == NULL || dec_stream->vdev.v4l2_dev == NULL)
987 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
989 /* Prevent others from starting/stopping streams while we
990 initiate/terminate passthrough mode */
992 if (itv->output_mode == OUT_PASSTHROUGH) {
995 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
998 /* Fully initialize stream, and then unflag init */
999 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1000 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1002 /* Setup YUV Decoder */
1003 ivtv_setup_v4l2_decode_stream(dec_stream);
1006 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
1007 atomic_inc(&itv->decoding);
1009 /* Setup capture if not already done */
1010 if (atomic_read(&itv->capturing) == 0) {
1011 cx2341x_handler_setup(&itv->cxhdl);
1012 cx2341x_handler_set_busy(&itv->cxhdl, 1);
1015 /* Start Passthrough Mode */
1016 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
1017 atomic_inc(&itv->capturing);
1021 if (itv->output_mode != OUT_PASSTHROUGH)
1024 /* Stop Passthrough Mode */
1025 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
1026 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
1028 atomic_dec(&itv->capturing);
1029 atomic_dec(&itv->decoding);
1030 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1031 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1032 itv->output_mode = OUT_NONE;
1033 if (atomic_read(&itv->capturing) == 0)
1034 cx2341x_handler_set_busy(&itv->cxhdl, 0);