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