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