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 <media/v4l2-event.h>
47 static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
49 .read = ivtv_v4l2_read,
50 .write = ivtv_v4l2_write,
51 .open = ivtv_v4l2_open,
52 .unlocked_ioctl = ivtv_v4l2_ioctl,
53 .release = ivtv_v4l2_close,
54 .poll = ivtv_v4l2_enc_poll,
57 static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
59 .read = ivtv_v4l2_read,
60 .write = ivtv_v4l2_write,
61 .open = ivtv_v4l2_open,
62 .unlocked_ioctl = ivtv_v4l2_ioctl,
63 .release = ivtv_v4l2_close,
64 .poll = ivtv_v4l2_dec_poll,
67 #define IVTV_V4L2_DEC_MPG_OFFSET 16 /* offset from 0 to register decoder mpg v4l2 minors on */
68 #define IVTV_V4L2_ENC_PCM_OFFSET 24 /* offset from 0 to register pcm v4l2 minors on */
69 #define IVTV_V4L2_ENC_YUV_OFFSET 32 /* offset from 0 to register yuv v4l2 minors on */
70 #define IVTV_V4L2_DEC_YUV_OFFSET 48 /* offset from 0 to register decoder yuv v4l2 minors on */
71 #define IVTV_V4L2_DEC_VBI_OFFSET 8 /* offset from 0 to register decoder vbi input v4l2 minors on */
72 #define IVTV_V4L2_DEC_VOUT_OFFSET 16 /* offset from 0 to register vbi output v4l2 minors on */
79 enum v4l2_buf_type buf_type;
80 const struct v4l2_file_operations *fops;
81 } ivtv_stream_info[] = {
82 { /* IVTV_ENC_STREAM_TYPE_MPG */
85 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
88 { /* IVTV_ENC_STREAM_TYPE_YUV */
90 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
91 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
94 { /* IVTV_ENC_STREAM_TYPE_VBI */
97 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE,
100 { /* IVTV_ENC_STREAM_TYPE_PCM */
102 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
103 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE,
106 { /* IVTV_ENC_STREAM_TYPE_RAD */
109 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE,
112 { /* IVTV_DEC_STREAM_TYPE_MPG */
114 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
115 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
118 { /* IVTV_DEC_STREAM_TYPE_VBI */
120 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
121 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE,
124 { /* IVTV_DEC_STREAM_TYPE_VOUT */
126 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
127 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT,
130 { /* IVTV_DEC_STREAM_TYPE_YUV */
132 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
133 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
138 static void ivtv_stream_init(struct ivtv *itv, int type)
140 struct ivtv_stream *s = &itv->streams[type];
141 struct video_device *vdev = s->vdev;
143 /* we need to keep vdev, so restore it afterwards */
144 memset(s, 0, sizeof(*s));
147 /* initialize ivtv_stream fields */
150 s->name = ivtv_stream_info[type].name;
152 if (ivtv_stream_info[type].pio)
153 s->dma = PCI_DMA_NONE;
155 s->dma = ivtv_stream_info[type].dma;
156 s->buf_size = itv->stream_buf_size[type];
158 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
159 spin_lock_init(&s->qlock);
160 init_waitqueue_head(&s->waitq);
162 s->sg_handle = IVTV_DMA_UNMAPPED;
163 ivtv_queue_init(&s->q_free);
164 ivtv_queue_init(&s->q_full);
165 ivtv_queue_init(&s->q_dma);
166 ivtv_queue_init(&s->q_predma);
167 ivtv_queue_init(&s->q_io);
170 static int ivtv_prep_dev(struct ivtv *itv, int type)
172 struct ivtv_stream *s = &itv->streams[type];
173 int num_offset = ivtv_stream_info[type].num_offset;
174 int num = itv->instance + ivtv_first_minor + num_offset;
176 /* These four fields are always initialized. If vdev == NULL, then
177 this stream is not in use. In that case no other fields but these
182 s->name = ivtv_stream_info[type].name;
184 /* Check whether the radio is supported */
185 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
187 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
190 /* User explicitly selected 0 buffers for these streams, so don't
192 if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
193 itv->options.kilobytes[type] == 0) {
194 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
198 ivtv_stream_init(itv, type);
200 /* allocate and initialize the v4l2 video device structure */
201 s->vdev = video_device_alloc();
202 if (s->vdev == NULL) {
203 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
207 snprintf(s->vdev->name, sizeof(s->vdev->name), "%s %s",
208 itv->v4l2_dev.name, s->name);
211 s->vdev->v4l2_dev = &itv->v4l2_dev;
212 s->vdev->fops = ivtv_stream_info[type].fops;
213 s->vdev->release = video_device_release;
214 s->vdev->tvnorms = V4L2_STD_ALL;
215 ivtv_set_funcs(s->vdev);
219 /* Initialize v4l2 variables and prepare v4l2 devices */
220 int ivtv_streams_setup(struct ivtv *itv)
224 /* Setup V4L2 Devices */
225 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
227 if (ivtv_prep_dev(itv, type))
230 if (itv->streams[type].vdev == NULL)
233 /* Allocate Stream */
234 if (ivtv_stream_alloc(&itv->streams[type]))
237 if (type == IVTV_MAX_STREAMS)
240 /* One or more streams could not be initialized. Clean 'em all up. */
241 ivtv_streams_cleanup(itv, 0);
245 static int ivtv_reg_dev(struct ivtv *itv, int type)
247 struct ivtv_stream *s = &itv->streams[type];
248 int vfl_type = ivtv_stream_info[type].vfl_type;
256 /* card number + user defined offset + device offset */
257 if (type != IVTV_ENC_STREAM_TYPE_MPG) {
258 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
261 num = s_mpg->vdev->num + ivtv_stream_info[type].num_offset;
263 video_set_drvdata(s->vdev, s);
265 /* Register device. First try the desired minor, then any free one. */
266 if (video_register_device_no_warn(s->vdev, vfl_type, num)) {
267 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
269 video_device_release(s->vdev);
273 name = video_device_node_name(s->vdev);
276 case VFL_TYPE_GRABBER:
277 IVTV_INFO("Registered device %s for %s (%d kB)\n",
278 name, s->name, itv->options.kilobytes[type]);
281 IVTV_INFO("Registered device %s for %s\n",
285 if (itv->options.kilobytes[type])
286 IVTV_INFO("Registered device %s for %s (%d kB)\n",
287 name, s->name, itv->options.kilobytes[type]);
289 IVTV_INFO("Registered device %s for %s\n",
296 /* Register v4l2 devices */
297 int ivtv_streams_register(struct ivtv *itv)
302 /* Register V4L2 devices */
303 for (type = 0; type < IVTV_MAX_STREAMS; type++)
304 err |= ivtv_reg_dev(itv, type);
309 /* One or more streams could not be initialized. Clean 'em all up. */
310 ivtv_streams_cleanup(itv, 1);
314 /* Unregister v4l2 devices */
315 void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
319 /* Teardown all streams */
320 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
321 struct video_device *vdev = itv->streams[type].vdev;
323 itv->streams[type].vdev = NULL;
327 ivtv_stream_free(&itv->streams[type]);
328 /* Unregister or release device */
330 video_unregister_device(vdev);
332 video_device_release(vdev);
336 static void ivtv_vbi_setup(struct ivtv *itv)
338 int raw = ivtv_raw_vbi(itv);
339 u32 data[CX2341X_MBOX_MAX_DATA];
344 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
346 /* setup VBI registers */
348 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
350 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
352 /* determine number of lines and total number of VBI bytes.
353 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
354 The '- 1' byte is probably an unused U or V byte. Or something...
355 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
356 header, 42 data bytes + checksum (to be confirmed) */
358 lines = itv->vbi.count * 2;
360 lines = itv->is_60hz ? 24 : 38;
361 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
365 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
367 /* Note: sliced vs raw flag doesn't seem to have any effect
368 TODO: check mode (0x02) value with older ivtv versions. */
369 data[0] = raw | 0x02 | (0xbd << 8);
371 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
373 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
374 data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
375 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
376 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
377 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
378 code. These values for raw VBI are obtained from a driver disassembly. The sliced
379 start/stop codes was deduced from this, but they do not appear in the driver.
380 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
381 However, I have no idea what these values are for. */
382 if (itv->hw_flags & IVTV_HW_CX25840) {
383 /* Setup VBI for the cx25840 digitizer */
385 data[3] = 0x20602060;
386 data[4] = 0x30703070;
388 data[3] = 0xB0F0B0F0;
389 data[4] = 0xA0E0A0E0;
391 /* Lines per frame */
394 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
396 /* Setup VBI for the saa7115 digitizer */
398 data[3] = 0x25256262;
399 data[4] = 0x387F7F7F;
401 data[3] = 0xABABECEC;
402 data[4] = 0xB6F1F1F1;
404 /* Lines per frame */
407 data[6] = itv->vbi.enc_size / lines;
411 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
412 data[0], data[1], data[2], data[5], data[6]);
414 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
416 /* returns the VBI encoder memory area. */
417 itv->vbi.enc_start = data[2];
418 itv->vbi.fpi = data[0];
422 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
423 itv->vbi.enc_start, data[1], itv->vbi.fpi);
426 Note that the sliced argument seems to have no effect. */
427 for (i = 2; i <= 24; i++) {
431 valid = i >= 10 && i < 22;
433 valid = i >= 6 && i < 24;
435 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
437 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
441 /* Remaining VBI questions:
442 - Is it possible to select particular VBI lines only for inclusion in the MPEG
443 stream? Currently you can only get the first X lines.
444 - Is mixed raw and sliced VBI possible?
445 - What's the meaning of the raw/sliced flag?
446 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
449 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
451 u32 data[CX2341X_MBOX_MAX_DATA];
452 struct ivtv *itv = s->itv;
453 struct cx2341x_mpeg_params *p = &itv->params;
454 int captype = 0, subtype = 0;
455 int enable_passthrough = 0;
460 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
463 case IVTV_ENC_STREAM_TYPE_MPG:
467 /* Stop Passthrough */
468 if (itv->output_mode == OUT_PASSTHROUGH) {
469 ivtv_passthrough_mode(itv, 0);
470 enable_passthrough = 1;
472 itv->mpg_data_received = itv->vbi_data_inserted = 0;
473 itv->dualwatch_jiffies = jiffies;
474 itv->dualwatch_stereo_mode = p->audio_properties & 0x0300;
475 itv->search_pack_header = 0;
478 case IVTV_ENC_STREAM_TYPE_YUV:
479 if (itv->output_mode == OUT_PASSTHROUGH) {
481 subtype = 11; /* video+audio+decoder */
487 case IVTV_ENC_STREAM_TYPE_PCM:
491 case IVTV_ENC_STREAM_TYPE_VBI:
496 itv->vbi.inserted_frame = 0;
497 memset(itv->vbi.sliced_mpeg_size,
498 0, sizeof(itv->vbi.sliced_mpeg_size));
503 s->subtype = subtype;
504 s->buffers_stolen = 0;
506 /* Clear Streamoff flags in case left from last capture */
507 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
509 if (atomic_read(&itv->capturing) == 0) {
512 /* Always use frame based mode. Experiments have demonstrated that byte
513 stream based mode results in dropped frames and corruption. Not often,
514 but occasionally. Many thanks go to Leonard Orb who spent a lot of
515 effort and time trying to trace the cause of the drop outs. */
516 /* 1 frame per DMA */
517 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
518 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
520 /* Stuff from Windows, we don't know what it is */
521 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
522 /* According to the docs, this should be correct. However, this is
523 untested. I don't dare enable this without having tested it.
524 Only very few old cards actually have this hardware combination.
525 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
526 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
528 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
529 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
530 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
531 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
533 /* assign placeholder */
534 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
535 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
537 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
539 else if (itv->card->hw_all & IVTV_HW_SAA7114)
544 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
547 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
551 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
552 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
553 itv->pgm_info_offset = data[0];
554 itv->pgm_info_num = data[1];
555 itv->pgm_info_write_idx = 0;
556 itv->pgm_info_read_idx = 0;
558 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
559 itv->pgm_info_offset, itv->pgm_info_num);
561 /* Setup API for Stream */
562 cx2341x_update(itv, ivtv_api_func, NULL, p);
564 /* mute if capturing radio */
565 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
566 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
567 1 | (p->video_mute_yuv << 8));
571 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
572 /* event notification (on) */
573 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
574 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
577 if (atomic_read(&itv->capturing) == 0) {
578 /* Clear all Pending Interrupts */
579 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
581 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
583 /* Initialize Digitizer for Capture */
584 /* Avoid tinny audio problem - ensure audio clocks are going */
585 v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
586 /* Avoid unpredictable PCI bus hang - disable video clocks */
587 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
588 ivtv_msleep_timeout(300, 1);
589 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
590 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
594 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
596 IVTV_DEBUG_WARN( "Error starting capture!\n");
600 /* Start Passthrough */
601 if (enable_passthrough) {
602 ivtv_passthrough_mode(itv, 1);
605 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
606 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
608 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
610 /* you're live! sit back and await interrupts :) */
611 atomic_inc(&itv->capturing);
615 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
617 u32 data[CX2341X_MBOX_MAX_DATA];
618 struct ivtv *itv = s->itv;
619 struct cx2341x_mpeg_params *p = &itv->params;
625 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
627 /* set audio mode to left/stereo for dual/stereo mode. */
628 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
630 /* set number of internal decoder buffers */
631 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
634 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
636 /* extract from user packets */
637 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
638 itv->vbi.dec_start = data[0];
640 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
641 itv->vbi.dec_start, data[1]);
643 /* set decoder source settings */
644 /* Data type: 0 = mpeg from host,
645 1 = yuv from encoder,
648 case IVTV_DEC_STREAM_TYPE_YUV:
649 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
650 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
652 case IVTV_DEC_STREAM_TYPE_MPG:
657 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
658 p->width, p->height, p->audio_properties)) {
659 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
664 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
666 struct ivtv *itv = s->itv;
671 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
672 return 0; /* already started */
674 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
676 ivtv_setup_v4l2_decode_stream(s);
678 /* set dma size to 65536 bytes */
679 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
681 /* Clear Streamoff */
682 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
684 /* Zero out decoder counters */
685 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
686 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
687 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
688 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
689 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
690 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
691 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
692 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
694 /* turn on notification of dual/stereo mode change */
695 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
698 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
700 /* Clear the following Interrupt mask bits for decoding */
701 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
702 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
704 /* you're live! sit back and await interrupts :) */
705 atomic_inc(&itv->decoding);
709 void ivtv_stop_all_captures(struct ivtv *itv)
713 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
714 struct ivtv_stream *s = &itv->streams[i];
718 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
719 ivtv_stop_v4l2_encode_stream(s, 0);
724 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
726 struct ivtv *itv = s->itv;
727 DECLARE_WAITQUEUE(wait, current);
734 /* This function assumes that you are allowed to stop the capture
735 and that we are actually capturing */
737 IVTV_DEBUG_INFO("Stop Capture\n");
739 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
741 if (atomic_read(&itv->capturing) == 0)
745 case IVTV_ENC_STREAM_TYPE_YUV:
748 case IVTV_ENC_STREAM_TYPE_PCM:
751 case IVTV_ENC_STREAM_TYPE_VBI:
754 case IVTV_ENC_STREAM_TYPE_MPG:
760 /* Stop Capture Mode */
761 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
768 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
769 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
771 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
772 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
773 /* only run these if we're shutting down the last cap */
774 unsigned long duration;
775 unsigned long then = jiffies;
777 add_wait_queue(&itv->eos_waitq, &wait);
779 set_current_state(TASK_INTERRUPTIBLE);
781 /* wait 2s for EOS interrupt */
782 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
784 then + msecs_to_jiffies(2000))) {
785 schedule_timeout(msecs_to_jiffies(10));
788 /* To convert jiffies to ms, we must multiply by 1000
789 * and divide by HZ. To avoid runtime division, we
790 * convert this to multiplication by 1000/HZ.
791 * Since integer division truncates, we get the best
792 * accuracy if we do a rounding calculation of the constant.
793 * Think of the case where HZ is 1024.
795 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
797 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
798 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
799 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
801 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
803 set_current_state(TASK_RUNNING);
804 remove_wait_queue(&itv->eos_waitq, &wait);
805 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
808 /* Handle any pending interrupts */
809 ivtv_msleep_timeout(100, 1);
812 atomic_dec(&itv->capturing);
814 /* Clear capture and no-read bits */
815 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
817 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
818 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
820 if (atomic_read(&itv->capturing) > 0) {
824 /* Set the following Interrupt mask bits for capture */
825 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
826 del_timer(&itv->dma_timer);
828 /* event notification (off) */
829 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
830 /* type: 0 = refresh */
831 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
832 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
833 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
836 /* Raw-passthrough is implied on start. Make sure it's stopped so
837 the encoder will re-initialize when next started */
838 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
845 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
847 static const struct v4l2_event ev = {
848 .type = V4L2_EVENT_EOS,
850 struct ivtv *itv = s->itv;
855 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
858 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
861 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
864 if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
867 /* Wait until the decoder is no longer running */
869 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
870 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
873 u32 data[CX2341X_MBOX_MAX_DATA];
874 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
875 if (s->q_full.buffers + s->q_dma.buffers == 0) {
880 if (ivtv_msleep_timeout(100, 1))
884 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
886 /* turn off notification of dual/stereo mode change */
887 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
889 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
890 del_timer(&itv->dma_timer);
892 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
893 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
894 ivtv_flush_queues(s);
896 /* decrement decoding */
897 atomic_dec(&itv->decoding);
899 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
900 wake_up(&itv->event_waitq);
901 v4l2_event_queue(s->vdev, &ev);
903 /* wake up wait queues */
909 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
911 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
912 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
914 if (yuv_stream->vdev == NULL || dec_stream->vdev == NULL)
917 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
919 /* Prevent others from starting/stopping streams while we
920 initiate/terminate passthrough mode */
922 if (itv->output_mode == OUT_PASSTHROUGH) {
925 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
928 /* Fully initialize stream, and then unflag init */
929 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
930 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
932 /* Setup YUV Decoder */
933 ivtv_setup_v4l2_decode_stream(dec_stream);
936 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
937 atomic_inc(&itv->decoding);
939 /* Setup capture if not already done */
940 if (atomic_read(&itv->capturing) == 0) {
941 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
944 /* Start Passthrough Mode */
945 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
946 atomic_inc(&itv->capturing);
950 if (itv->output_mode != OUT_PASSTHROUGH)
953 /* Stop Passthrough Mode */
954 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
955 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
957 atomic_dec(&itv->capturing);
958 atomic_dec(&itv->decoding);
959 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
960 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
961 itv->output_mode = OUT_NONE;