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