?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (6715): ivtv: Remove unnecessary register update
[linux-2.6/verdex.git] / drivers / media / video / ivtv / ivtv-ioctl.c
blobfd6826f472e3c99ac50029602e0e38ffc136aba7
1 /*
2 ioctl system call
3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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 <linux/dvb/audio.h>
39 #include <linux/i2c-id.h>
40
41 u16 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
57 static 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
63 static 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
91 void 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
104 static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
105 {
106 int f, l;
107 u16 set = 0;
108
109 for (f = 0; f < 2; f++) {
110 for (l = 0; l < 24; l++) {
111 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
112 set |= fmt->service_lines[f][l];
113 }
114 }
115 return set != 0;
116 }
117
118 u16 get_service_set(struct v4l2_sliced_vbi_format *fmt)
119 {
120 int f, l;
121 u16 set = 0;
122
123 for (f = 0; f < 2; f++) {
124 for (l = 0; l < 24; l++) {
125 set |= fmt->service_lines[f][l];
126 }
127 }
128 return set;
129 }
130
131 static const struct {
132 v4l2_std_id std;
133 char *name;
134 } enum_stds[] = {
135 { V4L2_STD_PAL_BG | V4L2_STD_PAL_H, "PAL-BGH" },
136 { V4L2_STD_PAL_DK, "PAL-DK" },
137 { V4L2_STD_PAL_I, "PAL-I" },
138 { V4L2_STD_PAL_M, "PAL-M" },
139 { V4L2_STD_PAL_N, "PAL-N" },
140 { V4L2_STD_PAL_Nc, "PAL-Nc" },
141 { V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H, "SECAM-BGH" },
142 { V4L2_STD_SECAM_DK, "SECAM-DK" },
143 { V4L2_STD_SECAM_L, "SECAM-L" },
144 { V4L2_STD_SECAM_LC, "SECAM-L'" },
145 { V4L2_STD_NTSC_M, "NTSC-M" },
146 { V4L2_STD_NTSC_M_JP, "NTSC-J" },
147 { V4L2_STD_NTSC_M_KR, "NTSC-K" },
148 };
149
150 static const struct v4l2_standard ivtv_std_60hz =
151 {
152 .frameperiod = {.numerator = 1001, .denominator = 30000},
153 .framelines = 525,
154 };
155
156 static const struct v4l2_standard ivtv_std_50hz =
157 {
158 .frameperiod = {.numerator = 1, .denominator = 25},
159 .framelines = 625,
160 };
161
162 void ivtv_set_osd_alpha(struct ivtv *itv)
163 {
164 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
165 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
166 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
167 }
168
169 int ivtv_set_speed(struct ivtv *itv, int speed)
170 {
171 u32 data[CX2341X_MBOX_MAX_DATA];
172 struct ivtv_stream *s;
173 int single_step = (speed == 1 || speed == -1);
174 DEFINE_WAIT(wait);
175
176 if (speed == 0) speed = 1000;
177
178 /* No change? */
179 if (speed == itv->speed && !single_step)
180 return 0;
181
182 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
183
184 if (single_step && (speed < 0) == (itv->speed < 0)) {
185 /* Single step video and no need to change direction */
186 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
187 itv->speed = speed;
188 return 0;
189 }
190 if (single_step)
191 /* Need to change direction */
192 speed = speed < 0 ? -1000 : 1000;
193
194 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
195 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
196 data[1] = (speed < 0);
197 data[2] = speed < 0 ? 3 : 7;
198 data[3] = itv->params.video_b_frames;
199 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
200 data[5] = 0;
201 data[6] = 0;
202
203 if (speed == 1500 || speed == -1500) data[0] |= 1;
204 else if (speed == 2000 || speed == -2000) data[0] |= 2;
205 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
206 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
207
208 /* If not decoding, just change speed setting */
209 if (atomic_read(&itv->decoding) > 0) {
210 int got_sig = 0;
211
212 /* Stop all DMA and decoding activity */
213 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
214
215 /* Wait for any DMA to finish */
216 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
217 while (itv->i_flags & IVTV_F_I_DMA) {
218 got_sig = signal_pending(current);
219 if (got_sig)
220 break;
221 got_sig = 0;
222 schedule();
223 }
224 finish_wait(&itv->dma_waitq, &wait);
225 if (got_sig)
226 return -EINTR;
227
228 /* Change Speed safely */
229 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
230 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
231 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
232 }
233 if (single_step) {
234 speed = (speed < 0) ? -1 : 1;
235 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
236 }
237 itv->speed = speed;
238 return 0;
239 }
240
241 static int ivtv_validate_speed(int cur_speed, int new_speed)
242 {
243 int fact = new_speed < 0 ? -1 : 1;
244 int s;
245
246 if (new_speed < 0) new_speed = -new_speed;
247 if (cur_speed < 0) cur_speed = -cur_speed;
248
249 if (cur_speed <= new_speed) {
250 if (new_speed > 1500) return fact * 2000;
251 if (new_speed > 1000) return fact * 1500;
252 }
253 else {
254 if (new_speed >= 2000) return fact * 2000;
255 if (new_speed >= 1500) return fact * 1500;
256 if (new_speed >= 1000) return fact * 1000;
257 }
258 if (new_speed == 0) return 1000;
259 if (new_speed == 1 || new_speed == 1000) return fact * new_speed;
260
261 s = new_speed;
262 new_speed = 1000 / new_speed;
263 if (1000 / cur_speed == new_speed)
264 new_speed += (cur_speed < s) ? -1 : 1;
265 if (new_speed > 60) return 1000 / (fact * 60);
266 return 1000 / (fact * new_speed);
267 }
268
269 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
270 struct video_command *vc, int try)
271 {
272 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
273
274 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
275 return -EINVAL;
276
277 switch (vc->cmd) {
278 case VIDEO_CMD_PLAY: {
279 vc->flags = 0;
280 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
281 if (vc->play.speed < 0)
282 vc->play.format = VIDEO_PLAY_FMT_GOP;
283 if (try) break;
284
285 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
286 return -EBUSY;
287 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
288 /* forces ivtv_set_speed to be called */
289 itv->speed = 0;
290 }
291 return ivtv_start_decoding(id, vc->play.speed);
292 }
293
294 case VIDEO_CMD_STOP:
295 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
296 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
297 vc->stop.pts = 0;
298 if (try) break;
299 if (atomic_read(&itv->decoding) == 0)
300 return 0;
301 if (itv->output_mode != OUT_MPG)
302 return -EBUSY;
303
304 itv->output_mode = OUT_NONE;
305 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
306
307 case VIDEO_CMD_FREEZE:
308 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
309 if (try) break;
310 if (itv->output_mode != OUT_MPG)
311 return -EBUSY;
312 if (atomic_read(&itv->decoding) > 0) {
313 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
314 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
315 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
316 }
317 break;
318
319 case VIDEO_CMD_CONTINUE:
320 vc->flags = 0;
321 if (try) break;
322 if (itv->output_mode != OUT_MPG)
323 return -EBUSY;
324 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
325 int speed = itv->speed;
326 itv->speed = 0;
327 return ivtv_start_decoding(id, speed);
328 }
329 break;
330
331 default:
332 return -EINVAL;
333 }
334 return 0;
335 }
336
337 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
338 {
339 struct v4l2_register *regs = arg;
340 unsigned long flags;
341 volatile u8 __iomem *reg_start;
342
343 if (!capable(CAP_SYS_ADMIN))
344 return -EPERM;
345 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
346 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
347 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
348 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
349 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
350 else if (regs->reg >= 0 && regs->reg < IVTV_ENCODER_SIZE)
351 reg_start = itv->enc_mem;
352 else
353 return -EINVAL;
354
355 spin_lock_irqsave(&ivtv_cards_lock, flags);
356 if (cmd == VIDIOC_DBG_G_REGISTER) {
357 regs->val = readl(regs->reg + reg_start);
358 } else {
359 writel(regs->val, regs->reg + reg_start);
360 }
361 spin_unlock_irqrestore(&ivtv_cards_lock, flags);
362 return 0;
363 }
364
365 static int ivtv_get_fmt(struct ivtv *itv, int streamtype, struct v4l2_format *fmt)
366 {
367 switch (fmt->type) {
368 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
369 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
370 return -EINVAL;
371 fmt->fmt.pix.width = itv->main_rect.width;
372 fmt->fmt.pix.height = itv->main_rect.height;
373 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
374 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
375 if (itv->output_mode == OUT_UDMA_YUV) {
376 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
377 case IVTV_YUV_MODE_INTERLACED:
378 fmt->fmt.pix.field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
379 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
380 break;
381 case IVTV_YUV_MODE_PROGRESSIVE:
382 fmt->fmt.pix.field = V4L2_FIELD_NONE;
383 break;
384 default:
385 fmt->fmt.pix.field = V4L2_FIELD_ANY;
386 break;
387 }
388 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
389 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
390 fmt->fmt.pix.sizeimage =
391 fmt->fmt.pix.height * fmt->fmt.pix.width +
392 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
393 }
394 else if (itv->output_mode == OUT_YUV ||
395 streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
396 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
397 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
398 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
399 fmt->fmt.pix.sizeimage =
400 fmt->fmt.pix.height * fmt->fmt.pix.width +
401 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
402 } else {
403 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
404 fmt->fmt.pix.sizeimage = 128 * 1024;
405 }
406 break;
407
408 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
409 fmt->fmt.pix.width = itv->params.width;
410 fmt->fmt.pix.height = itv->params.height;
411 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
412 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
413 if (streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
414 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
415 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
416 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
417 fmt->fmt.pix.sizeimage =
418 fmt->fmt.pix.height * fmt->fmt.pix.width +
419 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
420 } else {
421 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
422 fmt->fmt.pix.sizeimage = 128 * 1024;
423 }
424 break;
425
426 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
427 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
428 return -EINVAL;
429 fmt->fmt.win.chromakey = itv->osd_chroma_key;
430 fmt->fmt.win.global_alpha = itv->osd_global_alpha;
431 break;
432
433 case V4L2_BUF_TYPE_VBI_CAPTURE:
434 fmt->fmt.vbi.sampling_rate = 27000000;
435 fmt->fmt.vbi.offset = 248;
436 fmt->fmt.vbi.samples_per_line = itv->vbi.raw_decoder_line_size - 4;
437 fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
438 fmt->fmt.vbi.start[0] = itv->vbi.start[0];
439 fmt->fmt.vbi.start[1] = itv->vbi.start[1];
440 fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = itv->vbi.count;
441 break;
442
443 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
444 {
445 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
446
447 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
448 return -EINVAL;
449 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
450 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
451 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
452 if (itv->is_60hz) {
453 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
454 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
455 } else {
456 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
457 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
458 }
459 vbifmt->service_set = get_service_set(vbifmt);
460 break;
461 }
462
463 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
464 {
465 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
466
467 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
468 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
469 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
470
471 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
472 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
473 V4L2_SLICED_VBI_525;
474 expand_service_set(vbifmt, itv->is_50hz);
475 break;
476 }
477
478 itv->video_dec_func(itv, VIDIOC_G_FMT, fmt);
479 vbifmt->service_set = get_service_set(vbifmt);
480 break;
481 }
482 case V4L2_BUF_TYPE_VBI_OUTPUT:
483 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
484 default:
485 return -EINVAL;
486 }
487 return 0;
488 }
489
490 static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
491 struct v4l2_format *fmt, int set_fmt)
492 {
493 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
494 u16 set;
495
496 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
497 struct v4l2_rect r;
498 int field;
499
500 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
501 return -EINVAL;
502 field = fmt->fmt.pix.field;
503 r.top = 0;
504 r.left = 0;
505 r.width = fmt->fmt.pix.width;
506 r.height = fmt->fmt.pix.height;
507 ivtv_get_fmt(itv, streamtype, fmt);
508 if (itv->output_mode != OUT_UDMA_YUV) {
509 /* TODO: would setting the rect also be valid for this mode? */
510 fmt->fmt.pix.width = r.width;
511 fmt->fmt.pix.height = r.height;
512 }
513 if (itv->output_mode == OUT_UDMA_YUV) {
514 /* TODO: add checks for validity */
515 fmt->fmt.pix.field = field;
516 }
517 if (set_fmt) {
518 if (itv->output_mode == OUT_UDMA_YUV) {
519 switch (field) {
520 case V4L2_FIELD_NONE:
521 itv->yuv_info.lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
522 break;
523 case V4L2_FIELD_ANY:
524 itv->yuv_info.lace_mode = IVTV_YUV_MODE_AUTO;
525 break;
526 case V4L2_FIELD_INTERLACED_BT:
527 itv->yuv_info.lace_mode =
528 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
529 break;
530 case V4L2_FIELD_INTERLACED_TB:
531 default:
532 itv->yuv_info.lace_mode = IVTV_YUV_MODE_INTERLACED;
533 break;
534 }
535 itv->yuv_info.lace_sync_field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
536
537 /* Force update of yuv registers */
538 itv->yuv_info.yuv_forced_update = 1;
539 return 0;
540 }
541 }
542 return 0;
543 }
544
545 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY) {
546 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
547 return -EINVAL;
548 if (set_fmt) {
549 itv->osd_chroma_key = fmt->fmt.win.chromakey;
550 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
551 ivtv_set_osd_alpha(itv);
552 }
553 return 0;
554 }
555
556 /* set window size */
557 if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
558 struct cx2341x_mpeg_params *p = &itv->params;
559 int w = fmt->fmt.pix.width;
560 int h = fmt->fmt.pix.height;
561
562 if (w > 720) w = 720;
563 else if (w < 1) w = 1;
564 if (h > (itv->is_50hz ? 576 : 480)) h = (itv->is_50hz ? 576 : 480);
565 else if (h < 2) h = 2;
566 ivtv_get_fmt(itv, streamtype, fmt);
567 fmt->fmt.pix.width = w;
568 fmt->fmt.pix.height = h;
569
570 if (!set_fmt || (p->width == w && p->height == h))
571 return 0;
572 if (atomic_read(&itv->capturing) > 0)
573 return -EBUSY;
574
575 p->width = w;
576 p->height = h;
577 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
578 p->video_temporal_filter = 0;
579 else
580 p->video_temporal_filter = 8;
581 if (p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
582 fmt->fmt.pix.width /= 2;
583 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
584 return ivtv_get_fmt(itv, streamtype, fmt);
585 }
586
587 /* set raw VBI format */
588 if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
589 if (set_fmt && atomic_read(&itv->capturing) > 0) {
590 return -EBUSY;
591 }
592 if (set_fmt) {
593 itv->vbi.sliced_in->service_set = 0;
594 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
595 }
596 return ivtv_get_fmt(itv, streamtype, fmt);
597 }
598
599 /* set sliced VBI output
600 In principle the user could request that only certain
601 VBI types are output and that the others are ignored.
602 I.e., suppress CC in the even fields or only output
603 WSS and no VPS. Currently though there is no choice. */
604 if (fmt->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
605 return ivtv_get_fmt(itv, streamtype, fmt);
606
607 /* any else but sliced VBI capture is an error */
608 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
609 return -EINVAL;
610
611 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI)
612 return ivtv_get_fmt(itv, streamtype, fmt);
613
614 /* set sliced VBI capture format */
615 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
616 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
617
618 if (vbifmt->service_set)
619 expand_service_set(vbifmt, itv->is_50hz);
620 set = check_service_set(vbifmt, itv->is_50hz);
621 vbifmt->service_set = get_service_set(vbifmt);
622
623 if (!set_fmt)
624 return 0;
625 if (set == 0)
626 return -EINVAL;
627 if (atomic_read(&itv->capturing) > 0) {
628 return -EBUSY;
629 }
630 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
631 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
632 return 0;
633 }
634
635 static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
636 {
637 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
638 struct ivtv *itv = id->itv;
639 struct v4l2_register *reg = arg;
640
641 switch (cmd) {
642 /* ioctls to allow direct access to the encoder registers for testing */
643 case VIDIOC_DBG_G_REGISTER:
644 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
645 return ivtv_itvc(itv, cmd, arg);
646 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
647 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
648 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
649
650 case VIDIOC_DBG_S_REGISTER:
651 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
652 return ivtv_itvc(itv, cmd, arg);
653 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
654 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
655 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
656
657 case VIDIOC_G_CHIP_IDENT: {
658 struct v4l2_chip_ident *chip = arg;
659
660 chip->ident = V4L2_IDENT_NONE;
661 chip->revision = 0;
662 if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
663 if (v4l2_chip_match_host(reg->match_type, reg->match_chip)) {
664 struct v4l2_chip_ident *chip = arg;
665
666 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
667 }
668 return 0;
669 }
670 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
671 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
672 if (reg->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
673 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
674 return -EINVAL;
675 }
676
677 case VIDIOC_INT_S_AUDIO_ROUTING: {
678 struct v4l2_routing *route = arg;
679
680 ivtv_i2c_hw(itv, itv->card->hw_audio, VIDIOC_INT_S_AUDIO_ROUTING, route);
681 break;
682 }
683
684 case VIDIOC_INT_RESET: {
685 u32 val = *(u32 *)arg;
686
687 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) {
688 ivtv_reset_ir_gpio(itv);
689 }
690 if (val & 0x02) {
691 itv->video_dec_func(itv, cmd, 0);
692 }
693 break;
694 }
695
696 default:
697 return -EINVAL;
698 }
699 return 0;
700 }
701
702 int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
703 {
704 struct ivtv_open_id *id = NULL;
705 u32 data[CX2341X_MBOX_MAX_DATA];
706
707 if (filp) id = (struct ivtv_open_id *)filp->private_data;
708
709 switch (cmd) {
710 case VIDIOC_G_PRIORITY:
711 {
712 enum v4l2_priority *p = arg;
713
714 *p = v4l2_prio_max(&itv->prio);
715 break;
716 }
717
718 case VIDIOC_S_PRIORITY:
719 {
720 enum v4l2_priority *prio = arg;
721
722 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
723 }
724
725 case VIDIOC_QUERYCAP:{
726 struct v4l2_capability *vcap = arg;
727
728 memset(vcap, 0, sizeof(*vcap));
729 strcpy(vcap->driver, IVTV_DRIVER_NAME); /* driver name */
730 strcpy(vcap->card, itv->card_name); /* card type */
731 strcpy(vcap->bus_info, pci_name(itv->dev)); /* bus info... */
732 vcap->version = IVTV_DRIVER_VERSION; /* version */
733 vcap->capabilities = itv->v4l2_cap; /* capabilities */
734
735 /* reserved.. must set to 0! */
736 vcap->reserved[0] = vcap->reserved[1] =
737 vcap->reserved[2] = vcap->reserved[3] = 0;
738 break;
739 }
740
741 case VIDIOC_ENUMAUDIO:{
742 struct v4l2_audio *vin = arg;
743
744 return ivtv_get_audio_input(itv, vin->index, vin);
745 }
746
747 case VIDIOC_G_AUDIO:{
748 struct v4l2_audio *vin = arg;
749
750 vin->index = itv->audio_input;
751 return ivtv_get_audio_input(itv, vin->index, vin);
752 }
753
754 case VIDIOC_S_AUDIO:{
755 struct v4l2_audio *vout = arg;
756
757 if (vout->index >= itv->nof_audio_inputs)
758 return -EINVAL;
759 itv->audio_input = vout->index;
760 ivtv_audio_set_io(itv);
761 break;
762 }
763
764 case VIDIOC_ENUMAUDOUT:{
765 struct v4l2_audioout *vin = arg;
766
767 /* set it to defaults from our table */
768 return ivtv_get_audio_output(itv, vin->index, vin);
769 }
770
771 case VIDIOC_G_AUDOUT:{
772 struct v4l2_audioout *vin = arg;
773
774 vin->index = 0;
775 return ivtv_get_audio_output(itv, vin->index, vin);
776 }
777
778 case VIDIOC_S_AUDOUT:{
779 struct v4l2_audioout *vout = arg;
780
781 return ivtv_get_audio_output(itv, vout->index, vout);
782 }
783
784 case VIDIOC_ENUMINPUT:{
785 struct v4l2_input *vin = arg;
786
787 /* set it to defaults from our table */
788 return ivtv_get_input(itv, vin->index, vin);
789 }
790
791 case VIDIOC_ENUMOUTPUT:{
792 struct v4l2_output *vout = arg;
793
794 return ivtv_get_output(itv, vout->index, vout);
795 }
796
797 case VIDIOC_TRY_FMT:
798 case VIDIOC_S_FMT: {
799 struct v4l2_format *fmt = arg;
800
801 return ivtv_try_or_set_fmt(itv, id->type, fmt, cmd == VIDIOC_S_FMT);
802 }
803
804 case VIDIOC_G_FMT: {
805 struct v4l2_format *fmt = arg;
806 int type = fmt->type;
807
808 memset(fmt, 0, sizeof(*fmt));
809 fmt->type = type;
810 return ivtv_get_fmt(itv, id->type, fmt);
811 }
812
813 case VIDIOC_CROPCAP: {
814 struct v4l2_cropcap *cropcap = arg;
815
816 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
817 cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
818 return -EINVAL;
819 cropcap->bounds.top = cropcap->bounds.left = 0;
820 cropcap->bounds.width = 720;
821 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
822 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
823 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
824 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
825 } else {
826 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
827 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
828 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
829 }
830 cropcap->defrect = cropcap->bounds;
831 return 0;
832 }
833
834 case VIDIOC_S_CROP: {
835 struct v4l2_crop *crop = arg;
836
837 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
838 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
839 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
840 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
841 itv->main_rect = crop->c;
842 return 0;
843 }
844 return -EINVAL;
845 }
846 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
847 return -EINVAL;
848 return itv->video_dec_func(itv, VIDIOC_S_CROP, arg);
849 }
850
851 case VIDIOC_G_CROP: {
852 struct v4l2_crop *crop = arg;
853
854 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
855 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
856 crop->c = itv->main_rect;
857 return 0;
858 }
859 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
860 return -EINVAL;
861 return itv->video_dec_func(itv, VIDIOC_G_CROP, arg);
862 }
863
864 case VIDIOC_ENUM_FMT: {
865 static struct v4l2_fmtdesc formats[] = {
866 { 0, 0, 0,
867 "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12,
868 { 0, 0, 0, 0 }
869 },
870 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
871 "MPEG", V4L2_PIX_FMT_MPEG,
872 { 0, 0, 0, 0 }
873 }
874 };
875 struct v4l2_fmtdesc *fmt = arg;
876 enum v4l2_buf_type type = fmt->type;
877
878 switch (type) {
879 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
880 break;
881 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
882 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
883 return -EINVAL;
884 break;
885 default:
886 return -EINVAL;
887 }
888 if (fmt->index > 1)
889 return -EINVAL;
890 *fmt = formats[fmt->index];
891 fmt->type = type;
892 return 0;
893 }
894
895 case VIDIOC_G_INPUT:{
896 *(int *)arg = itv->active_input;
897 break;
898 }
899
900 case VIDIOC_S_INPUT:{
901 int inp = *(int *)arg;
902
903 if (inp < 0 || inp >= itv->nof_inputs)
904 return -EINVAL;
905
906 if (inp == itv->active_input) {
907 IVTV_DEBUG_INFO("Input unchanged\n");
908 break;
909 }
910 if (atomic_read(&itv->capturing) > 0) {
911 return -EBUSY;
912 }
913 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
914 itv->active_input, inp);
915
916 itv->active_input = inp;
917 /* Set the audio input to whatever is appropriate for the
918 input type. */
919 itv->audio_input = itv->card->video_inputs[inp].audio_index;
920
921 /* prevent others from messing with the streams until
922 we're finished changing inputs. */
923 ivtv_mute(itv);
924 ivtv_video_set_io(itv);
925 ivtv_audio_set_io(itv);
926 ivtv_unmute(itv);
927 break;
928 }
929
930 case VIDIOC_G_OUTPUT:{
931 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
932 return -EINVAL;
933 *(int *)arg = itv->active_output;
934 break;
935 }
936
937 case VIDIOC_S_OUTPUT:{
938 int outp = *(int *)arg;
939 struct v4l2_routing route;
940
941 if (outp >= itv->card->nof_outputs)
942 return -EINVAL;
943
944 if (outp == itv->active_output) {
945 IVTV_DEBUG_INFO("Output unchanged\n");
946 break;
947 }
948 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
949 itv->active_output, outp);
950
951 itv->active_output = outp;
952 route.input = SAA7127_INPUT_TYPE_NORMAL;
953 route.output = itv->card->video_outputs[outp].video_output;
954 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
955 break;
956 }
957
958 case VIDIOC_G_FREQUENCY:{
959 struct v4l2_frequency *vf = arg;
960
961 if (vf->tuner != 0)
962 return -EINVAL;
963 ivtv_call_i2c_clients(itv, cmd, arg);
964 break;
965 }
966
967 case VIDIOC_S_FREQUENCY:{
968 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
969
970 if (vf.tuner != 0)
971 return -EINVAL;
972
973 ivtv_mute(itv);
974 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
975 ivtv_call_i2c_clients(itv, cmd, &vf);
976 ivtv_unmute(itv);
977 break;
978 }
979
980 case VIDIOC_ENUMSTD:{
981 struct v4l2_standard *vs = arg;
982 int idx = vs->index;
983
984 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
985 return -EINVAL;
986
987 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
988 ivtv_std_60hz : ivtv_std_50hz;
989 vs->index = idx;
990 vs->id = enum_stds[idx].std;
991 strcpy(vs->name, enum_stds[idx].name);
992 break;
993 }
994
995 case VIDIOC_G_STD:{
996 *(v4l2_std_id *) arg = itv->std;
997 break;
998 }
999
1000 case VIDIOC_S_STD: {
1001 v4l2_std_id std = *(v4l2_std_id *) arg;
1002
1003 if ((std & V4L2_STD_ALL) == 0)
1004 return -EINVAL;
1005
1006 if (std == itv->std)
1007 break;
1008
1009 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1010 atomic_read(&itv->capturing) > 0 ||
1011 atomic_read(&itv->decoding) > 0) {
1012 /* Switching standard would turn off the radio or mess
1013 with already running streams, prevent that by
1014 returning EBUSY. */
1015 return -EBUSY;
1016 }
1017
1018 itv->std = std;
1019 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1020 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1021 itv->params.width = 720;
1022 itv->params.height = itv->is_50hz ? 576 : 480;
1023 itv->vbi.count = itv->is_50hz ? 18 : 12;
1024 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1025 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1026 if (itv->hw_flags & IVTV_HW_CX25840) {
1027 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1028 }
1029 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1030
1031 /* Tuner */
1032 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1033
1034 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1035 /* set display standard */
1036 itv->std_out = std;
1037 itv->is_out_60hz = itv->is_60hz;
1038 itv->is_out_50hz = itv->is_50hz;
1039 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1040 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1041 itv->main_rect.left = itv->main_rect.top = 0;
1042 itv->main_rect.width = 720;
1043 itv->main_rect.height = itv->params.height;
1044 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1045 720, itv->main_rect.height, 0, 0);
1046 }
1047 break;
1048 }
1049
1050 case VIDIOC_S_TUNER: { /* Setting tuner can only set audio mode */
1051 struct v4l2_tuner *vt = arg;
1052
1053 if (vt->index != 0)
1054 return -EINVAL;
1055
1056 ivtv_call_i2c_clients(itv, VIDIOC_S_TUNER, vt);
1057 break;
1058 }
1059
1060 case VIDIOC_G_TUNER: {
1061 struct v4l2_tuner *vt = arg;
1062
1063 if (vt->index != 0)
1064 return -EINVAL;
1065
1066 memset(vt, 0, sizeof(*vt));
1067 ivtv_call_i2c_clients(itv, VIDIOC_G_TUNER, vt);
1068
1069 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1070 strcpy(vt->name, "ivtv Radio Tuner");
1071 vt->type = V4L2_TUNER_RADIO;
1072 } else {
1073 strcpy(vt->name, "ivtv TV Tuner");
1074 vt->type = V4L2_TUNER_ANALOG_TV;
1075 }
1076 break;
1077 }
1078
1079 case VIDIOC_G_SLICED_VBI_CAP: {
1080 struct v4l2_sliced_vbi_cap *cap = arg;
1081 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1082 int f, l;
1083 enum v4l2_buf_type type = cap->type;
1084
1085 memset(cap, 0, sizeof(*cap));
1086 cap->type = type;
1087 if (type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1088 for (f = 0; f < 2; f++) {
1089 for (l = 0; l < 24; l++) {
1090 if (valid_service_line(f, l, itv->is_50hz)) {
1091 cap->service_lines[f][l] = set;
1092 }
1093 }
1094 }
1095 return 0;
1096 }
1097 if (type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1098 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1099 return -EINVAL;
1100 if (itv->is_60hz) {
1101 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1102 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1103 } else {
1104 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1105 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1106 }
1107 return 0;
1108 }
1109 return -EINVAL;
1110 }
1111
1112 case VIDIOC_G_ENC_INDEX: {
1113 struct v4l2_enc_idx *idx = arg;
1114 struct v4l2_enc_idx_entry *e = idx->entry;
1115 int entries;
1116 int i;
1117
1118 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1119 IVTV_MAX_PGM_INDEX;
1120 if (entries > V4L2_ENC_IDX_ENTRIES)
1121 entries = V4L2_ENC_IDX_ENTRIES;
1122 idx->entries = 0;
1123 for (i = 0; i < entries; i++) {
1124 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1125 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1126 idx->entries++;
1127 e++;
1128 }
1129 }
1130 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1131 break;
1132 }
1133
1134 case VIDIOC_ENCODER_CMD:
1135 case VIDIOC_TRY_ENCODER_CMD: {
1136 struct v4l2_encoder_cmd *enc = arg;
1137 int try = cmd == VIDIOC_TRY_ENCODER_CMD;
1138
1139 memset(&enc->raw, 0, sizeof(enc->raw));
1140 switch (enc->cmd) {
1141 case V4L2_ENC_CMD_START:
1142 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1143 enc->flags = 0;
1144 if (try)
1145 return 0;
1146 return ivtv_start_capture(id);
1147
1148 case V4L2_ENC_CMD_STOP:
1149 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1150 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1151 if (try)
1152 return 0;
1153 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1154 return 0;
1155
1156 case V4L2_ENC_CMD_PAUSE:
1157 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1158 enc->flags = 0;
1159 if (try)
1160 return 0;
1161 if (!atomic_read(&itv->capturing))
1162 return -EPERM;
1163 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1164 return 0;
1165 ivtv_mute(itv);
1166 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1167 break;
1168
1169 case V4L2_ENC_CMD_RESUME:
1170 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1171 enc->flags = 0;
1172 if (try)
1173 return 0;
1174 if (!atomic_read(&itv->capturing))
1175 return -EPERM;
1176 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1177 return 0;
1178 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1179 ivtv_unmute(itv);
1180 break;
1181 default:
1182 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1183 return -EINVAL;
1184 }
1185 break;
1186 }
1187
1188 case VIDIOC_G_FBUF: {
1189 struct v4l2_framebuffer *fb = arg;
1190 int pixfmt;
1191 static u32 pixel_format[16] = {
1192 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1193 V4L2_PIX_FMT_RGB565,
1194 V4L2_PIX_FMT_RGB555,
1195 V4L2_PIX_FMT_RGB444,
1196 V4L2_PIX_FMT_RGB32,
1197 0,
1198 0,
1199 0,
1200 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1201 V4L2_PIX_FMT_YUV565,
1202 V4L2_PIX_FMT_YUV555,
1203 V4L2_PIX_FMT_YUV444,
1204 V4L2_PIX_FMT_YUV32,
1205 0,
1206 0,
1207 0,
1208 };
1209
1210 memset(fb, 0, sizeof(*fb));
1211 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1212 return -EINVAL;
1213 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1214 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1215 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1216 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1217 pixfmt = (data[0] >> 3) & 0xf;
1218 fb->fmt.pixelformat = pixel_format[pixfmt];
1219 fb->fmt.width = itv->osd_rect.width;
1220 fb->fmt.height = itv->osd_rect.height;
1221 fb->base = (void *)itv->osd_video_pbase;
1222 if (itv->osd_chroma_key_state)
1223 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1224 if (itv->osd_global_alpha_state)
1225 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1226 pixfmt &= 7;
1227 /* no local alpha for RGB565 or unknown formats */
1228 if (pixfmt == 1 || pixfmt > 4)
1229 break;
1230 /* 16-bit formats have inverted local alpha */
1231 if (pixfmt == 2 || pixfmt == 3)
1232 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1233 else
1234 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1235 if (itv->osd_local_alpha_state) {
1236 /* 16-bit formats have inverted local alpha */
1237 if (pixfmt == 2 || pixfmt == 3)
1238 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1239 else
1240 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1241 }
1242 break;
1243 }
1244
1245 case VIDIOC_S_FBUF: {
1246 struct v4l2_framebuffer *fb = arg;
1247
1248 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1249 return -EINVAL;
1250 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1251 itv->osd_local_alpha_state =
1252 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1253 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1254 ivtv_set_osd_alpha(itv);
1255 break;
1256 }
1257
1258 case VIDIOC_OVERLAY: {
1259 int *on = arg;
1260
1261 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1262 return -EINVAL;
1263 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1264 break;
1265 }
1266
1267 case VIDIOC_LOG_STATUS:
1268 {
1269 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1270 struct v4l2_input vidin;
1271 struct v4l2_audio audin;
1272 int i;
1273
1274 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv->num);
1275 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1276 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1277 struct tveeprom tv;
1278
1279 ivtv_read_eeprom(itv, &tv);
1280 }
1281 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1282 ivtv_get_input(itv, itv->active_input, &vidin);
1283 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1284 IVTV_INFO("Video Input: %s\n", vidin.name);
1285 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1286 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1287 if (has_output) {
1288 struct v4l2_output vidout;
1289 struct v4l2_audioout audout;
1290 int mode = itv->output_mode;
1291 static const char * const output_modes[5] = {
1292 "None",
1293 "MPEG Streaming",
1294 "YUV Streaming",
1295 "YUV Frames",
1296 "Passthrough",
1297 };
1298 static const char * const audio_modes[5] = {
1299 "Stereo",
1300 "Left",
1301 "Right",
1302 "Mono",
1303 "Swapped"
1304 };
1305 static const char * const alpha_mode[4] = {
1306 "None",
1307 "Global",
1308 "Local",
1309 "Global and Local"
1310 };
1311 static const char * const pixel_format[16] = {
1312 "ARGB Indexed",
1313 "RGB 5:6:5",
1314 "ARGB 1:5:5:5",
1315 "ARGB 1:4:4:4",
1316 "ARGB 8:8:8:8",
1317 "5",
1318 "6",
1319 "7",
1320 "AYUV Indexed",
1321 "YUV 5:6:5",
1322 "AYUV 1:5:5:5",
1323 "AYUV 1:4:4:4",
1324 "AYUV 8:8:8:8",
1325 "13",
1326 "14",
1327 "15",
1328 };
1329
1330 ivtv_get_output(itv, itv->active_output, &vidout);
1331 ivtv_get_audio_output(itv, 0, &audout);
1332 IVTV_INFO("Video Output: %s\n", vidout.name);
1333 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1334 audio_modes[itv->audio_stereo_mode],
1335 audio_modes[itv->audio_bilingual_mode]);
1336 if (mode < 0 || mode > OUT_PASSTHROUGH)
1337 mode = OUT_NONE;
1338 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1339 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1340 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1341 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1342 data[0] & 1 ? "On" : "Off",
1343 alpha_mode[(data[0] >> 1) & 0x3],
1344 pixel_format[(data[0] >> 3) & 0xf]);
1345 }
1346 IVTV_INFO("Tuner: %s\n",
1347 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1348 cx2341x_log_status(&itv->params, itv->name);
1349 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1350 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1351 struct ivtv_stream *s = &itv->streams[i];
1352
1353 if (s->v4l2dev == NULL || s->buffers == 0)
1354 continue;
1355 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1356 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1357 (s->buffers * s->buf_size) / 1024, s->buffers);
1358 }
1359 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1360 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv->num);
1361 break;
1362 }
1363
1364 default:
1365 return -EINVAL;
1366 }
1367 return 0;
1368 }
1369
1370 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1371 {
1372 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1373 struct ivtv *itv = id->itv;
1374 int nonblocking = filp->f_flags & O_NONBLOCK;
1375 struct ivtv_stream *s = &itv->streams[id->type];
1376
1377 switch (cmd) {
1378 case IVTV_IOC_DMA_FRAME: {
1379 struct ivtv_dma_frame *args = arg;
1380
1381 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1382 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1383 return -EINVAL;
1384 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1385 return -EINVAL;
1386 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1387 return 0;
1388 if (ivtv_claim_stream(id, id->type)) {
1389 return -EBUSY;
1390 }
1391 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1392 ivtv_release_stream(s);
1393 return -EBUSY;
1394 }
1395 /* Mark that this file handle started the UDMA_YUV mode */
1396 id->yuv_frames = 1;
1397 if (args->y_source == NULL)
1398 return 0;
1399 return ivtv_yuv_prep_frame(itv, args);
1400 }
1401
1402 case VIDEO_GET_PTS: {
1403 u32 data[CX2341X_MBOX_MAX_DATA];
1404 u64 *pts = arg;
1405
1406 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1407 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1408 *pts = s->dma_pts;
1409 break;
1410 }
1411 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1412 return -EINVAL;
1413
1414 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1415 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1416 (u64)itv->last_dec_timing[1];
1417 break;
1418 }
1419 *pts = 0;
1420 if (atomic_read(&itv->decoding)) {
1421 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1422 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1423 return -EIO;
1424 }
1425 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1426 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1427 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1428 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1429 }
1430 break;
1431 }
1432
1433 case VIDEO_GET_FRAME_COUNT: {
1434 u32 data[CX2341X_MBOX_MAX_DATA];
1435 u64 *frame = arg;
1436
1437 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1438 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1439 *frame = 0;
1440 break;
1441 }
1442 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1443 return -EINVAL;
1444
1445 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1446 *frame = itv->last_dec_timing[0];
1447 break;
1448 }
1449 *frame = 0;
1450 if (atomic_read(&itv->decoding)) {
1451 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1452 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1453 return -EIO;
1454 }
1455 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1456 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1457 *frame = data[0];
1458 }
1459 break;
1460 }
1461
1462 case VIDEO_PLAY: {
1463 struct video_command vc;
1464
1465 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1466 memset(&vc, 0, sizeof(vc));
1467 vc.cmd = VIDEO_CMD_PLAY;
1468 return ivtv_video_command(itv, id, &vc, 0);
1469 }
1470
1471 case VIDEO_STOP: {
1472 struct video_command vc;
1473
1474 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1475 memset(&vc, 0, sizeof(vc));
1476 vc.cmd = VIDEO_CMD_STOP;
1477 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1478 return ivtv_video_command(itv, id, &vc, 0);
1479 }
1480
1481 case VIDEO_FREEZE: {
1482 struct video_command vc;
1483
1484 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1485 memset(&vc, 0, sizeof(vc));
1486 vc.cmd = VIDEO_CMD_FREEZE;
1487 return ivtv_video_command(itv, id, &vc, 0);
1488 }
1489
1490 case VIDEO_CONTINUE: {
1491 struct video_command vc;
1492
1493 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1494 memset(&vc, 0, sizeof(vc));
1495 vc.cmd = VIDEO_CMD_CONTINUE;
1496 return ivtv_video_command(itv, id, &vc, 0);
1497 }
1498
1499 case VIDEO_COMMAND:
1500 case VIDEO_TRY_COMMAND: {
1501 struct video_command *vc = arg;
1502 int try = (cmd == VIDEO_TRY_COMMAND);
1503
1504 if (try)
1505 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1506 else
1507 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1508 return ivtv_video_command(itv, id, vc, try);
1509 }
1510
1511 case VIDEO_GET_EVENT: {
1512 struct video_event *ev = arg;
1513 DEFINE_WAIT(wait);
1514
1515 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1516 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1517 return -EINVAL;
1518 memset(ev, 0, sizeof(*ev));
1519 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1520
1521 while (1) {
1522 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1523 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1524 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1525 ev->type = VIDEO_EVENT_VSYNC;
1526 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1527 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1528 if (itv->output_mode == OUT_UDMA_YUV &&
1529 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1530 IVTV_YUV_MODE_PROGRESSIVE) {
1531 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1532 }
1533 }
1534 if (ev->type)
1535 return 0;
1536 if (nonblocking)
1537 return -EAGAIN;
1538 /* Wait for event. Note that serialize_lock is locked,
1539 so to allow other processes to access the driver while
1540 we are waiting unlock first and later lock again. */
1541 mutex_unlock(&itv->serialize_lock);
1542 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1543 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1544 schedule();
1545 finish_wait(&itv->event_waitq, &wait);
1546 mutex_lock(&itv->serialize_lock);
1547 if (signal_pending(current)) {
1548 /* return if a signal was received */
1549 IVTV_DEBUG_INFO("User stopped wait for event\n");
1550 return -EINTR;
1551 }
1552 }
1553 break;
1554 }
1555
1556 default:
1557 return -EINVAL;
1558 }
1559 return 0;
1560 }
1561
1562 static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1563 unsigned int cmd, void *arg)
1564 {
1565 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1566 struct ivtv *itv = id->itv;
1567 int ret;
1568
1569 /* check priority */
1570 switch (cmd) {
1571 case VIDIOC_S_CTRL:
1572 case VIDIOC_S_STD:
1573 case VIDIOC_S_INPUT:
1574 case VIDIOC_S_OUTPUT:
1575 case VIDIOC_S_TUNER:
1576 case VIDIOC_S_FREQUENCY:
1577 case VIDIOC_S_FMT:
1578 case VIDIOC_S_CROP:
1579 case VIDIOC_S_AUDIO:
1580 case VIDIOC_S_AUDOUT:
1581 case VIDIOC_S_EXT_CTRLS:
1582 case VIDIOC_S_FBUF:
1583 case VIDIOC_OVERLAY:
1584 ret = v4l2_prio_check(&itv->prio, &id->prio);
1585 if (ret)
1586 return ret;
1587 }
1588
1589 switch (cmd) {
1590 case VIDIOC_DBG_G_REGISTER:
1591 case VIDIOC_DBG_S_REGISTER:
1592 case VIDIOC_G_CHIP_IDENT:
1593 case VIDIOC_INT_S_AUDIO_ROUTING:
1594 case VIDIOC_INT_RESET:
1595 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1596 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1597 v4l_printk_ioctl(cmd);
1598 }
1599 return ivtv_debug_ioctls(filp, cmd, arg);
1600
1601 case VIDIOC_G_PRIORITY:
1602 case VIDIOC_S_PRIORITY:
1603 case VIDIOC_QUERYCAP:
1604 case VIDIOC_ENUMINPUT:
1605 case VIDIOC_G_INPUT:
1606 case VIDIOC_S_INPUT:
1607 case VIDIOC_ENUMOUTPUT:
1608 case VIDIOC_G_OUTPUT:
1609 case VIDIOC_S_OUTPUT:
1610 case VIDIOC_G_FMT:
1611 case VIDIOC_S_FMT:
1612 case VIDIOC_TRY_FMT:
1613 case VIDIOC_ENUM_FMT:
1614 case VIDIOC_CROPCAP:
1615 case VIDIOC_G_CROP:
1616 case VIDIOC_S_CROP:
1617 case VIDIOC_G_FREQUENCY:
1618 case VIDIOC_S_FREQUENCY:
1619 case VIDIOC_ENUMSTD:
1620 case VIDIOC_G_STD:
1621 case VIDIOC_S_STD:
1622 case VIDIOC_S_TUNER:
1623 case VIDIOC_G_TUNER:
1624 case VIDIOC_ENUMAUDIO:
1625 case VIDIOC_S_AUDIO:
1626 case VIDIOC_G_AUDIO:
1627 case VIDIOC_ENUMAUDOUT:
1628 case VIDIOC_S_AUDOUT:
1629 case VIDIOC_G_AUDOUT:
1630 case VIDIOC_G_SLICED_VBI_CAP:
1631 case VIDIOC_LOG_STATUS:
1632 case VIDIOC_G_ENC_INDEX:
1633 case VIDIOC_ENCODER_CMD:
1634 case VIDIOC_TRY_ENCODER_CMD:
1635 case VIDIOC_G_FBUF:
1636 case VIDIOC_S_FBUF:
1637 case VIDIOC_OVERLAY:
1638 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1639 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1640 v4l_printk_ioctl(cmd);
1641 }
1642 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1643
1644 case VIDIOC_QUERYMENU:
1645 case VIDIOC_QUERYCTRL:
1646 case VIDIOC_S_CTRL:
1647 case VIDIOC_G_CTRL:
1648 case VIDIOC_S_EXT_CTRLS:
1649 case VIDIOC_G_EXT_CTRLS:
1650 case VIDIOC_TRY_EXT_CTRLS:
1651 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1652 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1653 v4l_printk_ioctl(cmd);
1654 }
1655 return ivtv_control_ioctls(itv, cmd, arg);
1656
1657 case IVTV_IOC_DMA_FRAME:
1658 case VIDEO_GET_PTS:
1659 case VIDEO_GET_FRAME_COUNT:
1660 case VIDEO_GET_EVENT:
1661 case VIDEO_PLAY:
1662 case VIDEO_STOP:
1663 case VIDEO_FREEZE:
1664 case VIDEO_CONTINUE:
1665 case VIDEO_COMMAND:
1666 case VIDEO_TRY_COMMAND:
1667 return ivtv_decoder_ioctls(filp, cmd, arg);
1668
1669 case 0x00005401: /* Handle isatty() calls */
1670 return -EINVAL;
1671 default:
1672 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1673 ivtv_v4l2_do_ioctl);
1674 }
1675 return 0;
1676 }
1677
1678 static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1679 unsigned int cmd, unsigned long arg)
1680 {
1681 /* Filter dvb ioctls that cannot be handled by video_usercopy */
1682 switch (cmd) {
1683 case VIDEO_SELECT_SOURCE:
1684 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1685 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1686 return -EINVAL;
1687 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1688
1689 case AUDIO_SET_MUTE:
1690 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1691 itv->speed_mute_audio = arg;
1692 return 0;
1693
1694 case AUDIO_CHANNEL_SELECT:
1695 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1696 if (arg > AUDIO_STEREO_SWAPPED)
1697 return -EINVAL;
1698 itv->audio_stereo_mode = arg;
1699 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1700 return 0;
1701
1702 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1703 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1704 if (arg > AUDIO_STEREO_SWAPPED)
1705 return -EINVAL;
1706 itv->audio_bilingual_mode = arg;
1707 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1708 return 0;
1709
1710 default:
1711 break;
1712 }
1713 return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1714 }
1715
1716 int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1717 unsigned long arg)
1718 {
1719 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1720 struct ivtv *itv = id->itv;
1721 int res;
1722
1723 mutex_lock(&itv->serialize_lock);
1724 res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1725 mutex_unlock(&itv->serialize_lock);
1726 return res;
1727 }
Verdex Pro support