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,
54 .release = ivtv_v4l2_close,
55 .poll = ivtv_v4l2_enc_poll,
58 static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
60 .read = ivtv_v4l2_read,
61 .write = ivtv_v4l2_write,
62 .open = ivtv_v4l2_open,
63 .unlocked_ioctl = video_ioctl2,
64 .release = ivtv_v4l2_close,
65 .poll = ivtv_v4l2_dec_poll,
68 #define IVTV_V4L2_DEC_MPG_OFFSET 16 /* offset from 0 to register decoder mpg v4l2 minors on */
69 #define IVTV_V4L2_ENC_PCM_OFFSET 24 /* offset from 0 to register pcm v4l2 minors on */
70 #define IVTV_V4L2_ENC_YUV_OFFSET 32 /* offset from 0 to register yuv v4l2 minors on */
71 #define IVTV_V4L2_DEC_YUV_OFFSET 48 /* offset from 0 to register decoder yuv v4l2 minors on */
72 #define IVTV_V4L2_DEC_VBI_OFFSET 8 /* offset from 0 to register decoder vbi input v4l2 minors on */
73 #define IVTV_V4L2_DEC_VOUT_OFFSET 16 /* offset from 0 to register vbi output v4l2 minors on */
80 enum v4l2_buf_type buf_type;
82 const struct v4l2_file_operations *fops;
83 } ivtv_stream_info[] = {
84 { /* IVTV_ENC_STREAM_TYPE_MPG */
87 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
88 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
89 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
92 { /* IVTV_ENC_STREAM_TYPE_YUV */
94 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
95 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
96 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
97 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
100 { /* IVTV_ENC_STREAM_TYPE_VBI */
103 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE,
104 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_TUNER |
105 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
108 { /* IVTV_ENC_STREAM_TYPE_PCM */
110 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
111 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE,
112 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
115 { /* IVTV_ENC_STREAM_TYPE_RAD */
118 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE,
119 V4L2_CAP_RADIO | V4L2_CAP_TUNER,
122 { /* IVTV_DEC_STREAM_TYPE_MPG */
124 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
125 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
126 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
129 { /* IVTV_DEC_STREAM_TYPE_VBI */
131 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
132 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE,
133 V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_READWRITE,
136 { /* IVTV_DEC_STREAM_TYPE_VOUT */
138 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
139 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT,
140 V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
143 { /* IVTV_DEC_STREAM_TYPE_YUV */
145 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
146 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
147 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
152 static void ivtv_stream_init(struct ivtv *itv, int type)
154 struct ivtv_stream *s = &itv->streams[type];
155 struct video_device *vdev = s->vdev;
157 /* we need to keep vdev, so restore it afterwards */
158 memset(s, 0, sizeof(*s));
161 /* initialize ivtv_stream fields */
164 s->name = ivtv_stream_info[type].name;
165 s->caps = ivtv_stream_info[type].v4l2_caps;
167 if (ivtv_stream_info[type].pio)
168 s->dma = PCI_DMA_NONE;
170 s->dma = ivtv_stream_info[type].dma;
171 s->buf_size = itv->stream_buf_size[type];
173 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
174 spin_lock_init(&s->qlock);
175 init_waitqueue_head(&s->waitq);
176 s->sg_handle = IVTV_DMA_UNMAPPED;
177 ivtv_queue_init(&s->q_free);
178 ivtv_queue_init(&s->q_full);
179 ivtv_queue_init(&s->q_dma);
180 ivtv_queue_init(&s->q_predma);
181 ivtv_queue_init(&s->q_io);
184 static int ivtv_prep_dev(struct ivtv *itv, int type)
186 struct ivtv_stream *s = &itv->streams[type];
187 int num_offset = ivtv_stream_info[type].num_offset;
188 int num = itv->instance + ivtv_first_minor + num_offset;
190 /* These four fields are always initialized. If vdev == NULL, then
191 this stream is not in use. In that case no other fields but these
196 s->name = ivtv_stream_info[type].name;
198 /* Check whether the radio is supported */
199 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
201 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
204 /* User explicitly selected 0 buffers for these streams, so don't
206 if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
207 itv->options.kilobytes[type] == 0) {
208 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
212 ivtv_stream_init(itv, type);
214 /* allocate and initialize the v4l2 video device structure */
215 s->vdev = video_device_alloc();
216 if (s->vdev == NULL) {
217 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
221 snprintf(s->vdev->name, sizeof(s->vdev->name), "%s %s",
222 itv->v4l2_dev.name, s->name);
225 s->vdev->v4l2_dev = &itv->v4l2_dev;
226 s->vdev->fops = ivtv_stream_info[type].fops;
227 s->vdev->ctrl_handler = itv->v4l2_dev.ctrl_handler;
228 s->vdev->release = video_device_release;
229 s->vdev->tvnorms = V4L2_STD_ALL;
230 s->vdev->lock = &itv->serialize_lock;
231 /* Locking in file operations other than ioctl should be done
232 by the driver, not the V4L2 core.
233 This driver needs auditing so that this flag can be removed. */
234 set_bit(V4L2_FL_LOCK_ALL_FOPS, &s->vdev->flags);
235 set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev->flags);
236 ivtv_set_funcs(s->vdev);
240 /* Initialize v4l2 variables and prepare v4l2 devices */
241 int ivtv_streams_setup(struct ivtv *itv)
245 /* Setup V4L2 Devices */
246 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
248 if (ivtv_prep_dev(itv, type))
251 if (itv->streams[type].vdev == NULL)
254 /* Allocate Stream */
255 if (ivtv_stream_alloc(&itv->streams[type]))
258 if (type == IVTV_MAX_STREAMS)
261 /* One or more streams could not be initialized. Clean 'em all up. */
262 ivtv_streams_cleanup(itv, 0);
266 static int ivtv_reg_dev(struct ivtv *itv, int type)
268 struct ivtv_stream *s = &itv->streams[type];
269 int vfl_type = ivtv_stream_info[type].vfl_type;
277 /* card number + user defined offset + device offset */
278 if (type != IVTV_ENC_STREAM_TYPE_MPG) {
279 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
282 num = s_mpg->vdev->num + ivtv_stream_info[type].num_offset;
284 video_set_drvdata(s->vdev, s);
286 /* Register device. First try the desired minor, then any free one. */
287 if (video_register_device_no_warn(s->vdev, vfl_type, num)) {
288 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
290 video_device_release(s->vdev);
294 name = video_device_node_name(s->vdev);
297 case VFL_TYPE_GRABBER:
298 IVTV_INFO("Registered device %s for %s (%d kB)\n",
299 name, s->name, itv->options.kilobytes[type]);
302 IVTV_INFO("Registered device %s for %s\n",
306 if (itv->options.kilobytes[type])
307 IVTV_INFO("Registered device %s for %s (%d kB)\n",
308 name, s->name, itv->options.kilobytes[type]);
310 IVTV_INFO("Registered device %s for %s\n",
317 /* Register v4l2 devices */
318 int ivtv_streams_register(struct ivtv *itv)
323 /* Register V4L2 devices */
324 for (type = 0; type < IVTV_MAX_STREAMS; type++)
325 err |= ivtv_reg_dev(itv, type);
330 /* One or more streams could not be initialized. Clean 'em all up. */
331 ivtv_streams_cleanup(itv, 1);
335 /* Unregister v4l2 devices */
336 void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
340 /* Teardown all streams */
341 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
342 struct video_device *vdev = itv->streams[type].vdev;
344 itv->streams[type].vdev = NULL;
348 ivtv_stream_free(&itv->streams[type]);
349 /* Unregister or release device */
351 video_unregister_device(vdev);
353 video_device_release(vdev);
357 static void ivtv_vbi_setup(struct ivtv *itv)
359 int raw = ivtv_raw_vbi(itv);
360 u32 data[CX2341X_MBOX_MAX_DATA];
365 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
367 /* setup VBI registers */
369 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
371 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
373 /* determine number of lines and total number of VBI bytes.
374 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
375 The '- 1' byte is probably an unused U or V byte. Or something...
376 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
377 header, 42 data bytes + checksum (to be confirmed) */
379 lines = itv->vbi.count * 2;
381 lines = itv->is_60hz ? 24 : 38;
382 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
386 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
388 /* Note: sliced vs raw flag doesn't seem to have any effect
389 TODO: check mode (0x02) value with older ivtv versions. */
390 data[0] = raw | 0x02 | (0xbd << 8);
392 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
394 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
395 data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
396 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
397 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
398 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
399 code. These values for raw VBI are obtained from a driver disassembly. The sliced
400 start/stop codes was deduced from this, but they do not appear in the driver.
401 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
402 However, I have no idea what these values are for. */
403 if (itv->hw_flags & IVTV_HW_CX25840) {
404 /* Setup VBI for the cx25840 digitizer */
406 data[3] = 0x20602060;
407 data[4] = 0x30703070;
409 data[3] = 0xB0F0B0F0;
410 data[4] = 0xA0E0A0E0;
412 /* Lines per frame */
415 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
417 /* Setup VBI for the saa7115 digitizer */
419 data[3] = 0x25256262;
420 data[4] = 0x387F7F7F;
422 data[3] = 0xABABECEC;
423 data[4] = 0xB6F1F1F1;
425 /* Lines per frame */
428 data[6] = itv->vbi.enc_size / lines;
432 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
433 data[0], data[1], data[2], data[5], data[6]);
435 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
437 /* returns the VBI encoder memory area. */
438 itv->vbi.enc_start = data[2];
439 itv->vbi.fpi = data[0];
443 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
444 itv->vbi.enc_start, data[1], itv->vbi.fpi);
447 Note that the sliced argument seems to have no effect. */
448 for (i = 2; i <= 24; i++) {
452 valid = i >= 10 && i < 22;
454 valid = i >= 6 && i < 24;
456 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
458 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
462 /* Remaining VBI questions:
463 - Is it possible to select particular VBI lines only for inclusion in the MPEG
464 stream? Currently you can only get the first X lines.
465 - Is mixed raw and sliced VBI possible?
466 - What's the meaning of the raw/sliced flag?
467 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
470 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
472 u32 data[CX2341X_MBOX_MAX_DATA];
473 struct ivtv *itv = s->itv;
474 int captype = 0, subtype = 0;
475 int enable_passthrough = 0;
480 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
483 case IVTV_ENC_STREAM_TYPE_MPG:
487 /* Stop Passthrough */
488 if (itv->output_mode == OUT_PASSTHROUGH) {
489 ivtv_passthrough_mode(itv, 0);
490 enable_passthrough = 1;
492 itv->mpg_data_received = itv->vbi_data_inserted = 0;
493 itv->dualwatch_jiffies = jiffies;
494 itv->dualwatch_stereo_mode = v4l2_ctrl_g_ctrl(itv->cxhdl.audio_mode);
495 itv->search_pack_header = 0;
498 case IVTV_ENC_STREAM_TYPE_YUV:
499 if (itv->output_mode == OUT_PASSTHROUGH) {
501 subtype = 11; /* video+audio+decoder */
507 case IVTV_ENC_STREAM_TYPE_PCM:
511 case IVTV_ENC_STREAM_TYPE_VBI:
516 itv->vbi.inserted_frame = 0;
517 memset(itv->vbi.sliced_mpeg_size,
518 0, sizeof(itv->vbi.sliced_mpeg_size));
523 s->subtype = subtype;
524 s->buffers_stolen = 0;
526 /* Clear Streamoff flags in case left from last capture */
527 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
529 if (atomic_read(&itv->capturing) == 0) {
532 /* Always use frame based mode. Experiments have demonstrated that byte
533 stream based mode results in dropped frames and corruption. Not often,
534 but occasionally. Many thanks go to Leonard Orb who spent a lot of
535 effort and time trying to trace the cause of the drop outs. */
536 /* 1 frame per DMA */
537 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
538 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
540 /* Stuff from Windows, we don't know what it is */
541 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
542 /* According to the docs, this should be correct. However, this is
543 untested. I don't dare enable this without having tested it.
544 Only very few old cards actually have this hardware combination.
545 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
546 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
548 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
549 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
550 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
551 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
553 /* assign placeholder */
554 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
555 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
557 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
559 else if (itv->card->hw_all & IVTV_HW_SAA7114)
564 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
567 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
571 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
572 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
573 itv->pgm_info_offset = data[0];
574 itv->pgm_info_num = data[1];
575 itv->pgm_info_write_idx = 0;
576 itv->pgm_info_read_idx = 0;
578 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
579 itv->pgm_info_offset, itv->pgm_info_num);
581 /* Setup API for Stream */
582 cx2341x_handler_setup(&itv->cxhdl);
584 /* mute if capturing radio */
585 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
586 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
587 1 | (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
591 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
592 /* event notification (on) */
593 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
594 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
597 if (atomic_read(&itv->capturing) == 0) {
598 /* Clear all Pending Interrupts */
599 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
601 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
603 cx2341x_handler_set_busy(&itv->cxhdl, 1);
605 /* Initialize Digitizer for Capture */
606 /* Avoid tinny audio problem - ensure audio clocks are going */
607 v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
608 /* Avoid unpredictable PCI bus hang - disable video clocks */
609 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
610 ivtv_msleep_timeout(300, 0);
611 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
612 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
616 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
618 IVTV_DEBUG_WARN( "Error starting capture!\n");
622 /* Start Passthrough */
623 if (enable_passthrough) {
624 ivtv_passthrough_mode(itv, 1);
627 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
628 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
630 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
632 /* you're live! sit back and await interrupts :) */
633 atomic_inc(&itv->capturing);
637 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
639 u32 data[CX2341X_MBOX_MAX_DATA];
640 struct ivtv *itv = s->itv;
648 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
650 width = itv->cxhdl.width;
651 height = itv->cxhdl.height;
653 /* set audio mode to left/stereo for dual/stereo mode. */
654 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
656 /* set number of internal decoder buffers */
657 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
660 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
662 /* extract from user packets */
663 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
664 itv->vbi.dec_start = data[0];
666 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
667 itv->vbi.dec_start, data[1]);
669 /* set decoder source settings */
670 /* Data type: 0 = mpeg from host,
671 1 = yuv from encoder,
674 case IVTV_DEC_STREAM_TYPE_YUV:
675 if (itv->output_mode == OUT_PASSTHROUGH) {
678 /* Fake size to avoid switching video standard */
681 height = itv->is_out_50hz ? 576 : 480;
683 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
685 case IVTV_DEC_STREAM_TYPE_MPG:
690 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
691 width, height, itv->cxhdl.audio_properties)) {
692 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
695 /* Decoder sometimes dies here, so wait a moment */
696 ivtv_msleep_timeout(10, 0);
698 /* Known failure point for firmware, so check */
699 return ivtv_firmware_check(itv, "ivtv_setup_v4l2_decode_stream");
702 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
704 struct ivtv *itv = s->itv;
710 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
711 return 0; /* already started */
713 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
715 rc = ivtv_setup_v4l2_decode_stream(s);
717 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
721 /* set dma size to 65536 bytes */
722 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
724 /* Clear Streamoff */
725 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
727 /* Zero out decoder counters */
728 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
729 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
730 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
731 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
732 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
733 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
734 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
735 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
737 /* turn on notification of dual/stereo mode change */
738 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
741 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
743 /* Let things settle before we actually start */
744 ivtv_msleep_timeout(10, 0);
746 /* Clear the following Interrupt mask bits for decoding */
747 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
748 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
750 /* you're live! sit back and await interrupts :) */
751 atomic_inc(&itv->decoding);
755 void ivtv_stop_all_captures(struct ivtv *itv)
759 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
760 struct ivtv_stream *s = &itv->streams[i];
764 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
765 ivtv_stop_v4l2_encode_stream(s, 0);
770 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
772 struct ivtv *itv = s->itv;
773 DECLARE_WAITQUEUE(wait, current);
780 /* This function assumes that you are allowed to stop the capture
781 and that we are actually capturing */
783 IVTV_DEBUG_INFO("Stop Capture\n");
785 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
787 if (atomic_read(&itv->capturing) == 0)
791 case IVTV_ENC_STREAM_TYPE_YUV:
794 case IVTV_ENC_STREAM_TYPE_PCM:
797 case IVTV_ENC_STREAM_TYPE_VBI:
800 case IVTV_ENC_STREAM_TYPE_MPG:
806 /* Stop Capture Mode */
807 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
814 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
815 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
817 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
818 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
819 /* only run these if we're shutting down the last cap */
820 unsigned long duration;
821 unsigned long then = jiffies;
823 add_wait_queue(&itv->eos_waitq, &wait);
825 set_current_state(TASK_INTERRUPTIBLE);
827 /* wait 2s for EOS interrupt */
828 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
830 then + msecs_to_jiffies(2000))) {
831 schedule_timeout(msecs_to_jiffies(10));
834 /* To convert jiffies to ms, we must multiply by 1000
835 * and divide by HZ. To avoid runtime division, we
836 * convert this to multiplication by 1000/HZ.
837 * Since integer division truncates, we get the best
838 * accuracy if we do a rounding calculation of the constant.
839 * Think of the case where HZ is 1024.
841 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
843 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
844 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
845 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
847 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
849 set_current_state(TASK_RUNNING);
850 remove_wait_queue(&itv->eos_waitq, &wait);
851 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
854 /* Handle any pending interrupts */
855 ivtv_msleep_timeout(100, 0);
858 atomic_dec(&itv->capturing);
860 /* Clear capture and no-read bits */
861 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
863 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
864 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
866 if (atomic_read(&itv->capturing) > 0) {
870 cx2341x_handler_set_busy(&itv->cxhdl, 0);
872 /* Set the following Interrupt mask bits for capture */
873 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
874 del_timer(&itv->dma_timer);
876 /* event notification (off) */
877 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
878 /* type: 0 = refresh */
879 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
880 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
881 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
884 /* Raw-passthrough is implied on start. Make sure it's stopped so
885 the encoder will re-initialize when next started */
886 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
893 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
895 static const struct v4l2_event ev = {
896 .type = V4L2_EVENT_EOS,
898 struct ivtv *itv = s->itv;
903 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
906 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
909 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
912 if (!(flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) || pts) {
915 /* Wait until the decoder is no longer running */
917 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
918 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
921 u32 data[CX2341X_MBOX_MAX_DATA];
922 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
923 if (s->q_full.buffers + s->q_dma.buffers == 0) {
928 if (ivtv_msleep_timeout(100, 1))
932 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & V4L2_DEC_CMD_STOP_TO_BLACK, 0, 0);
934 /* turn off notification of dual/stereo mode change */
935 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
937 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
938 del_timer(&itv->dma_timer);
940 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
941 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
942 ivtv_flush_queues(s);
944 /* decoder needs time to settle */
945 ivtv_msleep_timeout(40, 0);
947 /* decrement decoding */
948 atomic_dec(&itv->decoding);
950 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
951 wake_up(&itv->event_waitq);
952 v4l2_event_queue(s->vdev, &ev);
954 /* wake up wait queues */
960 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
962 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
963 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
965 if (yuv_stream->vdev == NULL || dec_stream->vdev == NULL)
968 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
970 /* Prevent others from starting/stopping streams while we
971 initiate/terminate passthrough mode */
973 if (itv->output_mode == OUT_PASSTHROUGH) {
976 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
979 /* Fully initialize stream, and then unflag init */
980 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
981 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
983 /* Setup YUV Decoder */
984 ivtv_setup_v4l2_decode_stream(dec_stream);
987 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
988 atomic_inc(&itv->decoding);
990 /* Setup capture if not already done */
991 if (atomic_read(&itv->capturing) == 0) {
992 cx2341x_handler_setup(&itv->cxhdl);
993 cx2341x_handler_set_busy(&itv->cxhdl, 1);
996 /* Start Passthrough Mode */
997 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
998 atomic_inc(&itv->capturing);
1002 if (itv->output_mode != OUT_PASSTHROUGH)
1005 /* Stop Passthrough Mode */
1006 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
1007 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
1009 atomic_dec(&itv->capturing);
1010 atomic_dec(&itv->decoding);
1011 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1012 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1013 itv->output_mode = OUT_NONE;
1014 if (atomic_read(&itv->capturing) == 0)
1015 cx2341x_handler_set_busy(&itv->cxhdl, 0);