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