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