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