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
= ivtv_v4l2_ioctl
,
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
= ivtv_v4l2_ioctl
,
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
;
81 const struct v4l2_file_operations
*fops
;
82 } ivtv_stream_info
[] = {
83 { /* IVTV_ENC_STREAM_TYPE_MPG */
86 PCI_DMA_FROMDEVICE
, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
89 { /* IVTV_ENC_STREAM_TYPE_YUV */
91 VFL_TYPE_GRABBER
, IVTV_V4L2_ENC_YUV_OFFSET
,
92 PCI_DMA_FROMDEVICE
, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
95 { /* IVTV_ENC_STREAM_TYPE_VBI */
98 PCI_DMA_FROMDEVICE
, 0, V4L2_BUF_TYPE_VBI_CAPTURE
,
101 { /* IVTV_ENC_STREAM_TYPE_PCM */
103 VFL_TYPE_GRABBER
, IVTV_V4L2_ENC_PCM_OFFSET
,
104 PCI_DMA_FROMDEVICE
, 0, V4L2_BUF_TYPE_PRIVATE
,
107 { /* IVTV_ENC_STREAM_TYPE_RAD */
110 PCI_DMA_NONE
, 1, V4L2_BUF_TYPE_PRIVATE
,
113 { /* IVTV_DEC_STREAM_TYPE_MPG */
115 VFL_TYPE_GRABBER
, IVTV_V4L2_DEC_MPG_OFFSET
,
116 PCI_DMA_TODEVICE
, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT
,
119 { /* IVTV_DEC_STREAM_TYPE_VBI */
121 VFL_TYPE_VBI
, IVTV_V4L2_DEC_VBI_OFFSET
,
122 PCI_DMA_NONE
, 1, V4L2_BUF_TYPE_VBI_CAPTURE
,
125 { /* IVTV_DEC_STREAM_TYPE_VOUT */
127 VFL_TYPE_VBI
, IVTV_V4L2_DEC_VOUT_OFFSET
,
128 PCI_DMA_NONE
, 1, V4L2_BUF_TYPE_VBI_OUTPUT
,
131 { /* IVTV_DEC_STREAM_TYPE_YUV */
133 VFL_TYPE_GRABBER
, IVTV_V4L2_DEC_YUV_OFFSET
,
134 PCI_DMA_TODEVICE
, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT
,
139 static void ivtv_stream_init(struct ivtv
*itv
, int type
)
141 struct ivtv_stream
*s
= &itv
->streams
[type
];
142 struct video_device
*vdev
= s
->vdev
;
144 /* we need to keep vdev, so restore it afterwards */
145 memset(s
, 0, sizeof(*s
));
148 /* initialize ivtv_stream fields */
151 s
->name
= ivtv_stream_info
[type
].name
;
153 if (ivtv_stream_info
[type
].pio
)
154 s
->dma
= PCI_DMA_NONE
;
156 s
->dma
= ivtv_stream_info
[type
].dma
;
157 s
->buf_size
= itv
->stream_buf_size
[type
];
159 s
->buffers
= (itv
->options
.kilobytes
[type
] * 1024 + s
->buf_size
- 1) / s
->buf_size
;
160 spin_lock_init(&s
->qlock
);
161 init_waitqueue_head(&s
->waitq
);
163 s
->sg_handle
= IVTV_DMA_UNMAPPED
;
164 ivtv_queue_init(&s
->q_free
);
165 ivtv_queue_init(&s
->q_full
);
166 ivtv_queue_init(&s
->q_dma
);
167 ivtv_queue_init(&s
->q_predma
);
168 ivtv_queue_init(&s
->q_io
);
171 static int ivtv_prep_dev(struct ivtv
*itv
, int type
)
173 struct ivtv_stream
*s
= &itv
->streams
[type
];
174 int num_offset
= ivtv_stream_info
[type
].num_offset
;
175 int num
= itv
->instance
+ ivtv_first_minor
+ num_offset
;
177 /* These four fields are always initialized. If vdev == NULL, then
178 this stream is not in use. In that case no other fields but these
183 s
->name
= ivtv_stream_info
[type
].name
;
185 /* Check whether the radio is supported */
186 if (type
== IVTV_ENC_STREAM_TYPE_RAD
&& !(itv
->v4l2_cap
& V4L2_CAP_RADIO
))
188 if (type
>= IVTV_DEC_STREAM_TYPE_MPG
&& !(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
191 /* User explicitly selected 0 buffers for these streams, so don't
193 if (ivtv_stream_info
[type
].dma
!= PCI_DMA_NONE
&&
194 itv
->options
.kilobytes
[type
] == 0) {
195 IVTV_INFO("Disabled %s device\n", ivtv_stream_info
[type
].name
);
199 ivtv_stream_init(itv
, type
);
201 /* allocate and initialize the v4l2 video device structure */
202 s
->vdev
= video_device_alloc();
203 if (s
->vdev
== NULL
) {
204 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s
->name
);
208 snprintf(s
->vdev
->name
, sizeof(s
->vdev
->name
), "%s %s",
209 itv
->v4l2_dev
.name
, s
->name
);
212 s
->vdev
->v4l2_dev
= &itv
->v4l2_dev
;
213 s
->vdev
->ctrl_handler
= itv
->v4l2_dev
.ctrl_handler
;
214 s
->vdev
->fops
= ivtv_stream_info
[type
].fops
;
215 s
->vdev
->release
= video_device_release
;
216 s
->vdev
->tvnorms
= V4L2_STD_ALL
;
217 set_bit(V4L2_FL_USE_FH_PRIO
, &s
->vdev
->flags
);
218 ivtv_set_funcs(s
->vdev
);
222 /* Initialize v4l2 variables and prepare v4l2 devices */
223 int ivtv_streams_setup(struct ivtv
*itv
)
227 /* Setup V4L2 Devices */
228 for (type
= 0; type
< IVTV_MAX_STREAMS
; type
++) {
230 if (ivtv_prep_dev(itv
, type
))
233 if (itv
->streams
[type
].vdev
== NULL
)
236 /* Allocate Stream */
237 if (ivtv_stream_alloc(&itv
->streams
[type
]))
240 if (type
== IVTV_MAX_STREAMS
)
243 /* One or more streams could not be initialized. Clean 'em all up. */
244 ivtv_streams_cleanup(itv
, 0);
248 static int ivtv_reg_dev(struct ivtv
*itv
, int type
)
250 struct ivtv_stream
*s
= &itv
->streams
[type
];
251 int vfl_type
= ivtv_stream_info
[type
].vfl_type
;
259 /* card number + user defined offset + device offset */
260 if (type
!= IVTV_ENC_STREAM_TYPE_MPG
) {
261 struct ivtv_stream
*s_mpg
= &itv
->streams
[IVTV_ENC_STREAM_TYPE_MPG
];
264 num
= s_mpg
->vdev
->num
+ ivtv_stream_info
[type
].num_offset
;
266 video_set_drvdata(s
->vdev
, s
);
268 /* Register device. First try the desired minor, then any free one. */
269 if (video_register_device_no_warn(s
->vdev
, vfl_type
, num
)) {
270 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
272 video_device_release(s
->vdev
);
276 name
= video_device_node_name(s
->vdev
);
279 case VFL_TYPE_GRABBER
:
280 IVTV_INFO("Registered device %s for %s (%d kB)\n",
281 name
, s
->name
, itv
->options
.kilobytes
[type
]);
284 IVTV_INFO("Registered device %s for %s\n",
288 if (itv
->options
.kilobytes
[type
])
289 IVTV_INFO("Registered device %s for %s (%d kB)\n",
290 name
, s
->name
, itv
->options
.kilobytes
[type
]);
292 IVTV_INFO("Registered device %s for %s\n",
299 /* Register v4l2 devices */
300 int ivtv_streams_register(struct ivtv
*itv
)
305 /* Register V4L2 devices */
306 for (type
= 0; type
< IVTV_MAX_STREAMS
; type
++)
307 err
|= ivtv_reg_dev(itv
, type
);
312 /* One or more streams could not be initialized. Clean 'em all up. */
313 ivtv_streams_cleanup(itv
, 1);
317 /* Unregister v4l2 devices */
318 void ivtv_streams_cleanup(struct ivtv
*itv
, int unregister
)
322 /* Teardown all streams */
323 for (type
= 0; type
< IVTV_MAX_STREAMS
; type
++) {
324 struct video_device
*vdev
= itv
->streams
[type
].vdev
;
326 itv
->streams
[type
].vdev
= NULL
;
330 ivtv_stream_free(&itv
->streams
[type
]);
331 /* Unregister or release device */
333 video_unregister_device(vdev
);
335 video_device_release(vdev
);
339 static void ivtv_vbi_setup(struct ivtv
*itv
)
341 int raw
= ivtv_raw_vbi(itv
);
342 u32 data
[CX2341X_MBOX_MAX_DATA
];
347 ivtv_vapi(itv
, CX2341X_ENC_SET_VBI_LINE
, 5, 0xffff , 0, 0, 0, 0);
349 /* setup VBI registers */
351 v4l2_subdev_call(itv
->sd_video
, vbi
, s_raw_fmt
, &itv
->vbi
.in
.fmt
.vbi
);
353 v4l2_subdev_call(itv
->sd_video
, vbi
, s_sliced_fmt
, &itv
->vbi
.in
.fmt
.sliced
);
355 /* determine number of lines and total number of VBI bytes.
356 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
357 The '- 1' byte is probably an unused U or V byte. Or something...
358 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
359 header, 42 data bytes + checksum (to be confirmed) */
361 lines
= itv
->vbi
.count
* 2;
363 lines
= itv
->is_60hz
? 24 : 38;
364 if (itv
->is_60hz
&& (itv
->hw_flags
& IVTV_HW_CX25840
))
368 itv
->vbi
.enc_size
= lines
* (raw
? itv
->vbi
.raw_size
: itv
->vbi
.sliced_size
);
370 /* Note: sliced vs raw flag doesn't seem to have any effect
371 TODO: check mode (0x02) value with older ivtv versions. */
372 data
[0] = raw
| 0x02 | (0xbd << 8);
374 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
376 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
377 data
[2] = raw
? 4 : 4 * (itv
->vbi
.raw_size
/ itv
->vbi
.enc_size
);
378 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
379 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
380 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
381 code. These values for raw VBI are obtained from a driver disassembly. The sliced
382 start/stop codes was deduced from this, but they do not appear in the driver.
383 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
384 However, I have no idea what these values are for. */
385 if (itv
->hw_flags
& IVTV_HW_CX25840
) {
386 /* Setup VBI for the cx25840 digitizer */
388 data
[3] = 0x20602060;
389 data
[4] = 0x30703070;
391 data
[3] = 0xB0F0B0F0;
392 data
[4] = 0xA0E0A0E0;
394 /* Lines per frame */
397 data
[6] = (raw
? itv
->vbi
.raw_size
: itv
->vbi
.sliced_size
);
399 /* Setup VBI for the saa7115 digitizer */
401 data
[3] = 0x25256262;
402 data
[4] = 0x387F7F7F;
404 data
[3] = 0xABABECEC;
405 data
[4] = 0xB6F1F1F1;
407 /* Lines per frame */
410 data
[6] = itv
->vbi
.enc_size
/ lines
;
414 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
415 data
[0], data
[1], data
[2], data
[5], data
[6]);
417 ivtv_api(itv
, CX2341X_ENC_SET_VBI_CONFIG
, 7, data
);
419 /* returns the VBI encoder memory area. */
420 itv
->vbi
.enc_start
= data
[2];
421 itv
->vbi
.fpi
= data
[0];
425 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
426 itv
->vbi
.enc_start
, data
[1], itv
->vbi
.fpi
);
429 Note that the sliced argument seems to have no effect. */
430 for (i
= 2; i
<= 24; i
++) {
434 valid
= i
>= 10 && i
< 22;
436 valid
= i
>= 6 && i
< 24;
438 ivtv_vapi(itv
, CX2341X_ENC_SET_VBI_LINE
, 5, i
- 1,
440 ivtv_vapi(itv
, CX2341X_ENC_SET_VBI_LINE
, 5, (i
- 1) | 0x80000000,
444 /* Remaining VBI questions:
445 - Is it possible to select particular VBI lines only for inclusion in the MPEG
446 stream? Currently you can only get the first X lines.
447 - Is mixed raw and sliced VBI possible?
448 - What's the meaning of the raw/sliced flag?
449 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
452 int ivtv_start_v4l2_encode_stream(struct ivtv_stream
*s
)
454 u32 data
[CX2341X_MBOX_MAX_DATA
];
455 struct ivtv
*itv
= s
->itv
;
456 int captype
= 0, subtype
= 0;
457 int enable_passthrough
= 0;
462 IVTV_DEBUG_INFO("Start encoder stream %s\n", s
->name
);
465 case IVTV_ENC_STREAM_TYPE_MPG
:
469 /* Stop Passthrough */
470 if (itv
->output_mode
== OUT_PASSTHROUGH
) {
471 ivtv_passthrough_mode(itv
, 0);
472 enable_passthrough
= 1;
474 itv
->mpg_data_received
= itv
->vbi_data_inserted
= 0;
475 itv
->dualwatch_jiffies
= jiffies
;
476 itv
->dualwatch_stereo_mode
= v4l2_ctrl_g_ctrl(itv
->cxhdl
.audio_mode
);
477 itv
->search_pack_header
= 0;
480 case IVTV_ENC_STREAM_TYPE_YUV
:
481 if (itv
->output_mode
== OUT_PASSTHROUGH
) {
483 subtype
= 11; /* video+audio+decoder */
489 case IVTV_ENC_STREAM_TYPE_PCM
:
493 case IVTV_ENC_STREAM_TYPE_VBI
:
498 itv
->vbi
.inserted_frame
= 0;
499 memset(itv
->vbi
.sliced_mpeg_size
,
500 0, sizeof(itv
->vbi
.sliced_mpeg_size
));
505 s
->subtype
= subtype
;
506 s
->buffers_stolen
= 0;
508 /* Clear Streamoff flags in case left from last capture */
509 clear_bit(IVTV_F_S_STREAMOFF
, &s
->s_flags
);
511 if (atomic_read(&itv
->capturing
) == 0) {
514 /* Always use frame based mode. Experiments have demonstrated that byte
515 stream based mode results in dropped frames and corruption. Not often,
516 but occasionally. Many thanks go to Leonard Orb who spent a lot of
517 effort and time trying to trace the cause of the drop outs. */
518 /* 1 frame per DMA */
519 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
520 ivtv_vapi(itv
, CX2341X_ENC_SET_DMA_BLOCK_SIZE
, 2, 1, 1);
522 /* Stuff from Windows, we don't know what it is */
523 ivtv_vapi(itv
, CX2341X_ENC_SET_VERT_CROP_LINE
, 1, 0);
524 /* According to the docs, this should be correct. However, this is
525 untested. I don't dare enable this without having tested it.
526 Only very few old cards actually have this hardware combination.
527 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
528 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
530 ivtv_vapi(itv
, CX2341X_ENC_MISC
, 2, 3, !itv
->has_cx23415
);
531 ivtv_vapi(itv
, CX2341X_ENC_MISC
, 2, 8, 0);
532 ivtv_vapi(itv
, CX2341X_ENC_MISC
, 2, 4, 1);
533 ivtv_vapi(itv
, CX2341X_ENC_MISC
, 1, 12);
535 /* assign placeholder */
536 ivtv_vapi(itv
, CX2341X_ENC_SET_PLACEHOLDER
, 12,
537 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
539 if (itv
->card
->hw_all
& (IVTV_HW_SAA7115
| IVTV_HW_SAA717X
))
541 else if (itv
->card
->hw_all
& IVTV_HW_SAA7114
)
546 ivtv_vapi(itv
, CX2341X_ENC_SET_NUM_VSYNC_LINES
, 2, digitizer
, digitizer
);
549 if (itv
->v4l2_cap
& V4L2_CAP_VBI_CAPTURE
) {
553 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
554 ivtv_vapi_result(itv
, data
, CX2341X_ENC_SET_PGM_INDEX_INFO
, 2, 7, 400);
555 itv
->pgm_info_offset
= data
[0];
556 itv
->pgm_info_num
= data
[1];
557 itv
->pgm_info_write_idx
= 0;
558 itv
->pgm_info_read_idx
= 0;
560 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
561 itv
->pgm_info_offset
, itv
->pgm_info_num
);
563 /* Setup API for Stream */
564 cx2341x_handler_setup(&itv
->cxhdl
);
566 /* mute if capturing radio */
567 if (test_bit(IVTV_F_I_RADIO_USER
, &itv
->i_flags
))
568 ivtv_vapi(itv
, CX2341X_ENC_MUTE_VIDEO
, 1,
569 1 | (v4l2_ctrl_g_ctrl(itv
->cxhdl
.video_mute_yuv
) << 8));
573 if (itv
->has_cx23415
&& !test_and_set_bit(IVTV_F_I_DIG_RST
, &itv
->i_flags
)) {
574 /* event notification (on) */
575 ivtv_vapi(itv
, CX2341X_ENC_SET_EVENT_NOTIFICATION
, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST
, -1);
576 ivtv_clear_irq_mask(itv
, IVTV_IRQ_ENC_VIM_RST
);
579 if (atomic_read(&itv
->capturing
) == 0) {
580 /* Clear all Pending Interrupts */
581 ivtv_set_irq_mask(itv
, IVTV_IRQ_MASK_CAPTURE
);
583 clear_bit(IVTV_F_I_EOS
, &itv
->i_flags
);
585 cx2341x_handler_set_busy(&itv
->cxhdl
, 1);
587 /* Initialize Digitizer for Capture */
588 /* Avoid tinny audio problem - ensure audio clocks are going */
589 v4l2_subdev_call(itv
->sd_audio
, audio
, s_stream
, 1);
590 /* Avoid unpredictable PCI bus hang - disable video clocks */
591 v4l2_subdev_call(itv
->sd_video
, video
, s_stream
, 0);
592 ivtv_msleep_timeout(300, 1);
593 ivtv_vapi(itv
, CX2341X_ENC_INITIALIZE_INPUT
, 0);
594 v4l2_subdev_call(itv
->sd_video
, video
, s_stream
, 1);
598 if (ivtv_vapi(itv
, CX2341X_ENC_START_CAPTURE
, 2, captype
, subtype
))
600 IVTV_DEBUG_WARN( "Error starting capture!\n");
604 /* Start Passthrough */
605 if (enable_passthrough
) {
606 ivtv_passthrough_mode(itv
, 1);
609 if (s
->type
== IVTV_ENC_STREAM_TYPE_VBI
)
610 ivtv_clear_irq_mask(itv
, IVTV_IRQ_ENC_VBI_CAP
);
612 ivtv_clear_irq_mask(itv
, IVTV_IRQ_MASK_CAPTURE
);
614 /* you're live! sit back and await interrupts :) */
615 atomic_inc(&itv
->capturing
);
619 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream
*s
)
621 u32 data
[CX2341X_MBOX_MAX_DATA
];
622 struct ivtv
*itv
= s
->itv
;
630 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
632 width
= itv
->cxhdl
.width
;
633 height
= itv
->cxhdl
.height
;
635 /* set audio mode to left/stereo for dual/stereo mode. */
636 ivtv_vapi(itv
, CX2341X_DEC_SET_AUDIO_MODE
, 2, itv
->audio_bilingual_mode
, itv
->audio_stereo_mode
);
638 /* set number of internal decoder buffers */
639 ivtv_vapi(itv
, CX2341X_DEC_SET_DISPLAY_BUFFERS
, 1, 0);
642 ivtv_vapi(itv
, CX2341X_DEC_SET_PREBUFFERING
, 1, 1);
644 /* extract from user packets */
645 ivtv_vapi_result(itv
, data
, CX2341X_DEC_EXTRACT_VBI
, 1, 1);
646 itv
->vbi
.dec_start
= data
[0];
648 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
649 itv
->vbi
.dec_start
, data
[1]);
651 /* set decoder source settings */
652 /* Data type: 0 = mpeg from host,
653 1 = yuv from encoder,
656 case IVTV_DEC_STREAM_TYPE_YUV
:
657 if (itv
->output_mode
== OUT_PASSTHROUGH
) {
660 /* Fake size to avoid switching video standard */
663 height
= itv
->is_out_50hz
? 576 : 480;
665 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype
);
667 case IVTV_DEC_STREAM_TYPE_MPG
:
672 if (ivtv_vapi(itv
, CX2341X_DEC_SET_DECODER_SOURCE
, 4, datatype
,
673 width
, height
, itv
->cxhdl
.audio_properties
)) {
674 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
677 /* Decoder sometimes dies here, so wait a moment */
678 ivtv_msleep_timeout(10, 0);
680 /* Known failure point for firmware, so check */
681 return ivtv_firmware_check(itv
, "ivtv_setup_v4l2_decode_stream");
684 int ivtv_start_v4l2_decode_stream(struct ivtv_stream
*s
, int gop_offset
)
686 struct ivtv
*itv
= s
->itv
;
692 if (test_and_set_bit(IVTV_F_S_STREAMING
, &s
->s_flags
))
693 return 0; /* already started */
695 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s
->name
, gop_offset
);
697 rc
= ivtv_setup_v4l2_decode_stream(s
);
699 clear_bit(IVTV_F_S_STREAMING
, &s
->s_flags
);
703 /* set dma size to 65536 bytes */
704 ivtv_vapi(itv
, CX2341X_DEC_SET_DMA_BLOCK_SIZE
, 1, 65536);
706 /* Clear Streamoff */
707 clear_bit(IVTV_F_S_STREAMOFF
, &s
->s_flags
);
709 /* Zero out decoder counters */
710 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA_END
].data
[0]);
711 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA_END
].data
[1]);
712 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA_END
].data
[2]);
713 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA_END
].data
[3]);
714 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA
].data
[0]);
715 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA
].data
[1]);
716 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA
].data
[2]);
717 writel(0, &itv
->dec_mbox
.mbox
[IVTV_MBOX_DMA
].data
[3]);
719 /* turn on notification of dual/stereo mode change */
720 ivtv_vapi(itv
, CX2341X_DEC_SET_EVENT_NOTIFICATION
, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG
, -1);
723 ivtv_vapi(itv
, CX2341X_DEC_START_PLAYBACK
, 2, gop_offset
, 0);
725 /* Let things settle before we actually start */
726 ivtv_msleep_timeout(10, 0);
728 /* Clear the following Interrupt mask bits for decoding */
729 ivtv_clear_irq_mask(itv
, IVTV_IRQ_MASK_DECODE
);
730 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv
->irqmask
);
732 /* you're live! sit back and await interrupts :) */
733 atomic_inc(&itv
->decoding
);
737 void ivtv_stop_all_captures(struct ivtv
*itv
)
741 for (i
= IVTV_MAX_STREAMS
- 1; i
>= 0; i
--) {
742 struct ivtv_stream
*s
= &itv
->streams
[i
];
746 if (test_bit(IVTV_F_S_STREAMING
, &s
->s_flags
)) {
747 ivtv_stop_v4l2_encode_stream(s
, 0);
752 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream
*s
, int gop_end
)
754 struct ivtv
*itv
= s
->itv
;
755 DECLARE_WAITQUEUE(wait
, current
);
762 /* This function assumes that you are allowed to stop the capture
763 and that we are actually capturing */
765 IVTV_DEBUG_INFO("Stop Capture\n");
767 if (s
->type
== IVTV_DEC_STREAM_TYPE_VOUT
)
769 if (atomic_read(&itv
->capturing
) == 0)
773 case IVTV_ENC_STREAM_TYPE_YUV
:
776 case IVTV_ENC_STREAM_TYPE_PCM
:
779 case IVTV_ENC_STREAM_TYPE_VBI
:
782 case IVTV_ENC_STREAM_TYPE_MPG
:
788 /* Stop Capture Mode */
789 if (s
->type
== IVTV_ENC_STREAM_TYPE_MPG
&& gop_end
) {
796 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
797 ivtv_vapi(itv
, CX2341X_ENC_STOP_CAPTURE
, 3, stopmode
, cap_type
, s
->subtype
);
799 if (!test_bit(IVTV_F_S_PASSTHROUGH
, &s
->s_flags
)) {
800 if (s
->type
== IVTV_ENC_STREAM_TYPE_MPG
&& gop_end
) {
801 /* only run these if we're shutting down the last cap */
802 unsigned long duration
;
803 unsigned long then
= jiffies
;
805 add_wait_queue(&itv
->eos_waitq
, &wait
);
807 set_current_state(TASK_INTERRUPTIBLE
);
809 /* wait 2s for EOS interrupt */
810 while (!test_bit(IVTV_F_I_EOS
, &itv
->i_flags
) &&
812 then
+ msecs_to_jiffies(2000))) {
813 schedule_timeout(msecs_to_jiffies(10));
816 /* To convert jiffies to ms, we must multiply by 1000
817 * and divide by HZ. To avoid runtime division, we
818 * convert this to multiplication by 1000/HZ.
819 * Since integer division truncates, we get the best
820 * accuracy if we do a rounding calculation of the constant.
821 * Think of the case where HZ is 1024.
823 duration
= ((1000 + HZ
/ 2) / HZ
) * (jiffies
- then
);
825 if (!test_bit(IVTV_F_I_EOS
, &itv
->i_flags
)) {
826 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s
->name
);
827 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s
->name
, duration
);
829 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s
->name
, duration
);
831 set_current_state(TASK_RUNNING
);
832 remove_wait_queue(&itv
->eos_waitq
, &wait
);
833 set_bit(IVTV_F_S_STREAMOFF
, &s
->s_flags
);
836 /* Handle any pending interrupts */
837 ivtv_msleep_timeout(100, 1);
840 atomic_dec(&itv
->capturing
);
842 /* Clear capture and no-read bits */
843 clear_bit(IVTV_F_S_STREAMING
, &s
->s_flags
);
845 if (s
->type
== IVTV_ENC_STREAM_TYPE_VBI
)
846 ivtv_set_irq_mask(itv
, IVTV_IRQ_ENC_VBI_CAP
);
848 if (atomic_read(&itv
->capturing
) > 0) {
852 cx2341x_handler_set_busy(&itv
->cxhdl
, 0);
854 /* Set the following Interrupt mask bits for capture */
855 ivtv_set_irq_mask(itv
, IVTV_IRQ_MASK_CAPTURE
);
856 del_timer(&itv
->dma_timer
);
858 /* event notification (off) */
859 if (test_and_clear_bit(IVTV_F_I_DIG_RST
, &itv
->i_flags
)) {
860 /* type: 0 = refresh */
861 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
862 ivtv_vapi(itv
, CX2341X_ENC_SET_EVENT_NOTIFICATION
, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST
, -1);
863 ivtv_set_irq_mask(itv
, IVTV_IRQ_ENC_VIM_RST
);
866 /* Raw-passthrough is implied on start. Make sure it's stopped so
867 the encoder will re-initialize when next started */
868 ivtv_vapi(itv
, CX2341X_ENC_STOP_CAPTURE
, 3, 1, 2, 7);
875 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream
*s
, int flags
, u64 pts
)
877 static const struct v4l2_event ev
= {
878 .type
= V4L2_EVENT_EOS
,
880 struct ivtv
*itv
= s
->itv
;
885 if (s
->type
!= IVTV_DEC_STREAM_TYPE_YUV
&& s
->type
!= IVTV_DEC_STREAM_TYPE_MPG
)
888 if (!test_bit(IVTV_F_S_STREAMING
, &s
->s_flags
))
891 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts
, flags
);
894 if (!(flags
& VIDEO_CMD_STOP_IMMEDIATELY
) || pts
) {
897 /* Wait until the decoder is no longer running */
899 ivtv_vapi(itv
, CX2341X_DEC_STOP_PLAYBACK
, 3,
900 0, (u32
)(pts
& 0xffffffff), (u32
)(pts
>> 32));
903 u32 data
[CX2341X_MBOX_MAX_DATA
];
904 ivtv_vapi_result(itv
, data
, CX2341X_DEC_GET_XFER_INFO
, 0);
905 if (s
->q_full
.buffers
+ s
->q_dma
.buffers
== 0) {
910 if (ivtv_msleep_timeout(100, 1))
914 ivtv_vapi(itv
, CX2341X_DEC_STOP_PLAYBACK
, 3, flags
& VIDEO_CMD_STOP_TO_BLACK
, 0, 0);
916 /* turn off notification of dual/stereo mode change */
917 ivtv_vapi(itv
, CX2341X_DEC_SET_EVENT_NOTIFICATION
, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG
, -1);
919 ivtv_set_irq_mask(itv
, IVTV_IRQ_MASK_DECODE
);
920 del_timer(&itv
->dma_timer
);
922 clear_bit(IVTV_F_S_NEEDS_DATA
, &s
->s_flags
);
923 clear_bit(IVTV_F_S_STREAMING
, &s
->s_flags
);
924 ivtv_flush_queues(s
);
926 /* decoder needs time to settle */
927 ivtv_msleep_timeout(40, 0);
929 /* decrement decoding */
930 atomic_dec(&itv
->decoding
);
932 set_bit(IVTV_F_I_EV_DEC_STOPPED
, &itv
->i_flags
);
933 wake_up(&itv
->event_waitq
);
934 v4l2_event_queue(s
->vdev
, &ev
);
936 /* wake up wait queues */
942 int ivtv_passthrough_mode(struct ivtv
*itv
, int enable
)
944 struct ivtv_stream
*yuv_stream
= &itv
->streams
[IVTV_ENC_STREAM_TYPE_YUV
];
945 struct ivtv_stream
*dec_stream
= &itv
->streams
[IVTV_DEC_STREAM_TYPE_YUV
];
947 if (yuv_stream
->vdev
== NULL
|| dec_stream
->vdev
== NULL
)
950 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
952 /* Prevent others from starting/stopping streams while we
953 initiate/terminate passthrough mode */
955 if (itv
->output_mode
== OUT_PASSTHROUGH
) {
958 if (ivtv_set_output_mode(itv
, OUT_PASSTHROUGH
) != OUT_PASSTHROUGH
)
961 /* Fully initialize stream, and then unflag init */
962 set_bit(IVTV_F_S_PASSTHROUGH
, &dec_stream
->s_flags
);
963 set_bit(IVTV_F_S_STREAMING
, &dec_stream
->s_flags
);
965 /* Setup YUV Decoder */
966 ivtv_setup_v4l2_decode_stream(dec_stream
);
969 ivtv_vapi(itv
, CX2341X_DEC_START_PLAYBACK
, 2, 0, 1);
970 atomic_inc(&itv
->decoding
);
972 /* Setup capture if not already done */
973 if (atomic_read(&itv
->capturing
) == 0) {
974 cx2341x_handler_setup(&itv
->cxhdl
);
975 cx2341x_handler_set_busy(&itv
->cxhdl
, 1);
978 /* Start Passthrough Mode */
979 ivtv_vapi(itv
, CX2341X_ENC_START_CAPTURE
, 2, 2, 11);
980 atomic_inc(&itv
->capturing
);
984 if (itv
->output_mode
!= OUT_PASSTHROUGH
)
987 /* Stop Passthrough Mode */
988 ivtv_vapi(itv
, CX2341X_ENC_STOP_CAPTURE
, 3, 1, 2, 11);
989 ivtv_vapi(itv
, CX2341X_DEC_STOP_PLAYBACK
, 3, 1, 0, 0);
991 atomic_dec(&itv
->capturing
);
992 atomic_dec(&itv
->decoding
);
993 clear_bit(IVTV_F_S_PASSTHROUGH
, &dec_stream
->s_flags
);
994 clear_bit(IVTV_F_S_STREAMING
, &dec_stream
->s_flags
);
995 itv
->output_mode
= OUT_NONE
;
996 if (atomic_read(&itv
->capturing
) == 0)
997 cx2341x_handler_set_busy(&itv
->cxhdl
, 0);