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