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