1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include "ivtv-driver.h"
37#include "ivtv-fileops.h"
38#include "ivtv-queue.h"
39#include "ivtv-mailbox.h"
40#include "ivtv-ioctl.h"
41#include "ivtv-irq.h"
42#include "ivtv-yuv.h"
43#include "ivtv-cards.h"
44#include "ivtv-streams.h"
45#include "ivtv-firmware.h"
46#include <media/v4l2-event.h>
47
48static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
49 .owner = THIS_MODULE,
50 .read = ivtv_v4l2_read,
51 .write = ivtv_v4l2_write,
52 .open = ivtv_v4l2_open,
53 .unlocked_ioctl = video_ioctl2,
54 .release = ivtv_v4l2_close,
55 .poll = ivtv_v4l2_enc_poll,
56};
57
58static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
59 .owner = THIS_MODULE,
60 .read = ivtv_v4l2_read,
61 .write = ivtv_v4l2_write,
62 .open = ivtv_v4l2_open,
63 .unlocked_ioctl = video_ioctl2,
64 .release = ivtv_v4l2_close,
65 .poll = ivtv_v4l2_dec_poll,
66};
67
68static const struct v4l2_file_operations ivtv_v4l2_radio_fops = {
69 .owner = THIS_MODULE,
70 .open = ivtv_v4l2_open,
71 .unlocked_ioctl = video_ioctl2,
72 .release = ivtv_v4l2_close,
73 .poll = ivtv_v4l2_enc_poll,
74};
75
76#define IVTV_V4L2_DEC_MPG_OFFSET 16
77#define IVTV_V4L2_ENC_PCM_OFFSET 24
78#define IVTV_V4L2_ENC_YUV_OFFSET 32
79#define IVTV_V4L2_DEC_YUV_OFFSET 48
80#define IVTV_V4L2_DEC_VBI_OFFSET 8
81#define IVTV_V4L2_DEC_VOUT_OFFSET 16
82
83static struct {
84 const char *name;
85 int vfl_type;
86 int num_offset;
87 int dma, pio;
88 u32 v4l2_caps;
89 const struct v4l2_file_operations *fops;
90} ivtv_stream_info[] = {
91 {
92 "encoder MPG",
93 VFL_TYPE_GRABBER, 0,
94 PCI_DMA_FROMDEVICE, 0,
95 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
96 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
97 &ivtv_v4l2_enc_fops
98 },
99 {
100 "encoder YUV",
101 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
102 PCI_DMA_FROMDEVICE, 0,
103 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
104 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
105 &ivtv_v4l2_enc_fops
106 },
107 {
108 "encoder VBI",
109 VFL_TYPE_VBI, 0,
110 PCI_DMA_FROMDEVICE, 0,
111 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_TUNER |
112 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
113 &ivtv_v4l2_enc_fops
114 },
115 {
116 "encoder PCM",
117 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
118 PCI_DMA_FROMDEVICE, 0,
119 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
120 &ivtv_v4l2_enc_fops
121 },
122 {
123 "encoder radio",
124 VFL_TYPE_RADIO, 0,
125 PCI_DMA_NONE, 1,
126 V4L2_CAP_RADIO | V4L2_CAP_TUNER,
127 &ivtv_v4l2_radio_fops
128 },
129 {
130 "decoder MPG",
131 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
132 PCI_DMA_TODEVICE, 0,
133 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
134 &ivtv_v4l2_dec_fops
135 },
136 {
137 "decoder VBI",
138 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
139 PCI_DMA_NONE, 1,
140 V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_READWRITE,
141 &ivtv_v4l2_enc_fops
142 },
143 {
144 "decoder VOUT",
145 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
146 PCI_DMA_NONE, 1,
147 V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
148 &ivtv_v4l2_dec_fops
149 },
150 {
151 "decoder YUV",
152 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
153 PCI_DMA_TODEVICE, 0,
154 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
155 &ivtv_v4l2_dec_fops
156 }
157};
158
159static void ivtv_stream_init(struct ivtv *itv, int type)
160{
161 struct ivtv_stream *s = &itv->streams[type];
162 struct video_device *vdev = s->vdev;
163
164
165 memset(s, 0, sizeof(*s));
166 s->vdev = vdev;
167
168
169 s->itv = itv;
170 s->type = type;
171 s->name = ivtv_stream_info[type].name;
172 s->caps = ivtv_stream_info[type].v4l2_caps;
173
174 if (ivtv_stream_info[type].pio)
175 s->dma = PCI_DMA_NONE;
176 else
177 s->dma = ivtv_stream_info[type].dma;
178 s->buf_size = itv->stream_buf_size[type];
179 if (s->buf_size)
180 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
181 spin_lock_init(&s->qlock);
182 init_waitqueue_head(&s->waitq);
183 s->sg_handle = IVTV_DMA_UNMAPPED;
184 ivtv_queue_init(&s->q_free);
185 ivtv_queue_init(&s->q_full);
186 ivtv_queue_init(&s->q_dma);
187 ivtv_queue_init(&s->q_predma);
188 ivtv_queue_init(&s->q_io);
189}
190
191static int ivtv_prep_dev(struct ivtv *itv, int type)
192{
193 struct ivtv_stream *s = &itv->streams[type];
194 int num_offset = ivtv_stream_info[type].num_offset;
195 int num = itv->instance + ivtv_first_minor + num_offset;
196
197
198
199
200 s->vdev = NULL;
201 s->itv = itv;
202 s->type = type;
203 s->name = ivtv_stream_info[type].name;
204
205
206 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
207 return 0;
208 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
209 return 0;
210
211
212
213 if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
214 itv->options.kilobytes[type] == 0) {
215 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
216 return 0;
217 }
218
219 ivtv_stream_init(itv, type);
220
221
222 s->vdev = video_device_alloc();
223 if (s->vdev == NULL) {
224 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
225 return -ENOMEM;
226 }
227
228 snprintf(s->vdev->name, sizeof(s->vdev->name), "%s %s",
229 itv->v4l2_dev.name, s->name);
230
231 s->vdev->num = num;
232 s->vdev->v4l2_dev = &itv->v4l2_dev;
233 if (ivtv_stream_info[type].v4l2_caps &
234 (V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_SLICED_VBI_OUTPUT))
235 s->vdev->vfl_dir = VFL_DIR_TX;
236 s->vdev->fops = ivtv_stream_info[type].fops;
237 s->vdev->ctrl_handler = itv->v4l2_dev.ctrl_handler;
238 s->vdev->release = video_device_release;
239 s->vdev->tvnorms = V4L2_STD_ALL;
240 s->vdev->lock = &itv->serialize_lock;
241 if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {
242 v4l2_disable_ioctl(s->vdev, VIDIOC_S_AUDIO);
243 v4l2_disable_ioctl(s->vdev, VIDIOC_G_AUDIO);
244 v4l2_disable_ioctl(s->vdev, VIDIOC_ENUMAUDIO);
245 v4l2_disable_ioctl(s->vdev, VIDIOC_ENUMINPUT);
246 v4l2_disable_ioctl(s->vdev, VIDIOC_S_INPUT);
247 v4l2_disable_ioctl(s->vdev, VIDIOC_G_INPUT);
248 v4l2_disable_ioctl(s->vdev, VIDIOC_S_FREQUENCY);
249 v4l2_disable_ioctl(s->vdev, VIDIOC_G_FREQUENCY);
250 v4l2_disable_ioctl(s->vdev, VIDIOC_S_TUNER);
251 v4l2_disable_ioctl(s->vdev, VIDIOC_G_TUNER);
252 v4l2_disable_ioctl(s->vdev, VIDIOC_S_STD);
253 }
254 set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev->flags);
255 ivtv_set_funcs(s->vdev);
256 return 0;
257}
258
259
260int ivtv_streams_setup(struct ivtv *itv)
261{
262 int type;
263
264
265 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
266
267 if (ivtv_prep_dev(itv, type))
268 break;
269
270 if (itv->streams[type].vdev == NULL)
271 continue;
272
273
274 if (ivtv_stream_alloc(&itv->streams[type]))
275 break;
276 }
277 if (type == IVTV_MAX_STREAMS)
278 return 0;
279
280
281 ivtv_streams_cleanup(itv, 0);
282 return -ENOMEM;
283}
284
285static int ivtv_reg_dev(struct ivtv *itv, int type)
286{
287 struct ivtv_stream *s = &itv->streams[type];
288 int vfl_type = ivtv_stream_info[type].vfl_type;
289 const char *name;
290 int num;
291
292 if (s->vdev == NULL)
293 return 0;
294
295 num = s->vdev->num;
296
297 if (type != IVTV_ENC_STREAM_TYPE_MPG) {
298 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
299
300 if (s_mpg->vdev)
301 num = s_mpg->vdev->num + ivtv_stream_info[type].num_offset;
302 }
303 video_set_drvdata(s->vdev, s);
304
305
306 if (video_register_device_no_warn(s->vdev, vfl_type, num)) {
307 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
308 s->name, num);
309 video_device_release(s->vdev);
310 s->vdev = NULL;
311 return -ENOMEM;
312 }
313 name = video_device_node_name(s->vdev);
314
315 switch (vfl_type) {
316 case VFL_TYPE_GRABBER:
317 IVTV_INFO("Registered device %s for %s (%d kB)\n",
318 name, s->name, itv->options.kilobytes[type]);
319 break;
320 case VFL_TYPE_RADIO:
321 IVTV_INFO("Registered device %s for %s\n",
322 name, s->name);
323 break;
324 case VFL_TYPE_VBI:
325 if (itv->options.kilobytes[type])
326 IVTV_INFO("Registered device %s for %s (%d kB)\n",
327 name, s->name, itv->options.kilobytes[type]);
328 else
329 IVTV_INFO("Registered device %s for %s\n",
330 name, s->name);
331 break;
332 }
333 return 0;
334}
335
336
337int ivtv_streams_register(struct ivtv *itv)
338{
339 int type;
340 int err = 0;
341
342
343 for (type = 0; type < IVTV_MAX_STREAMS; type++)
344 err |= ivtv_reg_dev(itv, type);
345
346 if (err == 0)
347 return 0;
348
349
350 ivtv_streams_cleanup(itv, 1);
351 return -ENOMEM;
352}
353
354
355void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
356{
357 int type;
358
359
360 for (type = 0; type < IVTV_MAX_STREAMS; type++) {
361 struct video_device *vdev = itv->streams[type].vdev;
362
363 itv->streams[type].vdev = NULL;
364 if (vdev == NULL)
365 continue;
366
367 ivtv_stream_free(&itv->streams[type]);
368
369 if (unregister)
370 video_unregister_device(vdev);
371 else
372 video_device_release(vdev);
373 }
374}
375
376static void ivtv_vbi_setup(struct ivtv *itv)
377{
378 int raw = ivtv_raw_vbi(itv);
379 u32 data[CX2341X_MBOX_MAX_DATA];
380 int lines;
381 int i;
382
383
384 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
385
386
387 if (raw)
388 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
389 else
390 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
391
392
393
394
395
396
397 if (raw) {
398 lines = itv->vbi.count * 2;
399 } else {
400 lines = itv->is_60hz ? 24 : 38;
401 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
402 lines += 2;
403 }
404
405 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
406
407
408
409 data[0] = raw | 0x02 | (0xbd << 8);
410
411
412 data[1] = 1;
413
414 data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
415
416
417
418
419
420
421
422 if (itv->hw_flags & IVTV_HW_CX25840) {
423
424 if (raw) {
425 data[3] = 0x20602060;
426 data[4] = 0x30703070;
427 } else {
428 data[3] = 0xB0F0B0F0;
429 data[4] = 0xA0E0A0E0;
430 }
431
432 data[5] = lines;
433
434 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
435 } else {
436
437 if (raw) {
438 data[3] = 0x25256262;
439 data[4] = 0x387F7F7F;
440 } else {
441 data[3] = 0xABABECEC;
442 data[4] = 0xB6F1F1F1;
443 }
444
445 data[5] = lines;
446
447 data[6] = itv->vbi.enc_size / lines;
448 }
449
450 IVTV_DEBUG_INFO(
451 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
452 data[0], data[1], data[2], data[5], data[6]);
453
454 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
455
456
457 itv->vbi.enc_start = data[2];
458 itv->vbi.fpi = data[0];
459 if (!itv->vbi.fpi)
460 itv->vbi.fpi = 1;
461
462 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
463 itv->vbi.enc_start, data[1], itv->vbi.fpi);
464
465
466
467 for (i = 2; i <= 24; i++) {
468 int valid;
469
470 if (itv->is_60hz) {
471 valid = i >= 10 && i < 22;
472 } else {
473 valid = i >= 6 && i < 24;
474 }
475 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
476 valid, 0 , 0, 0);
477 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
478 valid, 0, 0, 0);
479 }
480
481
482
483
484
485
486
487}
488
489int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
490{
491 u32 data[CX2341X_MBOX_MAX_DATA];
492 struct ivtv *itv = s->itv;
493 int captype = 0, subtype = 0;
494 int enable_passthrough = 0;
495
496 if (s->vdev == NULL)
497 return -EINVAL;
498
499 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
500
501 switch (s->type) {
502 case IVTV_ENC_STREAM_TYPE_MPG:
503 captype = 0;
504 subtype = 3;
505
506
507 if (itv->output_mode == OUT_PASSTHROUGH) {
508 ivtv_passthrough_mode(itv, 0);
509 enable_passthrough = 1;
510 }
511 itv->mpg_data_received = itv->vbi_data_inserted = 0;
512 itv->dualwatch_jiffies = jiffies;
513 itv->dualwatch_stereo_mode = v4l2_ctrl_g_ctrl(itv->cxhdl.audio_mode);
514 itv->search_pack_header = 0;
515 break;
516
517 case IVTV_ENC_STREAM_TYPE_YUV:
518 if (itv->output_mode == OUT_PASSTHROUGH) {
519 captype = 2;
520 subtype = 11;
521 break;
522 }
523 captype = 1;
524 subtype = 1;
525 break;
526 case IVTV_ENC_STREAM_TYPE_PCM:
527 captype = 1;
528 subtype = 2;
529 break;
530 case IVTV_ENC_STREAM_TYPE_VBI:
531 captype = 1;
532 subtype = 4;
533
534 itv->vbi.frame = 0;
535 itv->vbi.inserted_frame = 0;
536 memset(itv->vbi.sliced_mpeg_size,
537 0, sizeof(itv->vbi.sliced_mpeg_size));
538 break;
539 default:
540 return -EINVAL;
541 }
542 s->subtype = subtype;
543 s->buffers_stolen = 0;
544
545
546 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
547
548 if (atomic_read(&itv->capturing) == 0) {
549 int digitizer;
550
551
552
553
554
555
556
557 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
558
559
560 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
561
562
563
564
565
566
567 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
568 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
569 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
570 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
571
572
573 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
574 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
575
576 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
577 digitizer = 0xF1;
578 else if (itv->card->hw_all & IVTV_HW_SAA7114)
579 digitizer = 0xEF;
580 else
581 digitizer = 0x140;
582
583 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
584
585
586 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
587 ivtv_vbi_setup(itv);
588 }
589
590
591 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
592 itv->pgm_info_offset = data[0];
593 itv->pgm_info_num = data[1];
594 itv->pgm_info_write_idx = 0;
595 itv->pgm_info_read_idx = 0;
596
597 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
598 itv->pgm_info_offset, itv->pgm_info_num);
599
600
601 cx2341x_handler_setup(&itv->cxhdl);
602
603
604 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
605 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
606 1 | (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
607 }
608
609
610 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
611
612 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
613 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
614 }
615
616 if (atomic_read(&itv->capturing) == 0) {
617
618 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
619
620 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
621
622 cx2341x_handler_set_busy(&itv->cxhdl, 1);
623
624
625
626 v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
627
628 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
629 ivtv_msleep_timeout(300, 0);
630 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
631 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
632 }
633
634
635 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
636 {
637 IVTV_DEBUG_WARN( "Error starting capture!\n");
638 return -EINVAL;
639 }
640
641
642 if (enable_passthrough) {
643 ivtv_passthrough_mode(itv, 1);
644 }
645
646 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
647 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
648 else
649 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
650
651
652 atomic_inc(&itv->capturing);
653 return 0;
654}
655EXPORT_SYMBOL(ivtv_start_v4l2_encode_stream);
656
657static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
658{
659 u32 data[CX2341X_MBOX_MAX_DATA];
660 struct ivtv *itv = s->itv;
661 int datatype;
662 u16 width;
663 u16 height;
664
665 if (s->vdev == NULL)
666 return -EINVAL;
667
668 IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
669
670 width = itv->cxhdl.width;
671 height = itv->cxhdl.height;
672
673
674 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
675
676
677 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
678
679
680 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
681
682
683 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
684 itv->vbi.dec_start = data[0];
685
686 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
687 itv->vbi.dec_start, data[1]);
688
689
690
691
692
693 switch (s->type) {
694 case IVTV_DEC_STREAM_TYPE_YUV:
695 if (itv->output_mode == OUT_PASSTHROUGH) {
696 datatype = 1;
697 } else {
698
699 datatype = 2;
700 width = 720;
701 height = itv->is_out_50hz ? 576 : 480;
702 }
703 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
704 break;
705 case IVTV_DEC_STREAM_TYPE_MPG:
706 default:
707 datatype = 0;
708 break;
709 }
710 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
711 width, height, itv->cxhdl.audio_properties)) {
712 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
713 }
714
715
716 ivtv_msleep_timeout(10, 0);
717
718
719 return ivtv_firmware_check(itv, "ivtv_setup_v4l2_decode_stream");
720}
721
722int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
723{
724 struct ivtv *itv = s->itv;
725 int rc;
726
727 if (s->vdev == NULL)
728 return -EINVAL;
729
730 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
731 return 0;
732
733 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
734
735 rc = ivtv_setup_v4l2_decode_stream(s);
736 if (rc < 0) {
737 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
738 return rc;
739 }
740
741
742 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
743
744
745 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
746
747
748 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
749 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
750 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
751 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
752 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
753 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
754 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
755 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
756
757
758 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
759
760
761 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
762
763
764 ivtv_msleep_timeout(10, 0);
765
766
767 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
768 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
769
770
771 atomic_inc(&itv->decoding);
772 return 0;
773}
774
775void ivtv_stop_all_captures(struct ivtv *itv)
776{
777 int i;
778
779 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
780 struct ivtv_stream *s = &itv->streams[i];
781
782 if (s->vdev == NULL)
783 continue;
784 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
785 ivtv_stop_v4l2_encode_stream(s, 0);
786 }
787 }
788}
789
790int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
791{
792 struct ivtv *itv = s->itv;
793 DECLARE_WAITQUEUE(wait, current);
794 int cap_type;
795 int stopmode;
796
797 if (s->vdev == NULL)
798 return -EINVAL;
799
800
801
802
803 IVTV_DEBUG_INFO("Stop Capture\n");
804
805 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
806 return 0;
807 if (atomic_read(&itv->capturing) == 0)
808 return 0;
809
810 switch (s->type) {
811 case IVTV_ENC_STREAM_TYPE_YUV:
812 cap_type = 1;
813 break;
814 case IVTV_ENC_STREAM_TYPE_PCM:
815 cap_type = 1;
816 break;
817 case IVTV_ENC_STREAM_TYPE_VBI:
818 cap_type = 1;
819 break;
820 case IVTV_ENC_STREAM_TYPE_MPG:
821 default:
822 cap_type = 0;
823 break;
824 }
825
826
827 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
828 stopmode = 0;
829 } else {
830 stopmode = 1;
831 }
832
833
834
835 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
836
837 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
838 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
839
840 unsigned long duration;
841 unsigned long then = jiffies;
842
843 add_wait_queue(&itv->eos_waitq, &wait);
844
845 set_current_state(TASK_INTERRUPTIBLE);
846
847
848 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
849 time_before(jiffies,
850 then + msecs_to_jiffies(2000))) {
851 schedule_timeout(msecs_to_jiffies(10));
852 }
853
854
855
856
857
858
859
860
861 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
862
863 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
864 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
865 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
866 } else {
867 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
868 }
869 set_current_state(TASK_RUNNING);
870 remove_wait_queue(&itv->eos_waitq, &wait);
871 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
872 }
873
874
875 ivtv_msleep_timeout(100, 0);
876 }
877
878 atomic_dec(&itv->capturing);
879
880
881 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
882
883 if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
884 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
885
886 if (atomic_read(&itv->capturing) > 0) {
887 return 0;
888 }
889
890 cx2341x_handler_set_busy(&itv->cxhdl, 0);
891
892
893 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
894 del_timer(&itv->dma_timer);
895
896
897 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
898
899
900 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
901 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
902 }
903
904
905
906 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
907
908 wake_up(&s->waitq);
909
910 return 0;
911}
912EXPORT_SYMBOL(ivtv_stop_v4l2_encode_stream);
913
914int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
915{
916 static const struct v4l2_event ev = {
917 .type = V4L2_EVENT_EOS,
918 };
919 struct ivtv *itv = s->itv;
920
921 if (s->vdev == NULL)
922 return -EINVAL;
923
924 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
925 return -EINVAL;
926
927 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
928 return 0;
929
930 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
931
932
933 if (!(flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) || pts) {
934 u32 tmp = 0;
935
936
937 if (pts) {
938 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
939 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
940 }
941 while (1) {
942 u32 data[CX2341X_MBOX_MAX_DATA];
943 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
944 if (s->q_full.buffers + s->q_dma.buffers == 0) {
945 if (tmp == data[3])
946 break;
947 tmp = data[3];
948 }
949 if (ivtv_msleep_timeout(100, 1))
950 break;
951 }
952 }
953 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & V4L2_DEC_CMD_STOP_TO_BLACK, 0, 0);
954
955
956 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
957
958 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
959 del_timer(&itv->dma_timer);
960
961 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
962 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
963 ivtv_flush_queues(s);
964
965
966 ivtv_msleep_timeout(40, 0);
967
968
969 atomic_dec(&itv->decoding);
970
971 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
972 wake_up(&itv->event_waitq);
973 v4l2_event_queue(s->vdev, &ev);
974
975
976 wake_up(&s->waitq);
977
978 return 0;
979}
980
981int ivtv_passthrough_mode(struct ivtv *itv, int enable)
982{
983 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
984 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
985
986 if (yuv_stream->vdev == NULL || dec_stream->vdev == NULL)
987 return -EINVAL;
988
989 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
990
991
992
993 if (enable) {
994 if (itv->output_mode == OUT_PASSTHROUGH) {
995 return 0;
996 }
997 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
998 return -EBUSY;
999
1000
1001 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1002 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1003
1004
1005 ivtv_setup_v4l2_decode_stream(dec_stream);
1006
1007
1008 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
1009 atomic_inc(&itv->decoding);
1010
1011
1012 if (atomic_read(&itv->capturing) == 0) {
1013 cx2341x_handler_setup(&itv->cxhdl);
1014 cx2341x_handler_set_busy(&itv->cxhdl, 1);
1015 }
1016
1017
1018 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
1019 atomic_inc(&itv->capturing);
1020 return 0;
1021 }
1022
1023 if (itv->output_mode != OUT_PASSTHROUGH)
1024 return 0;
1025
1026
1027 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
1028 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
1029
1030 atomic_dec(&itv->capturing);
1031 atomic_dec(&itv->decoding);
1032 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1033 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1034 itv->output_mode = OUT_NONE;
1035 if (atomic_read(&itv->capturing) == 0)
1036 cx2341x_handler_set_busy(&itv->cxhdl, 0);
1037
1038 return 0;
1039}
1040