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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
754{
755 struct ivtv *itv = fh2id(fh)->itv;
756
757 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
758 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
759 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
760 vcap->capabilities = itv->v4l2_cap;
761 return 0;
762}
763
764static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
765{
766 struct ivtv *itv = fh2id(fh)->itv;
767
768 return ivtv_get_audio_input(itv, vin->index, vin);
769}
770
771static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
772{
773 struct ivtv *itv = fh2id(fh)->itv;
774
775 vin->index = itv->audio_input;
776 return ivtv_get_audio_input(itv, vin->index, vin);
777}
778
779static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
780{
781 struct ivtv *itv = fh2id(fh)->itv;
782
783 if (vout->index >= itv->nof_audio_inputs)
784 return -EINVAL;
785
786 itv->audio_input = vout->index;
787 ivtv_audio_set_io(itv);
788
789 return 0;
790}
791
792static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
793{
794 struct ivtv *itv = fh2id(fh)->itv;
795
796
797 return ivtv_get_audio_output(itv, vin->index, vin);
798}
799
800static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
801{
802 struct ivtv *itv = fh2id(fh)->itv;
803
804 vin->index = 0;
805 return ivtv_get_audio_output(itv, vin->index, vin);
806}
807
808static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
809{
810 struct ivtv *itv = fh2id(fh)->itv;
811
812 return ivtv_get_audio_output(itv, vout->index, vout);
813}
814
815static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
816{
817 struct ivtv *itv = fh2id(fh)->itv;
818
819
820 return ivtv_get_input(itv, vin->index, vin);
821}
822
823static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
824{
825 struct ivtv *itv = fh2id(fh)->itv;
826
827 return ivtv_get_output(itv, vout->index, vout);
828}
829
830static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
831{
832 struct ivtv_open_id *id = fh2id(fh);
833 struct ivtv *itv = id->itv;
834 struct yuv_playback_info *yi = &itv->yuv_info;
835 int streamtype;
836
837 streamtype = id->type;
838
839 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
840 return -EINVAL;
841 cropcap->bounds.top = cropcap->bounds.left = 0;
842 cropcap->bounds.width = 720;
843 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
844 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
845 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
846 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
847 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
848 if (yi->track_osd) {
849 cropcap->bounds.width = yi->osd_full_w;
850 cropcap->bounds.height = yi->osd_full_h;
851 } else {
852 cropcap->bounds.width = 720;
853 cropcap->bounds.height =
854 itv->is_out_50hz ? 576 : 480;
855 }
856 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
857 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
858 } else {
859 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
860 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
861 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
862 }
863 cropcap->defrect = cropcap->bounds;
864 return 0;
865}
866
867static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
868{
869 struct ivtv_open_id *id = fh2id(fh);
870 struct ivtv *itv = id->itv;
871 struct yuv_playback_info *yi = &itv->yuv_info;
872 int streamtype;
873
874 streamtype = id->type;
875
876 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
877 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
878 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
879 yi->main_rect = crop->c;
880 return 0;
881 } else {
882 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
883 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
884 itv->main_rect = crop->c;
885 return 0;
886 }
887 }
888 return -EINVAL;
889 }
890 return -EINVAL;
891}
892
893static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
894{
895 struct ivtv_open_id *id = fh2id(fh);
896 struct ivtv *itv = id->itv;
897 struct yuv_playback_info *yi = &itv->yuv_info;
898 int streamtype;
899
900 streamtype = id->type;
901
902 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
903 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
904 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
905 crop->c = yi->main_rect;
906 else
907 crop->c = itv->main_rect;
908 return 0;
909 }
910 return -EINVAL;
911}
912
913static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
914{
915 static struct v4l2_fmtdesc formats[] = {
916 { 0, 0, 0,
917 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
918 { 0, 0, 0, 0 }
919 },
920 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
921 "MPEG", V4L2_PIX_FMT_MPEG,
922 { 0, 0, 0, 0 }
923 }
924 };
925 enum v4l2_buf_type type = fmt->type;
926
927 if (fmt->index > 1)
928 return -EINVAL;
929
930 *fmt = formats[fmt->index];
931 fmt->type = type;
932 return 0;
933}
934
935static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
936{
937 struct ivtv *itv = fh2id(fh)->itv;
938
939 static struct v4l2_fmtdesc formats[] = {
940 { 0, 0, 0,
941 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
942 { 0, 0, 0, 0 }
943 },
944 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
945 "MPEG", V4L2_PIX_FMT_MPEG,
946 { 0, 0, 0, 0 }
947 }
948 };
949 enum v4l2_buf_type type = fmt->type;
950
951 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
952 return -EINVAL;
953
954 if (fmt->index > 1)
955 return -EINVAL;
956
957 *fmt = formats[fmt->index];
958 fmt->type = type;
959
960 return 0;
961}
962
963static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
964{
965 struct ivtv *itv = fh2id(fh)->itv;
966
967 *i = itv->active_input;
968
969 return 0;
970}
971
972int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
973{
974 struct ivtv *itv = fh2id(fh)->itv;
975
976 if (inp < 0 || inp >= itv->nof_inputs)
977 return -EINVAL;
978
979 if (inp == itv->active_input) {
980 IVTV_DEBUG_INFO("Input unchanged\n");
981 return 0;
982 }
983
984 if (atomic_read(&itv->capturing) > 0) {
985 return -EBUSY;
986 }
987
988 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
989 itv->active_input, inp);
990
991 itv->active_input = inp;
992
993
994 itv->audio_input = itv->card->video_inputs[inp].audio_index;
995
996
997
998 ivtv_mute(itv);
999 ivtv_video_set_io(itv);
1000 ivtv_audio_set_io(itv);
1001 ivtv_unmute(itv);
1002
1003 return 0;
1004}
1005
1006static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1007{
1008 struct ivtv *itv = fh2id(fh)->itv;
1009
1010 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1011 return -EINVAL;
1012
1013 *i = itv->active_output;
1014
1015 return 0;
1016}
1017
1018static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1019{
1020 struct ivtv *itv = fh2id(fh)->itv;
1021
1022 if (outp >= itv->card->nof_outputs)
1023 return -EINVAL;
1024
1025 if (outp == itv->active_output) {
1026 IVTV_DEBUG_INFO("Output unchanged\n");
1027 return 0;
1028 }
1029 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1030 itv->active_output, outp);
1031
1032 itv->active_output = outp;
1033 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1034 SAA7127_INPUT_TYPE_NORMAL,
1035 itv->card->video_outputs[outp].video_output, 0);
1036
1037 return 0;
1038}
1039
1040static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1041{
1042 struct ivtv *itv = fh2id(fh)->itv;
1043
1044 if (vf->tuner != 0)
1045 return -EINVAL;
1046
1047 ivtv_call_all(itv, tuner, g_frequency, vf);
1048 return 0;
1049}
1050
1051int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1052{
1053 struct ivtv *itv = fh2id(fh)->itv;
1054
1055 if (vf->tuner != 0)
1056 return -EINVAL;
1057
1058 ivtv_mute(itv);
1059 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1060 ivtv_call_all(itv, tuner, s_frequency, vf);
1061 ivtv_unmute(itv);
1062 return 0;
1063}
1064
1065static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1066{
1067 struct ivtv *itv = fh2id(fh)->itv;
1068
1069 *std = itv->std;
1070 return 0;
1071}
1072
1073void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id *std)
1074{
1075 itv->std = *std;
1076 itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1077 itv->is_50hz = !itv->is_60hz;
1078 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1079 itv->cxhdl.width = 720;
1080 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1081 itv->vbi.count = itv->is_50hz ? 18 : 12;
1082 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1083 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1084
1085 if (itv->hw_flags & IVTV_HW_CX25840)
1086 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1087
1088
1089 ivtv_call_all(itv, core, s_std, itv->std);
1090}
1091
1092void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
1093{
1094 struct yuv_playback_info *yi = &itv->yuv_info;
1095 DEFINE_WAIT(wait);
1096 int f;
1097
1098
1099 itv->std_out = *std;
1100 itv->is_out_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1101 itv->is_out_50hz = !itv->is_out_60hz;
1102 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1103
1104
1105
1106
1107
1108
1109
1110 for (f = 0; f < 4; f++) {
1111 prepare_to_wait(&itv->vsync_waitq, &wait,
1112 TASK_UNINTERRUPTIBLE);
1113 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1114 break;
1115 schedule_timeout(msecs_to_jiffies(25));
1116 }
1117 finish_wait(&itv->vsync_waitq, &wait);
1118
1119 if (f == 4)
1120 IVTV_WARN("Mode change failed to sync to decoder\n");
1121
1122 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1123 itv->main_rect.left = 0;
1124 itv->main_rect.top = 0;
1125 itv->main_rect.width = 720;
1126 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1127 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1128 720, itv->main_rect.height, 0, 0);
1129 yi->main_rect = itv->main_rect;
1130 if (!itv->osd_info) {
1131 yi->osd_full_w = 720;
1132 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1133 }
1134}
1135
1136int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1137{
1138 struct ivtv *itv = fh2id(fh)->itv;
1139
1140 if ((*std & V4L2_STD_ALL) == 0)
1141 return -EINVAL;
1142
1143 if (*std == itv->std)
1144 return 0;
1145
1146 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1147 atomic_read(&itv->capturing) > 0 ||
1148 atomic_read(&itv->decoding) > 0) {
1149
1150
1151 return -EBUSY;
1152 }
1153
1154 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1155 (unsigned long long)itv->std);
1156
1157 ivtv_s_std_enc(itv, std);
1158 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1159 ivtv_s_std_dec(itv, std);
1160
1161 return 0;
1162}
1163
1164static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1165{
1166 struct ivtv_open_id *id = fh2id(fh);
1167 struct ivtv *itv = id->itv;
1168
1169 if (vt->index != 0)
1170 return -EINVAL;
1171
1172 ivtv_call_all(itv, tuner, s_tuner, vt);
1173
1174 return 0;
1175}
1176
1177static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1178{
1179 struct ivtv *itv = fh2id(fh)->itv;
1180
1181 if (vt->index != 0)
1182 return -EINVAL;
1183
1184 ivtv_call_all(itv, tuner, g_tuner, vt);
1185
1186 if (vt->type == V4L2_TUNER_RADIO)
1187 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1188 else
1189 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1190 return 0;
1191}
1192
1193static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1194{
1195 struct ivtv *itv = fh2id(fh)->itv;
1196 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1197 int f, l;
1198
1199 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1200 for (f = 0; f < 2; f++) {
1201 for (l = 0; l < 24; l++) {
1202 if (valid_service_line(f, l, itv->is_50hz))
1203 cap->service_lines[f][l] = set;
1204 }
1205 }
1206 } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1207 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1208 return -EINVAL;
1209 if (itv->is_60hz) {
1210 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1211 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1212 } else {
1213 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1214 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1215 }
1216 } else {
1217 return -EINVAL;
1218 }
1219
1220 set = 0;
1221 for (f = 0; f < 2; f++)
1222 for (l = 0; l < 24; l++)
1223 set |= cap->service_lines[f][l];
1224 cap->service_set = set;
1225 return 0;
1226}
1227
1228static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1229{
1230 struct ivtv *itv = fh2id(fh)->itv;
1231 struct v4l2_enc_idx_entry *e = idx->entry;
1232 int entries;
1233 int i;
1234
1235 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1236 IVTV_MAX_PGM_INDEX;
1237 if (entries > V4L2_ENC_IDX_ENTRIES)
1238 entries = V4L2_ENC_IDX_ENTRIES;
1239 idx->entries = 0;
1240 for (i = 0; i < entries; i++) {
1241 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1242 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1243 idx->entries++;
1244 e++;
1245 }
1246 }
1247 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1248 return 0;
1249}
1250
1251static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1252{
1253 struct ivtv_open_id *id = fh2id(fh);
1254 struct ivtv *itv = id->itv;
1255
1256
1257 switch (enc->cmd) {
1258 case V4L2_ENC_CMD_START:
1259 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1260 enc->flags = 0;
1261 return ivtv_start_capture(id);
1262
1263 case V4L2_ENC_CMD_STOP:
1264 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1265 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1266 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1267 return 0;
1268
1269 case V4L2_ENC_CMD_PAUSE:
1270 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1271 enc->flags = 0;
1272
1273 if (!atomic_read(&itv->capturing))
1274 return -EPERM;
1275 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1276 return 0;
1277
1278 ivtv_mute(itv);
1279 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1280 break;
1281
1282 case V4L2_ENC_CMD_RESUME:
1283 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1284 enc->flags = 0;
1285
1286 if (!atomic_read(&itv->capturing))
1287 return -EPERM;
1288
1289 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1290 return 0;
1291
1292 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1293 ivtv_unmute(itv);
1294 break;
1295 default:
1296 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1297 return -EINVAL;
1298 }
1299
1300 return 0;
1301}
1302
1303static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1304{
1305 struct ivtv *itv = fh2id(fh)->itv;
1306
1307 switch (enc->cmd) {
1308 case V4L2_ENC_CMD_START:
1309 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1310 enc->flags = 0;
1311 return 0;
1312
1313 case V4L2_ENC_CMD_STOP:
1314 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1315 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1316 return 0;
1317
1318 case V4L2_ENC_CMD_PAUSE:
1319 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1320 enc->flags = 0;
1321 return 0;
1322
1323 case V4L2_ENC_CMD_RESUME:
1324 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1325 enc->flags = 0;
1326 return 0;
1327 default:
1328 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1329 return -EINVAL;
1330 }
1331}
1332
1333static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1334{
1335 struct ivtv *itv = fh2id(fh)->itv;
1336 u32 data[CX2341X_MBOX_MAX_DATA];
1337 struct yuv_playback_info *yi = &itv->yuv_info;
1338
1339 int pixfmt;
1340 static u32 pixel_format[16] = {
1341 V4L2_PIX_FMT_PAL8,
1342 V4L2_PIX_FMT_RGB565,
1343 V4L2_PIX_FMT_RGB555,
1344 V4L2_PIX_FMT_RGB444,
1345 V4L2_PIX_FMT_RGB32,
1346 0,
1347 0,
1348 0,
1349 V4L2_PIX_FMT_PAL8,
1350 V4L2_PIX_FMT_YUV565,
1351 V4L2_PIX_FMT_YUV555,
1352 V4L2_PIX_FMT_YUV444,
1353 V4L2_PIX_FMT_YUV32,
1354 0,
1355 0,
1356 0,
1357 };
1358
1359 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1360 return -EINVAL;
1361 if (!itv->osd_video_pbase)
1362 return -EINVAL;
1363
1364 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1365 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1366
1367 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1368 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1369 pixfmt = (data[0] >> 3) & 0xf;
1370
1371 fb->fmt.pixelformat = pixel_format[pixfmt];
1372 fb->fmt.width = itv->osd_rect.width;
1373 fb->fmt.height = itv->osd_rect.height;
1374 fb->fmt.field = V4L2_FIELD_INTERLACED;
1375 fb->fmt.bytesperline = fb->fmt.width;
1376 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1377 fb->fmt.field = V4L2_FIELD_INTERLACED;
1378 fb->fmt.priv = 0;
1379 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1380 fb->fmt.bytesperline *= 2;
1381 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1382 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1383 fb->fmt.bytesperline *= 2;
1384 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1385 fb->base = (void *)itv->osd_video_pbase;
1386 fb->flags = 0;
1387
1388 if (itv->osd_chroma_key_state)
1389 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1390
1391 if (itv->osd_global_alpha_state)
1392 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1393
1394 if (yi->track_osd)
1395 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1396
1397 pixfmt &= 7;
1398
1399
1400 if (pixfmt == 1 || pixfmt > 4)
1401 return 0;
1402
1403
1404 if (pixfmt == 2 || pixfmt == 3)
1405 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1406 else
1407 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1408
1409 if (itv->osd_local_alpha_state) {
1410
1411 if (pixfmt == 2 || pixfmt == 3)
1412 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1413 else
1414 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1415 }
1416
1417 return 0;
1418}
1419
1420static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1421{
1422 struct ivtv_open_id *id = fh2id(fh);
1423 struct ivtv *itv = id->itv;
1424 struct yuv_playback_info *yi = &itv->yuv_info;
1425
1426 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1427 return -EINVAL;
1428 if (!itv->osd_video_pbase)
1429 return -EINVAL;
1430
1431 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1432 itv->osd_local_alpha_state =
1433 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1434 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1435 ivtv_set_osd_alpha(itv);
1436 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1437 return ivtv_g_fbuf(file, fh, fb);
1438}
1439
1440static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1441{
1442 struct ivtv_open_id *id = fh2id(fh);
1443 struct ivtv *itv = id->itv;
1444
1445 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1446 return -EINVAL;
1447
1448 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1449
1450 return 0;
1451}
1452
1453static int ivtv_subscribe_event(struct v4l2_fh *fh, struct v4l2_event_subscription *sub)
1454{
1455 switch (sub->type) {
1456 case V4L2_EVENT_VSYNC:
1457 case V4L2_EVENT_EOS:
1458 case V4L2_EVENT_CTRL:
1459 return v4l2_event_subscribe(fh, sub, 0);
1460 default:
1461 return -EINVAL;
1462 }
1463}
1464
1465static int ivtv_log_status(struct file *file, void *fh)
1466{
1467 struct ivtv *itv = fh2id(fh)->itv;
1468 u32 data[CX2341X_MBOX_MAX_DATA];
1469
1470 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1471 struct v4l2_input vidin;
1472 struct v4l2_audio audin;
1473 int i;
1474
1475 IVTV_INFO("================= START STATUS CARD #%d =================\n",
1476 itv->instance);
1477 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1478 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1479 struct tveeprom tv;
1480
1481 ivtv_read_eeprom(itv, &tv);
1482 }
1483 ivtv_call_all(itv, core, log_status);
1484 ivtv_get_input(itv, itv->active_input, &vidin);
1485 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1486 IVTV_INFO("Video Input: %s\n", vidin.name);
1487 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1488 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1489 if (has_output) {
1490 struct v4l2_output vidout;
1491 struct v4l2_audioout audout;
1492 int mode = itv->output_mode;
1493 static const char * const output_modes[5] = {
1494 "None",
1495 "MPEG Streaming",
1496 "YUV Streaming",
1497 "YUV Frames",
1498 "Passthrough",
1499 };
1500 static const char * const audio_modes[5] = {
1501 "Stereo",
1502 "Left",
1503 "Right",
1504 "Mono",
1505 "Swapped"
1506 };
1507 static const char * const alpha_mode[4] = {
1508 "None",
1509 "Global",
1510 "Local",
1511 "Global and Local"
1512 };
1513 static const char * const pixel_format[16] = {
1514 "ARGB Indexed",
1515 "RGB 5:6:5",
1516 "ARGB 1:5:5:5",
1517 "ARGB 1:4:4:4",
1518 "ARGB 8:8:8:8",
1519 "5",
1520 "6",
1521 "7",
1522 "AYUV Indexed",
1523 "YUV 5:6:5",
1524 "AYUV 1:5:5:5",
1525 "AYUV 1:4:4:4",
1526 "AYUV 8:8:8:8",
1527 "13",
1528 "14",
1529 "15",
1530 };
1531
1532 ivtv_get_output(itv, itv->active_output, &vidout);
1533 ivtv_get_audio_output(itv, 0, &audout);
1534 IVTV_INFO("Video Output: %s\n", vidout.name);
1535 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1536 audio_modes[itv->audio_stereo_mode],
1537 audio_modes[itv->audio_bilingual_mode]);
1538 if (mode < 0 || mode > OUT_PASSTHROUGH)
1539 mode = OUT_NONE;
1540 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1541 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1542 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1543 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1544 data[0] & 1 ? "On" : "Off",
1545 alpha_mode[(data[0] >> 1) & 0x3],
1546 pixel_format[(data[0] >> 3) & 0xf]);
1547 }
1548 IVTV_INFO("Tuner: %s\n",
1549 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1550 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1551 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1552 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1553 struct ivtv_stream *s = &itv->streams[i];
1554
1555 if (s->vdev == NULL || s->buffers == 0)
1556 continue;
1557 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1558 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1559 (s->buffers * s->buf_size) / 1024, s->buffers);
1560 }
1561
1562 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1563 (long long)itv->mpg_data_received,
1564 (long long)itv->vbi_data_inserted);
1565 IVTV_INFO("================== END STATUS CARD #%d ==================\n",
1566 itv->instance);
1567
1568 return 0;
1569}
1570
1571static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1572{
1573 struct ivtv_open_id *id = fh2id(filp->private_data);
1574 struct ivtv *itv = id->itv;
1575 int nonblocking = filp->f_flags & O_NONBLOCK;
1576 struct ivtv_stream *s = &itv->streams[id->type];
1577 unsigned long iarg = (unsigned long)arg;
1578
1579 switch (cmd) {
1580 case IVTV_IOC_DMA_FRAME: {
1581 struct ivtv_dma_frame *args = arg;
1582
1583 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1584 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1585 return -EINVAL;
1586 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1587 return -EINVAL;
1588 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1589 return 0;
1590 if (ivtv_start_decoding(id, id->type)) {
1591 return -EBUSY;
1592 }
1593 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1594 ivtv_release_stream(s);
1595 return -EBUSY;
1596 }
1597
1598 id->yuv_frames = 1;
1599 if (args->y_source == NULL)
1600 return 0;
1601 return ivtv_yuv_prep_frame(itv, args);
1602 }
1603
1604 case VIDEO_GET_PTS: {
1605 u32 data[CX2341X_MBOX_MAX_DATA];
1606 u64 *pts = arg;
1607
1608 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1609 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1610 *pts = s->dma_pts;
1611 break;
1612 }
1613 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1614 return -EINVAL;
1615
1616 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1617 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1618 (u64)itv->last_dec_timing[1];
1619 break;
1620 }
1621 *pts = 0;
1622 if (atomic_read(&itv->decoding)) {
1623 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1624 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1625 return -EIO;
1626 }
1627 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1628 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1629 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1630
1631 }
1632 break;
1633 }
1634
1635 case VIDEO_GET_FRAME_COUNT: {
1636 u32 data[CX2341X_MBOX_MAX_DATA];
1637 u64 *frame = arg;
1638
1639 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1640 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1641 *frame = 0;
1642 break;
1643 }
1644 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1645 return -EINVAL;
1646
1647 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1648 *frame = itv->last_dec_timing[0];
1649 break;
1650 }
1651 *frame = 0;
1652 if (atomic_read(&itv->decoding)) {
1653 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1654 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1655 return -EIO;
1656 }
1657 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1658 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1659 *frame = data[0];
1660 }
1661 break;
1662 }
1663
1664 case VIDEO_PLAY: {
1665 struct video_command vc;
1666
1667 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1668 memset(&vc, 0, sizeof(vc));
1669 vc.cmd = VIDEO_CMD_PLAY;
1670 return ivtv_video_command(itv, id, &vc, 0);
1671 }
1672
1673 case VIDEO_STOP: {
1674 struct video_command vc;
1675
1676 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1677 memset(&vc, 0, sizeof(vc));
1678 vc.cmd = VIDEO_CMD_STOP;
1679 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1680 return ivtv_video_command(itv, id, &vc, 0);
1681 }
1682
1683 case VIDEO_FREEZE: {
1684 struct video_command vc;
1685
1686 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1687 memset(&vc, 0, sizeof(vc));
1688 vc.cmd = VIDEO_CMD_FREEZE;
1689 return ivtv_video_command(itv, id, &vc, 0);
1690 }
1691
1692 case VIDEO_CONTINUE: {
1693 struct video_command vc;
1694
1695 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1696 memset(&vc, 0, sizeof(vc));
1697 vc.cmd = VIDEO_CMD_CONTINUE;
1698 return ivtv_video_command(itv, id, &vc, 0);
1699 }
1700
1701 case VIDEO_COMMAND:
1702 case VIDEO_TRY_COMMAND: {
1703 struct video_command *vc = arg;
1704 int try = (cmd == VIDEO_TRY_COMMAND);
1705
1706 if (try)
1707 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1708 else
1709 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1710 return ivtv_video_command(itv, id, vc, try);
1711 }
1712
1713 case VIDEO_GET_EVENT: {
1714 struct video_event *ev = arg;
1715 DEFINE_WAIT(wait);
1716
1717 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1718 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1719 return -EINVAL;
1720 memset(ev, 0, sizeof(*ev));
1721 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1722
1723 while (1) {
1724 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1725 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1726 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1727 ev->type = VIDEO_EVENT_VSYNC;
1728 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1729 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1730 if (itv->output_mode == OUT_UDMA_YUV &&
1731 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1732 IVTV_YUV_MODE_PROGRESSIVE) {
1733 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1734 }
1735 }
1736 if (ev->type)
1737 return 0;
1738 if (nonblocking)
1739 return -EAGAIN;
1740
1741
1742
1743 mutex_unlock(&itv->serialize_lock);
1744 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1745 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1746 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1747 schedule();
1748 finish_wait(&itv->event_waitq, &wait);
1749 mutex_lock(&itv->serialize_lock);
1750 if (signal_pending(current)) {
1751
1752 IVTV_DEBUG_INFO("User stopped wait for event\n");
1753 return -EINTR;
1754 }
1755 }
1756 break;
1757 }
1758
1759 case VIDEO_SELECT_SOURCE:
1760 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1761 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1762 return -EINVAL;
1763 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1764
1765 case AUDIO_SET_MUTE:
1766 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1767 itv->speed_mute_audio = iarg;
1768 return 0;
1769
1770 case AUDIO_CHANNEL_SELECT:
1771 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1772 if (iarg > AUDIO_STEREO_SWAPPED)
1773 return -EINVAL;
1774 itv->audio_stereo_mode = iarg;
1775 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1776 return 0;
1777
1778 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1779 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1780 if (iarg > AUDIO_STEREO_SWAPPED)
1781 return -EINVAL;
1782 itv->audio_bilingual_mode = iarg;
1783 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1784 return 0;
1785
1786 default:
1787 return -EINVAL;
1788 }
1789 return 0;
1790}
1791
1792static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1793 int cmd, void *arg)
1794{
1795 struct ivtv *itv = fh2id(fh)->itv;
1796
1797 if (!valid_prio) {
1798 switch (cmd) {
1799 case VIDEO_PLAY:
1800 case VIDEO_STOP:
1801 case VIDEO_FREEZE:
1802 case VIDEO_CONTINUE:
1803 case VIDEO_COMMAND:
1804 case VIDEO_SELECT_SOURCE:
1805 case AUDIO_SET_MUTE:
1806 case AUDIO_CHANNEL_SELECT:
1807 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1808 return -EBUSY;
1809 }
1810 }
1811
1812 switch (cmd) {
1813 case VIDIOC_INT_RESET: {
1814 u32 val = *(u32 *)arg;
1815
1816 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1817 ivtv_reset_ir_gpio(itv);
1818 if (val & 0x02)
1819 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1820 break;
1821 }
1822
1823 case IVTV_IOC_DMA_FRAME:
1824 case VIDEO_GET_PTS:
1825 case VIDEO_GET_FRAME_COUNT:
1826 case VIDEO_GET_EVENT:
1827 case VIDEO_PLAY:
1828 case VIDEO_STOP:
1829 case VIDEO_FREEZE:
1830 case VIDEO_CONTINUE:
1831 case VIDEO_COMMAND:
1832 case VIDEO_TRY_COMMAND:
1833 case VIDEO_SELECT_SOURCE:
1834 case AUDIO_SET_MUTE:
1835 case AUDIO_CHANNEL_SELECT:
1836 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1837 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1838
1839 default:
1840 return -EINVAL;
1841 }
1842 return 0;
1843}
1844
1845static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1846 unsigned int cmd, unsigned long arg)
1847{
1848 struct video_device *vfd = video_devdata(filp);
1849 long ret;
1850
1851 if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1852 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1853 ret = video_ioctl2(filp, cmd, arg);
1854 vfd->debug = 0;
1855 return ret;
1856}
1857
1858long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1859{
1860 struct ivtv_open_id *id = fh2id(filp->private_data);
1861 struct ivtv *itv = id->itv;
1862 long res;
1863
1864
1865 if (cmd == VIDIOC_DQEVENT)
1866 return ivtv_serialized_ioctl(itv, filp, cmd, arg);
1867 mutex_lock(&itv->serialize_lock);
1868 res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1869 mutex_unlock(&itv->serialize_lock);
1870 return res;
1871}
1872
1873static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1874 .vidioc_querycap = ivtv_querycap,
1875 .vidioc_s_audio = ivtv_s_audio,
1876 .vidioc_g_audio = ivtv_g_audio,
1877 .vidioc_enumaudio = ivtv_enumaudio,
1878 .vidioc_s_audout = ivtv_s_audout,
1879 .vidioc_g_audout = ivtv_g_audout,
1880 .vidioc_enum_input = ivtv_enum_input,
1881 .vidioc_enum_output = ivtv_enum_output,
1882 .vidioc_enumaudout = ivtv_enumaudout,
1883 .vidioc_cropcap = ivtv_cropcap,
1884 .vidioc_s_crop = ivtv_s_crop,
1885 .vidioc_g_crop = ivtv_g_crop,
1886 .vidioc_g_input = ivtv_g_input,
1887 .vidioc_s_input = ivtv_s_input,
1888 .vidioc_g_output = ivtv_g_output,
1889 .vidioc_s_output = ivtv_s_output,
1890 .vidioc_g_frequency = ivtv_g_frequency,
1891 .vidioc_s_frequency = ivtv_s_frequency,
1892 .vidioc_s_tuner = ivtv_s_tuner,
1893 .vidioc_g_tuner = ivtv_g_tuner,
1894 .vidioc_g_enc_index = ivtv_g_enc_index,
1895 .vidioc_g_fbuf = ivtv_g_fbuf,
1896 .vidioc_s_fbuf = ivtv_s_fbuf,
1897 .vidioc_g_std = ivtv_g_std,
1898 .vidioc_s_std = ivtv_s_std,
1899 .vidioc_overlay = ivtv_overlay,
1900 .vidioc_log_status = ivtv_log_status,
1901 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1902 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1903 .vidioc_try_encoder_cmd = ivtv_try_encoder_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 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1925#ifdef CONFIG_VIDEO_ADV_DEBUG
1926 .vidioc_g_register = ivtv_g_register,
1927 .vidioc_s_register = ivtv_s_register,
1928#endif
1929 .vidioc_default = ivtv_default,
1930 .vidioc_subscribe_event = ivtv_subscribe_event,
1931 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1932};
1933
1934void ivtv_set_funcs(struct video_device *vdev)
1935{
1936 vdev->ioctl_ops = &ivtv_ioctl_ops;
1937}
1938
