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