projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'v3.7-rc3' into for-linus to sync up with recent USB changes
[deliverable/linux.git] / drivers / media / pci / ivtv / ivtv-streams.c
CommitLineData
1a0adaf3
HV		 1/*
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"
1a0adaf3
HV		 38#include "ivtv-queue.h"
39#include "ivtv-mailbox.h"
1a0adaf3 40#include "ivtv-ioctl.h"
33c0fcad 41#include "ivtv-irq.h"
612570f2 42#include "ivtv-yuv.h"
1a0adaf3 43#include "ivtv-cards.h"
612570f2 44#include "ivtv-streams.h"
914610e8 45#include "ivtv-firmware.h"
09250193 46#include <media/v4l2-event.h>
1a0adaf3 47
bec43661 48static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
daf20d95
HV		 49 .owner = THIS_MODULE,
50 .read = ivtv_v4l2_read,
51 .write = ivtv_v4l2_write,
52 .open = ivtv_v4l2_open,
074689d6 53 .unlocked_ioctl = video_ioctl2,
daf20d95
HV		 54 .release = ivtv_v4l2_close,
55 .poll = ivtv_v4l2_enc_poll,
1a0adaf3
HV		 56};
57
bec43661 58static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
daf20d95
HV		 59 .owner = THIS_MODULE,
60 .read = ivtv_v4l2_read,
61 .write = ivtv_v4l2_write,
62 .open = ivtv_v4l2_open,
074689d6 63 .unlocked_ioctl = video_ioctl2,
daf20d95
HV		 64 .release = ivtv_v4l2_close,
65 .poll = ivtv_v4l2_dec_poll,
1a0adaf3
HV		 66};
67
7eaf4966
HV		 68static const struct v4l2_file_operations ivtv_v4l2_radio_fops = {
69 .owner = THIS_MODULE,
70 .open = ivtv_v4l2_open,
71 .unlocked_ioctl = video_ioctl2,
72 .release = ivtv_v4l2_close,
73 .poll = ivtv_v4l2_enc_poll,
74};
75
33c0fcad
HV		 76#define IVTV_V4L2_DEC_MPG_OFFSET 16 /* offset from 0 to register decoder mpg v4l2 minors on */
77#define IVTV_V4L2_ENC_PCM_OFFSET 24 /* offset from 0 to register pcm v4l2 minors on */
78#define IVTV_V4L2_ENC_YUV_OFFSET 32 /* offset from 0 to register yuv v4l2 minors on */
79#define IVTV_V4L2_DEC_YUV_OFFSET 48 /* offset from 0 to register decoder yuv v4l2 minors on */
80#define IVTV_V4L2_DEC_VBI_OFFSET 8 /* offset from 0 to register decoder vbi input v4l2 minors on */
81#define IVTV_V4L2_DEC_VOUT_OFFSET 16 /* offset from 0 to register vbi output v4l2 minors on */
82
31ec1356 83static struct {
1a0adaf3
HV		 84 const char *name;
85 int vfl_type;
dd89601d 86 int num_offset;
1a0adaf3 87 int dma, pio;
d0c8b2d4 88 u32 v4l2_caps;
bec43661 89 const struct v4l2_file_operations *fops;
1a0adaf3
HV		 90} ivtv_stream_info[] = {
91 { /* IVTV_ENC_STREAM_TYPE_MPG */
7c03a448 92 "encoder MPG",
1a0adaf3 93 VFL_TYPE_GRABBER, 0,
ff82b211 94 PCI_DMA_FROMDEVICE, 0,
d0c8b2d4
HV		 95 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
96 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
1a0adaf3
HV		 97 &ivtv_v4l2_enc_fops
98 },
99 { /* IVTV_ENC_STREAM_TYPE_YUV */
100 "encoder YUV",
101 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
ff82b211 102 PCI_DMA_FROMDEVICE, 0,
d0c8b2d4
HV		 103 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
104 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
1a0adaf3
HV		 105 &ivtv_v4l2_enc_fops
106 },
107 { /* IVTV_ENC_STREAM_TYPE_VBI */
108 "encoder VBI",
109 VFL_TYPE_VBI, 0,
ff82b211 110 PCI_DMA_FROMDEVICE, 0,
d0c8b2d4
HV		 111 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_TUNER |
112 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
1a0adaf3
HV		 113 &ivtv_v4l2_enc_fops
114 },
115 { /* IVTV_ENC_STREAM_TYPE_PCM */
7c03a448 116 "encoder PCM",
1a0adaf3 117 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
ff82b211 118 PCI_DMA_FROMDEVICE, 0,
d0c8b2d4 119 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
1a0adaf3
HV		 120 &ivtv_v4l2_enc_fops
121 },
122 { /* IVTV_ENC_STREAM_TYPE_RAD */
123 "encoder radio",
124 VFL_TYPE_RADIO, 0,
ff82b211 125 PCI_DMA_NONE, 1,
d0c8b2d4 126 V4L2_CAP_RADIO | V4L2_CAP_TUNER,
7eaf4966 127 &ivtv_v4l2_radio_fops
1a0adaf3
HV		 128 },
129 { /* IVTV_DEC_STREAM_TYPE_MPG */
7c03a448 130 "decoder MPG",
1a0adaf3 131 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
ff82b211 132 PCI_DMA_TODEVICE, 0,
d0c8b2d4 133 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
1a0adaf3
HV		 134 &ivtv_v4l2_dec_fops
135 },
136 { /* IVTV_DEC_STREAM_TYPE_VBI */
137 "decoder VBI",
138 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
ff82b211 139 PCI_DMA_NONE, 1,
d0c8b2d4 140 V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_READWRITE,
1a0adaf3
HV		 141 &ivtv_v4l2_enc_fops
142 },
143 { /* IVTV_DEC_STREAM_TYPE_VOUT */
144 "decoder VOUT",
145 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
ff82b211 146 PCI_DMA_NONE, 1,
d0c8b2d4 147 V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
1a0adaf3
HV		 148 &ivtv_v4l2_dec_fops
149 },
150 { /* IVTV_DEC_STREAM_TYPE_YUV */
151 "decoder YUV",
152 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
ff82b211 153 PCI_DMA_TODEVICE, 0,
d0c8b2d4 154 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
1a0adaf3
HV		 155 &ivtv_v4l2_dec_fops
156 }
157};
158
159static void ivtv_stream_init(struct ivtv *itv, int type)
160{
161 struct ivtv_stream *s = &itv->streams[type];
8ac05ae3 162 struct video_device *vdev = s->vdev;
1a0adaf3 163
8ac05ae3 164 /* we need to keep vdev, so restore it afterwards */
1a0adaf3 165 memset(s, 0, sizeof(*s));
8ac05ae3 166 s->vdev = vdev;
1a0adaf3
HV		 167
168 /* initialize ivtv_stream fields */
169 s->itv = itv;
170 s->type = type;
171 s->name = ivtv_stream_info[type].name;
d0c8b2d4 172 s->caps = ivtv_stream_info[type].v4l2_caps;
1a0adaf3
HV		 173
174 if (ivtv_stream_info[type].pio)
175 s->dma = PCI_DMA_NONE;
176 else
177 s->dma = ivtv_stream_info[type].dma;
178 s->buf_size = itv->stream_buf_size[type];
179 if (s->buf_size)
313e91e8 180 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
1a0adaf3
HV		 181 spin_lock_init(&s->qlock);
182 init_waitqueue_head(&s->waitq);
37093b1e 183 s->sg_handle = IVTV_DMA_UNMAPPED;
1a0adaf3
HV		 184 ivtv_queue_init(&s->q_free);
185 ivtv_queue_init(&s->q_full);
186 ivtv_queue_init(&s->q_dma);
187 ivtv_queue_init(&s->q_predma);
188 ivtv_queue_init(&s->q_io);
189}
190
18e16f9c 191static int ivtv_prep_dev(struct ivtv *itv, int type)
1a0adaf3
HV		 192{
193 struct ivtv_stream *s = &itv->streams[type];
dd89601d 194 int num_offset = ivtv_stream_info[type].num_offset;
67ec09fd 195 int num = itv->instance + ivtv_first_minor + num_offset;
1a0adaf3 196
8ac05ae3 197 /* These four fields are always initialized. If vdev == NULL, then
1a0adaf3
HV		 198 this stream is not in use. In that case no other fields but these
199 four can be used. */
8ac05ae3 200 s->vdev = NULL;
1a0adaf3
HV		 201 s->itv = itv;
202 s->type = type;
203 s->name = ivtv_stream_info[type].name;
204
205 /* Check whether the radio is supported */
206 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
207 return 0;
208 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
209 return 0;
210
1a0adaf3
HV		 211 /* User explicitly selected 0 buffers for these streams, so don't
212 create them. */
18e16f9c 213 if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
313e91e8 214 itv->options.kilobytes[type] == 0) {
1a0adaf3
HV		 215 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
216 return 0;
217 }
218
219 ivtv_stream_init(itv, type);
220
221 /* allocate and initialize the v4l2 video device structure */
8ac05ae3
HV		 222 s->vdev = video_device_alloc();
223 if (s->vdev == NULL) {
1a0adaf3
HV		 224 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
225 return -ENOMEM;
226 }
227
8ac05ae3
HV		 228 snprintf(s->vdev->name, sizeof(s->vdev->name), "%s %s",
229 itv->v4l2_dev.name, s->name);
1a0adaf3 230
8ac05ae3
HV		 231 s->vdev->num = num;
232 s->vdev->v4l2_dev = &itv->v4l2_dev;
954f340f
HV		 233 if (ivtv_stream_info[type].v4l2_caps &
234 (V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_SLICED_VBI_OUTPUT))
235 s->vdev->vfl_dir = VFL_DIR_TX;
8ac05ae3 236 s->vdev->fops = ivtv_stream_info[type].fops;
eb2ba855 237 s->vdev->ctrl_handler = itv->v4l2_dev.ctrl_handler;
8ac05ae3
HV		 238 s->vdev->release = video_device_release;
239 s->vdev->tvnorms = V4L2_STD_ALL;
cdc03781 240 s->vdev->lock = &itv->serialize_lock;
5f9c82c0
HV		 241 if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {
242 v4l2_disable_ioctl(s->vdev, VIDIOC_S_AUDIO);
243 v4l2_disable_ioctl(s->vdev, VIDIOC_G_AUDIO);
244 v4l2_disable_ioctl(s->vdev, VIDIOC_ENUMAUDIO);
245 v4l2_disable_ioctl(s->vdev, VIDIOC_ENUMINPUT);
246 v4l2_disable_ioctl(s->vdev, VIDIOC_S_INPUT);
247 v4l2_disable_ioctl(s->vdev, VIDIOC_G_INPUT);
248 v4l2_disable_ioctl(s->vdev, VIDIOC_S_FREQUENCY);
249 v4l2_disable_ioctl(s->vdev, VIDIOC_G_FREQUENCY);
250 v4l2_disable_ioctl(s->vdev, VIDIOC_S_TUNER);
251 v4l2_disable_ioctl(s->vdev, VIDIOC_G_TUNER);
252 v4l2_disable_ioctl(s->vdev, VIDIOC_S_STD);
253 }
b1a873a3 254 set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev->flags);
8ac05ae3 255 ivtv_set_funcs(s->vdev);
18e16f9c
HV		 256 return 0;
257}
258
259/* Initialize v4l2 variables and prepare v4l2 devices */
260int ivtv_streams_setup(struct ivtv *itv)
261{
262 int type;
263
264 /* Setup V4L2 Devices */
265 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
266 /* Prepare device */
267 if (ivtv_prep_dev(itv, type))
268 break;
269
8ac05ae3 270 if (itv->streams[type].vdev == NULL)
18e16f9c
HV		 271 continue;
272
273 /* Allocate Stream */
274 if (ivtv_stream_alloc(&itv->streams[type]))
275 break;
1a0adaf3 276 }
18e16f9c 277 if (type == IVTV_MAX_STREAMS)
1a0adaf3 278 return 0;
18e16f9c
HV		 279
280 /* One or more streams could not be initialized. Clean 'em all up. */
3f98387e 281 ivtv_streams_cleanup(itv, 0);
18e16f9c
HV		 282 return -ENOMEM;
283}
284
285static int ivtv_reg_dev(struct ivtv *itv, int type)
286{
287 struct ivtv_stream *s = &itv->streams[type];
288 int vfl_type = ivtv_stream_info[type].vfl_type;
38c7c036 289 const char *name;
dd89601d 290 int num;
18e16f9c 291
8ac05ae3 292 if (s->vdev == NULL)
18e16f9c
HV		 293 return 0;
294
8ac05ae3 295 num = s->vdev->num;
dd89601d
HV		 296 /* card number + user defined offset + device offset */
297 if (type != IVTV_ENC_STREAM_TYPE_MPG) {
298 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
299
8ac05ae3
HV		 300 if (s_mpg->vdev)
301 num = s_mpg->vdev->num + ivtv_stream_info[type].num_offset;
dd89601d 302 }
8ac05ae3 303 video_set_drvdata(s->vdev, s);
dd89601d 304
18e16f9c 305 /* Register device. First try the desired minor, then any free one. */
6b5270d2 306 if (video_register_device_no_warn(s->vdev, vfl_type, num)) {
581644d9 307 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
dd89601d 308 s->name, num);
8ac05ae3
HV		 309 video_device_release(s->vdev);
310 s->vdev = NULL;
18e16f9c 311 return -ENOMEM;
1a0adaf3 312 }
38c7c036 313 name = video_device_node_name(s->vdev);
1a0adaf3
HV		 314
315 switch (vfl_type) {
316 case VFL_TYPE_GRABBER:
38c7c036
LP		 317 IVTV_INFO("Registered device %s for %s (%d kB)\n",
318 name, s->name, itv->options.kilobytes[type]);
1a0adaf3
HV		 319 break;
320 case VFL_TYPE_RADIO:
38c7c036
LP		 321 IVTV_INFO("Registered device %s for %s\n",
322 name, s->name);
1a0adaf3
HV		 323 break;
324 case VFL_TYPE_VBI:
313e91e8 325 if (itv->options.kilobytes[type])
38c7c036
LP		 326 IVTV_INFO("Registered device %s for %s (%d kB)\n",
327 name, s->name, itv->options.kilobytes[type]);
1a0adaf3 328 else
38c7c036
LP		 329 IVTV_INFO("Registered device %s for %s\n",
330 name, s->name);
1a0adaf3
HV		 331 break;
332 }
333 return 0;
334}
335
18e16f9c
HV		 336/* Register v4l2 devices */
337int ivtv_streams_register(struct ivtv *itv)
1a0adaf3
HV		 338{
339 int type;
18e16f9c 340 int err = 0;
1a0adaf3 341
18e16f9c
HV		 342 /* Register V4L2 devices */
343 for (type = 0; type < IVTV_MAX_STREAMS; type++)
344 err |= ivtv_reg_dev(itv, type);
1a0adaf3 345
18e16f9c 346 if (err == 0)
1a0adaf3 347 return 0;
1a0adaf3
HV		 348
349 /* One or more streams could not be initialized. Clean 'em all up. */
3f98387e 350 ivtv_streams_cleanup(itv, 1);
1a0adaf3
HV		 351 return -ENOMEM;
352}
353
354/* Unregister v4l2 devices */
3f98387e 355void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
1a0adaf3
HV		 356{
357 int type;
358
359 /* Teardown all streams */
360 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
8ac05ae3 361 struct video_device *vdev = itv->streams[type].vdev;
1a0adaf3 362
8ac05ae3 363 itv->streams[type].vdev = NULL;
1a0adaf3
HV		 364 if (vdev == NULL)
365 continue;
366
367 ivtv_stream_free(&itv->streams[type]);
3f98387e
HV		 368 /* Unregister or release device */
369 if (unregister)
370 video_unregister_device(vdev);
371 else
372 video_device_release(vdev);
1a0adaf3
HV		 373 }
374}
375
376static void ivtv_vbi_setup(struct ivtv *itv)
377{
a8b86435 378 int raw = ivtv_raw_vbi(itv);
1a0adaf3
HV		 379 u32 data[CX2341X_MBOX_MAX_DATA];
380 int lines;
381 int i;
382
1a0adaf3
HV		 383 /* Reset VBI */
384 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
385
1a0adaf3 386 /* setup VBI registers */
4ff0790b
HV		 387 if (raw)
388 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
389 else
390 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
1a0adaf3
HV		 391
392 /* determine number of lines and total number of VBI bytes.
393 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
394 The '- 1' byte is probably an unused U or V byte. Or something...
395 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
396 header, 42 data bytes + checksum (to be confirmed) */
397 if (raw) {
398 lines = itv->vbi.count * 2;
399 } else {
400 lines = itv->is_60hz ? 24 : 38;
401 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
402 lines += 2;
403 }
404
405 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
406
407 /* Note: sliced vs raw flag doesn't seem to have any effect
408 TODO: check mode (0x02) value with older ivtv versions. */
409 data[0] = raw | 0x02 | (0xbd << 8);
410
411 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
412 data[1] = 1;
413 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
d526afe0 414 data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
1a0adaf3
HV		 415 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
416 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
417 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
418 code. These values for raw VBI are obtained from a driver disassembly. The sliced
419 start/stop codes was deduced from this, but they do not appear in the driver.
420 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
421 However, I have no idea what these values are for. */
422 if (itv->hw_flags & IVTV_HW_CX25840) {
423 /* Setup VBI for the cx25840 digitizer */
424 if (raw) {
425 data[3] = 0x20602060;
426 data[4] = 0x30703070;
427 } else {
428 data[3] = 0xB0F0B0F0;
429 data[4] = 0xA0E0A0E0;
430 }
431 /* Lines per frame */
432 data[5] = lines;
433 /* bytes per line */
434 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
435 } else {
436 /* Setup VBI for the saa7115 digitizer */
437 if (raw) {
438 data[3] = 0x25256262;
439 data[4] = 0x387F7F7F;
440 } else {
441 data[3] = 0xABABECEC;
442 data[4] = 0xB6F1F1F1;
443 }
444 /* Lines per frame */
445 data[5] = lines;
446 /* bytes per line */
447 data[6] = itv->vbi.enc_size / lines;
448 }
449
450 IVTV_DEBUG_INFO(
451 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
452 data[0], data[1], data[2], data[5], data[6]);
453
454 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
455
456 /* returns the VBI encoder memory area. */
457 itv->vbi.enc_start = data[2];
458 itv->vbi.fpi = data[0];
459 if (!itv->vbi.fpi)
460 itv->vbi.fpi = 1;
461
fd8b281a
HV		 462 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
463 itv->vbi.enc_start, data[1], itv->vbi.fpi);
1a0adaf3
HV		 464
465 /* select VBI lines.
466 Note that the sliced argument seems to have no effect. */
467 for (i = 2; i <= 24; i++) {
468 int valid;
469
470 if (itv->is_60hz) {
471 valid = i >= 10 && i < 22;
472 } else {
473 valid = i >= 6 && i < 24;
474 }
475 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
476 valid, 0 , 0, 0);
477 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
478 valid, 0, 0, 0);
479 }
480
481 /* Remaining VBI questions:
482 - Is it possible to select particular VBI lines only for inclusion in the MPEG
483 stream? Currently you can only get the first X lines.
484 - Is mixed raw and sliced VBI possible?
485 - What's the meaning of the raw/sliced flag?
486 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
487}
488
489int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
490{
491 u32 data[CX2341X_MBOX_MAX_DATA];
492 struct ivtv *itv = s->itv;
493 int captype = 0, subtype = 0;
494 int enable_passthrough = 0;
495
8ac05ae3 496 if (s->vdev == NULL)
1a0adaf3
HV		 497 return -EINVAL;
498
499 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
500
501 switch (s->type) {
502 case IVTV_ENC_STREAM_TYPE_MPG:
503 captype = 0;
504 subtype = 3;
505
506 /* Stop Passthrough */
507 if (itv->output_mode == OUT_PASSTHROUGH) {
508 ivtv_passthrough_mode(itv, 0);
509 enable_passthrough = 1;
510 }
511 itv->mpg_data_received = itv->vbi_data_inserted = 0;
512 itv->dualwatch_jiffies = jiffies;
f7b80e69 513 itv->dualwatch_stereo_mode = v4l2_ctrl_g_ctrl(itv->cxhdl.audio_mode);
1a0adaf3
HV		 514 itv->search_pack_header = 0;
515 break;
516
517 case IVTV_ENC_STREAM_TYPE_YUV:
518 if (itv->output_mode == OUT_PASSTHROUGH) {
519 captype = 2;
520 subtype = 11; /* video+audio+decoder */
521 break;
522 }
523 captype = 1;
524 subtype = 1;
525 break;
526 case IVTV_ENC_STREAM_TYPE_PCM:
527 captype = 1;
528 subtype = 2;
529 break;
530 case IVTV_ENC_STREAM_TYPE_VBI:
531 captype = 1;
532 subtype = 4;
533
534 itv->vbi.frame = 0;
535 itv->vbi.inserted_frame = 0;
536 memset(itv->vbi.sliced_mpeg_size,
537 0, sizeof(itv->vbi.sliced_mpeg_size));
538 break;
539 default:
540 return -EINVAL;
541 }
542 s->subtype = subtype;
543 s->buffers_stolen = 0;
544
1a0adaf3
HV		 545 /* Clear Streamoff flags in case left from last capture */
546 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
547
548 if (atomic_read(&itv->capturing) == 0) {
fd8b281a
HV		 549 int digitizer;
550
1a0adaf3
HV		 551 /* Always use frame based mode. Experiments have demonstrated that byte
552 stream based mode results in dropped frames and corruption. Not often,
553 but occasionally. Many thanks go to Leonard Orb who spent a lot of
554 effort and time trying to trace the cause of the drop outs. */
555 /* 1 frame per DMA */
556 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
557 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
558
559 /* Stuff from Windows, we don't know what it is */
560 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
561 /* According to the docs, this should be correct. However, this is
562 untested. I don't dare enable this without having tested it.
563 Only very few old cards actually have this hardware combination.
564 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
565 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
566 */
567 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
568 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
569 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
570 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
571
572 /* assign placeholder */
573 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
574 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
575
fd8b281a
HV		 576 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
577 digitizer = 0xF1;
578 else if (itv->card->hw_all & IVTV_HW_SAA7114)
579 digitizer = 0xEF;
580 else /* cx25840 */
581 digitizer = 0x140;
582
583 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
1a0adaf3
HV		 584
585 /* Setup VBI */
586 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
587 ivtv_vbi_setup(itv);
588 }
589
590 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
591 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
592 itv->pgm_info_offset = data[0];
593 itv->pgm_info_num = data[1];
594 itv->pgm_info_write_idx = 0;
595 itv->pgm_info_read_idx = 0;
596
597 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
598 itv->pgm_info_offset, itv->pgm_info_num);
599
600 /* Setup API for Stream */
f7b80e69 601 cx2341x_handler_setup(&itv->cxhdl);
254d6eb1
HV		 602
603 /* mute if capturing radio */
604 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
605 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
f7b80e69 606 1 | (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
1a0adaf3
HV		 607 }
608
609 /* Vsync Setup */
610 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
611 /* event notification (on) */
612 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
613 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
614 }
615
616 if (atomic_read(&itv->capturing) == 0) {
617 /* Clear all Pending Interrupts */
618 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
619
620 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
621
f7b80e69
HV		 622 cx2341x_handler_set_busy(&itv->cxhdl, 1);
623
1a0adaf3 624 /* Initialize Digitizer for Capture */
3ccc646b
AW		 625 /* Avoid tinny audio problem - ensure audio clocks are going */
626 v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
627 /* Avoid unpredictable PCI bus hang - disable video clocks */
67ec09fd 628 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
7700a0d2 629 ivtv_msleep_timeout(300, 0);
1a0adaf3 630 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
67ec09fd 631 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
1a0adaf3
HV		 632 }
633
634 /* begin_capture */
635 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
636 {
637 IVTV_DEBUG_WARN( "Error starting capture!\n");
638 return -EINVAL;
639 }
640
641 /* Start Passthrough */
642 if (enable_passthrough) {
643 ivtv_passthrough_mode(itv, 1);
644 }
645
646 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
647 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
648 else
649 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
650
651 /* you're live! sit back and await interrupts :) */
652 atomic_inc(&itv->capturing);
653 return 0;
654}
269c11fb 655EXPORT_SYMBOL(ivtv_start_v4l2_encode_stream);
1a0adaf3
HV		 656
657static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
658{
659 u32 data[CX2341X_MBOX_MAX_DATA];
660 struct ivtv *itv = s->itv;
661 int datatype;
bd62307b
IA		 662 u16 width;
663 u16 height;
1a0adaf3 664
8ac05ae3 665 if (s->vdev == NULL)
1a0adaf3
HV		 666 return -EINVAL;
667
668 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
669
f7b80e69
HV		 670 width = itv->cxhdl.width;
671 height = itv->cxhdl.height;
bd62307b 672
1a0adaf3
HV		 673 /* set audio mode to left/stereo for dual/stereo mode. */
674 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
675
676 /* set number of internal decoder buffers */
677 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
678
679 /* prebuffering */
680 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
681
682 /* extract from user packets */
683 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
684 itv->vbi.dec_start = data[0];
685
686 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
687 itv->vbi.dec_start, data[1]);
688
689 /* set decoder source settings */
690 /* Data type: 0 = mpeg from host,
691 1 = yuv from encoder,
692 2 = yuv_from_host */
693 switch (s->type) {
694 case IVTV_DEC_STREAM_TYPE_YUV:
bd62307b
IA		 695 if (itv->output_mode == OUT_PASSTHROUGH) {
696 datatype = 1;
697 } else {
698 /* Fake size to avoid switching video standard */
699 datatype = 2;
700 width = 720;
701 height = itv->is_out_50hz ? 576 : 480;
702 }
1a0adaf3
HV		 703 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
704 break;
705 case IVTV_DEC_STREAM_TYPE_MPG:
706 default:
707 datatype = 0;
708 break;
709 }
710 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
f7b80e69 711 width, height, itv->cxhdl.audio_properties)) {
5a338c38 712 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
1a0adaf3 713 }
666092c6
IA		 714
715 /* Decoder sometimes dies here, so wait a moment */
716 ivtv_msleep_timeout(10, 0);
717
914610e8 718 /* Known failure point for firmware, so check */
215659d1 719 return ivtv_firmware_check(itv, "ivtv_setup_v4l2_decode_stream");
1a0adaf3
HV		 720}
721
722int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
723{
724 struct ivtv *itv = s->itv;
914610e8 725 int rc;
1a0adaf3 726
8ac05ae3 727 if (s->vdev == NULL)
1a0adaf3
HV		 728 return -EINVAL;
729
730 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
731 return 0; /* already started */
732
733 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
734
914610e8
IA		 735 rc = ivtv_setup_v4l2_decode_stream(s);
736 if (rc < 0) {
737 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
738 return rc;
739 }
1a0adaf3
HV		 740
741 /* set dma size to 65536 bytes */
742 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
743
77aded6b 744 /* Clear Streamoff */
1a0adaf3
HV		 745 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
746
747 /* Zero out decoder counters */
33c0fcad
HV		 748 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
749 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
750 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
751 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
1a0adaf3
HV		 752 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
753 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
754 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
755 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
756
757 /* turn on notification of dual/stereo mode change */
758 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
759
760 /* start playback */
761 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
762
666092c6
IA		 763 /* Let things settle before we actually start */
764 ivtv_msleep_timeout(10, 0);
765
1a0adaf3
HV		 766 /* Clear the following Interrupt mask bits for decoding */
767 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
768 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
769
770 /* you're live! sit back and await interrupts :) */
771 atomic_inc(&itv->decoding);
772 return 0;
773}
774
775void ivtv_stop_all_captures(struct ivtv *itv)
776{
777 int i;
778
779 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
780 struct ivtv_stream *s = &itv->streams[i];
781
8ac05ae3 782 if (s->vdev == NULL)
1a0adaf3
HV		 783 continue;
784 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
785 ivtv_stop_v4l2_encode_stream(s, 0);
786 }
787 }
788}
789
790int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
791{
792 struct ivtv *itv = s->itv;
793 DECLARE_WAITQUEUE(wait, current);
794 int cap_type;
1a0adaf3 795 int stopmode;
1a0adaf3 796
8ac05ae3 797 if (s->vdev == NULL)
1a0adaf3
HV		 798 return -EINVAL;
799
800 /* This function assumes that you are allowed to stop the capture
801 and that we are actually capturing */
802
803 IVTV_DEBUG_INFO("Stop Capture\n");
804
805 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
806 return 0;
807 if (atomic_read(&itv->capturing) == 0)
808 return 0;
809
810 switch (s->type) {
811 case IVTV_ENC_STREAM_TYPE_YUV:
812 cap_type = 1;
813 break;
814 case IVTV_ENC_STREAM_TYPE_PCM:
815 cap_type = 1;
816 break;
817 case IVTV_ENC_STREAM_TYPE_VBI:
818 cap_type = 1;
819 break;
820 case IVTV_ENC_STREAM_TYPE_MPG:
821 default:
822 cap_type = 0;
823 break;
824 }
825
826 /* Stop Capture Mode */
827 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
828 stopmode = 0;
829 } else {
830 stopmode = 1;
831 }
832
833 /* end_capture */
834 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
835 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
836
1a0adaf3
HV		 837 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
838 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
839 /* only run these if we're shutting down the last cap */
840 unsigned long duration;
559e196a 841 unsigned long then = jiffies;
1a0adaf3 842
fd8b281a 843 add_wait_queue(&itv->eos_waitq, &wait);
1a0adaf3
HV		 844
845 set_current_state(TASK_INTERRUPTIBLE);
846
847 /* wait 2s for EOS interrupt */
201700d3 848 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
168c626c
JL		 849 time_before(jiffies,
850 then + msecs_to_jiffies(2000))) {
201700d3 851 schedule_timeout(msecs_to_jiffies(10));
1a0adaf3
HV		 852 }
853
854 /* To convert jiffies to ms, we must multiply by 1000
855 * and divide by HZ. To avoid runtime division, we
856 * convert this to multiplication by 1000/HZ.
857 * Since integer division truncates, we get the best
858 * accuracy if we do a rounding calculation of the constant.
859 * Think of the case where HZ is 1024.
860 */
861 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
862
863 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
864 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
865 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
866 } else {
867 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
868 }
869 set_current_state(TASK_RUNNING);
fd8b281a 870 remove_wait_queue(&itv->eos_waitq, &wait);
559e196a 871 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
1a0adaf3
HV		 872 }
873
3562c43b 874 /* Handle any pending interrupts */
7700a0d2 875 ivtv_msleep_timeout(100, 0);
1a0adaf3
HV		 876 }
877
878 atomic_dec(&itv->capturing);
879
880 /* Clear capture and no-read bits */
881 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
882
883 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
884 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
885
886 if (atomic_read(&itv->capturing) > 0) {
887 return 0;
888 }
889
f7b80e69
HV		 890 cx2341x_handler_set_busy(&itv->cxhdl, 0);
891
1a0adaf3
HV		 892 /* Set the following Interrupt mask bits for capture */
893 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
e17a06ba 894 del_timer(&itv->dma_timer);
1a0adaf3 895
f8859691
HV		 896 /* event notification (off) */
897 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
898 /* type: 0 = refresh */
899 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
900 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
901 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
902 }
903
9a766d55
IA		 904 /* Raw-passthrough is implied on start. Make sure it's stopped so
905 the encoder will re-initialize when next started */
906 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
907
1a0adaf3
HV		 908 wake_up(&s->waitq);
909
910 return 0;
911}
269c11fb 912EXPORT_SYMBOL(ivtv_stop_v4l2_encode_stream);
1a0adaf3
HV		 913
914int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
915{
09250193
HV		 916 static const struct v4l2_event ev = {
917 .type = V4L2_EVENT_EOS,
918 };
1a0adaf3
HV		 919 struct ivtv *itv = s->itv;
920
8ac05ae3 921 if (s->vdev == NULL)
1a0adaf3
HV		 922 return -EINVAL;
923
924 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
925 return -EINVAL;
926
927 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
928 return 0;
929
c4385098 930 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
1a0adaf3
HV		 931
932 /* Stop Decoder */
da8ec560 933 if (!(flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) || pts) {
1a0adaf3
HV		 934 u32 tmp = 0;
935
936 /* Wait until the decoder is no longer running */
937 if (pts) {
938 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
939 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
940 }
941 while (1) {
942 u32 data[CX2341X_MBOX_MAX_DATA];
943 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
944 if (s->q_full.buffers + s->q_dma.buffers == 0) {
945 if (tmp == data[3])
946 break;
947 tmp = data[3];
948 }
201700d3 949 if (ivtv_msleep_timeout(100, 1))
1a0adaf3
HV		 950 break;
951 }
952 }
da8ec560 953 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & V4L2_DEC_CMD_STOP_TO_BLACK, 0, 0);
1a0adaf3
HV		 954
955 /* turn off notification of dual/stereo mode change */
956 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
957
958 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
e17a06ba 959 del_timer(&itv->dma_timer);
1a0adaf3
HV		 960
961 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
962 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
963 ivtv_flush_queues(s);
964
f06b9bd4
IA		 965 /* decoder needs time to settle */
966 ivtv_msleep_timeout(40, 0);
967
1a0adaf3
HV		 968 /* decrement decoding */
969 atomic_dec(&itv->decoding);
970
971 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
972 wake_up(&itv->event_waitq);
09250193 973 v4l2_event_queue(s->vdev, &ev);
1a0adaf3
HV		 974
975 /* wake up wait queues */
976 wake_up(&s->waitq);
977
978 return 0;
979}
980
981int ivtv_passthrough_mode(struct ivtv *itv, int enable)
982{
983 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
984 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
985
8ac05ae3 986 if (yuv_stream->vdev == NULL || dec_stream->vdev == NULL)
1a0adaf3
HV		 987 return -EINVAL;
988
989 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
990
991 /* Prevent others from starting/stopping streams while we
992 initiate/terminate passthrough mode */
993 if (enable) {
994 if (itv->output_mode == OUT_PASSTHROUGH) {
995 return 0;
996 }
997 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
998 return -EBUSY;
999
1000 /* Fully initialize stream, and then unflag init */
1001 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1002 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1003
1004 /* Setup YUV Decoder */
1005 ivtv_setup_v4l2_decode_stream(dec_stream);
1006
1007 /* Start Decoder */
1008 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
1009 atomic_inc(&itv->decoding);
1010
1011 /* Setup capture if not already done */
1012 if (atomic_read(&itv->capturing) == 0) {
f7b80e69
HV		 1013 cx2341x_handler_setup(&itv->cxhdl);
1014 cx2341x_handler_set_busy(&itv->cxhdl, 1);
1a0adaf3
HV		 1015 }
1016
1017 /* Start Passthrough Mode */
1018 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
1019 atomic_inc(&itv->capturing);
1020 return 0;
1021 }
1022
1023 if (itv->output_mode != OUT_PASSTHROUGH)
1024 return 0;
1025
1026 /* Stop Passthrough Mode */
1027 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
1028 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
1029
1030 atomic_dec(&itv->capturing);
1031 atomic_dec(&itv->decoding);
1032 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1033 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1034 itv->output_mode = OUT_NONE;
f7b80e69
HV		 1035 if (atomic_read(&itv->capturing) == 0)
1036 cx2341x_handler_set_busy(&itv->cxhdl, 0);
1a0adaf3
HV		 1037
1038 return 0;
1039}
Linux kernel - Deliverables
This page took 0.816774 seconds and 5 git commands to generate.