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