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