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