blob: 854a950af78c757ae95ff9f8a39a6a7a6f1d3ede [file] [log] [blame]
Hans Verkuil1a0adaf2007-04-27 12:31:25 -03001/*
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>
6
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.
11
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.
16
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
20 */
21
22/* License: GPL
23 * Author: Kevin Thayer <nufan_wfk at yahoo dot com>
24 *
25 * This file will hold API related functions, both internal (firmware api)
26 * and external (v4l2, etc)
27 *
28 * -----
29 * MPG600/MPG160 support by T.Adachi <tadachi@tadachi-net.com>
30 * and Takeru KOMORIYA<komoriya@paken.org>
31 *
32 * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
33 * using information provided by Jiun-Kuei Jung @ AVerMedia.
34 */
35
36#include "ivtv-driver.h"
37#include "ivtv-fileops.h"
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030038#include "ivtv-queue.h"
39#include "ivtv-mailbox.h"
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030040#include "ivtv-ioctl.h"
Hans Verkuil33c0fca2007-08-23 06:32:46 -030041#include "ivtv-irq.h"
Hans Verkuil612570f2007-08-23 05:42:59 -030042#include "ivtv-yuv.h"
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030043#include "ivtv-cards.h"
Hans Verkuil612570f2007-08-23 05:42:59 -030044#include "ivtv-streams.h"
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030045
Hans Verkuilbec43662008-12-30 06:58:20 -030046static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
Hans Verkuildaf20d92008-05-12 11:21:58 -030047 .owner = THIS_MODULE,
48 .read = ivtv_v4l2_read,
49 .write = ivtv_v4l2_write,
50 .open = ivtv_v4l2_open,
Hans Verkuil09882f02008-10-18 13:42:24 -030051 .unlocked_ioctl = ivtv_v4l2_ioctl,
Hans Verkuildaf20d92008-05-12 11:21:58 -030052 .release = ivtv_v4l2_close,
53 .poll = ivtv_v4l2_enc_poll,
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030054};
55
Hans Verkuilbec43662008-12-30 06:58:20 -030056static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
Hans Verkuildaf20d92008-05-12 11:21:58 -030057 .owner = THIS_MODULE,
58 .read = ivtv_v4l2_read,
59 .write = ivtv_v4l2_write,
60 .open = ivtv_v4l2_open,
Hans Verkuil09882f02008-10-18 13:42:24 -030061 .unlocked_ioctl = ivtv_v4l2_ioctl,
Hans Verkuildaf20d92008-05-12 11:21:58 -030062 .release = ivtv_v4l2_close,
63 .poll = ivtv_v4l2_dec_poll,
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030064};
65
Hans Verkuil33c0fca2007-08-23 06:32:46 -030066#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 */
72
Hans Verkuil31ec1352007-03-03 08:50:42 -030073static struct {
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030074 const char *name;
75 int vfl_type;
Hans Verkuildd896012008-10-04 08:36:54 -030076 int num_offset;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030077 int dma, pio;
78 enum v4l2_buf_type buf_type;
Hans Verkuilbec43662008-12-30 06:58:20 -030079 const struct v4l2_file_operations *fops;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030080} ivtv_stream_info[] = {
81 { /* IVTV_ENC_STREAM_TYPE_MPG */
Hans Verkuil7c03a442007-08-19 18:59:42 -030082 "encoder MPG",
Hans Verkuil1a0adaf2007-04-27 12:31:25 -030083 VFL_TYPE_GRABBER, 0,
84 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
85 &ivtv_v4l2_enc_fops
86 },
87 { /* IVTV_ENC_STREAM_TYPE_YUV */
88 "encoder YUV",
89 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
90 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
91 &ivtv_v4l2_enc_fops
92 },
93 { /* IVTV_ENC_STREAM_TYPE_VBI */
94 "encoder VBI",
95 VFL_TYPE_VBI, 0,
96 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE,
97 &ivtv_v4l2_enc_fops
98 },
99 { /* IVTV_ENC_STREAM_TYPE_PCM */
Hans Verkuil7c03a442007-08-19 18:59:42 -0300100 "encoder PCM",
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300101 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
102 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE,
103 &ivtv_v4l2_enc_fops
104 },
105 { /* IVTV_ENC_STREAM_TYPE_RAD */
106 "encoder radio",
107 VFL_TYPE_RADIO, 0,
108 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE,
109 &ivtv_v4l2_enc_fops
110 },
111 { /* IVTV_DEC_STREAM_TYPE_MPG */
Hans Verkuil7c03a442007-08-19 18:59:42 -0300112 "decoder MPG",
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300113 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
114 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
115 &ivtv_v4l2_dec_fops
116 },
117 { /* IVTV_DEC_STREAM_TYPE_VBI */
118 "decoder VBI",
119 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
120 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE,
121 &ivtv_v4l2_enc_fops
122 },
123 { /* IVTV_DEC_STREAM_TYPE_VOUT */
124 "decoder VOUT",
125 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
126 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT,
127 &ivtv_v4l2_dec_fops
128 },
129 { /* IVTV_DEC_STREAM_TYPE_YUV */
130 "decoder YUV",
131 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
132 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
133 &ivtv_v4l2_dec_fops
134 }
135};
136
137static void ivtv_stream_init(struct ivtv *itv, int type)
138{
139 struct ivtv_stream *s = &itv->streams[type];
140 struct video_device *dev = s->v4l2dev;
141
142 /* we need to keep v4l2dev, so restore it afterwards */
143 memset(s, 0, sizeof(*s));
144 s->v4l2dev = dev;
145
146 /* initialize ivtv_stream fields */
147 s->itv = itv;
148 s->type = type;
149 s->name = ivtv_stream_info[type].name;
150
151 if (ivtv_stream_info[type].pio)
152 s->dma = PCI_DMA_NONE;
153 else
154 s->dma = ivtv_stream_info[type].dma;
155 s->buf_size = itv->stream_buf_size[type];
156 if (s->buf_size)
Hans Verkuil313e91e2007-08-19 05:32:33 -0300157 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300158 spin_lock_init(&s->qlock);
159 init_waitqueue_head(&s->waitq);
160 s->id = -1;
Hans Verkuil37093b12007-07-28 19:45:50 -0300161 s->sg_handle = IVTV_DMA_UNMAPPED;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300162 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);
167}
168
Hans Verkuil18e16f92007-10-13 05:54:48 -0300169static int ivtv_prep_dev(struct ivtv *itv, int type)
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300170{
171 struct ivtv_stream *s = &itv->streams[type];
Hans Verkuildd896012008-10-04 08:36:54 -0300172 int num_offset = ivtv_stream_info[type].num_offset;
Hans Verkuil67ec09f2008-11-29 19:38:23 -0300173 int num = itv->instance + ivtv_first_minor + num_offset;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300174
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
177 four can be used. */
178 s->v4l2dev = NULL;
179 s->itv = itv;
180 s->type = type;
181 s->name = ivtv_stream_info[type].name;
182
183 /* Check whether the radio is supported */
184 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
185 return 0;
186 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
187 return 0;
188
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300189 /* User explicitly selected 0 buffers for these streams, so don't
190 create them. */
Hans Verkuil18e16f92007-10-13 05:54:48 -0300191 if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
Hans Verkuil313e91e2007-08-19 05:32:33 -0300192 itv->options.kilobytes[type] == 0) {
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300193 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
194 return 0;
195 }
196
197 ivtv_stream_init(itv, type);
198
199 /* allocate and initialize the v4l2 video device structure */
200 s->v4l2dev = video_device_alloc();
201 if (s->v4l2dev == NULL) {
202 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
203 return -ENOMEM;
204 }
205
Hans Verkuil67ec09f2008-11-29 19:38:23 -0300206 snprintf(s->v4l2dev->name, sizeof(s->v4l2dev->name), "%s %s",
207 itv->device.name, s->name);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300208
Hans Verkuildd896012008-10-04 08:36:54 -0300209 s->v4l2dev->num = num;
Hans Verkuil4efc9ab2008-12-23 07:35:45 -0300210 s->v4l2dev->v4l2_dev = &itv->device;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300211 s->v4l2dev->fops = ivtv_stream_info[type].fops;
212 s->v4l2dev->release = video_device_release;
Hans Verkuil3f038d82008-05-29 16:43:54 -0300213 s->v4l2dev->tvnorms = V4L2_STD_ALL;
214 ivtv_set_funcs(s->v4l2dev);
Hans Verkuil18e16f92007-10-13 05:54:48 -0300215 return 0;
216}
217
218/* Initialize v4l2 variables and prepare v4l2 devices */
219int ivtv_streams_setup(struct ivtv *itv)
220{
221 int type;
222
223 /* Setup V4L2 Devices */
224 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
225 /* Prepare device */
226 if (ivtv_prep_dev(itv, type))
227 break;
228
229 if (itv->streams[type].v4l2dev == NULL)
230 continue;
231
232 /* Allocate Stream */
233 if (ivtv_stream_alloc(&itv->streams[type]))
234 break;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300235 }
Hans Verkuil18e16f92007-10-13 05:54:48 -0300236 if (type == IVTV_MAX_STREAMS)
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300237 return 0;
Hans Verkuil18e16f92007-10-13 05:54:48 -0300238
239 /* One or more streams could not be initialized. Clean 'em all up. */
Hans Verkuil3f983872008-05-01 10:31:12 -0300240 ivtv_streams_cleanup(itv, 0);
Hans Verkuil18e16f92007-10-13 05:54:48 -0300241 return -ENOMEM;
242}
243
244static int ivtv_reg_dev(struct ivtv *itv, int type)
245{
246 struct ivtv_stream *s = &itv->streams[type];
247 int vfl_type = ivtv_stream_info[type].vfl_type;
Hans Verkuildd896012008-10-04 08:36:54 -0300248 int num;
Hans Verkuil18e16f92007-10-13 05:54:48 -0300249
250 if (s->v4l2dev == NULL)
251 return 0;
252
Hans Verkuildd896012008-10-04 08:36:54 -0300253 num = s->v4l2dev->num;
254 /* card number + user defined offset + device offset */
255 if (type != IVTV_ENC_STREAM_TYPE_MPG) {
256 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
257
258 if (s_mpg->v4l2dev)
259 num = s_mpg->v4l2dev->num + ivtv_stream_info[type].num_offset;
260 }
Hans Verkuil67ec09f2008-11-29 19:38:23 -0300261 video_set_drvdata(s->v4l2dev, s);
Hans Verkuildd896012008-10-04 08:36:54 -0300262
Hans Verkuil18e16f92007-10-13 05:54:48 -0300263 /* Register device. First try the desired minor, then any free one. */
Hans Verkuildd896012008-10-04 08:36:54 -0300264 if (video_register_device(s->v4l2dev, vfl_type, num)) {
265 IVTV_ERR("Couldn't register v4l2 device for %s kernel number %d\n",
266 s->name, num);
Hans Verkuil18e16f92007-10-13 05:54:48 -0300267 video_device_release(s->v4l2dev);
268 s->v4l2dev = NULL;
269 return -ENOMEM;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300270 }
Hans Verkuildd896012008-10-04 08:36:54 -0300271 num = s->v4l2dev->num;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300272
273 switch (vfl_type) {
274 case VFL_TYPE_GRABBER:
Hans Verkuil313e91e2007-08-19 05:32:33 -0300275 IVTV_INFO("Registered device video%d for %s (%d kB)\n",
Hans Verkuildd896012008-10-04 08:36:54 -0300276 num, s->name, itv->options.kilobytes[type]);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300277 break;
278 case VFL_TYPE_RADIO:
279 IVTV_INFO("Registered device radio%d for %s\n",
Hans Verkuildd896012008-10-04 08:36:54 -0300280 num, s->name);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300281 break;
282 case VFL_TYPE_VBI:
Hans Verkuil313e91e2007-08-19 05:32:33 -0300283 if (itv->options.kilobytes[type])
284 IVTV_INFO("Registered device vbi%d for %s (%d kB)\n",
Hans Verkuildd896012008-10-04 08:36:54 -0300285 num, s->name, itv->options.kilobytes[type]);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300286 else
287 IVTV_INFO("Registered device vbi%d for %s\n",
Hans Verkuildd896012008-10-04 08:36:54 -0300288 num, s->name);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300289 break;
290 }
291 return 0;
292}
293
Hans Verkuil18e16f92007-10-13 05:54:48 -0300294/* Register v4l2 devices */
295int ivtv_streams_register(struct ivtv *itv)
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300296{
297 int type;
Hans Verkuil18e16f92007-10-13 05:54:48 -0300298 int err = 0;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300299
Hans Verkuil18e16f92007-10-13 05:54:48 -0300300 /* Register V4L2 devices */
301 for (type = 0; type < IVTV_MAX_STREAMS; type++)
302 err |= ivtv_reg_dev(itv, type);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300303
Hans Verkuil18e16f92007-10-13 05:54:48 -0300304 if (err == 0)
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300305 return 0;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300306
307 /* One or more streams could not be initialized. Clean 'em all up. */
Hans Verkuil3f983872008-05-01 10:31:12 -0300308 ivtv_streams_cleanup(itv, 1);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300309 return -ENOMEM;
310}
311
312/* Unregister v4l2 devices */
Hans Verkuil3f983872008-05-01 10:31:12 -0300313void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300314{
315 int type;
316
317 /* Teardown all streams */
318 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
319 struct video_device *vdev = itv->streams[type].v4l2dev;
320
321 itv->streams[type].v4l2dev = NULL;
322 if (vdev == NULL)
323 continue;
324
325 ivtv_stream_free(&itv->streams[type]);
Hans Verkuil3f983872008-05-01 10:31:12 -0300326 /* Unregister or release device */
327 if (unregister)
328 video_unregister_device(vdev);
329 else
330 video_device_release(vdev);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300331 }
332}
333
334static void ivtv_vbi_setup(struct ivtv *itv)
335{
Hans Verkuila8b86432008-10-04 08:05:30 -0300336 int raw = ivtv_raw_vbi(itv);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300337 u32 data[CX2341X_MBOX_MAX_DATA];
338 int lines;
339 int i;
340
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300341 /* Reset VBI */
342 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
343
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300344 /* setup VBI registers */
Hans Verkuil67ec09f2008-11-29 19:38:23 -0300345 v4l2_subdev_call(itv->sd_video, video, s_fmt, &itv->vbi.in);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300346
347 /* determine number of lines and total number of VBI bytes.
348 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
349 The '- 1' byte is probably an unused U or V byte. Or something...
350 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
351 header, 42 data bytes + checksum (to be confirmed) */
352 if (raw) {
353 lines = itv->vbi.count * 2;
354 } else {
355 lines = itv->is_60hz ? 24 : 38;
356 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
357 lines += 2;
358 }
359
360 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
361
362 /* Note: sliced vs raw flag doesn't seem to have any effect
363 TODO: check mode (0x02) value with older ivtv versions. */
364 data[0] = raw | 0x02 | (0xbd << 8);
365
366 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
367 data[1] = 1;
368 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
Hans Verkuild526afe2008-09-03 16:47:14 -0300369 data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300370 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
371 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
372 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
373 code. These values for raw VBI are obtained from a driver disassembly. The sliced
374 start/stop codes was deduced from this, but they do not appear in the driver.
375 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
376 However, I have no idea what these values are for. */
377 if (itv->hw_flags & IVTV_HW_CX25840) {
378 /* Setup VBI for the cx25840 digitizer */
379 if (raw) {
380 data[3] = 0x20602060;
381 data[4] = 0x30703070;
382 } else {
383 data[3] = 0xB0F0B0F0;
384 data[4] = 0xA0E0A0E0;
385 }
386 /* Lines per frame */
387 data[5] = lines;
388 /* bytes per line */
389 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
390 } else {
391 /* Setup VBI for the saa7115 digitizer */
392 if (raw) {
393 data[3] = 0x25256262;
394 data[4] = 0x387F7F7F;
395 } else {
396 data[3] = 0xABABECEC;
397 data[4] = 0xB6F1F1F1;
398 }
399 /* Lines per frame */
400 data[5] = lines;
401 /* bytes per line */
402 data[6] = itv->vbi.enc_size / lines;
403 }
404
405 IVTV_DEBUG_INFO(
406 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
407 data[0], data[1], data[2], data[5], data[6]);
408
409 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
410
411 /* returns the VBI encoder memory area. */
412 itv->vbi.enc_start = data[2];
413 itv->vbi.fpi = data[0];
414 if (!itv->vbi.fpi)
415 itv->vbi.fpi = 1;
416
Hans Verkuilfd8b2812007-08-23 10:13:15 -0300417 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
418 itv->vbi.enc_start, data[1], itv->vbi.fpi);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300419
420 /* select VBI lines.
421 Note that the sliced argument seems to have no effect. */
422 for (i = 2; i <= 24; i++) {
423 int valid;
424
425 if (itv->is_60hz) {
426 valid = i >= 10 && i < 22;
427 } else {
428 valid = i >= 6 && i < 24;
429 }
430 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
431 valid, 0 , 0, 0);
432 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
433 valid, 0, 0, 0);
434 }
435
436 /* Remaining VBI questions:
437 - Is it possible to select particular VBI lines only for inclusion in the MPEG
438 stream? Currently you can only get the first X lines.
439 - Is mixed raw and sliced VBI possible?
440 - What's the meaning of the raw/sliced flag?
441 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
442}
443
444int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
445{
446 u32 data[CX2341X_MBOX_MAX_DATA];
447 struct ivtv *itv = s->itv;
Hans Verkuil254d6eb2007-10-14 17:19:37 -0300448 struct cx2341x_mpeg_params *p = &itv->params;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300449 int captype = 0, subtype = 0;
450 int enable_passthrough = 0;
451
452 if (s->v4l2dev == NULL)
453 return -EINVAL;
454
455 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
456
457 switch (s->type) {
458 case IVTV_ENC_STREAM_TYPE_MPG:
459 captype = 0;
460 subtype = 3;
461
462 /* Stop Passthrough */
463 if (itv->output_mode == OUT_PASSTHROUGH) {
464 ivtv_passthrough_mode(itv, 0);
465 enable_passthrough = 1;
466 }
467 itv->mpg_data_received = itv->vbi_data_inserted = 0;
468 itv->dualwatch_jiffies = jiffies;
Hans Verkuil254d6eb2007-10-14 17:19:37 -0300469 itv->dualwatch_stereo_mode = p->audio_properties & 0x0300;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300470 itv->search_pack_header = 0;
471 break;
472
473 case IVTV_ENC_STREAM_TYPE_YUV:
474 if (itv->output_mode == OUT_PASSTHROUGH) {
475 captype = 2;
476 subtype = 11; /* video+audio+decoder */
477 break;
478 }
479 captype = 1;
480 subtype = 1;
481 break;
482 case IVTV_ENC_STREAM_TYPE_PCM:
483 captype = 1;
484 subtype = 2;
485 break;
486 case IVTV_ENC_STREAM_TYPE_VBI:
487 captype = 1;
488 subtype = 4;
489
490 itv->vbi.frame = 0;
491 itv->vbi.inserted_frame = 0;
492 memset(itv->vbi.sliced_mpeg_size,
493 0, sizeof(itv->vbi.sliced_mpeg_size));
494 break;
495 default:
496 return -EINVAL;
497 }
498 s->subtype = subtype;
499 s->buffers_stolen = 0;
500
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300501 /* Clear Streamoff flags in case left from last capture */
502 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
503
504 if (atomic_read(&itv->capturing) == 0) {
Hans Verkuilfd8b2812007-08-23 10:13:15 -0300505 int digitizer;
506
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300507 /* Always use frame based mode. Experiments have demonstrated that byte
508 stream based mode results in dropped frames and corruption. Not often,
509 but occasionally. Many thanks go to Leonard Orb who spent a lot of
510 effort and time trying to trace the cause of the drop outs. */
511 /* 1 frame per DMA */
512 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
513 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
514
515 /* Stuff from Windows, we don't know what it is */
516 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
517 /* According to the docs, this should be correct. However, this is
518 untested. I don't dare enable this without having tested it.
519 Only very few old cards actually have this hardware combination.
520 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
521 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
522 */
523 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
524 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
525 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
526 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
527
528 /* assign placeholder */
529 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
530 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
531
Hans Verkuilfd8b2812007-08-23 10:13:15 -0300532 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
533 digitizer = 0xF1;
534 else if (itv->card->hw_all & IVTV_HW_SAA7114)
535 digitizer = 0xEF;
536 else /* cx25840 */
537 digitizer = 0x140;
538
539 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300540
541 /* Setup VBI */
542 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
543 ivtv_vbi_setup(itv);
544 }
545
546 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
547 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
548 itv->pgm_info_offset = data[0];
549 itv->pgm_info_num = data[1];
550 itv->pgm_info_write_idx = 0;
551 itv->pgm_info_read_idx = 0;
552
553 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
554 itv->pgm_info_offset, itv->pgm_info_num);
555
556 /* Setup API for Stream */
Hans Verkuil254d6eb2007-10-14 17:19:37 -0300557 cx2341x_update(itv, ivtv_api_func, NULL, p);
558
559 /* mute if capturing radio */
560 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
561 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
562 1 | (p->video_mute_yuv << 8));
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300563 }
564
565 /* Vsync Setup */
566 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
567 /* event notification (on) */
568 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
569 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
570 }
571
572 if (atomic_read(&itv->capturing) == 0) {
573 /* Clear all Pending Interrupts */
574 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
575
576 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
577
578 /* Initialize Digitizer for Capture */
Hans Verkuil67ec09f2008-11-29 19:38:23 -0300579 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
Hans Verkuil3562c432007-08-18 11:46:05 -0300580 ivtv_msleep_timeout(300, 1);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300581 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
Hans Verkuil67ec09f2008-11-29 19:38:23 -0300582 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300583 }
584
585 /* begin_capture */
586 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
587 {
588 IVTV_DEBUG_WARN( "Error starting capture!\n");
589 return -EINVAL;
590 }
591
592 /* Start Passthrough */
593 if (enable_passthrough) {
594 ivtv_passthrough_mode(itv, 1);
595 }
596
597 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
598 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
599 else
600 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
601
602 /* you're live! sit back and await interrupts :) */
603 atomic_inc(&itv->capturing);
604 return 0;
605}
606
607static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
608{
609 u32 data[CX2341X_MBOX_MAX_DATA];
610 struct ivtv *itv = s->itv;
Hans Verkuil254d6eb2007-10-14 17:19:37 -0300611 struct cx2341x_mpeg_params *p = &itv->params;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300612 int datatype;
613
614 if (s->v4l2dev == NULL)
615 return -EINVAL;
616
617 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
618
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300619 /* set audio mode to left/stereo for dual/stereo mode. */
620 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
621
622 /* set number of internal decoder buffers */
623 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
624
625 /* prebuffering */
626 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
627
628 /* extract from user packets */
629 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
630 itv->vbi.dec_start = data[0];
631
632 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
633 itv->vbi.dec_start, data[1]);
634
635 /* set decoder source settings */
636 /* Data type: 0 = mpeg from host,
637 1 = yuv from encoder,
638 2 = yuv_from_host */
639 switch (s->type) {
640 case IVTV_DEC_STREAM_TYPE_YUV:
641 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
642 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
643 break;
644 case IVTV_DEC_STREAM_TYPE_MPG:
645 default:
646 datatype = 0;
647 break;
648 }
649 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
Hans Verkuil254d6eb2007-10-14 17:19:37 -0300650 p->width, p->height, p->audio_properties)) {
Hans Verkuil5a338c32007-07-22 09:39:56 -0300651 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300652 }
653 return 0;
654}
655
656int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
657{
658 struct ivtv *itv = s->itv;
659
660 if (s->v4l2dev == NULL)
661 return -EINVAL;
662
663 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
664 return 0; /* already started */
665
666 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
667
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300668 ivtv_setup_v4l2_decode_stream(s);
669
670 /* set dma size to 65536 bytes */
671 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
672
Ian Armstrong77aded62007-11-05 14:27:09 -0300673 /* Clear Streamoff */
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300674 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
675
676 /* Zero out decoder counters */
Hans Verkuil33c0fca2007-08-23 06:32:46 -0300677 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
678 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
679 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
680 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300681 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
682 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
683 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
684 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
685
686 /* turn on notification of dual/stereo mode change */
687 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
688
689 /* start playback */
690 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
691
692 /* Clear the following Interrupt mask bits for decoding */
693 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
694 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
695
696 /* you're live! sit back and await interrupts :) */
697 atomic_inc(&itv->decoding);
698 return 0;
699}
700
701void ivtv_stop_all_captures(struct ivtv *itv)
702{
703 int i;
704
705 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
706 struct ivtv_stream *s = &itv->streams[i];
707
708 if (s->v4l2dev == NULL)
709 continue;
710 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
711 ivtv_stop_v4l2_encode_stream(s, 0);
712 }
713 }
714}
715
716int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
717{
718 struct ivtv *itv = s->itv;
719 DECLARE_WAITQUEUE(wait, current);
720 int cap_type;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300721 int stopmode;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300722
723 if (s->v4l2dev == NULL)
724 return -EINVAL;
725
726 /* This function assumes that you are allowed to stop the capture
727 and that we are actually capturing */
728
729 IVTV_DEBUG_INFO("Stop Capture\n");
730
731 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
732 return 0;
733 if (atomic_read(&itv->capturing) == 0)
734 return 0;
735
736 switch (s->type) {
737 case IVTV_ENC_STREAM_TYPE_YUV:
738 cap_type = 1;
739 break;
740 case IVTV_ENC_STREAM_TYPE_PCM:
741 cap_type = 1;
742 break;
743 case IVTV_ENC_STREAM_TYPE_VBI:
744 cap_type = 1;
745 break;
746 case IVTV_ENC_STREAM_TYPE_MPG:
747 default:
748 cap_type = 0;
749 break;
750 }
751
752 /* Stop Capture Mode */
753 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
754 stopmode = 0;
755 } else {
756 stopmode = 1;
757 }
758
759 /* end_capture */
760 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
761 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
762
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300763 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
764 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
765 /* only run these if we're shutting down the last cap */
766 unsigned long duration;
Hans Verkuil559e1962007-08-23 17:51:07 -0300767 unsigned long then = jiffies;
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300768
Hans Verkuilfd8b2812007-08-23 10:13:15 -0300769 add_wait_queue(&itv->eos_waitq, &wait);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300770
771 set_current_state(TASK_INTERRUPTIBLE);
772
773 /* wait 2s for EOS interrupt */
Mauro Carvalho Chehab201700d2007-07-19 11:21:04 -0300774 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
Julia Lawall168c6262008-04-16 16:13:15 -0300775 time_before(jiffies,
776 then + msecs_to_jiffies(2000))) {
Mauro Carvalho Chehab201700d2007-07-19 11:21:04 -0300777 schedule_timeout(msecs_to_jiffies(10));
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300778 }
779
780 /* To convert jiffies to ms, we must multiply by 1000
781 * and divide by HZ. To avoid runtime division, we
782 * convert this to multiplication by 1000/HZ.
783 * Since integer division truncates, we get the best
784 * accuracy if we do a rounding calculation of the constant.
785 * Think of the case where HZ is 1024.
786 */
787 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
788
789 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
790 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
791 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
792 } else {
793 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
794 }
795 set_current_state(TASK_RUNNING);
Hans Verkuilfd8b2812007-08-23 10:13:15 -0300796 remove_wait_queue(&itv->eos_waitq, &wait);
Hans Verkuil559e1962007-08-23 17:51:07 -0300797 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300798 }
799
Hans Verkuil3562c432007-08-18 11:46:05 -0300800 /* Handle any pending interrupts */
801 ivtv_msleep_timeout(100, 1);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300802 }
803
804 atomic_dec(&itv->capturing);
805
806 /* Clear capture and no-read bits */
807 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
808
809 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
810 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
811
812 if (atomic_read(&itv->capturing) > 0) {
813 return 0;
814 }
815
816 /* Set the following Interrupt mask bits for capture */
817 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
Hans Verkuile17a06b2007-08-18 15:48:42 -0300818 del_timer(&itv->dma_timer);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300819
Hans Verkuilf8859692007-07-10 14:58:33 -0300820 /* event notification (off) */
821 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
822 /* type: 0 = refresh */
823 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
824 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
825 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
826 }
827
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300828 wake_up(&s->waitq);
829
830 return 0;
831}
832
833int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
834{
835 struct ivtv *itv = s->itv;
836
837 if (s->v4l2dev == NULL)
838 return -EINVAL;
839
840 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
841 return -EINVAL;
842
843 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
844 return 0;
845
Hans Verkuilc4385092007-06-07 09:04:03 -0300846 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300847
848 /* Stop Decoder */
849 if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
850 u32 tmp = 0;
851
852 /* Wait until the decoder is no longer running */
853 if (pts) {
854 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
855 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
856 }
857 while (1) {
858 u32 data[CX2341X_MBOX_MAX_DATA];
859 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
860 if (s->q_full.buffers + s->q_dma.buffers == 0) {
861 if (tmp == data[3])
862 break;
863 tmp = data[3];
864 }
Mauro Carvalho Chehab201700d2007-07-19 11:21:04 -0300865 if (ivtv_msleep_timeout(100, 1))
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300866 break;
867 }
868 }
869 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
870
871 /* turn off notification of dual/stereo mode change */
872 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
873
874 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
Hans Verkuile17a06b2007-08-18 15:48:42 -0300875 del_timer(&itv->dma_timer);
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300876
877 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
878 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
879 ivtv_flush_queues(s);
880
Hans Verkuil1a0adaf2007-04-27 12:31:25 -0300881 /* decrement decoding */
882 atomic_dec(&itv->decoding);
883
884 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
885 wake_up(&itv->event_waitq);
886
887 /* wake up wait queues */
888 wake_up(&s->waitq);
889
890 return 0;
891}
892
893int ivtv_passthrough_mode(struct ivtv *itv, int enable)
894{
895 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
896 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
897
898 if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
899 return -EINVAL;
900
901 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
902
903 /* Prevent others from starting/stopping streams while we
904 initiate/terminate passthrough mode */
905 if (enable) {
906 if (itv->output_mode == OUT_PASSTHROUGH) {
907 return 0;
908 }
909 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
910 return -EBUSY;
911
912 /* Fully initialize stream, and then unflag init */
913 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
914 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
915
916 /* Setup YUV Decoder */
917 ivtv_setup_v4l2_decode_stream(dec_stream);
918
919 /* Start Decoder */
920 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
921 atomic_inc(&itv->decoding);
922
923 /* Setup capture if not already done */
924 if (atomic_read(&itv->capturing) == 0) {
925 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
926 }
927
928 /* Start Passthrough Mode */
929 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
930 atomic_inc(&itv->capturing);
931 return 0;
932 }
933
934 if (itv->output_mode != OUT_PASSTHROUGH)
935 return 0;
936
937 /* Stop Passthrough Mode */
938 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
939 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
940
941 atomic_dec(&itv->capturing);
942 atomic_dec(&itv->decoding);
943 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
944 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
945 itv->output_mode = OUT_NONE;
946
947 return 0;
948}