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