?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (6006): tuner: move last_div to tuner-simple private data
[wrt350n-kernel.git] / drivers / media / video / ivtv / ivtv-streams.c
blob405e2e3fcb4901427e8caed2e4a41119e9ae9cd3
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 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
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.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
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.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 */
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 /* Big serialization lock to ensure no two streams are started
441 simultaneously: that can give all sorts of weird results. */
442 mutex_lock(&itv->serialize_lock);
443 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
444
445 switch (s->type) {
446 case IVTV_ENC_STREAM_TYPE_MPG:
447 captype = 0;
448 subtype = 3;
449
450 /* Stop Passthrough */
451 if (itv->output_mode == OUT_PASSTHROUGH) {
452 ivtv_passthrough_mode(itv, 0);
453 enable_passthrough = 1;
454 }
455 itv->mpg_data_received = itv->vbi_data_inserted = 0;
456 itv->dualwatch_jiffies = jiffies;
457 itv->dualwatch_stereo_mode = itv->params.audio_properties & 0x0300;
458 itv->search_pack_header = 0;
459 break;
460
461 case IVTV_ENC_STREAM_TYPE_YUV:
462 if (itv->output_mode == OUT_PASSTHROUGH) {
463 captype = 2;
464 subtype = 11; /* video+audio+decoder */
465 break;
466 }
467 captype = 1;
468 subtype = 1;
469 break;
470 case IVTV_ENC_STREAM_TYPE_PCM:
471 captype = 1;
472 subtype = 2;
473 break;
474 case IVTV_ENC_STREAM_TYPE_VBI:
475 captype = 1;
476 subtype = 4;
477
478 itv->vbi.frame = 0;
479 itv->vbi.inserted_frame = 0;
480 memset(itv->vbi.sliced_mpeg_size,
481 0, sizeof(itv->vbi.sliced_mpeg_size));
482 break;
483 default:
484 mutex_unlock(&itv->serialize_lock);
485 return -EINVAL;
486 }
487 s->subtype = subtype;
488 s->buffers_stolen = 0;
489
490 /* mute/unmute video */
491 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1, test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? 1 : 0);
492
493 /* Clear Streamoff flags in case left from last capture */
494 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
495
496 if (atomic_read(&itv->capturing) == 0) {
497 /* Always use frame based mode. Experiments have demonstrated that byte
498 stream based mode results in dropped frames and corruption. Not often,
499 but occasionally. Many thanks go to Leonard Orb who spent a lot of
500 effort and time trying to trace the cause of the drop outs. */
501 /* 1 frame per DMA */
502 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
503 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
504
505 /* Stuff from Windows, we don't know what it is */
506 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
507 /* According to the docs, this should be correct. However, this is
508 untested. I don't dare enable this without having tested it.
509 Only very few old cards actually have this hardware combination.
510 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
511 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
512 */
513 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
514 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
515 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
516 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
517
518 /* assign placeholder */
519 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
520 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
521
522 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, itv->digitizer, itv->digitizer);
523
524 /* Setup VBI */
525 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
526 ivtv_vbi_setup(itv);
527 }
528
529 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
530 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
531 itv->pgm_info_offset = data[0];
532 itv->pgm_info_num = data[1];
533 itv->pgm_info_write_idx = 0;
534 itv->pgm_info_read_idx = 0;
535
536 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
537 itv->pgm_info_offset, itv->pgm_info_num);
538
539 /* Setup API for Stream */
540 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
541 }
542
543 /* Vsync Setup */
544 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
545 /* event notification (on) */
546 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
547 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
548 }
549
550 if (atomic_read(&itv->capturing) == 0) {
551 /* Clear all Pending Interrupts */
552 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
553
554 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
555
556 /* Initialize Digitizer for Capture */
557 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
558
559 ivtv_msleep_timeout(100, 0);
560 }
561
562 /* begin_capture */
563 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
564 {
565 IVTV_DEBUG_WARN( "Error starting capture!\n");
566 mutex_unlock(&itv->serialize_lock);
567 return -EINVAL;
568 }
569
570 /* Start Passthrough */
571 if (enable_passthrough) {
572 ivtv_passthrough_mode(itv, 1);
573 }
574
575 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
576 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
577 else
578 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
579
580 /* you're live! sit back and await interrupts :) */
581 atomic_inc(&itv->capturing);
582 mutex_unlock(&itv->serialize_lock);
583 return 0;
584 }
585
586 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
587 {
588 u32 data[CX2341X_MBOX_MAX_DATA];
589 struct ivtv *itv = s->itv;
590 int datatype;
591
592 if (s->v4l2dev == NULL)
593 return -EINVAL;
594
595 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
596
597 /* set audio mode to left/stereo for dual/stereo mode. */
598 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
599
600 /* set number of internal decoder buffers */
601 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
602
603 /* prebuffering */
604 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
605
606 /* extract from user packets */
607 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
608 itv->vbi.dec_start = data[0];
609
610 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
611 itv->vbi.dec_start, data[1]);
612
613 /* set decoder source settings */
614 /* Data type: 0 = mpeg from host,
615 1 = yuv from encoder,
616 2 = yuv_from_host */
617 switch (s->type) {
618 case IVTV_DEC_STREAM_TYPE_YUV:
619 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
620 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
621 break;
622 case IVTV_DEC_STREAM_TYPE_MPG:
623 default:
624 datatype = 0;
625 break;
626 }
627 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
628 itv->params.width, itv->params.height, itv->params.audio_properties)) {
629 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
630 }
631 return 0;
632 }
633
634 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
635 {
636 struct ivtv *itv = s->itv;
637
638 if (s->v4l2dev == NULL)
639 return -EINVAL;
640
641 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
642 return 0; /* already started */
643
644 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
645
646 /* Clear Streamoff */
647 if (s->type == IVTV_DEC_STREAM_TYPE_YUV) {
648 /* Initialize Decoder */
649 /* Reprogram Decoder YUV Buffers for YUV */
650 write_reg(yuv_offset[0] >> 4, 0x82c);
651 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
652 write_reg(yuv_offset[0] >> 4, 0x834);
653 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
654
655 write_reg_sync(0x00000000 | (0x0c << 16) | (0x0b << 8), 0x2d24);
656
657 write_reg_sync(0x00108080, 0x2898);
658 /* Enable YUV decoder output */
659 write_reg_sync(0x01, IVTV_REG_VDM);
660 }
661
662 ivtv_setup_v4l2_decode_stream(s);
663
664 /* set dma size to 65536 bytes */
665 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
666
667 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
668
669 /* Zero out decoder counters */
670 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[0]);
671 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[1]);
672 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[2]);
673 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[3]);
674 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
675 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
676 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
677 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
678
679 /* turn on notification of dual/stereo mode change */
680 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
681
682 /* start playback */
683 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
684
685 /* Clear the following Interrupt mask bits for decoding */
686 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
687 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
688
689 /* you're live! sit back and await interrupts :) */
690 atomic_inc(&itv->decoding);
691 return 0;
692 }
693
694 void ivtv_stop_all_captures(struct ivtv *itv)
695 {
696 int i;
697
698 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
699 struct ivtv_stream *s = &itv->streams[i];
700
701 if (s->v4l2dev == NULL)
702 continue;
703 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
704 ivtv_stop_v4l2_encode_stream(s, 0);
705 }
706 }
707 }
708
709 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
710 {
711 struct ivtv *itv = s->itv;
712 DECLARE_WAITQUEUE(wait, current);
713 int cap_type;
714 unsigned long then;
715 int stopmode;
716 u32 data[CX2341X_MBOX_MAX_DATA];
717
718 if (s->v4l2dev == NULL)
719 return -EINVAL;
720
721 /* This function assumes that you are allowed to stop the capture
722 and that we are actually capturing */
723
724 IVTV_DEBUG_INFO("Stop Capture\n");
725
726 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
727 return 0;
728 if (atomic_read(&itv->capturing) == 0)
729 return 0;
730
731 switch (s->type) {
732 case IVTV_ENC_STREAM_TYPE_YUV:
733 cap_type = 1;
734 break;
735 case IVTV_ENC_STREAM_TYPE_PCM:
736 cap_type = 1;
737 break;
738 case IVTV_ENC_STREAM_TYPE_VBI:
739 cap_type = 1;
740 break;
741 case IVTV_ENC_STREAM_TYPE_MPG:
742 default:
743 cap_type = 0;
744 break;
745 }
746
747 /* Stop Capture Mode */
748 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
749 stopmode = 0;
750 } else {
751 stopmode = 1;
752 }
753
754 /* end_capture */
755 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
756 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
757
758 then = jiffies;
759
760 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
761 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
762 /* only run these if we're shutting down the last cap */
763 unsigned long duration;
764
765 then = jiffies;
766 add_wait_queue(&itv->cap_w, &wait);
767
768 set_current_state(TASK_INTERRUPTIBLE);
769
770 /* wait 2s for EOS interrupt */
771 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
772 jiffies < then + msecs_to_jiffies (2000)) {
773 schedule_timeout(msecs_to_jiffies(10));
774 }
775
776 /* To convert jiffies to ms, we must multiply by 1000
777 * and divide by HZ. To avoid runtime division, we
778 * convert this to multiplication by 1000/HZ.
779 * Since integer division truncates, we get the best
780 * accuracy if we do a rounding calculation of the constant.
781 * Think of the case where HZ is 1024.
782 */
783 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
784
785 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
786 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
787 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
788 } else {
789 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
790 }
791 set_current_state(TASK_RUNNING);
792 remove_wait_queue(&itv->cap_w, &wait);
793 }
794
795 then = jiffies;
796 /* Make sure DMA is complete */
797 add_wait_queue(&s->waitq, &wait);
798 do {
799 /* check if DMA is pending */
800 if ((s->type == IVTV_ENC_STREAM_TYPE_MPG) && /* MPG Only */
801 (read_reg(IVTV_REG_DMASTATUS) & 0x02)) {
802 /* Check for last DMA */
803 ivtv_vapi_result(itv, data, CX2341X_ENC_GET_SEQ_END, 2, 0, 0);
804
805 if (data[0] == 1) {
806 IVTV_DEBUG_DMA("%s: Last DMA of size 0x%08x\n", s->name, data[1]);
807 break;
808 }
809 } else if (read_reg(IVTV_REG_DMASTATUS) & 0x02) {
810 break;
811 }
812 } while (!ivtv_msleep_timeout(10, 1) &&
813 then + msecs_to_jiffies(2000) > jiffies);
814
815 set_current_state(TASK_RUNNING);
816 remove_wait_queue(&s->waitq, &wait);
817 }
818
819 atomic_dec(&itv->capturing);
820
821 /* Clear capture and no-read bits */
822 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
823
824 /* ensure these global cleanup actions are done only once */
825 mutex_lock(&itv->serialize_lock);
826
827 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
828 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
829
830 if (atomic_read(&itv->capturing) > 0) {
831 mutex_unlock(&itv->serialize_lock);
832 return 0;
833 }
834
835 /* Set the following Interrupt mask bits for capture */
836 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
837
838 /* event notification (off) */
839 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
840 /* type: 0 = refresh */
841 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
842 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
843 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
844 }
845
846 wake_up(&s->waitq);
847 mutex_unlock(&itv->serialize_lock);
848
849 return 0;
850 }
851
852 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
853 {
854 struct ivtv *itv = s->itv;
855
856 if (s->v4l2dev == NULL)
857 return -EINVAL;
858
859 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
860 return -EINVAL;
861
862 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
863 return 0;
864
865 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
866
867 /* Stop Decoder */
868 if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
869 u32 tmp = 0;
870
871 /* Wait until the decoder is no longer running */
872 if (pts) {
873 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
874 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
875 }
876 while (1) {
877 u32 data[CX2341X_MBOX_MAX_DATA];
878 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
879 if (s->q_full.buffers + s->q_dma.buffers == 0) {
880 if (tmp == data[3])
881 break;
882 tmp = data[3];
883 }
884 if (ivtv_msleep_timeout(100, 1))
885 break;
886 }
887 }
888 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
889
890 /* turn off notification of dual/stereo mode change */
891 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
892
893 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
894
895 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
896 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
897 ivtv_flush_queues(s);
898
899 /* decrement decoding */
900 atomic_dec(&itv->decoding);
901
902 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
903 wake_up(&itv->event_waitq);
904
905 /* wake up wait queues */
906 wake_up(&s->waitq);
907
908 return 0;
909 }
910
911 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
912 {
913 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
914 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
915
916 if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
917 return -EINVAL;
918
919 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
920
921 /* Prevent others from starting/stopping streams while we
922 initiate/terminate passthrough mode */
923 if (enable) {
924 if (itv->output_mode == OUT_PASSTHROUGH) {
925 return 0;
926 }
927 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
928 return -EBUSY;
929
930 /* Fully initialize stream, and then unflag init */
931 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
932 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
933
934 /* Setup YUV Decoder */
935 ivtv_setup_v4l2_decode_stream(dec_stream);
936
937 /* Start Decoder */
938 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
939 atomic_inc(&itv->decoding);
940
941 /* Setup capture if not already done */
942 if (atomic_read(&itv->capturing) == 0) {
943 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
944 }
945
946 /* Start Passthrough Mode */
947 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
948 atomic_inc(&itv->capturing);
949 return 0;
950 }
951
952 if (itv->output_mode != OUT_PASSTHROUGH)
953 return 0;
954
955 /* Stop Passthrough Mode */
956 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
957 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
958
959 atomic_dec(&itv->capturing);
960 atomic_dec(&itv->decoding);
961 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
962 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
963 itv->output_mode = OUT_NONE;
964
965 return 0;
966 }
WRT350N Kernel Patches