?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libata pata_via: ACPI checks for 80wire cable
[pv_ops_mirror.git] / drivers / media / video / ivtv / ivtv-ioctl.c
blob206eee7542db826803db08c73b8778c757f75bca
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 int w = fmt->fmt.pix.width;
559 int h = fmt->fmt.pix.height;
560
561 if (w > 720) w = 720;
562 else if (w < 1) w = 1;
563 if (h > (itv->is_50hz ? 576 : 480)) h = (itv->is_50hz ? 576 : 480);
564 else if (h < 2) h = 2;
565 ivtv_get_fmt(itv, streamtype, fmt);
566 fmt->fmt.pix.width = w;
567 fmt->fmt.pix.height = h;
568
569 if (!set_fmt || (itv->params.width == w && itv->params.height == h))
570 return 0;
571 if (atomic_read(&itv->capturing) > 0)
572 return -EBUSY;
573
574 itv->params.width = w;
575 itv->params.height = h;
576 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
577 itv->params.video_temporal_filter = 0;
578 else
579 itv->params.video_temporal_filter = 8;
580 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
581 return ivtv_get_fmt(itv, streamtype, fmt);
582 }
583
584 /* set raw VBI format */
585 if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
586 if (set_fmt && atomic_read(&itv->capturing) > 0) {
587 return -EBUSY;
588 }
589 if (set_fmt) {
590 itv->vbi.sliced_in->service_set = 0;
591 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
592 }
593 return ivtv_get_fmt(itv, streamtype, fmt);
594 }
595
596 /* set sliced VBI output
597 In principle the user could request that only certain
598 VBI types are output and that the others are ignored.
599 I.e., suppress CC in the even fields or only output
600 WSS and no VPS. Currently though there is no choice. */
601 if (fmt->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
602 return ivtv_get_fmt(itv, streamtype, fmt);
603
604 /* any else but sliced VBI capture is an error */
605 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
606 return -EINVAL;
607
608 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI)
609 return ivtv_get_fmt(itv, streamtype, fmt);
610
611 /* set sliced VBI capture format */
612 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
613 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
614
615 if (vbifmt->service_set)
616 expand_service_set(vbifmt, itv->is_50hz);
617 set = check_service_set(vbifmt, itv->is_50hz);
618 vbifmt->service_set = get_service_set(vbifmt);
619
620 if (!set_fmt)
621 return 0;
622 if (set == 0)
623 return -EINVAL;
624 if (atomic_read(&itv->capturing) > 0) {
625 return -EBUSY;
626 }
627 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
628 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
629 return 0;
630 }
631
632 static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
633 {
634 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
635 struct ivtv *itv = id->itv;
636 struct v4l2_register *reg = arg;
637
638 switch (cmd) {
639 /* ioctls to allow direct access to the encoder registers for testing */
640 case VIDIOC_DBG_G_REGISTER:
641 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
642 return ivtv_itvc(itv, cmd, arg);
643 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
644 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
645 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
646
647 case VIDIOC_DBG_S_REGISTER:
648 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
649 return ivtv_itvc(itv, cmd, arg);
650 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
651 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
652 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
653
654 case VIDIOC_G_CHIP_IDENT: {
655 struct v4l2_chip_ident *chip = arg;
656
657 chip->ident = V4L2_IDENT_NONE;
658 chip->revision = 0;
659 if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
660 if (v4l2_chip_match_host(reg->match_type, reg->match_chip)) {
661 struct v4l2_chip_ident *chip = arg;
662
663 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
664 }
665 return 0;
666 }
667 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
668 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
669 if (reg->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
670 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
671 return -EINVAL;
672 }
673
674 case VIDIOC_INT_S_AUDIO_ROUTING: {
675 struct v4l2_routing *route = arg;
676
677 ivtv_i2c_hw(itv, itv->card->hw_audio, VIDIOC_INT_S_AUDIO_ROUTING, route);
678 break;
679 }
680
681 case VIDIOC_INT_RESET: {
682 u32 val = *(u32 *)arg;
683
684 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) {
685 ivtv_reset_ir_gpio(itv);
686 }
687 if (val & 0x02) {
688 itv->video_dec_func(itv, cmd, 0);
689 }
690 break;
691 }
692
693 default:
694 return -EINVAL;
695 }
696 return 0;
697 }
698
699 int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
700 {
701 struct ivtv_open_id *id = NULL;
702 u32 data[CX2341X_MBOX_MAX_DATA];
703
704 if (filp) id = (struct ivtv_open_id *)filp->private_data;
705
706 switch (cmd) {
707 case VIDIOC_G_PRIORITY:
708 {
709 enum v4l2_priority *p = arg;
710
711 *p = v4l2_prio_max(&itv->prio);
712 break;
713 }
714
715 case VIDIOC_S_PRIORITY:
716 {
717 enum v4l2_priority *prio = arg;
718
719 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
720 }
721
722 case VIDIOC_QUERYCAP:{
723 struct v4l2_capability *vcap = arg;
724
725 memset(vcap, 0, sizeof(*vcap));
726 strcpy(vcap->driver, IVTV_DRIVER_NAME); /* driver name */
727 strcpy(vcap->card, itv->card_name); /* card type */
728 strcpy(vcap->bus_info, pci_name(itv->dev)); /* bus info... */
729 vcap->version = IVTV_DRIVER_VERSION; /* version */
730 vcap->capabilities = itv->v4l2_cap; /* capabilities */
731
732 /* reserved.. must set to 0! */
733 vcap->reserved[0] = vcap->reserved[1] =
734 vcap->reserved[2] = vcap->reserved[3] = 0;
735 break;
736 }
737
738 case VIDIOC_ENUMAUDIO:{
739 struct v4l2_audio *vin = arg;
740
741 return ivtv_get_audio_input(itv, vin->index, vin);
742 }
743
744 case VIDIOC_G_AUDIO:{
745 struct v4l2_audio *vin = arg;
746
747 vin->index = itv->audio_input;
748 return ivtv_get_audio_input(itv, vin->index, vin);
749 }
750
751 case VIDIOC_S_AUDIO:{
752 struct v4l2_audio *vout = arg;
753
754 if (vout->index >= itv->nof_audio_inputs)
755 return -EINVAL;
756 itv->audio_input = vout->index;
757 ivtv_audio_set_io(itv);
758 break;
759 }
760
761 case VIDIOC_ENUMAUDOUT:{
762 struct v4l2_audioout *vin = arg;
763
764 /* set it to defaults from our table */
765 return ivtv_get_audio_output(itv, vin->index, vin);
766 }
767
768 case VIDIOC_G_AUDOUT:{
769 struct v4l2_audioout *vin = arg;
770
771 vin->index = 0;
772 return ivtv_get_audio_output(itv, vin->index, vin);
773 }
774
775 case VIDIOC_S_AUDOUT:{
776 struct v4l2_audioout *vout = arg;
777
778 return ivtv_get_audio_output(itv, vout->index, vout);
779 }
780
781 case VIDIOC_ENUMINPUT:{
782 struct v4l2_input *vin = arg;
783
784 /* set it to defaults from our table */
785 return ivtv_get_input(itv, vin->index, vin);
786 }
787
788 case VIDIOC_ENUMOUTPUT:{
789 struct v4l2_output *vout = arg;
790
791 return ivtv_get_output(itv, vout->index, vout);
792 }
793
794 case VIDIOC_TRY_FMT:
795 case VIDIOC_S_FMT: {
796 struct v4l2_format *fmt = arg;
797
798 return ivtv_try_or_set_fmt(itv, id->type, fmt, cmd == VIDIOC_S_FMT);
799 }
800
801 case VIDIOC_G_FMT: {
802 struct v4l2_format *fmt = arg;
803 int type = fmt->type;
804
805 memset(fmt, 0, sizeof(*fmt));
806 fmt->type = type;
807 return ivtv_get_fmt(itv, id->type, fmt);
808 }
809
810 case VIDIOC_CROPCAP: {
811 struct v4l2_cropcap *cropcap = arg;
812
813 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
814 cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
815 return -EINVAL;
816 cropcap->bounds.top = cropcap->bounds.left = 0;
817 cropcap->bounds.width = 720;
818 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
819 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
820 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
821 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
822 } else {
823 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
824 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
825 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
826 }
827 cropcap->defrect = cropcap->bounds;
828 return 0;
829 }
830
831 case VIDIOC_S_CROP: {
832 struct v4l2_crop *crop = arg;
833
834 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
835 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
836 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
837 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
838 itv->main_rect = crop->c;
839 return 0;
840 }
841 return -EINVAL;
842 }
843 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
844 return -EINVAL;
845 return itv->video_dec_func(itv, VIDIOC_S_CROP, arg);
846 }
847
848 case VIDIOC_G_CROP: {
849 struct v4l2_crop *crop = arg;
850
851 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
852 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
853 crop->c = itv->main_rect;
854 return 0;
855 }
856 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
857 return -EINVAL;
858 return itv->video_dec_func(itv, VIDIOC_G_CROP, arg);
859 }
860
861 case VIDIOC_ENUM_FMT: {
862 static struct v4l2_fmtdesc formats[] = {
863 { 0, 0, 0,
864 "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12,
865 { 0, 0, 0, 0 }
866 },
867 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
868 "MPEG", V4L2_PIX_FMT_MPEG,
869 { 0, 0, 0, 0 }
870 }
871 };
872 struct v4l2_fmtdesc *fmt = arg;
873 enum v4l2_buf_type type = fmt->type;
874
875 switch (type) {
876 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
877 break;
878 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
879 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
880 return -EINVAL;
881 break;
882 default:
883 return -EINVAL;
884 }
885 if (fmt->index > 1)
886 return -EINVAL;
887 *fmt = formats[fmt->index];
888 fmt->type = type;
889 return 0;
890 }
891
892 case VIDIOC_G_INPUT:{
893 *(int *)arg = itv->active_input;
894 break;
895 }
896
897 case VIDIOC_S_INPUT:{
898 int inp = *(int *)arg;
899
900 if (inp < 0 || inp >= itv->nof_inputs)
901 return -EINVAL;
902
903 if (inp == itv->active_input) {
904 IVTV_DEBUG_INFO("Input unchanged\n");
905 break;
906 }
907 if (atomic_read(&itv->capturing) > 0) {
908 return -EBUSY;
909 }
910 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
911 itv->active_input, inp);
912
913 itv->active_input = inp;
914 /* Set the audio input to whatever is appropriate for the
915 input type. */
916 itv->audio_input = itv->card->video_inputs[inp].audio_index;
917
918 /* prevent others from messing with the streams until
919 we're finished changing inputs. */
920 ivtv_mute(itv);
921 ivtv_video_set_io(itv);
922 ivtv_audio_set_io(itv);
923 ivtv_unmute(itv);
924 break;
925 }
926
927 case VIDIOC_G_OUTPUT:{
928 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
929 return -EINVAL;
930 *(int *)arg = itv->active_output;
931 break;
932 }
933
934 case VIDIOC_S_OUTPUT:{
935 int outp = *(int *)arg;
936 struct v4l2_routing route;
937
938 if (outp >= itv->card->nof_outputs)
939 return -EINVAL;
940
941 if (outp == itv->active_output) {
942 IVTV_DEBUG_INFO("Output unchanged\n");
943 break;
944 }
945 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
946 itv->active_output, outp);
947
948 itv->active_output = outp;
949 route.input = SAA7127_INPUT_TYPE_NORMAL;
950 route.output = itv->card->video_outputs[outp].video_output;
951 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
952 break;
953 }
954
955 case VIDIOC_G_FREQUENCY:{
956 struct v4l2_frequency *vf = arg;
957
958 if (vf->tuner != 0)
959 return -EINVAL;
960 ivtv_call_i2c_clients(itv, cmd, arg);
961 break;
962 }
963
964 case VIDIOC_S_FREQUENCY:{
965 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
966
967 if (vf.tuner != 0)
968 return -EINVAL;
969
970 ivtv_mute(itv);
971 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
972 ivtv_call_i2c_clients(itv, cmd, &vf);
973 ivtv_unmute(itv);
974 break;
975 }
976
977 case VIDIOC_ENUMSTD:{
978 struct v4l2_standard *vs = arg;
979 int idx = vs->index;
980
981 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
982 return -EINVAL;
983
984 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
985 ivtv_std_60hz : ivtv_std_50hz;
986 vs->index = idx;
987 vs->id = enum_stds[idx].std;
988 strcpy(vs->name, enum_stds[idx].name);
989 break;
990 }
991
992 case VIDIOC_G_STD:{
993 *(v4l2_std_id *) arg = itv->std;
994 break;
995 }
996
997 case VIDIOC_S_STD: {
998 v4l2_std_id std = *(v4l2_std_id *) arg;
999
1000 if ((std & V4L2_STD_ALL) == 0)
1001 return -EINVAL;
1002
1003 if (std == itv->std)
1004 break;
1005
1006 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1007 atomic_read(&itv->capturing) > 0 ||
1008 atomic_read(&itv->decoding) > 0) {
1009 /* Switching standard would turn off the radio or mess
1010 with already running streams, prevent that by
1011 returning EBUSY. */
1012 return -EBUSY;
1013 }
1014
1015 itv->std = std;
1016 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1017 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1018 itv->params.width = 720;
1019 itv->params.height = itv->is_50hz ? 576 : 480;
1020 itv->vbi.count = itv->is_50hz ? 18 : 12;
1021 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1022 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1023 if (itv->hw_flags & IVTV_HW_CX25840) {
1024 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1025 }
1026 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1027
1028 /* Tuner */
1029 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1030
1031 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1032 /* set display standard */
1033 itv->std_out = std;
1034 itv->is_out_60hz = itv->is_60hz;
1035 itv->is_out_50hz = itv->is_50hz;
1036 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1037 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1038 itv->main_rect.left = itv->main_rect.top = 0;
1039 itv->main_rect.width = 720;
1040 itv->main_rect.height = itv->params.height;
1041 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1042 720, itv->main_rect.height, 0, 0);
1043 }
1044 break;
1045 }
1046
1047 case VIDIOC_S_TUNER: { /* Setting tuner can only set audio mode */
1048 struct v4l2_tuner *vt = arg;
1049
1050 if (vt->index != 0)
1051 return -EINVAL;
1052
1053 ivtv_call_i2c_clients(itv, VIDIOC_S_TUNER, vt);
1054 break;
1055 }
1056
1057 case VIDIOC_G_TUNER: {
1058 struct v4l2_tuner *vt = arg;
1059
1060 if (vt->index != 0)
1061 return -EINVAL;
1062
1063 memset(vt, 0, sizeof(*vt));
1064 ivtv_call_i2c_clients(itv, VIDIOC_G_TUNER, vt);
1065
1066 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1067 strcpy(vt->name, "ivtv Radio Tuner");
1068 vt->type = V4L2_TUNER_RADIO;
1069 } else {
1070 strcpy(vt->name, "ivtv TV Tuner");
1071 vt->type = V4L2_TUNER_ANALOG_TV;
1072 }
1073 break;
1074 }
1075
1076 case VIDIOC_G_SLICED_VBI_CAP: {
1077 struct v4l2_sliced_vbi_cap *cap = arg;
1078 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1079 int f, l;
1080 enum v4l2_buf_type type = cap->type;
1081
1082 memset(cap, 0, sizeof(*cap));
1083 cap->type = type;
1084 if (type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1085 for (f = 0; f < 2; f++) {
1086 for (l = 0; l < 24; l++) {
1087 if (valid_service_line(f, l, itv->is_50hz)) {
1088 cap->service_lines[f][l] = set;
1089 }
1090 }
1091 }
1092 return 0;
1093 }
1094 if (type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1095 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1096 return -EINVAL;
1097 if (itv->is_60hz) {
1098 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1099 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1100 } else {
1101 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1102 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1103 }
1104 return 0;
1105 }
1106 return -EINVAL;
1107 }
1108
1109 case VIDIOC_G_ENC_INDEX: {
1110 struct v4l2_enc_idx *idx = arg;
1111 struct v4l2_enc_idx_entry *e = idx->entry;
1112 int entries;
1113 int i;
1114
1115 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1116 IVTV_MAX_PGM_INDEX;
1117 if (entries > V4L2_ENC_IDX_ENTRIES)
1118 entries = V4L2_ENC_IDX_ENTRIES;
1119 idx->entries = 0;
1120 for (i = 0; i < entries; i++) {
1121 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1122 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1123 idx->entries++;
1124 e++;
1125 }
1126 }
1127 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1128 break;
1129 }
1130
1131 case VIDIOC_ENCODER_CMD:
1132 case VIDIOC_TRY_ENCODER_CMD: {
1133 struct v4l2_encoder_cmd *enc = arg;
1134 int try = cmd == VIDIOC_TRY_ENCODER_CMD;
1135
1136 memset(&enc->raw, 0, sizeof(enc->raw));
1137 switch (enc->cmd) {
1138 case V4L2_ENC_CMD_START:
1139 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1140 enc->flags = 0;
1141 if (try)
1142 return 0;
1143 return ivtv_start_capture(id);
1144
1145 case V4L2_ENC_CMD_STOP:
1146 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1147 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1148 if (try)
1149 return 0;
1150 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1151 return 0;
1152
1153 case V4L2_ENC_CMD_PAUSE:
1154 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1155 enc->flags = 0;
1156 if (try)
1157 return 0;
1158 if (!atomic_read(&itv->capturing))
1159 return -EPERM;
1160 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1161 return 0;
1162 ivtv_mute(itv);
1163 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1164 break;
1165
1166 case V4L2_ENC_CMD_RESUME:
1167 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1168 enc->flags = 0;
1169 if (try)
1170 return 0;
1171 if (!atomic_read(&itv->capturing))
1172 return -EPERM;
1173 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1174 return 0;
1175 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1176 ivtv_unmute(itv);
1177 break;
1178 default:
1179 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1180 return -EINVAL;
1181 }
1182 break;
1183 }
1184
1185 case VIDIOC_G_FBUF: {
1186 struct v4l2_framebuffer *fb = arg;
1187 int pixfmt;
1188 static u32 pixel_format[16] = {
1189 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1190 V4L2_PIX_FMT_RGB565,
1191 V4L2_PIX_FMT_RGB555,
1192 V4L2_PIX_FMT_RGB444,
1193 V4L2_PIX_FMT_RGB32,
1194 0,
1195 0,
1196 0,
1197 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1198 V4L2_PIX_FMT_YUV565,
1199 V4L2_PIX_FMT_YUV555,
1200 V4L2_PIX_FMT_YUV444,
1201 V4L2_PIX_FMT_YUV32,
1202 0,
1203 0,
1204 0,
1205 };
1206
1207 memset(fb, 0, sizeof(*fb));
1208 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1209 return -EINVAL;
1210 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1211 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1212 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1213 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1214 pixfmt = (data[0] >> 3) & 0xf;
1215 fb->fmt.pixelformat = pixel_format[pixfmt];
1216 fb->fmt.width = itv->osd_rect.width;
1217 fb->fmt.height = itv->osd_rect.height;
1218 fb->base = (void *)itv->osd_video_pbase;
1219 if (itv->osd_chroma_key_state)
1220 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1221 if (itv->osd_global_alpha_state)
1222 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1223 pixfmt &= 7;
1224 /* no local alpha for RGB565 or unknown formats */
1225 if (pixfmt == 1 || pixfmt > 4)
1226 break;
1227 /* 16-bit formats have inverted local alpha */
1228 if (pixfmt == 2 || pixfmt == 3)
1229 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1230 else
1231 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1232 if (itv->osd_local_alpha_state) {
1233 /* 16-bit formats have inverted local alpha */
1234 if (pixfmt == 2 || pixfmt == 3)
1235 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1236 else
1237 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1238 }
1239 break;
1240 }
1241
1242 case VIDIOC_S_FBUF: {
1243 struct v4l2_framebuffer *fb = arg;
1244
1245 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1246 return -EINVAL;
1247 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1248 itv->osd_local_alpha_state =
1249 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1250 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1251 ivtv_set_osd_alpha(itv);
1252 break;
1253 }
1254
1255 case VIDIOC_OVERLAY: {
1256 int *on = arg;
1257
1258 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1259 return -EINVAL;
1260 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1261 break;
1262 }
1263
1264 case VIDIOC_LOG_STATUS:
1265 {
1266 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1267 struct v4l2_input vidin;
1268 struct v4l2_audio audin;
1269 int i;
1270
1271 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv->num);
1272 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1273 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1274 struct tveeprom tv;
1275
1276 ivtv_read_eeprom(itv, &tv);
1277 }
1278 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1279 ivtv_get_input(itv, itv->active_input, &vidin);
1280 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1281 IVTV_INFO("Video Input: %s\n", vidin.name);
1282 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1283 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1284 if (has_output) {
1285 struct v4l2_output vidout;
1286 struct v4l2_audioout audout;
1287 int mode = itv->output_mode;
1288 static const char * const output_modes[5] = {
1289 "None",
1290 "MPEG Streaming",
1291 "YUV Streaming",
1292 "YUV Frames",
1293 "Passthrough",
1294 };
1295 static const char * const audio_modes[5] = {
1296 "Stereo",
1297 "Left",
1298 "Right",
1299 "Mono",
1300 "Swapped"
1301 };
1302 static const char * const alpha_mode[4] = {
1303 "None",
1304 "Global",
1305 "Local",
1306 "Global and Local"
1307 };
1308 static const char * const pixel_format[16] = {
1309 "ARGB Indexed",
1310 "RGB 5:6:5",
1311 "ARGB 1:5:5:5",
1312 "ARGB 1:4:4:4",
1313 "ARGB 8:8:8:8",
1314 "5",
1315 "6",
1316 "7",
1317 "AYUV Indexed",
1318 "YUV 5:6:5",
1319 "AYUV 1:5:5:5",
1320 "AYUV 1:4:4:4",
1321 "AYUV 8:8:8:8",
1322 "13",
1323 "14",
1324 "15",
1325 };
1326
1327 ivtv_get_output(itv, itv->active_output, &vidout);
1328 ivtv_get_audio_output(itv, 0, &audout);
1329 IVTV_INFO("Video Output: %s\n", vidout.name);
1330 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1331 audio_modes[itv->audio_stereo_mode],
1332 audio_modes[itv->audio_bilingual_mode]);
1333 if (mode < 0 || mode > OUT_PASSTHROUGH)
1334 mode = OUT_NONE;
1335 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1336 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1337 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1338 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1339 data[0] & 1 ? "On" : "Off",
1340 alpha_mode[(data[0] >> 1) & 0x3],
1341 pixel_format[(data[0] >> 3) & 0xf]);
1342 }
1343 IVTV_INFO("Tuner: %s\n",
1344 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1345 cx2341x_log_status(&itv->params, itv->name);
1346 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1347 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1348 struct ivtv_stream *s = &itv->streams[i];
1349
1350 if (s->v4l2dev == NULL || s->buffers == 0)
1351 continue;
1352 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1353 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1354 (s->buffers * s->buf_size) / 1024, s->buffers);
1355 }
1356 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1357 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv->num);
1358 break;
1359 }
1360
1361 default:
1362 return -EINVAL;
1363 }
1364 return 0;
1365 }
1366
1367 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1368 {
1369 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1370 struct ivtv *itv = id->itv;
1371 int nonblocking = filp->f_flags & O_NONBLOCK;
1372 struct ivtv_stream *s = &itv->streams[id->type];
1373
1374 switch (cmd) {
1375 case IVTV_IOC_DMA_FRAME: {
1376 struct ivtv_dma_frame *args = arg;
1377
1378 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1379 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1380 return -EINVAL;
1381 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1382 return -EINVAL;
1383 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1384 return 0;
1385 if (ivtv_claim_stream(id, id->type)) {
1386 return -EBUSY;
1387 }
1388 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1389 ivtv_release_stream(s);
1390 return -EBUSY;
1391 }
1392 /* Mark that this file handle started the UDMA_YUV mode */
1393 id->yuv_frames = 1;
1394 if (args->y_source == NULL)
1395 return 0;
1396 return ivtv_yuv_prep_frame(itv, args);
1397 }
1398
1399 case VIDEO_GET_PTS: {
1400 u32 data[CX2341X_MBOX_MAX_DATA];
1401 u64 *pts = arg;
1402
1403 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1404 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1405 *pts = s->dma_pts;
1406 break;
1407 }
1408 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1409 return -EINVAL;
1410
1411 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1412 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1413 (u64)itv->last_dec_timing[1];
1414 break;
1415 }
1416 *pts = 0;
1417 if (atomic_read(&itv->decoding)) {
1418 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1419 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1420 return -EIO;
1421 }
1422 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1423 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1424 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1425 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1426 }
1427 break;
1428 }
1429
1430 case VIDEO_GET_FRAME_COUNT: {
1431 u32 data[CX2341X_MBOX_MAX_DATA];
1432 u64 *frame = arg;
1433
1434 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1435 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1436 *frame = 0;
1437 break;
1438 }
1439 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1440 return -EINVAL;
1441
1442 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1443 *frame = itv->last_dec_timing[0];
1444 break;
1445 }
1446 *frame = 0;
1447 if (atomic_read(&itv->decoding)) {
1448 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1449 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1450 return -EIO;
1451 }
1452 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1453 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1454 *frame = data[0];
1455 }
1456 break;
1457 }
1458
1459 case VIDEO_PLAY: {
1460 struct video_command vc;
1461
1462 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1463 memset(&vc, 0, sizeof(vc));
1464 vc.cmd = VIDEO_CMD_PLAY;
1465 return ivtv_video_command(itv, id, &vc, 0);
1466 }
1467
1468 case VIDEO_STOP: {
1469 struct video_command vc;
1470
1471 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1472 memset(&vc, 0, sizeof(vc));
1473 vc.cmd = VIDEO_CMD_STOP;
1474 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1475 return ivtv_video_command(itv, id, &vc, 0);
1476 }
1477
1478 case VIDEO_FREEZE: {
1479 struct video_command vc;
1480
1481 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1482 memset(&vc, 0, sizeof(vc));
1483 vc.cmd = VIDEO_CMD_FREEZE;
1484 return ivtv_video_command(itv, id, &vc, 0);
1485 }
1486
1487 case VIDEO_CONTINUE: {
1488 struct video_command vc;
1489
1490 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1491 memset(&vc, 0, sizeof(vc));
1492 vc.cmd = VIDEO_CMD_CONTINUE;
1493 return ivtv_video_command(itv, id, &vc, 0);
1494 }
1495
1496 case VIDEO_COMMAND:
1497 case VIDEO_TRY_COMMAND: {
1498 struct video_command *vc = arg;
1499 int try = (cmd == VIDEO_TRY_COMMAND);
1500
1501 if (try)
1502 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1503 else
1504 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1505 return ivtv_video_command(itv, id, vc, try);
1506 }
1507
1508 case VIDEO_GET_EVENT: {
1509 struct video_event *ev = arg;
1510 DEFINE_WAIT(wait);
1511
1512 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1513 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1514 return -EINVAL;
1515 memset(ev, 0, sizeof(*ev));
1516 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1517
1518 while (1) {
1519 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1520 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1521 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1522 ev->type = VIDEO_EVENT_VSYNC;
1523 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1524 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1525 if (itv->output_mode == OUT_UDMA_YUV &&
1526 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1527 IVTV_YUV_MODE_PROGRESSIVE) {
1528 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1529 }
1530 }
1531 if (ev->type)
1532 return 0;
1533 if (nonblocking)
1534 return -EAGAIN;
1535 /* Wait for event. Note that serialize_lock is locked,
1536 so to allow other processes to access the driver while
1537 we are waiting unlock first and later lock again. */
1538 mutex_unlock(&itv->serialize_lock);
1539 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1540 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1541 schedule();
1542 finish_wait(&itv->event_waitq, &wait);
1543 mutex_lock(&itv->serialize_lock);
1544 if (signal_pending(current)) {
1545 /* return if a signal was received */
1546 IVTV_DEBUG_INFO("User stopped wait for event\n");
1547 return -EINTR;
1548 }
1549 }
1550 break;
1551 }
1552
1553 default:
1554 return -EINVAL;
1555 }
1556 return 0;
1557 }
1558
1559 static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1560 unsigned int cmd, void *arg)
1561 {
1562 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1563 struct ivtv *itv = id->itv;
1564 int ret;
1565
1566 /* check priority */
1567 switch (cmd) {
1568 case VIDIOC_S_CTRL:
1569 case VIDIOC_S_STD:
1570 case VIDIOC_S_INPUT:
1571 case VIDIOC_S_OUTPUT:
1572 case VIDIOC_S_TUNER:
1573 case VIDIOC_S_FREQUENCY:
1574 case VIDIOC_S_FMT:
1575 case VIDIOC_S_CROP:
1576 case VIDIOC_S_AUDIO:
1577 case VIDIOC_S_AUDOUT:
1578 case VIDIOC_S_EXT_CTRLS:
1579 case VIDIOC_S_FBUF:
1580 case VIDIOC_OVERLAY:
1581 ret = v4l2_prio_check(&itv->prio, &id->prio);
1582 if (ret)
1583 return ret;
1584 }
1585
1586 switch (cmd) {
1587 case VIDIOC_DBG_G_REGISTER:
1588 case VIDIOC_DBG_S_REGISTER:
1589 case VIDIOC_G_CHIP_IDENT:
1590 case VIDIOC_INT_S_AUDIO_ROUTING:
1591 case VIDIOC_INT_RESET:
1592 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1593 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1594 v4l_printk_ioctl(cmd);
1595 }
1596 return ivtv_debug_ioctls(filp, cmd, arg);
1597
1598 case VIDIOC_G_PRIORITY:
1599 case VIDIOC_S_PRIORITY:
1600 case VIDIOC_QUERYCAP:
1601 case VIDIOC_ENUMINPUT:
1602 case VIDIOC_G_INPUT:
1603 case VIDIOC_S_INPUT:
1604 case VIDIOC_ENUMOUTPUT:
1605 case VIDIOC_G_OUTPUT:
1606 case VIDIOC_S_OUTPUT:
1607 case VIDIOC_G_FMT:
1608 case VIDIOC_S_FMT:
1609 case VIDIOC_TRY_FMT:
1610 case VIDIOC_ENUM_FMT:
1611 case VIDIOC_CROPCAP:
1612 case VIDIOC_G_CROP:
1613 case VIDIOC_S_CROP:
1614 case VIDIOC_G_FREQUENCY:
1615 case VIDIOC_S_FREQUENCY:
1616 case VIDIOC_ENUMSTD:
1617 case VIDIOC_G_STD:
1618 case VIDIOC_S_STD:
1619 case VIDIOC_S_TUNER:
1620 case VIDIOC_G_TUNER:
1621 case VIDIOC_ENUMAUDIO:
1622 case VIDIOC_S_AUDIO:
1623 case VIDIOC_G_AUDIO:
1624 case VIDIOC_ENUMAUDOUT:
1625 case VIDIOC_S_AUDOUT:
1626 case VIDIOC_G_AUDOUT:
1627 case VIDIOC_G_SLICED_VBI_CAP:
1628 case VIDIOC_LOG_STATUS:
1629 case VIDIOC_G_ENC_INDEX:
1630 case VIDIOC_ENCODER_CMD:
1631 case VIDIOC_TRY_ENCODER_CMD:
1632 case VIDIOC_G_FBUF:
1633 case VIDIOC_S_FBUF:
1634 case VIDIOC_OVERLAY:
1635 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1636 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1637 v4l_printk_ioctl(cmd);
1638 }
1639 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1640
1641 case VIDIOC_QUERYMENU:
1642 case VIDIOC_QUERYCTRL:
1643 case VIDIOC_S_CTRL:
1644 case VIDIOC_G_CTRL:
1645 case VIDIOC_S_EXT_CTRLS:
1646 case VIDIOC_G_EXT_CTRLS:
1647 case VIDIOC_TRY_EXT_CTRLS:
1648 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1649 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1650 v4l_printk_ioctl(cmd);
1651 }
1652 return ivtv_control_ioctls(itv, cmd, arg);
1653
1654 case IVTV_IOC_DMA_FRAME:
1655 case VIDEO_GET_PTS:
1656 case VIDEO_GET_FRAME_COUNT:
1657 case VIDEO_GET_EVENT:
1658 case VIDEO_PLAY:
1659 case VIDEO_STOP:
1660 case VIDEO_FREEZE:
1661 case VIDEO_CONTINUE:
1662 case VIDEO_COMMAND:
1663 case VIDEO_TRY_COMMAND:
1664 return ivtv_decoder_ioctls(filp, cmd, arg);
1665
1666 case 0x00005401: /* Handle isatty() calls */
1667 return -EINVAL;
1668 default:
1669 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1670 ivtv_v4l2_do_ioctl);
1671 }
1672 return 0;
1673 }
1674
1675 static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1676 unsigned int cmd, unsigned long arg)
1677 {
1678 /* Filter dvb ioctls that cannot be handled by video_usercopy */
1679 switch (cmd) {
1680 case VIDEO_SELECT_SOURCE:
1681 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1682 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1683 return -EINVAL;
1684 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1685
1686 case AUDIO_SET_MUTE:
1687 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1688 itv->speed_mute_audio = arg;
1689 return 0;
1690
1691 case AUDIO_CHANNEL_SELECT:
1692 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1693 if (arg > AUDIO_STEREO_SWAPPED)
1694 return -EINVAL;
1695 itv->audio_stereo_mode = arg;
1696 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1697 return 0;
1698
1699 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1700 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1701 if (arg > AUDIO_STEREO_SWAPPED)
1702 return -EINVAL;
1703 itv->audio_bilingual_mode = arg;
1704 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1705 return 0;
1706
1707 default:
1708 break;
1709 }
1710 return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1711 }
1712
1713 int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1714 unsigned long arg)
1715 {
1716 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1717 struct ivtv *itv = id->itv;
1718 int res;
1719
1720 mutex_lock(&itv->serialize_lock);
1721 res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1722 mutex_unlock(&itv->serialize_lock);
1723 return res;
1724 }
Mirror for ia64_pv_ops.git