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