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