projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-linus' of git://linux-nfs.org/~bfields/linux
[deliverable/linux.git] / drivers / media / video / 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"
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
49static 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
59static 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
31ec1356 69static struct {
1a0adaf3
HV		 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 MPEG",
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 audio",
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 MPEG",
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
133static 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.megabytes[type] * 1024 * 1024 / 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
165static 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.megabytes[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 MB)\n",
242 s->v4l2dev->minor, s->name, itv->options.megabytes[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.megabytes[type])
250 IVTV_INFO("Registered device vbi%d for %s (%d MB)\n",
251 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN,
252 s->name, itv->options.megabytes[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 */
262int 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 */
289void 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
310static 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 /* If Embed then streamtype must be Program */
318 /* TODO: should we really do this? */
319 if (0 && !raw && itv->vbi.insert_mpeg) {
320 itv->params.stream_type = 0;
321
322 /* assign stream type */
323 ivtv_vapi(itv, CX2341X_ENC_SET_STREAM_TYPE, 1, itv->params.stream_type);
324 }
325
326 /* Reset VBI */
327 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
328
329 if (itv->is_60hz) {
330 itv->vbi.count = 12;
331 itv->vbi.start[0] = 10;
332 itv->vbi.start[1] = 273;
333 } else { /* PAL/SECAM */
334 itv->vbi.count = 18;
335 itv->vbi.start[0] = 6;
336 itv->vbi.start[1] = 318;
337 }
338
339 /* setup VBI registers */
340 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
341
342 /* determine number of lines and total number of VBI bytes.
343 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
344 The '- 1' byte is probably an unused U or V byte. Or something...
345 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
346 header, 42 data bytes + checksum (to be confirmed) */
347 if (raw) {
348 lines = itv->vbi.count * 2;
349 } else {
350 lines = itv->is_60hz ? 24 : 38;
351 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
352 lines += 2;
353 }
354
355 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
356
357 /* Note: sliced vs raw flag doesn't seem to have any effect
358 TODO: check mode (0x02) value with older ivtv versions. */
359 data[0] = raw | 0x02 | (0xbd << 8);
360
361 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
362 data[1] = 1;
363 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
364 data[2] = raw ? 4 : 8;
365 /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
366 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
367 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
368 code. These values for raw VBI are obtained from a driver disassembly. The sliced
369 start/stop codes was deduced from this, but they do not appear in the driver.
370 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
371 However, I have no idea what these values are for. */
372 if (itv->hw_flags & IVTV_HW_CX25840) {
373 /* Setup VBI for the cx25840 digitizer */
374 if (raw) {
375 data[3] = 0x20602060;
376 data[4] = 0x30703070;
377 } else {
378 data[3] = 0xB0F0B0F0;
379 data[4] = 0xA0E0A0E0;
380 }
381 /* Lines per frame */
382 data[5] = lines;
383 /* bytes per line */
384 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
385 } else {
386 /* Setup VBI for the saa7115 digitizer */
387 if (raw) {
388 data[3] = 0x25256262;
389 data[4] = 0x387F7F7F;
390 } else {
391 data[3] = 0xABABECEC;
392 data[4] = 0xB6F1F1F1;
393 }
394 /* Lines per frame */
395 data[5] = lines;
396 /* bytes per line */
397 data[6] = itv->vbi.enc_size / lines;
398 }
399
400 IVTV_DEBUG_INFO(
401 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
402 data[0], data[1], data[2], data[5], data[6]);
403
404 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
405
406 /* returns the VBI encoder memory area. */
407 itv->vbi.enc_start = data[2];
408 itv->vbi.fpi = data[0];
409 if (!itv->vbi.fpi)
410 itv->vbi.fpi = 1;
411
412 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d lines 0x%08x\n",
413 itv->vbi.enc_start, data[1], itv->vbi.fpi, itv->digitizer);
414
415 /* select VBI lines.
416 Note that the sliced argument seems to have no effect. */
417 for (i = 2; i <= 24; i++) {
418 int valid;
419
420 if (itv->is_60hz) {
421 valid = i >= 10 && i < 22;
422 } else {
423 valid = i >= 6 && i < 24;
424 }
425 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
426 valid, 0 , 0, 0);
427 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
428 valid, 0, 0, 0);
429 }
430
431 /* Remaining VBI questions:
432 - Is it possible to select particular VBI lines only for inclusion in the MPEG
433 stream? Currently you can only get the first X lines.
434 - Is mixed raw and sliced VBI possible?
435 - What's the meaning of the raw/sliced flag?
436 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
437}
438
439int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
440{
441 u32 data[CX2341X_MBOX_MAX_DATA];
442 struct ivtv *itv = s->itv;
443 int captype = 0, subtype = 0;
444 int enable_passthrough = 0;
445
446 if (s->v4l2dev == NULL)
447 return -EINVAL;
448
f8859691
HV		 449 /* Big serialization lock to ensure no two streams are started
450 simultaneously: that can give all sorts of weird results. */
451 mutex_lock(&itv->serialize_lock);
1a0adaf3
HV		 452 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
453
454 switch (s->type) {
455 case IVTV_ENC_STREAM_TYPE_MPG:
456 captype = 0;
457 subtype = 3;
458
459 /* Stop Passthrough */
460 if (itv->output_mode == OUT_PASSTHROUGH) {
461 ivtv_passthrough_mode(itv, 0);
462 enable_passthrough = 1;
463 }
464 itv->mpg_data_received = itv->vbi_data_inserted = 0;
465 itv->dualwatch_jiffies = jiffies;
466 itv->dualwatch_stereo_mode = itv->params.audio_properties & 0x0300;
467 itv->search_pack_header = 0;
468 break;
469
470 case IVTV_ENC_STREAM_TYPE_YUV:
471 if (itv->output_mode == OUT_PASSTHROUGH) {
472 captype = 2;
473 subtype = 11; /* video+audio+decoder */
474 break;
475 }
476 captype = 1;
477 subtype = 1;
478 break;
479 case IVTV_ENC_STREAM_TYPE_PCM:
480 captype = 1;
481 subtype = 2;
482 break;
483 case IVTV_ENC_STREAM_TYPE_VBI:
484 captype = 1;
485 subtype = 4;
486
487 itv->vbi.frame = 0;
488 itv->vbi.inserted_frame = 0;
489 memset(itv->vbi.sliced_mpeg_size,
490 0, sizeof(itv->vbi.sliced_mpeg_size));
491 break;
492 default:
f8859691 493 mutex_unlock(&itv->serialize_lock);
1a0adaf3
HV		 494 return -EINVAL;
495 }
496 s->subtype = subtype;
497 s->buffers_stolen = 0;
498
499 /* mute/unmute video */
500 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1, test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? 1 : 0);
501
502 /* Clear Streamoff flags in case left from last capture */
503 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
504
505 if (atomic_read(&itv->capturing) == 0) {
506 /* Always use frame based mode. Experiments have demonstrated that byte
507 stream based mode results in dropped frames and corruption. Not often,
508 but occasionally. Many thanks go to Leonard Orb who spent a lot of
509 effort and time trying to trace the cause of the drop outs. */
510 /* 1 frame per DMA */
511 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
512 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
513
514 /* Stuff from Windows, we don't know what it is */
515 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
516 /* According to the docs, this should be correct. However, this is
517 untested. I don't dare enable this without having tested it.
518 Only very few old cards actually have this hardware combination.
519 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
520 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
521 */
522 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
523 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
524 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
525 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
526
527 /* assign placeholder */
528 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
529 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
530
531 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, itv->digitizer, itv->digitizer);
532
533 /* Setup VBI */
534 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
535 ivtv_vbi_setup(itv);
536 }
537
538 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
539 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
540 itv->pgm_info_offset = data[0];
541 itv->pgm_info_num = data[1];
542 itv->pgm_info_write_idx = 0;
543 itv->pgm_info_read_idx = 0;
544
545 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
546 itv->pgm_info_offset, itv->pgm_info_num);
547
548 /* Setup API for Stream */
549 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
550 }
551
552 /* Vsync Setup */
553 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
554 /* event notification (on) */
555 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
556 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
557 }
558
559 if (atomic_read(&itv->capturing) == 0) {
560 /* Clear all Pending Interrupts */
561 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
562
563 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
564
565 /* Initialize Digitizer for Capture */
566 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
567
568 ivtv_sleep_timeout(HZ / 10, 0);
569 }
570
571 /* begin_capture */
572 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
573 {
574 IVTV_DEBUG_WARN( "Error starting capture!\n");
f8859691 575 mutex_unlock(&itv->serialize_lock);
1a0adaf3
HV		 576 return -EINVAL;
577 }
578
579 /* Start Passthrough */
580 if (enable_passthrough) {
581 ivtv_passthrough_mode(itv, 1);
582 }
583
584 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
585 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
586 else
587 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
588
589 /* you're live! sit back and await interrupts :) */
590 atomic_inc(&itv->capturing);
f8859691 591 mutex_unlock(&itv->serialize_lock);
1a0adaf3
HV		 592 return 0;
593}
594
595static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
596{
597 u32 data[CX2341X_MBOX_MAX_DATA];
598 struct ivtv *itv = s->itv;
599 int datatype;
600
601 if (s->v4l2dev == NULL)
602 return -EINVAL;
603
604 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
605
606 /* disable VBI signals, if the MPEG stream contains VBI data,
607 then that data will be processed automatically for you. */
608 ivtv_disable_vbi(itv);
609
610 /* set audio mode to left/stereo for dual/stereo mode. */
611 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
612
613 /* set number of internal decoder buffers */
614 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
615
616 /* prebuffering */
617 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
618
619 /* extract from user packets */
620 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
621 itv->vbi.dec_start = data[0];
622
623 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
624 itv->vbi.dec_start, data[1]);
625
626 /* set decoder source settings */
627 /* Data type: 0 = mpeg from host,
628 1 = yuv from encoder,
629 2 = yuv_from_host */
630 switch (s->type) {
631 case IVTV_DEC_STREAM_TYPE_YUV:
632 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
633 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
634 break;
635 case IVTV_DEC_STREAM_TYPE_MPG:
636 default:
637 datatype = 0;
638 break;
639 }
640 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
641 itv->params.width, itv->params.height, itv->params.audio_properties)) {
642 IVTV_DEBUG_WARN("COULDN'T INITIALIZE DECODER SOURCE\n");
643 }
644 return 0;
645}
646
647int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
648{
649 struct ivtv *itv = s->itv;
650
651 if (s->v4l2dev == NULL)
652 return -EINVAL;
653
654 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
655 return 0; /* already started */
656
657 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
658
659 /* Clear Streamoff */
660 if (s->type == IVTV_DEC_STREAM_TYPE_YUV) {
661 /* Initialize Decoder */
662 /* Reprogram Decoder YUV Buffers for YUV */
663 write_reg(yuv_offset[0] >> 4, 0x82c);
664 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
665 write_reg(yuv_offset[0] >> 4, 0x834);
666 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
667
668 write_reg_sync(0x00000000 | (0x0c << 16) | (0x0b << 8), 0x2d24);
669
670 write_reg_sync(0x00108080, 0x2898);
671 /* Enable YUV decoder output */
672 write_reg_sync(0x01, IVTV_REG_VDM);
673 }
674
675 ivtv_setup_v4l2_decode_stream(s);
676
677 /* set dma size to 65536 bytes */
678 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
679
680 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
681
682 /* Zero out decoder counters */
683 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[0]);
684 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[1]);
685 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[2]);
686 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[3]);
687 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
688 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
689 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
690 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
691
692 /* turn on notification of dual/stereo mode change */
693 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
694
695 /* start playback */
696 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
697
698 /* Clear the following Interrupt mask bits for decoding */
699 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
700 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
701
702 /* you're live! sit back and await interrupts :) */
703 atomic_inc(&itv->decoding);
704 return 0;
705}
706
707void ivtv_stop_all_captures(struct ivtv *itv)
708{
709 int i;
710
711 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
712 struct ivtv_stream *s = &itv->streams[i];
713
714 if (s->v4l2dev == NULL)
715 continue;
716 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
717 ivtv_stop_v4l2_encode_stream(s, 0);
718 }
719 }
720}
721
722int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
723{
724 struct ivtv *itv = s->itv;
725 DECLARE_WAITQUEUE(wait, current);
726 int cap_type;
727 unsigned long then;
728 int stopmode;
729 u32 data[CX2341X_MBOX_MAX_DATA];
730
731 if (s->v4l2dev == NULL)
732 return -EINVAL;
733
734 /* This function assumes that you are allowed to stop the capture
735 and that we are actually capturing */
736
737 IVTV_DEBUG_INFO("Stop Capture\n");
738
739 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
740 return 0;
741 if (atomic_read(&itv->capturing) == 0)
742 return 0;
743
744 switch (s->type) {
745 case IVTV_ENC_STREAM_TYPE_YUV:
746 cap_type = 1;
747 break;
748 case IVTV_ENC_STREAM_TYPE_PCM:
749 cap_type = 1;
750 break;
751 case IVTV_ENC_STREAM_TYPE_VBI:
752 cap_type = 1;
753 break;
754 case IVTV_ENC_STREAM_TYPE_MPG:
755 default:
756 cap_type = 0;
757 break;
758 }
759
760 /* Stop Capture Mode */
761 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
762 stopmode = 0;
763 } else {
764 stopmode = 1;
765 }
766
767 /* end_capture */
768 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
769 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
770
1a0adaf3
HV		 771 then = jiffies;
772
773 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
774 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
775 /* only run these if we're shutting down the last cap */
776 unsigned long duration;
777
778 then = jiffies;
779 add_wait_queue(&itv->cap_w, &wait);
780
781 set_current_state(TASK_INTERRUPTIBLE);
782
783 /* wait 2s for EOS interrupt */
784 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) && jiffies < then + 2 * HZ) {
785 schedule_timeout(HZ / 100);
786 }
787
788 /* To convert jiffies to ms, we must multiply by 1000
789 * and divide by HZ. To avoid runtime division, we
790 * convert this to multiplication by 1000/HZ.
791 * Since integer division truncates, we get the best
792 * accuracy if we do a rounding calculation of the constant.
793 * Think of the case where HZ is 1024.
794 */
795 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
796
797 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
798 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
799 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
800 } else {
801 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
802 }
803 set_current_state(TASK_RUNNING);
804 remove_wait_queue(&itv->cap_w, &wait);
805 }
806
807 then = jiffies;
808 /* Make sure DMA is complete */
809 add_wait_queue(&s->waitq, &wait);
1a0adaf3
HV		 810 do {
811 /* check if DMA is pending */
812 if ((s->type == IVTV_ENC_STREAM_TYPE_MPG) && /* MPG Only */
813 (read_reg(IVTV_REG_DMASTATUS) & 0x02)) {
814 /* Check for last DMA */
815 ivtv_vapi_result(itv, data, CX2341X_ENC_GET_SEQ_END, 2, 0, 0);
816
817 if (data[0] == 1) {
818 IVTV_DEBUG_DMA("%s: Last DMA of size 0x%08x\n", s->name, data[1]);
819 break;
820 }
821 } else if (read_reg(IVTV_REG_DMASTATUS) & 0x02) {
822 break;
823 }
90851fe9 824 } while (!ivtv_sleep_timeout(HZ / 100, 1) && then + HZ * 2 > jiffies);
1a0adaf3
HV		 825
826 set_current_state(TASK_RUNNING);
827 remove_wait_queue(&s->waitq, &wait);
828 }
829
830 atomic_dec(&itv->capturing);
831
832 /* Clear capture and no-read bits */
833 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
834
f8859691
HV		 835 /* ensure these global cleanup actions are done only once */
836 mutex_lock(&itv->serialize_lock);
837
1a0adaf3
HV		 838 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
839 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
840
841 if (atomic_read(&itv->capturing) > 0) {
f8859691 842 mutex_unlock(&itv->serialize_lock);
1a0adaf3
HV		 843 return 0;
844 }
845
846 /* Set the following Interrupt mask bits for capture */
847 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
848
f8859691
HV		 849 /* event notification (off) */
850 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
851 /* type: 0 = refresh */
852 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
853 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
854 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
855 }
856
1a0adaf3 857 wake_up(&s->waitq);
f8859691 858 mutex_unlock(&itv->serialize_lock);
1a0adaf3
HV		 859
860 return 0;
861}
862
863int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
864{
865 struct ivtv *itv = s->itv;
866
867 if (s->v4l2dev == NULL)
868 return -EINVAL;
869
870 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
871 return -EINVAL;
872
873 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
874 return 0;
875
c4385098 876 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
1a0adaf3
HV		 877
878 /* Stop Decoder */
879 if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
880 u32 tmp = 0;
881
882 /* Wait until the decoder is no longer running */
883 if (pts) {
884 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
885 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
886 }
887 while (1) {
888 u32 data[CX2341X_MBOX_MAX_DATA];
889 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
890 if (s->q_full.buffers + s->q_dma.buffers == 0) {
891 if (tmp == data[3])
892 break;
893 tmp = data[3];
894 }
895 if (ivtv_sleep_timeout(HZ/10, 1))
896 break;
897 }
898 }
899 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
900
901 /* turn off notification of dual/stereo mode change */
902 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
903
904 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
905
906 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
907 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
908 ivtv_flush_queues(s);
909
910 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
911 /* disable VBI on TV-out */
912 ivtv_disable_vbi(itv);
913 }
914
915 /* decrement decoding */
916 atomic_dec(&itv->decoding);
917
918 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
919 wake_up(&itv->event_waitq);
920
921 /* wake up wait queues */
922 wake_up(&s->waitq);
923
924 return 0;
925}
926
927int ivtv_passthrough_mode(struct ivtv *itv, int enable)
928{
929 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
930 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
931
932 if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
933 return -EINVAL;
934
935 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
936
937 /* Prevent others from starting/stopping streams while we
938 initiate/terminate passthrough mode */
939 if (enable) {
940 if (itv->output_mode == OUT_PASSTHROUGH) {
941 return 0;
942 }
943 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
944 return -EBUSY;
945
946 /* Fully initialize stream, and then unflag init */
947 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
948 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
949
950 /* Setup YUV Decoder */
951 ivtv_setup_v4l2_decode_stream(dec_stream);
952
953 /* Start Decoder */
954 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
955 atomic_inc(&itv->decoding);
956
957 /* Setup capture if not already done */
958 if (atomic_read(&itv->capturing) == 0) {
959 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
960 }
961
962 /* Start Passthrough Mode */
963 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
964 atomic_inc(&itv->capturing);
965 return 0;
966 }
967
968 if (itv->output_mode != OUT_PASSTHROUGH)
969 return 0;
970
971 /* Stop Passthrough Mode */
972 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
973 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
974
975 atomic_dec(&itv->capturing);
976 atomic_dec(&itv->decoding);
977 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
978 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
979 itv->output_mode = OUT_NONE;
980
981 return 0;
982}
Linux kernel - Deliverables
This page took 0.101324 seconds and 5 git commands to generate.