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"
46 static const struct file_operations ivtv_v4l2_enc_fops = {
48 .read = ivtv_v4l2_read,
49 .write = ivtv_v4l2_write,
50 .open = ivtv_v4l2_open,
51 .ioctl = ivtv_v4l2_ioctl,
52 .release = ivtv_v4l2_close,
53 .poll = ivtv_v4l2_enc_poll,
56 static const struct file_operations ivtv_v4l2_dec_fops = {
58 .read = ivtv_v4l2_read,
59 .write = ivtv_v4l2_write,
60 .open = ivtv_v4l2_open,
61 .ioctl = ivtv_v4l2_ioctl,
62 .release = ivtv_v4l2_close,
63 .poll = ivtv_v4l2_dec_poll,
66 #define IVTV_V4L2_DEC_MPG_OFFSET 16 /* offset from 0 to register decoder mpg v4l2 minors on */
67 #define IVTV_V4L2_ENC_PCM_OFFSET 24 /* offset from 0 to register pcm v4l2 minors on */
68 #define IVTV_V4L2_ENC_YUV_OFFSET 32 /* offset from 0 to register yuv v4l2 minors on */
69 #define IVTV_V4L2_DEC_YUV_OFFSET 48 /* offset from 0 to register decoder yuv v4l2 minors on */
70 #define IVTV_V4L2_DEC_VBI_OFFSET 8 /* offset from 0 to register decoder vbi input v4l2 minors on */
71 #define IVTV_V4L2_DEC_VOUT_OFFSET 16 /* offset from 0 to register vbi output v4l2 minors on */
78 enum v4l2_buf_type buf_type;
79 const struct file_operations *fops;
80 } ivtv_stream_info[] = {
81 { /* IVTV_ENC_STREAM_TYPE_MPG */
84 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
87 { /* IVTV_ENC_STREAM_TYPE_YUV */
89 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
90 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
93 { /* IVTV_ENC_STREAM_TYPE_VBI */
96 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE,
99 { /* IVTV_ENC_STREAM_TYPE_PCM */
101 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
102 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE,
105 { /* IVTV_ENC_STREAM_TYPE_RAD */
108 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE,
111 { /* IVTV_DEC_STREAM_TYPE_MPG */
113 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
114 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
117 { /* IVTV_DEC_STREAM_TYPE_VBI */
119 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
120 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE,
123 { /* IVTV_DEC_STREAM_TYPE_VOUT */
125 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
126 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT,
129 { /* IVTV_DEC_STREAM_TYPE_YUV */
131 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
132 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
137 static void ivtv_stream_init(struct ivtv *itv, int type)
139 struct ivtv_stream *s = &itv->streams[type];
140 struct video_device *dev = s->v4l2dev;
142 /* we need to keep v4l2dev, so restore it afterwards */
143 memset(s, 0, sizeof(*s));
146 /* initialize ivtv_stream fields */
149 s->name = ivtv_stream_info[type].name;
151 if (ivtv_stream_info[type].pio)
152 s->dma = PCI_DMA_NONE;
154 s->dma = ivtv_stream_info[type].dma;
155 s->buf_size = itv->stream_buf_size[type];
157 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
158 spin_lock_init(&s->qlock);
159 init_waitqueue_head(&s->waitq);
161 s->sg_handle = IVTV_DMA_UNMAPPED;
162 ivtv_queue_init(&s->q_free);
163 ivtv_queue_init(&s->q_full);
164 ivtv_queue_init(&s->q_dma);
165 ivtv_queue_init(&s->q_predma);
166 ivtv_queue_init(&s->q_io);
169 static int ivtv_prep_dev(struct ivtv *itv, int type)
171 struct ivtv_stream *s = &itv->streams[type];
172 int minor_offset = ivtv_stream_info[type].minor_offset;
175 /* These four fields are always initialized. If v4l2dev == NULL, then
176 this stream is not in use. In that case no other fields but these
181 s->name = ivtv_stream_info[type].name;
183 /* Check whether the radio is supported */
184 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
186 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
189 /* card number + user defined offset + device offset */
190 minor = itv->num + ivtv_first_minor + minor_offset;
192 /* User explicitly selected 0 buffers for these streams, so don't
194 if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
195 itv->options.kilobytes[type] == 0) {
196 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
200 ivtv_stream_init(itv, type);
202 /* allocate and initialize the v4l2 video device structure */
203 s->v4l2dev = video_device_alloc();
204 if (s->v4l2dev == NULL) {
205 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
209 s->v4l2dev->type = VID_TYPE_CAPTURE | VID_TYPE_TUNER | VID_TYPE_TELETEXT |
210 VID_TYPE_CLIPPING | VID_TYPE_SCALES | VID_TYPE_MPEG_ENCODER;
211 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
212 s->v4l2dev->type |= VID_TYPE_MPEG_DECODER;
214 snprintf(s->v4l2dev->name, sizeof(s->v4l2dev->name), "ivtv%d %s",
217 s->v4l2dev->minor = minor;
218 s->v4l2dev->dev = &itv->dev->dev;
219 s->v4l2dev->fops = ivtv_stream_info[type].fops;
220 s->v4l2dev->release = video_device_release;
225 /* Initialize v4l2 variables and prepare v4l2 devices */
226 int ivtv_streams_setup(struct ivtv *itv)
230 /* Setup V4L2 Devices */
231 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
233 if (ivtv_prep_dev(itv, type))
236 if (itv->streams[type].v4l2dev == NULL)
239 /* Allocate Stream */
240 if (ivtv_stream_alloc(&itv->streams[type]))
243 if (type == IVTV_MAX_STREAMS)
246 /* One or more streams could not be initialized. Clean 'em all up. */
247 ivtv_streams_cleanup(itv, 0);
251 static int ivtv_reg_dev(struct ivtv *itv, int type)
253 struct ivtv_stream *s = &itv->streams[type];
254 int vfl_type = ivtv_stream_info[type].vfl_type;
257 if (s->v4l2dev == NULL)
260 minor = s->v4l2dev->minor;
261 /* Register device. First try the desired minor, then any free one. */
262 if (video_register_device(s->v4l2dev, vfl_type, minor) &&
263 video_register_device(s->v4l2dev, vfl_type, -1)) {
264 IVTV_ERR("Couldn't register v4l2 device for %s minor %d\n",
266 video_device_release(s->v4l2dev);
272 case VFL_TYPE_GRABBER:
273 IVTV_INFO("Registered device video%d for %s (%d kB)\n",
274 s->v4l2dev->minor, s->name, itv->options.kilobytes[type]);
277 IVTV_INFO("Registered device radio%d for %s\n",
278 s->v4l2dev->minor - MINOR_VFL_TYPE_RADIO_MIN, s->name);
281 if (itv->options.kilobytes[type])
282 IVTV_INFO("Registered device vbi%d for %s (%d kB)\n",
283 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN,
284 s->name, itv->options.kilobytes[type]);
286 IVTV_INFO("Registered device vbi%d for %s\n",
287 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN, s->name);
293 /* Register v4l2 devices */
294 int ivtv_streams_register(struct ivtv *itv)
299 /* Register V4L2 devices */
300 for (type = 0; type < IVTV_MAX_STREAMS; type++)
301 err |= ivtv_reg_dev(itv, type);
306 /* One or more streams could not be initialized. Clean 'em all up. */
307 ivtv_streams_cleanup(itv, 1);
311 /* Unregister v4l2 devices */
312 void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
316 /* Teardown all streams */
317 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
318 struct video_device *vdev = itv->streams[type].v4l2dev;
320 itv->streams[type].v4l2dev = NULL;
324 ivtv_stream_free(&itv->streams[type]);
325 /* Unregister or release device */
327 video_unregister_device(vdev);
329 video_device_release(vdev);
333 static void ivtv_vbi_setup(struct ivtv *itv)
335 int raw = itv->vbi.sliced_in->service_set == 0;
336 u32 data[CX2341X_MBOX_MAX_DATA];
341 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
343 /* setup VBI registers */
344 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
346 /* determine number of lines and total number of VBI bytes.
347 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
348 The '- 1' byte is probably an unused U or V byte. Or something...
349 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
350 header, 42 data bytes + checksum (to be confirmed) */
352 lines = itv->vbi.count * 2;
354 lines = itv->is_60hz ? 24 : 38;
355 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
359 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
361 /* Note: sliced vs raw flag doesn't seem to have any effect
362 TODO: check mode (0x02) value with older ivtv versions. */
363 data[0] = raw | 0x02 | (0xbd << 8);
365 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
367 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
368 data[2] = raw ? 4 : 8;
369 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
370 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
371 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
372 code. These values for raw VBI are obtained from a driver disassembly. The sliced
373 start/stop codes was deduced from this, but they do not appear in the driver.
374 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
375 However, I have no idea what these values are for. */
376 if (itv->hw_flags & IVTV_HW_CX25840) {
377 /* Setup VBI for the cx25840 digitizer */
379 data[3] = 0x20602060;
380 data[4] = 0x30703070;
382 data[3] = 0xB0F0B0F0;
383 data[4] = 0xA0E0A0E0;
385 /* Lines per frame */
388 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
390 /* Setup VBI for the saa7115 digitizer */
392 data[3] = 0x25256262;
393 data[4] = 0x387F7F7F;
395 data[3] = 0xABABECEC;
396 data[4] = 0xB6F1F1F1;
398 /* Lines per frame */
401 data[6] = itv->vbi.enc_size / lines;
405 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
406 data[0], data[1], data[2], data[5], data[6]);
408 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
410 /* returns the VBI encoder memory area. */
411 itv->vbi.enc_start = data[2];
412 itv->vbi.fpi = data[0];
416 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
417 itv->vbi.enc_start, data[1], itv->vbi.fpi);
420 Note that the sliced argument seems to have no effect. */
421 for (i = 2; i <= 24; i++) {
425 valid = i >= 10 && i < 22;
427 valid = i >= 6 && i < 24;
429 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
431 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
435 /* Remaining VBI questions:
436 - Is it possible to select particular VBI lines only for inclusion in the MPEG
437 stream? Currently you can only get the first X lines.
438 - Is mixed raw and sliced VBI possible?
439 - What's the meaning of the raw/sliced flag?
440 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
443 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
445 u32 data[CX2341X_MBOX_MAX_DATA];
446 struct ivtv *itv = s->itv;
447 struct cx2341x_mpeg_params *p = &itv->params;
448 int captype = 0, subtype = 0;
449 int enable_passthrough = 0;
451 if (s->v4l2dev == NULL)
454 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
457 case IVTV_ENC_STREAM_TYPE_MPG:
461 /* Stop Passthrough */
462 if (itv->output_mode == OUT_PASSTHROUGH) {
463 ivtv_passthrough_mode(itv, 0);
464 enable_passthrough = 1;
466 itv->mpg_data_received = itv->vbi_data_inserted = 0;
467 itv->dualwatch_jiffies = jiffies;
468 itv->dualwatch_stereo_mode = p->audio_properties & 0x0300;
469 itv->search_pack_header = 0;
472 case IVTV_ENC_STREAM_TYPE_YUV:
473 if (itv->output_mode == OUT_PASSTHROUGH) {
475 subtype = 11; /* video+audio+decoder */
481 case IVTV_ENC_STREAM_TYPE_PCM:
485 case IVTV_ENC_STREAM_TYPE_VBI:
490 itv->vbi.inserted_frame = 0;
491 memset(itv->vbi.sliced_mpeg_size,
492 0, sizeof(itv->vbi.sliced_mpeg_size));
497 s->subtype = subtype;
498 s->buffers_stolen = 0;
500 /* Clear Streamoff flags in case left from last capture */
501 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
503 if (atomic_read(&itv->capturing) == 0) {
506 /* Always use frame based mode. Experiments have demonstrated that byte
507 stream based mode results in dropped frames and corruption. Not often,
508 but occasionally. Many thanks go to Leonard Orb who spent a lot of
509 effort and time trying to trace the cause of the drop outs. */
510 /* 1 frame per DMA */
511 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
512 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
514 /* Stuff from Windows, we don't know what it is */
515 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
516 /* According to the docs, this should be correct. However, this is
517 untested. I don't dare enable this without having tested it.
518 Only very few old cards actually have this hardware combination.
519 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
520 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
522 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
523 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
524 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
525 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
527 /* assign placeholder */
528 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
529 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
531 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
533 else if (itv->card->hw_all & IVTV_HW_SAA7114)
538 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
541 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
545 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
546 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
547 itv->pgm_info_offset = data[0];
548 itv->pgm_info_num = data[1];
549 itv->pgm_info_write_idx = 0;
550 itv->pgm_info_read_idx = 0;
552 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
553 itv->pgm_info_offset, itv->pgm_info_num);
555 /* Setup API for Stream */
556 cx2341x_update(itv, ivtv_api_func, NULL, p);
558 /* mute if capturing radio */
559 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
560 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
561 1 | (p->video_mute_yuv << 8));
565 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
566 /* event notification (on) */
567 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
568 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
571 if (atomic_read(&itv->capturing) == 0) {
572 /* Clear all Pending Interrupts */
573 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
575 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
577 /* Initialize Digitizer for Capture */
578 itv->video_dec_func(itv, VIDIOC_STREAMOFF, NULL);
579 ivtv_msleep_timeout(300, 1);
580 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
581 itv->video_dec_func(itv, VIDIOC_STREAMON, NULL);
585 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
587 IVTV_DEBUG_WARN( "Error starting capture!\n");
591 /* Start Passthrough */
592 if (enable_passthrough) {
593 ivtv_passthrough_mode(itv, 1);
596 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
597 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
599 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
601 /* you're live! sit back and await interrupts :) */
602 atomic_inc(&itv->capturing);
606 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
608 u32 data[CX2341X_MBOX_MAX_DATA];
609 struct ivtv *itv = s->itv;
610 struct cx2341x_mpeg_params *p = &itv->params;
613 if (s->v4l2dev == NULL)
616 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
618 /* set audio mode to left/stereo for dual/stereo mode. */
619 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
621 /* set number of internal decoder buffers */
622 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
625 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
627 /* extract from user packets */
628 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
629 itv->vbi.dec_start = data[0];
631 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
632 itv->vbi.dec_start, data[1]);
634 /* set decoder source settings */
635 /* Data type: 0 = mpeg from host,
636 1 = yuv from encoder,
639 case IVTV_DEC_STREAM_TYPE_YUV:
640 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
641 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
643 case IVTV_DEC_STREAM_TYPE_MPG:
648 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
649 p->width, p->height, p->audio_properties)) {
650 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
655 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
657 struct ivtv *itv = s->itv;
659 if (s->v4l2dev == NULL)
662 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
663 return 0; /* already started */
665 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
667 ivtv_setup_v4l2_decode_stream(s);
669 /* set dma size to 65536 bytes */
670 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
672 /* Clear Streamoff */
673 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
675 /* Zero out decoder counters */
676 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
677 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
678 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
679 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
680 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
681 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
682 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
683 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
685 /* turn on notification of dual/stereo mode change */
686 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
689 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
691 /* Clear the following Interrupt mask bits for decoding */
692 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
693 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
695 /* you're live! sit back and await interrupts :) */
696 atomic_inc(&itv->decoding);
700 void ivtv_stop_all_captures(struct ivtv *itv)
704 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
705 struct ivtv_stream *s = &itv->streams[i];
707 if (s->v4l2dev == NULL)
709 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
710 ivtv_stop_v4l2_encode_stream(s, 0);
715 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
717 struct ivtv *itv = s->itv;
718 DECLARE_WAITQUEUE(wait, current);
722 if (s->v4l2dev == NULL)
725 /* This function assumes that you are allowed to stop the capture
726 and that we are actually capturing */
728 IVTV_DEBUG_INFO("Stop Capture\n");
730 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
732 if (atomic_read(&itv->capturing) == 0)
736 case IVTV_ENC_STREAM_TYPE_YUV:
739 case IVTV_ENC_STREAM_TYPE_PCM:
742 case IVTV_ENC_STREAM_TYPE_VBI:
745 case IVTV_ENC_STREAM_TYPE_MPG:
751 /* Stop Capture Mode */
752 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
759 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
760 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
762 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
763 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
764 /* only run these if we're shutting down the last cap */
765 unsigned long duration;
766 unsigned long then = jiffies;
768 add_wait_queue(&itv->eos_waitq, &wait);
770 set_current_state(TASK_INTERRUPTIBLE);
772 /* wait 2s for EOS interrupt */
773 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
775 then + msecs_to_jiffies(2000))) {
776 schedule_timeout(msecs_to_jiffies(10));
779 /* To convert jiffies to ms, we must multiply by 1000
780 * and divide by HZ. To avoid runtime division, we
781 * convert this to multiplication by 1000/HZ.
782 * Since integer division truncates, we get the best
783 * accuracy if we do a rounding calculation of the constant.
784 * Think of the case where HZ is 1024.
786 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
788 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
789 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
790 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
792 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
794 set_current_state(TASK_RUNNING);
795 remove_wait_queue(&itv->eos_waitq, &wait);
796 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
799 /* Handle any pending interrupts */
800 ivtv_msleep_timeout(100, 1);
803 atomic_dec(&itv->capturing);
805 /* Clear capture and no-read bits */
806 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
808 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
809 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
811 if (atomic_read(&itv->capturing) > 0) {
815 /* Set the following Interrupt mask bits for capture */
816 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
817 del_timer(&itv->dma_timer);
819 /* event notification (off) */
820 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
821 /* type: 0 = refresh */
822 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
823 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
824 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
832 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
834 struct ivtv *itv = s->itv;
836 if (s->v4l2dev == NULL)
839 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
842 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
845 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
848 if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
851 /* Wait until the decoder is no longer running */
853 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
854 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
857 u32 data[CX2341X_MBOX_MAX_DATA];
858 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
859 if (s->q_full.buffers + s->q_dma.buffers == 0) {
864 if (ivtv_msleep_timeout(100, 1))
868 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
870 /* turn off notification of dual/stereo mode change */
871 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
873 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
874 del_timer(&itv->dma_timer);
876 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
877 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
878 ivtv_flush_queues(s);
880 /* decrement decoding */
881 atomic_dec(&itv->decoding);
883 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
884 wake_up(&itv->event_waitq);
886 /* wake up wait queues */
892 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
894 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
895 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
897 if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
900 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
902 /* Prevent others from starting/stopping streams while we
903 initiate/terminate passthrough mode */
905 if (itv->output_mode == OUT_PASSTHROUGH) {
908 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
911 /* Fully initialize stream, and then unflag init */
912 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
913 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
915 /* Setup YUV Decoder */
916 ivtv_setup_v4l2_decode_stream(dec_stream);
919 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
920 atomic_inc(&itv->decoding);
922 /* Setup capture if not already done */
923 if (atomic_read(&itv->capturing) == 0) {
924 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
927 /* Start Passthrough Mode */
928 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
929 atomic_inc(&itv->capturing);
933 if (itv->output_mode != OUT_PASSTHROUGH)
936 /* Stop Passthrough Mode */
937 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
938 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
940 atomic_dec(&itv->capturing);
941 atomic_dec(&itv->decoding);
942 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
943 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
944 itv->output_mode = OUT_NONE;