1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "ivtv-driver.h"
22#include "ivtv-version.h"
23#include "ivtv-mailbox.h"
24#include "ivtv-i2c.h"
25#include "ivtv-queue.h"
26#include "ivtv-fileops.h"
27#include "ivtv-vbi.h"
28#include "ivtv-routing.h"
29#include "ivtv-streams.h"
30#include "ivtv-yuv.h"
31#include "ivtv-ioctl.h"
32#include "ivtv-gpio.h"
33#include "ivtv-controls.h"
34#include "ivtv-cards.h"
35#include <media/i2c/saa7127.h>
36#include <media/tveeprom.h>
37#include <media/v4l2-event.h>
38#include <linux/dvb/audio.h>
39
40u16 ivtv_service2vbi(int type)
41{
42 switch (type) {
43 case V4L2_SLICED_TELETEXT_B:
44 return IVTV_SLICED_TYPE_TELETEXT_B;
45 case V4L2_SLICED_CAPTION_525:
46 return IVTV_SLICED_TYPE_CAPTION_525;
47 case V4L2_SLICED_WSS_625:
48 return IVTV_SLICED_TYPE_WSS_625;
49 case V4L2_SLICED_VPS:
50 return IVTV_SLICED_TYPE_VPS;
51 default:
52 return 0;
53 }
54}
55
56static int valid_service_line(int field, int line, int is_pal)
57{
58 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
59 (!is_pal && line >= 10 && line < 22);
60}
61
62static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
63{
64 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
65 int i;
66
67 set = set & valid_set;
68 if (set == 0 || !valid_service_line(field, line, is_pal)) {
69 return 0;
70 }
71 if (!is_pal) {
72 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
73 return V4L2_SLICED_CAPTION_525;
74 }
75 else {
76 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
77 return V4L2_SLICED_VPS;
78 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
79 return V4L2_SLICED_WSS_625;
80 if (line == 23)
81 return 0;
82 }
83 for (i = 0; i < 32; i++) {
84 if ((1 << i) & set)
85 return 1 << i;
86 }
87 return 0;
88}
89
90void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
91{
92 u16 set = fmt->service_set;
93 int f, l;
94
95 fmt->service_set = 0;
96 for (f = 0; f < 2; f++) {
97 for (l = 0; l < 24; l++) {
98 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
99 }
100 }
101}
102
103static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
104{
105 int f, l;
106
107 for (f = 0; f < 2; f++) {
108 for (l = 0; l < 24; l++) {
109 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
110 }
111 }
112}
113
114u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
115{
116 int f, l;
117 u16 set = 0;
118
119 for (f = 0; f < 2; f++) {
120 for (l = 0; l < 24; l++) {
121 set |= fmt->service_lines[f][l];
122 }
123 }
124 return set;
125}
126
127void ivtv_set_osd_alpha(struct ivtv *itv)
128{
129 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
130 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
131 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
132}
133
134int ivtv_set_speed(struct ivtv *itv, int speed)
135{
136 u32 data[CX2341X_MBOX_MAX_DATA];
137 int single_step = (speed == 1 || speed == -1);
138 DEFINE_WAIT(wait);
139
140 if (speed == 0) speed = 1000;
141
142
143 if (speed == itv->speed && !single_step)
144 return 0;
145
146 if (single_step && (speed < 0) == (itv->speed < 0)) {
147
148 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
149 itv->speed = speed;
150 return 0;
151 }
152 if (single_step)
153
154 speed = speed < 0 ? -1000 : 1000;
155
156 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
157 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
158 data[1] = (speed < 0);
159 data[2] = speed < 0 ? 3 : 7;
160 data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
161 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
162 data[5] = 0;
163 data[6] = 0;
164
165 if (speed == 1500 || speed == -1500) data[0] |= 1;
166 else if (speed == 2000 || speed == -2000) data[0] |= 2;
167 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
168 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
169
170
171 if (atomic_read(&itv->decoding) > 0) {
172 int got_sig = 0;
173
174
175 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
176
177
178 mutex_unlock(&itv->serialize_lock);
179 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
180 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
181 got_sig = signal_pending(current);
182 if (got_sig)
183 break;
184 got_sig = 0;
185 schedule();
186 }
187 finish_wait(&itv->dma_waitq, &wait);
188 mutex_lock(&itv->serialize_lock);
189 if (got_sig)
190 return -EINTR;
191
192
193 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
194 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
195 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
196 }
197 if (single_step) {
198 speed = (speed < 0) ? -1 : 1;
199 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
200 }
201 itv->speed = speed;
202 return 0;
203}
204
205static int ivtv_validate_speed(int cur_speed, int new_speed)
206{
207 int fact = new_speed < 0 ? -1 : 1;
208 int s;
209
210 if (cur_speed == 0)
211 cur_speed = 1000;
212 if (new_speed < 0)
213 new_speed = -new_speed;
214 if (cur_speed < 0)
215 cur_speed = -cur_speed;
216
217 if (cur_speed <= new_speed) {
218 if (new_speed > 1500)
219 return fact * 2000;
220 if (new_speed > 1000)
221 return fact * 1500;
222 }
223 else {
224 if (new_speed >= 2000)
225 return fact * 2000;
226 if (new_speed >= 1500)
227 return fact * 1500;
228 if (new_speed >= 1000)
229 return fact * 1000;
230 }
231 if (new_speed == 0)
232 return 1000;
233 if (new_speed == 1 || new_speed == 1000)
234 return fact * new_speed;
235
236 s = new_speed;
237 new_speed = 1000 / new_speed;
238 if (1000 / cur_speed == new_speed)
239 new_speed += (cur_speed < s) ? -1 : 1;
240 if (new_speed > 60) return 1000 / (fact * 60);
241 return 1000 / (fact * new_speed);
242}
243
244static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
245 struct v4l2_decoder_cmd *dc, int try)
246{
247 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
248
249 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
250 return -EINVAL;
251
252 switch (dc->cmd) {
253 case V4L2_DEC_CMD_START: {
254 dc->flags &= V4L2_DEC_CMD_START_MUTE_AUDIO;
255 dc->start.speed = ivtv_validate_speed(itv->speed, dc->start.speed);
256 if (dc->start.speed < 0)
257 dc->start.format = V4L2_DEC_START_FMT_GOP;
258 else
259 dc->start.format = V4L2_DEC_START_FMT_NONE;
260 if (dc->start.speed != 500 && dc->start.speed != 1500)
261 dc->flags = dc->start.speed == 1000 ? 0 :
262 V4L2_DEC_CMD_START_MUTE_AUDIO;
263 if (try) break;
264
265 itv->speed_mute_audio = dc->flags & V4L2_DEC_CMD_START_MUTE_AUDIO;
266 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
267 return -EBUSY;
268 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
269
270 itv->speed = 0;
271 }
272 return ivtv_start_decoding(id, dc->start.speed);
273 }
274
275 case V4L2_DEC_CMD_STOP:
276 dc->flags &= V4L2_DEC_CMD_STOP_IMMEDIATELY | V4L2_DEC_CMD_STOP_TO_BLACK;
277 if (dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY)
278 dc->stop.pts = 0;
279 if (try) break;
280 if (atomic_read(&itv->decoding) == 0)
281 return 0;
282 if (itv->output_mode != OUT_MPG)
283 return -EBUSY;
284
285 itv->output_mode = OUT_NONE;
286 return ivtv_stop_v4l2_decode_stream(s, dc->flags, dc->stop.pts);
287
288 case V4L2_DEC_CMD_PAUSE:
289 dc->flags &= V4L2_DEC_CMD_PAUSE_TO_BLACK;
290 if (try) break;
291 if (!atomic_read(&itv->decoding))
292 return -EPERM;
293 if (itv->output_mode != OUT_MPG)
294 return -EBUSY;
295 if (atomic_read(&itv->decoding) > 0) {
296 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
297 (dc->flags & V4L2_DEC_CMD_PAUSE_TO_BLACK) ? 1 : 0);
298 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
299 }
300 break;
301
302 case V4L2_DEC_CMD_RESUME:
303 dc->flags = 0;
304 if (try) break;
305 if (!atomic_read(&itv->decoding))
306 return -EPERM;
307 if (itv->output_mode != OUT_MPG)
308 return -EBUSY;
309 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
310 int speed = itv->speed;
311 itv->speed = 0;
312 return ivtv_start_decoding(id, speed);
313 }
314 break;
315
316 default:
317 return -EINVAL;
318 }
319 return 0;
320}
321
322static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
323{
324 struct ivtv *itv = fh2id(fh)->itv;
325 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
326
327 vbifmt->reserved[0] = 0;
328 vbifmt->reserved[1] = 0;
329 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
330 return -EINVAL;
331 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
332 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
333 if (itv->is_60hz) {
334 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
335 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
336 } else {
337 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
338 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
339 }
340 vbifmt->service_set = ivtv_get_service_set(vbifmt);
341 return 0;
342}
343
344static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
345{
346 struct ivtv_open_id *id = fh2id(fh);
347 struct ivtv *itv = id->itv;
348 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
349
350 pixfmt->width = itv->cxhdl.width;
351 pixfmt->height = itv->cxhdl.height;
352 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
353 pixfmt->field = V4L2_FIELD_INTERLACED;
354 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
355 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
356
357 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
358 pixfmt->bytesperline = 720;
359 } else {
360 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
361 pixfmt->sizeimage = 128 * 1024;
362 pixfmt->bytesperline = 0;
363 }
364 return 0;
365}
366
367static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
368{
369 struct ivtv *itv = fh2id(fh)->itv;
370 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
371
372 vbifmt->sampling_rate = 27000000;
373 vbifmt->offset = 248;
374 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
375 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
376 vbifmt->start[0] = itv->vbi.start[0];
377 vbifmt->start[1] = itv->vbi.start[1];
378 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
379 vbifmt->flags = 0;
380 vbifmt->reserved[0] = 0;
381 vbifmt->reserved[1] = 0;
382 return 0;
383}
384
385static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
386{
387 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
388 struct ivtv_open_id *id = fh2id(fh);
389 struct ivtv *itv = id->itv;
390
391 vbifmt->reserved[0] = 0;
392 vbifmt->reserved[1] = 0;
393 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
394
395 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
396 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
397 V4L2_SLICED_VBI_525;
398 ivtv_expand_service_set(vbifmt, itv->is_50hz);
399 vbifmt->service_set = ivtv_get_service_set(vbifmt);
400 return 0;
401 }
402
403 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
404 vbifmt->service_set = ivtv_get_service_set(vbifmt);
405 return 0;
406}
407
408static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
409{
410 struct ivtv_open_id *id = fh2id(fh);
411 struct ivtv *itv = id->itv;
412 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
413
414 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
415 return -EINVAL;
416 pixfmt->width = itv->main_rect.width;
417 pixfmt->height = itv->main_rect.height;
418 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
419 pixfmt->field = V4L2_FIELD_INTERLACED;
420 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
421 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
422 case IVTV_YUV_MODE_INTERLACED:
423 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
424 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
425 break;
426 case IVTV_YUV_MODE_PROGRESSIVE:
427 pixfmt->field = V4L2_FIELD_NONE;
428 break;
429 default:
430 pixfmt->field = V4L2_FIELD_ANY;
431 break;
432 }
433 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
434 pixfmt->bytesperline = 720;
435 pixfmt->width = itv->yuv_info.v4l2_src_w;
436 pixfmt->height = itv->yuv_info.v4l2_src_h;
437
438 pixfmt->sizeimage =
439 1080 * ((pixfmt->height + 31) & ~31);
440 } else {
441 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
442 pixfmt->sizeimage = 128 * 1024;
443 pixfmt->bytesperline = 0;
444 }
445 return 0;
446}
447
448static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
449{
450 struct ivtv *itv = fh2id(fh)->itv;
451 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
452 struct v4l2_window *winfmt = &fmt->fmt.win;
453
454 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
455 return -EINVAL;
456 if (!itv->osd_video_pbase)
457 return -EINVAL;
458 winfmt->chromakey = itv->osd_chroma_key;
459 winfmt->global_alpha = itv->osd_global_alpha;
460 winfmt->field = V4L2_FIELD_INTERLACED;
461 winfmt->clips = NULL;
462 winfmt->clipcount = 0;
463 winfmt->bitmap = NULL;
464 winfmt->w.top = winfmt->w.left = 0;
465 winfmt->w.width = itv->osd_rect.width;
466 winfmt->w.height = itv->osd_rect.height;
467 return 0;
468}
469
470static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
471{
472 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
473}
474
475static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
476{
477 struct ivtv_open_id *id = fh2id(fh);
478 struct ivtv *itv = id->itv;
479 int w = fmt->fmt.pix.width;
480 int h = fmt->fmt.pix.height;
481 int min_h = 2;
482
483 w = min(w, 720);
484 w = max(w, 2);
485 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
486
487 h &= ~0x1f;
488 min_h = 32;
489 }
490 h = min(h, itv->is_50hz ? 576 : 480);
491 h = max(h, min_h);
492 ivtv_g_fmt_vid_cap(file, fh, fmt);
493 fmt->fmt.pix.width = w;
494 fmt->fmt.pix.height = h;
495 return 0;
496}
497
498static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
499{
500 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
501}
502
503static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
504{
505 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
506 struct ivtv_open_id *id = fh2id(fh);
507 struct ivtv *itv = id->itv;
508
509 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
510 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
511
512
513 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
514 vbifmt->reserved[0] = 0;
515 vbifmt->reserved[1] = 0;
516
517 if (vbifmt->service_set)
518 ivtv_expand_service_set(vbifmt, itv->is_50hz);
519 check_service_set(vbifmt, itv->is_50hz);
520 vbifmt->service_set = ivtv_get_service_set(vbifmt);
521 return 0;
522}
523
524static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
525{
526 struct ivtv_open_id *id = fh2id(fh);
527 s32 w = fmt->fmt.pix.width;
528 s32 h = fmt->fmt.pix.height;
529 int field = fmt->fmt.pix.field;
530 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
531
532 w = min(w, 720);
533 w = max(w, 2);
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549 h = min(h, 576);
550 h = max(h, 2);
551 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
552 fmt->fmt.pix.field = field;
553 fmt->fmt.pix.width = w;
554 fmt->fmt.pix.height = h;
555 return ret;
556}
557
558static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
559{
560 struct ivtv *itv = fh2id(fh)->itv;
561 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
562 u32 chromakey = fmt->fmt.win.chromakey;
563 u8 global_alpha = fmt->fmt.win.global_alpha;
564
565 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
566 return -EINVAL;
567 if (!itv->osd_video_pbase)
568 return -EINVAL;
569 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
570 fmt->fmt.win.chromakey = chromakey;
571 fmt->fmt.win.global_alpha = global_alpha;
572 return 0;
573}
574
575static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
576{
577 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
578}
579
580static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
581{
582 struct ivtv_open_id *id = fh2id(fh);
583 struct ivtv *itv = id->itv;
584 struct v4l2_subdev_format format = {
585 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
586 };
587 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
588 int w = fmt->fmt.pix.width;
589 int h = fmt->fmt.pix.height;
590
591 if (ret)
592 return ret;
593
594 if (itv->cxhdl.width == w && itv->cxhdl.height == h)
595 return 0;
596
597 if (atomic_read(&itv->capturing) > 0)
598 return -EBUSY;
599
600 itv->cxhdl.width = w;
601 itv->cxhdl.height = h;
602 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
603 fmt->fmt.pix.width /= 2;
604 format.format.width = fmt->fmt.pix.width;
605 format.format.height = h;
606 format.format.code = MEDIA_BUS_FMT_FIXED;
607 v4l2_subdev_call(itv->sd_video, pad, set_fmt, NULL, &format);
608 return ivtv_g_fmt_vid_cap(file, fh, fmt);
609}
610
611static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
612{
613 struct ivtv *itv = fh2id(fh)->itv;
614
615 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
616 return -EBUSY;
617 itv->vbi.sliced_in->service_set = 0;
618 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
619 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
620 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
621}
622
623static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
624{
625 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
626 struct ivtv_open_id *id = fh2id(fh);
627 struct ivtv *itv = id->itv;
628 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
629
630 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
631 return ret;
632
633 check_service_set(vbifmt, itv->is_50hz);
634 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
635 return -EBUSY;
636 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
637 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
638 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
639 return 0;
640}
641
642static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
643{
644 struct ivtv_open_id *id = fh2id(fh);
645 struct ivtv *itv = id->itv;
646 struct yuv_playback_info *yi = &itv->yuv_info;
647 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
648
649 if (ret)
650 return ret;
651
652 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
653 return 0;
654
655
656 if (yi->stream_size)
657 return -EBUSY;
658
659 yi->v4l2_src_w = fmt->fmt.pix.width;
660 yi->v4l2_src_h = fmt->fmt.pix.height;
661
662 switch (fmt->fmt.pix.field) {
663 case V4L2_FIELD_NONE:
664 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
665 break;
666 case V4L2_FIELD_ANY:
667 yi->lace_mode = IVTV_YUV_MODE_AUTO;
668 break;
669 case V4L2_FIELD_INTERLACED_BT:
670 yi->lace_mode =
671 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
672 break;
673 case V4L2_FIELD_INTERLACED_TB:
674 default:
675 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
676 break;
677 }
678 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
679
680 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
681 itv->dma_data_req_size =
682 1080 * ((yi->v4l2_src_h + 31) & ~31);
683
684 return 0;
685}
686
687static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
688{
689 struct ivtv *itv = fh2id(fh)->itv;
690 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
691
692 if (ret == 0) {
693 itv->osd_chroma_key = fmt->fmt.win.chromakey;
694 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
695 ivtv_set_osd_alpha(itv);
696 }
697 return ret;
698}
699
700#ifdef CONFIG_VIDEO_ADV_DEBUG
701static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val)
702{
703 volatile u8 __iomem *reg_start;
704
705 if (reg & 0x3)
706 return -EINVAL;
707 if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
708 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
709 else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET &&
710 reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
711 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
712 else if (reg < IVTV_ENCODER_SIZE)
713 reg_start = itv->enc_mem;
714 else
715 return -EINVAL;
716
717 if (get)
718 *val = readl(reg + reg_start);
719 else
720 writel(*val, reg + reg_start);
721 return 0;
722}
723
724static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
725{
726 struct ivtv *itv = fh2id(fh)->itv;
727
728 reg->size = 4;
729 return ivtv_itvc(itv, true, reg->reg, ®->val);
730}
731
732static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg)
733{
734 struct ivtv *itv = fh2id(fh)->itv;
735 u64 val = reg->val;
736
737 return ivtv_itvc(itv, false, reg->reg, &val);
738}
739#endif
740
741static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
742{
743 struct ivtv_open_id *id = fh2id(file->private_data);
744 struct ivtv *itv = id->itv;
745 struct ivtv_stream *s = &itv->streams[id->type];
746
747 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
748 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
749 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
750 vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
751 vcap->device_caps = s->caps;
752 if ((s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY) &&
753 !itv->osd_video_pbase) {
754 vcap->capabilities &= ~V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
755 vcap->device_caps &= ~V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
756 }
757 return 0;
758}
759
760static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
761{
762 struct ivtv *itv = fh2id(fh)->itv;
763
764 return ivtv_get_audio_input(itv, vin->index, vin);
765}
766
767static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
768{
769 struct ivtv *itv = fh2id(fh)->itv;
770
771 vin->index = itv->audio_input;
772 return ivtv_get_audio_input(itv, vin->index, vin);
773}
774
775static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
776{
777 struct ivtv *itv = fh2id(fh)->itv;
778
779 if (vout->index >= itv->nof_audio_inputs)
780 return -EINVAL;
781
782 itv->audio_input = vout->index;
783 ivtv_audio_set_io(itv);
784
785 return 0;
786}
787
788static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
789{
790 struct ivtv *itv = fh2id(fh)->itv;
791
792
793 return ivtv_get_audio_output(itv, vin->index, vin);
794}
795
796static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
797{
798 struct ivtv *itv = fh2id(fh)->itv;
799
800 vin->index = 0;
801 return ivtv_get_audio_output(itv, vin->index, vin);
802}
803
804static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
805{
806 struct ivtv *itv = fh2id(fh)->itv;
807
808 if (itv->card->video_outputs == NULL || vout->index != 0)
809 return -EINVAL;
810 return 0;
811}
812
813static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
814{
815 struct ivtv *itv = fh2id(fh)->itv;
816
817
818 return ivtv_get_input(itv, vin->index, vin);
819}
820
821static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
822{
823 struct ivtv *itv = fh2id(fh)->itv;
824
825 return ivtv_get_output(itv, vout->index, vout);
826}
827
828static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
829{
830 struct ivtv_open_id *id = fh2id(fh);
831 struct ivtv *itv = id->itv;
832
833 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
834 cropcap->pixelaspect.numerator = itv->is_50hz ? 54 : 11;
835 cropcap->pixelaspect.denominator = itv->is_50hz ? 59 : 10;
836 } else if (cropcap->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
837 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 54 : 11;
838 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 59 : 10;
839 } else {
840 return -EINVAL;
841 }
842 return 0;
843}
844
845static int ivtv_s_selection(struct file *file, void *fh,
846 struct v4l2_selection *sel)
847{
848 struct ivtv_open_id *id = fh2id(fh);
849 struct ivtv *itv = id->itv;
850 struct yuv_playback_info *yi = &itv->yuv_info;
851 struct v4l2_rect r = { 0, 0, 720, 0 };
852 int streamtype = id->type;
853
854 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
855 !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
856 return -EINVAL;
857
858 if (sel->target != V4L2_SEL_TGT_COMPOSE)
859 return -EINVAL;
860
861
862 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
863 !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
864 return -EINVAL;
865
866 r.height = itv->is_out_50hz ? 576 : 480;
867 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
868 r.width = yi->osd_full_w;
869 r.height = yi->osd_full_h;
870 }
871 sel->r.width = clamp(sel->r.width, 16U, r.width);
872 sel->r.height = clamp(sel->r.height, 16U, r.height);
873 sel->r.left = clamp_t(unsigned, sel->r.left, 0, r.width - sel->r.width);
874 sel->r.top = clamp_t(unsigned, sel->r.top, 0, r.height - sel->r.height);
875
876 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
877 yi->main_rect = sel->r;
878 return 0;
879 }
880 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
881 sel->r.width, sel->r.height, sel->r.left, sel->r.top)) {
882 itv->main_rect = sel->r;
883 return 0;
884 }
885 return -EINVAL;
886}
887
888static int ivtv_g_selection(struct file *file, void *fh,
889 struct v4l2_selection *sel)
890{
891 struct ivtv_open_id *id = fh2id(fh);
892 struct ivtv *itv = id->itv;
893 struct yuv_playback_info *yi = &itv->yuv_info;
894 struct v4l2_rect r = { 0, 0, 720, 0 };
895 int streamtype = id->type;
896
897 if (sel->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
898 switch (sel->target) {
899 case V4L2_SEL_TGT_CROP_DEFAULT:
900 case V4L2_SEL_TGT_CROP_BOUNDS:
901 sel->r.top = sel->r.left = 0;
902 sel->r.width = 720;
903 sel->r.height = itv->is_50hz ? 576 : 480;
904 return 0;
905 default:
906 return -EINVAL;
907 }
908 }
909
910 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
911 !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
912 return -EINVAL;
913
914 switch (sel->target) {
915 case V4L2_SEL_TGT_COMPOSE:
916 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
917 sel->r = yi->main_rect;
918 else
919 sel->r = itv->main_rect;
920 return 0;
921 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
922 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
923 r.height = itv->is_out_50hz ? 576 : 480;
924 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
925 r.width = yi->osd_full_w;
926 r.height = yi->osd_full_h;
927 }
928 sel->r = r;
929 return 0;
930 }
931 return -EINVAL;
932}
933
934static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
935{
936 static const struct v4l2_fmtdesc hm12 = {
937 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
938 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
939 { 0, 0, 0, 0 }
940 };
941 static const struct v4l2_fmtdesc mpeg = {
942 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
943 "MPEG", V4L2_PIX_FMT_MPEG,
944 { 0, 0, 0, 0 }
945 };
946 struct ivtv *itv = fh2id(fh)->itv;
947 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
948
949 if (fmt->index)
950 return -EINVAL;
951 if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
952 *fmt = mpeg;
953 else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
954 *fmt = hm12;
955 else
956 return -EINVAL;
957 return 0;
958}
959
960static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
961{
962 static const struct v4l2_fmtdesc hm12 = {
963 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0,
964 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
965 { 0, 0, 0, 0 }
966 };
967 static const struct v4l2_fmtdesc mpeg = {
968 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED,
969 "MPEG", V4L2_PIX_FMT_MPEG,
970 { 0, 0, 0, 0 }
971 };
972 struct ivtv *itv = fh2id(fh)->itv;
973 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
974
975 if (fmt->index)
976 return -EINVAL;
977 if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
978 *fmt = mpeg;
979 else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
980 *fmt = hm12;
981 else
982 return -EINVAL;
983 return 0;
984}
985
986static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
987{
988 struct ivtv *itv = fh2id(fh)->itv;
989
990 *i = itv->active_input;
991
992 return 0;
993}
994
995int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
996{
997 struct ivtv *itv = fh2id(fh)->itv;
998 v4l2_std_id std;
999 int i;
1000
1001 if (inp >= itv->nof_inputs)
1002 return -EINVAL;
1003
1004 if (inp == itv->active_input) {
1005 IVTV_DEBUG_INFO("Input unchanged\n");
1006 return 0;
1007 }
1008
1009 if (atomic_read(&itv->capturing) > 0) {
1010 return -EBUSY;
1011 }
1012
1013 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1014 itv->active_input, inp);
1015
1016 itv->active_input = inp;
1017
1018
1019 itv->audio_input = itv->card->video_inputs[inp].audio_index;
1020
1021 if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
1022 std = itv->tuner_std;
1023 else
1024 std = V4L2_STD_ALL;
1025 for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
1026 itv->streams[i].vdev.tvnorms = std;
1027
1028
1029
1030 ivtv_mute(itv);
1031 ivtv_video_set_io(itv);
1032 ivtv_audio_set_io(itv);
1033 ivtv_unmute(itv);
1034
1035 return 0;
1036}
1037
1038static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1039{
1040 struct ivtv *itv = fh2id(fh)->itv;
1041
1042 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1043 return -EINVAL;
1044
1045 *i = itv->active_output;
1046
1047 return 0;
1048}
1049
1050static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1051{
1052 struct ivtv *itv = fh2id(fh)->itv;
1053
1054 if (outp >= itv->card->nof_outputs)
1055 return -EINVAL;
1056
1057 if (outp == itv->active_output) {
1058 IVTV_DEBUG_INFO("Output unchanged\n");
1059 return 0;
1060 }
1061 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1062 itv->active_output, outp);
1063
1064 itv->active_output = outp;
1065 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1066 SAA7127_INPUT_TYPE_NORMAL,
1067 itv->card->video_outputs[outp].video_output, 0);
1068
1069 return 0;
1070}
1071
1072static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1073{
1074 struct ivtv *itv = fh2id(fh)->itv;
1075 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1076
1077 if (s->vdev.vfl_dir)
1078 return -ENOTTY;
1079 if (vf->tuner != 0)
1080 return -EINVAL;
1081
1082 ivtv_call_all(itv, tuner, g_frequency, vf);
1083 return 0;
1084}
1085
1086int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1087{
1088 struct ivtv *itv = fh2id(fh)->itv;
1089 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1090
1091 if (s->vdev.vfl_dir)
1092 return -ENOTTY;
1093 if (vf->tuner != 0)
1094 return -EINVAL;
1095
1096 ivtv_mute(itv);
1097 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1098 ivtv_call_all(itv, tuner, s_frequency, vf);
1099 ivtv_unmute(itv);
1100 return 0;
1101}
1102
1103static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1104{
1105 struct ivtv *itv = fh2id(fh)->itv;
1106
1107 *std = itv->std;
1108 return 0;
1109}
1110
1111void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1112{
1113 itv->std = std;
1114 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1115 itv->is_50hz = !itv->is_60hz;
1116 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1117 itv->cxhdl.width = 720;
1118 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1119 itv->vbi.count = itv->is_50hz ? 18 : 12;
1120 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1121 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1122
1123 if (itv->hw_flags & IVTV_HW_CX25840)
1124 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1125
1126
1127 ivtv_call_all(itv, video, s_std, itv->std);
1128}
1129
1130void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1131{
1132 struct yuv_playback_info *yi = &itv->yuv_info;
1133 DEFINE_WAIT(wait);
1134 int f;
1135
1136
1137 itv->std_out = std;
1138 itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1139 itv->is_out_50hz = !itv->is_out_60hz;
1140 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1141
1142
1143
1144
1145
1146
1147
1148 mutex_unlock(&itv->serialize_lock);
1149 for (f = 0; f < 4; f++) {
1150 prepare_to_wait(&itv->vsync_waitq, &wait,
1151 TASK_UNINTERRUPTIBLE);
1152 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1153 break;
1154 schedule_timeout(msecs_to_jiffies(25));
1155 }
1156 finish_wait(&itv->vsync_waitq, &wait);
1157 mutex_lock(&itv->serialize_lock);
1158
1159 if (f == 4)
1160 IVTV_WARN("Mode change failed to sync to decoder\n");
1161
1162 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1163 itv->main_rect.left = 0;
1164 itv->main_rect.top = 0;
1165 itv->main_rect.width = 720;
1166 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1167 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1168 720, itv->main_rect.height, 0, 0);
1169 yi->main_rect = itv->main_rect;
1170 if (!itv->osd_info) {
1171 yi->osd_full_w = 720;
1172 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1173 }
1174}
1175
1176static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1177{
1178 struct ivtv *itv = fh2id(fh)->itv;
1179
1180 if ((std & V4L2_STD_ALL) == 0)
1181 return -EINVAL;
1182
1183 if (std == itv->std)
1184 return 0;
1185
1186 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1187 atomic_read(&itv->capturing) > 0 ||
1188 atomic_read(&itv->decoding) > 0) {
1189
1190
1191 return -EBUSY;
1192 }
1193
1194 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1195 (unsigned long long)itv->std);
1196
1197 ivtv_s_std_enc(itv, std);
1198 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1199 ivtv_s_std_dec(itv, std);
1200
1201 return 0;
1202}
1203
1204static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1205{
1206 struct ivtv_open_id *id = fh2id(fh);
1207 struct ivtv *itv = id->itv;
1208
1209 if (vt->index != 0)
1210 return -EINVAL;
1211
1212 ivtv_call_all(itv, tuner, s_tuner, vt);
1213
1214 return 0;
1215}
1216
1217static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1218{
1219 struct ivtv *itv = fh2id(fh)->itv;
1220
1221 if (vt->index != 0)
1222 return -EINVAL;
1223
1224 ivtv_call_all(itv, tuner, g_tuner, vt);
1225
1226 if (vt->type == V4L2_TUNER_RADIO)
1227 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1228 else
1229 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1230 return 0;
1231}
1232
1233static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1234{
1235 struct ivtv *itv = fh2id(fh)->itv;
1236 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1237 int f, l;
1238
1239 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1240 for (f = 0; f < 2; f++) {
1241 for (l = 0; l < 24; l++) {
1242 if (valid_service_line(f, l, itv->is_50hz))
1243 cap->service_lines[f][l] = set;
1244 }
1245 }
1246 } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1247 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1248 return -EINVAL;
1249 if (itv->is_60hz) {
1250 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1251 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1252 } else {
1253 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1254 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1255 }
1256 } else {
1257 return -EINVAL;
1258 }
1259
1260 set = 0;
1261 for (f = 0; f < 2; f++)
1262 for (l = 0; l < 24; l++)
1263 set |= cap->service_lines[f][l];
1264 cap->service_set = set;
1265 return 0;
1266}
1267
1268static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1269{
1270 struct ivtv *itv = fh2id(fh)->itv;
1271 struct v4l2_enc_idx_entry *e = idx->entry;
1272 int entries;
1273 int i;
1274
1275 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1276 IVTV_MAX_PGM_INDEX;
1277 if (entries > V4L2_ENC_IDX_ENTRIES)
1278 entries = V4L2_ENC_IDX_ENTRIES;
1279 idx->entries = 0;
1280 idx->entries_cap = IVTV_MAX_PGM_INDEX;
1281 if (!atomic_read(&itv->capturing))
1282 return 0;
1283 for (i = 0; i < entries; i++) {
1284 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1285 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1286 idx->entries++;
1287 e++;
1288 }
1289 }
1290 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1291 return 0;
1292}
1293
1294static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1295{
1296 struct ivtv_open_id *id = fh2id(fh);
1297 struct ivtv *itv = id->itv;
1298
1299
1300 switch (enc->cmd) {
1301 case V4L2_ENC_CMD_START:
1302 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1303 enc->flags = 0;
1304 return ivtv_start_capture(id);
1305
1306 case V4L2_ENC_CMD_STOP:
1307 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1308 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1309 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1310 return 0;
1311
1312 case V4L2_ENC_CMD_PAUSE:
1313 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1314 enc->flags = 0;
1315
1316 if (!atomic_read(&itv->capturing))
1317 return -EPERM;
1318 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1319 return 0;
1320
1321 ivtv_mute(itv);
1322 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1323 break;
1324
1325 case V4L2_ENC_CMD_RESUME:
1326 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1327 enc->flags = 0;
1328
1329 if (!atomic_read(&itv->capturing))
1330 return -EPERM;
1331
1332 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1333 return 0;
1334
1335 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1336 ivtv_unmute(itv);
1337 break;
1338 default:
1339 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1340 return -EINVAL;
1341 }
1342
1343 return 0;
1344}
1345
1346static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1347{
1348 struct ivtv *itv = fh2id(fh)->itv;
1349
1350 switch (enc->cmd) {
1351 case V4L2_ENC_CMD_START:
1352 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1353 enc->flags = 0;
1354 return 0;
1355
1356 case V4L2_ENC_CMD_STOP:
1357 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1358 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1359 return 0;
1360
1361 case V4L2_ENC_CMD_PAUSE:
1362 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1363 enc->flags = 0;
1364 return 0;
1365
1366 case V4L2_ENC_CMD_RESUME:
1367 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1368 enc->flags = 0;
1369 return 0;
1370 default:
1371 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1372 return -EINVAL;
1373 }
1374}
1375
1376static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1377{
1378 struct ivtv *itv = fh2id(fh)->itv;
1379 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1380 u32 data[CX2341X_MBOX_MAX_DATA];
1381 struct yuv_playback_info *yi = &itv->yuv_info;
1382
1383 int pixfmt;
1384 static u32 pixel_format[16] = {
1385 V4L2_PIX_FMT_PAL8,
1386 V4L2_PIX_FMT_RGB565,
1387 V4L2_PIX_FMT_RGB555,
1388 V4L2_PIX_FMT_RGB444,
1389 V4L2_PIX_FMT_RGB32,
1390 0,
1391 0,
1392 0,
1393 V4L2_PIX_FMT_PAL8,
1394 V4L2_PIX_FMT_YUV565,
1395 V4L2_PIX_FMT_YUV555,
1396 V4L2_PIX_FMT_YUV444,
1397 V4L2_PIX_FMT_YUV32,
1398 0,
1399 0,
1400 0,
1401 };
1402
1403 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1404 return -ENOTTY;
1405 if (!itv->osd_video_pbase)
1406 return -ENOTTY;
1407
1408 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1409 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1410
1411 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1412 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1413 pixfmt = (data[0] >> 3) & 0xf;
1414
1415 fb->fmt.pixelformat = pixel_format[pixfmt];
1416 fb->fmt.width = itv->osd_rect.width;
1417 fb->fmt.height = itv->osd_rect.height;
1418 fb->fmt.field = V4L2_FIELD_INTERLACED;
1419 fb->fmt.bytesperline = fb->fmt.width;
1420 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1421 fb->fmt.field = V4L2_FIELD_INTERLACED;
1422 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1423 fb->fmt.bytesperline *= 2;
1424 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1425 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1426 fb->fmt.bytesperline *= 2;
1427 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1428 fb->base = (void *)itv->osd_video_pbase;
1429 fb->flags = 0;
1430
1431 if (itv->osd_chroma_key_state)
1432 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1433
1434 if (itv->osd_global_alpha_state)
1435 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1436
1437 if (yi->track_osd)
1438 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1439
1440 pixfmt &= 7;
1441
1442
1443 if (pixfmt == 1 || pixfmt > 4)
1444 return 0;
1445
1446
1447 if (pixfmt == 2 || pixfmt == 3)
1448 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1449 else
1450 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1451
1452 if (itv->osd_local_alpha_state) {
1453
1454 if (pixfmt == 2 || pixfmt == 3)
1455 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1456 else
1457 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1458 }
1459
1460 return 0;
1461}
1462
1463static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1464{
1465 struct ivtv_open_id *id = fh2id(fh);
1466 struct ivtv *itv = id->itv;
1467 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1468 struct yuv_playback_info *yi = &itv->yuv_info;
1469
1470 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1471 return -ENOTTY;
1472 if (!itv->osd_video_pbase)
1473 return -ENOTTY;
1474
1475 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1476 itv->osd_local_alpha_state =
1477 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1478 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1479 ivtv_set_osd_alpha(itv);
1480 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1481 return 0;
1482}
1483
1484static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1485{
1486 struct ivtv_open_id *id = fh2id(fh);
1487 struct ivtv *itv = id->itv;
1488 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1489
1490 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1491 return -ENOTTY;
1492 if (!itv->osd_video_pbase)
1493 return -ENOTTY;
1494
1495 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1496
1497 return 0;
1498}
1499
1500static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1501{
1502 switch (sub->type) {
1503 case V4L2_EVENT_VSYNC:
1504 case V4L2_EVENT_EOS:
1505 return v4l2_event_subscribe(fh, sub, 0, NULL);
1506 case V4L2_EVENT_CTRL:
1507 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
1508 default:
1509 return -EINVAL;
1510 }
1511}
1512
1513static int ivtv_log_status(struct file *file, void *fh)
1514{
1515 struct ivtv *itv = fh2id(fh)->itv;
1516 u32 data[CX2341X_MBOX_MAX_DATA];
1517
1518 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1519 struct v4l2_input vidin;
1520 struct v4l2_audio audin;
1521 int i;
1522
1523 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1524 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1525 struct tveeprom tv;
1526
1527 ivtv_read_eeprom(itv, &tv);
1528 }
1529 ivtv_call_all(itv, core, log_status);
1530 ivtv_get_input(itv, itv->active_input, &vidin);
1531 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1532 IVTV_INFO("Video Input: %s\n", vidin.name);
1533 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1534 itv->dualwatch_stereo_mode == V4L2_MPEG_AUDIO_MODE_DUAL ?
1535 " (Bilingual)" : "");
1536 if (has_output) {
1537 struct v4l2_output vidout;
1538 struct v4l2_audioout audout;
1539 int mode = itv->output_mode;
1540 static const char * const output_modes[5] = {
1541 "None",
1542 "MPEG Streaming",
1543 "YUV Streaming",
1544 "YUV Frames",
1545 "Passthrough",
1546 };
1547 static const char * const alpha_mode[4] = {
1548 "None",
1549 "Global",
1550 "Local",
1551 "Global and Local"
1552 };
1553 static const char * const pixel_format[16] = {
1554 "ARGB Indexed",
1555 "RGB 5:6:5",
1556 "ARGB 1:5:5:5",
1557 "ARGB 1:4:4:4",
1558 "ARGB 8:8:8:8",
1559 "5",
1560 "6",
1561 "7",
1562 "AYUV Indexed",
1563 "YUV 5:6:5",
1564 "AYUV 1:5:5:5",
1565 "AYUV 1:4:4:4",
1566 "AYUV 8:8:8:8",
1567 "13",
1568 "14",
1569 "15",
1570 };
1571
1572 ivtv_get_output(itv, itv->active_output, &vidout);
1573 ivtv_get_audio_output(itv, 0, &audout);
1574 IVTV_INFO("Video Output: %s\n", vidout.name);
1575 if (mode < 0 || mode > OUT_PASSTHROUGH)
1576 mode = OUT_NONE;
1577 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1578 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1579 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1580 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1581 data[0] & 1 ? "On" : "Off",
1582 alpha_mode[(data[0] >> 1) & 0x3],
1583 pixel_format[(data[0] >> 3) & 0xf]);
1584 }
1585 IVTV_INFO("Tuner: %s\n",
1586 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1587 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1588 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1589 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1590 struct ivtv_stream *s = &itv->streams[i];
1591
1592 if (s->vdev.v4l2_dev == NULL || s->buffers == 0)
1593 continue;
1594 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1595 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1596 (s->buffers * s->buf_size) / 1024, s->buffers);
1597 }
1598
1599 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1600 (long long)itv->mpg_data_received,
1601 (long long)itv->vbi_data_inserted);
1602 return 0;
1603}
1604
1605static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1606{
1607 struct ivtv_open_id *id = fh2id(file->private_data);
1608 struct ivtv *itv = id->itv;
1609
1610 IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1611 return ivtv_video_command(itv, id, dec, false);
1612}
1613
1614static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1615{
1616 struct ivtv_open_id *id = fh2id(file->private_data);
1617 struct ivtv *itv = id->itv;
1618
1619 IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1620 return ivtv_video_command(itv, id, dec, true);
1621}
1622
1623static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1624{
1625 struct ivtv_open_id *id = fh2id(filp->private_data);
1626 struct ivtv *itv = id->itv;
1627 int nonblocking = filp->f_flags & O_NONBLOCK;
1628 struct ivtv_stream *s = &itv->streams[id->type];
1629 unsigned long iarg = (unsigned long)arg;
1630
1631 switch (cmd) {
1632 case IVTV_IOC_DMA_FRAME: {
1633 struct ivtv_dma_frame *args = arg;
1634
1635 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1636 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1637 return -EINVAL;
1638 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1639 return -EINVAL;
1640 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1641 return 0;
1642 if (ivtv_start_decoding(id, id->type)) {
1643 return -EBUSY;
1644 }
1645 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1646 ivtv_release_stream(s);
1647 return -EBUSY;
1648 }
1649
1650 id->yuv_frames = 1;
1651 if (args->y_source == NULL)
1652 return 0;
1653 return ivtv_yuv_prep_frame(itv, args);
1654 }
1655
1656 case IVTV_IOC_PASSTHROUGH_MODE:
1657 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1658 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1659 return -EINVAL;
1660 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1661
1662 case VIDEO_GET_PTS: {
1663 s64 *pts = arg;
1664 s64 frame;
1665
1666 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1667 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1668 *pts = s->dma_pts;
1669 break;
1670 }
1671 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1672 return -EINVAL;
1673 return ivtv_g_pts_frame(itv, pts, &frame);
1674 }
1675
1676 case VIDEO_GET_FRAME_COUNT: {
1677 s64 *frame = arg;
1678 s64 pts;
1679
1680 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1681 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1682 *frame = 0;
1683 break;
1684 }
1685 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1686 return -EINVAL;
1687 return ivtv_g_pts_frame(itv, &pts, frame);
1688 }
1689
1690 case VIDEO_PLAY: {
1691 struct v4l2_decoder_cmd dc;
1692
1693 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1694 memset(&dc, 0, sizeof(dc));
1695 dc.cmd = V4L2_DEC_CMD_START;
1696 return ivtv_video_command(itv, id, &dc, 0);
1697 }
1698
1699 case VIDEO_STOP: {
1700 struct v4l2_decoder_cmd dc;
1701
1702 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1703 memset(&dc, 0, sizeof(dc));
1704 dc.cmd = V4L2_DEC_CMD_STOP;
1705 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1706 return ivtv_video_command(itv, id, &dc, 0);
1707 }
1708
1709 case VIDEO_FREEZE: {
1710 struct v4l2_decoder_cmd dc;
1711
1712 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1713 memset(&dc, 0, sizeof(dc));
1714 dc.cmd = V4L2_DEC_CMD_PAUSE;
1715 return ivtv_video_command(itv, id, &dc, 0);
1716 }
1717
1718 case VIDEO_CONTINUE: {
1719 struct v4l2_decoder_cmd dc;
1720
1721 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1722 memset(&dc, 0, sizeof(dc));
1723 dc.cmd = V4L2_DEC_CMD_RESUME;
1724 return ivtv_video_command(itv, id, &dc, 0);
1725 }
1726
1727 case VIDEO_COMMAND:
1728 case VIDEO_TRY_COMMAND: {
1729
1730
1731 struct v4l2_decoder_cmd *dc = arg;
1732 int try = (cmd == VIDEO_TRY_COMMAND);
1733
1734 if (try)
1735 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd);
1736 else
1737 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd);
1738 return ivtv_video_command(itv, id, dc, try);
1739 }
1740
1741 case VIDEO_GET_EVENT: {
1742 struct video_event *ev = arg;
1743 DEFINE_WAIT(wait);
1744
1745 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1746 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1747 return -EINVAL;
1748 memset(ev, 0, sizeof(*ev));
1749 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1750
1751 while (1) {
1752 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1753 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1754 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1755 ev->type = VIDEO_EVENT_VSYNC;
1756 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1757 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1758 if (itv->output_mode == OUT_UDMA_YUV &&
1759 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1760 IVTV_YUV_MODE_PROGRESSIVE) {
1761 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1762 }
1763 }
1764 if (ev->type)
1765 return 0;
1766 if (nonblocking)
1767 return -EAGAIN;
1768
1769
1770
1771 mutex_unlock(&itv->serialize_lock);
1772 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1773 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1774 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1775 schedule();
1776 finish_wait(&itv->event_waitq, &wait);
1777 mutex_lock(&itv->serialize_lock);
1778 if (signal_pending(current)) {
1779
1780 IVTV_DEBUG_INFO("User stopped wait for event\n");
1781 return -EINTR;
1782 }
1783 }
1784 break;
1785 }
1786
1787 case VIDEO_SELECT_SOURCE:
1788 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1789 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1790 return -EINVAL;
1791 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1792
1793 case AUDIO_SET_MUTE:
1794 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1795 itv->speed_mute_audio = iarg;
1796 return 0;
1797
1798 case AUDIO_CHANNEL_SELECT:
1799 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1800 if (iarg > AUDIO_STEREO_SWAPPED)
1801 return -EINVAL;
1802 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1803
1804 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1805 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1806 if (iarg > AUDIO_STEREO_SWAPPED)
1807 return -EINVAL;
1808 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1809
1810 default:
1811 return -EINVAL;
1812 }
1813 return 0;
1814}
1815
1816static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1817 unsigned int cmd, void *arg)
1818{
1819 struct ivtv *itv = fh2id(fh)->itv;
1820
1821 if (!valid_prio) {
1822 switch (cmd) {
1823 case IVTV_IOC_PASSTHROUGH_MODE:
1824 case VIDEO_PLAY:
1825 case VIDEO_STOP:
1826 case VIDEO_FREEZE:
1827 case VIDEO_CONTINUE:
1828 case VIDEO_COMMAND:
1829 case VIDEO_SELECT_SOURCE:
1830 case AUDIO_SET_MUTE:
1831 case AUDIO_CHANNEL_SELECT:
1832 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1833 return -EBUSY;
1834 }
1835 }
1836
1837 switch (cmd) {
1838 case VIDIOC_INT_RESET: {
1839 u32 val = *(u32 *)arg;
1840
1841 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1842 ivtv_reset_ir_gpio(itv);
1843 if (val & 0x02)
1844 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1845 break;
1846 }
1847
1848 case IVTV_IOC_DMA_FRAME:
1849 case IVTV_IOC_PASSTHROUGH_MODE:
1850 case VIDEO_GET_PTS:
1851 case VIDEO_GET_FRAME_COUNT:
1852 case VIDEO_GET_EVENT:
1853 case VIDEO_PLAY:
1854 case VIDEO_STOP:
1855 case VIDEO_FREEZE:
1856 case VIDEO_CONTINUE:
1857 case VIDEO_COMMAND:
1858 case VIDEO_TRY_COMMAND:
1859 case VIDEO_SELECT_SOURCE:
1860 case AUDIO_SET_MUTE:
1861 case AUDIO_CHANNEL_SELECT:
1862 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1863 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1864
1865 default:
1866 return -ENOTTY;
1867 }
1868 return 0;
1869}
1870
1871static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1872 .vidioc_querycap = ivtv_querycap,
1873 .vidioc_s_audio = ivtv_s_audio,
1874 .vidioc_g_audio = ivtv_g_audio,
1875 .vidioc_enumaudio = ivtv_enumaudio,
1876 .vidioc_s_audout = ivtv_s_audout,
1877 .vidioc_g_audout = ivtv_g_audout,
1878 .vidioc_enum_input = ivtv_enum_input,
1879 .vidioc_enum_output = ivtv_enum_output,
1880 .vidioc_enumaudout = ivtv_enumaudout,
1881 .vidioc_cropcap = ivtv_cropcap,
1882 .vidioc_s_selection = ivtv_s_selection,
1883 .vidioc_g_selection = ivtv_g_selection,
1884 .vidioc_g_input = ivtv_g_input,
1885 .vidioc_s_input = ivtv_s_input,
1886 .vidioc_g_output = ivtv_g_output,
1887 .vidioc_s_output = ivtv_s_output,
1888 .vidioc_g_frequency = ivtv_g_frequency,
1889 .vidioc_s_frequency = ivtv_s_frequency,
1890 .vidioc_s_tuner = ivtv_s_tuner,
1891 .vidioc_g_tuner = ivtv_g_tuner,
1892 .vidioc_g_enc_index = ivtv_g_enc_index,
1893 .vidioc_g_fbuf = ivtv_g_fbuf,
1894 .vidioc_s_fbuf = ivtv_s_fbuf,
1895 .vidioc_g_std = ivtv_g_std,
1896 .vidioc_s_std = ivtv_s_std,
1897 .vidioc_overlay = ivtv_overlay,
1898 .vidioc_log_status = ivtv_log_status,
1899 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1900 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1901 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1902 .vidioc_decoder_cmd = ivtv_decoder_cmd,
1903 .vidioc_try_decoder_cmd = ivtv_try_decoder_cmd,
1904 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1905 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1906 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1907 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1908 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1909 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1910 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1911 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1912 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1913 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1914 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1915 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1916 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1917 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1918 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1919 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1920 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1921 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1922 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1923 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1924#ifdef CONFIG_VIDEO_ADV_DEBUG
1925 .vidioc_g_register = ivtv_g_register,
1926 .vidioc_s_register = ivtv_s_register,
1927#endif
1928 .vidioc_default = ivtv_default,
1929 .vidioc_subscribe_event = ivtv_subscribe_event,
1930 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1931};
1932
1933void ivtv_set_funcs(struct video_device *vdev)
1934{
1935 vdev->ioctl_ops = &ivtv_ioctl_ops;
1936}
1937
