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