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