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