projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (6091): ivtv: header cleanup
[deliverable/linux.git] / drivers / media / video / ivtv / ivtv-ioctl.c
CommitLineData
1a0adaf3
HV		 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-audio.h"
29#include "ivtv-video.h"
30#include "ivtv-streams.h"
31#include "ivtv-yuv.h"
32#include "ivtv-ioctl.h"
33#include "ivtv-gpio.h"
34#include "ivtv-controls.h"
35#include "ivtv-cards.h"
36#include <media/saa7127.h>
37#include <media/tveeprom.h>
38#include <media/v4l2-chip-ident.h>
39#include <linux/dvb/audio.h>
40#include <linux/i2c-id.h>
41
42u16 service2vbi(int type)
43{
44 switch (type) {
45 case V4L2_SLICED_TELETEXT_B:
46 return IVTV_SLICED_TYPE_TELETEXT_B;
47 case V4L2_SLICED_CAPTION_525:
48 return IVTV_SLICED_TYPE_CAPTION_525;
49 case V4L2_SLICED_WSS_625:
50 return IVTV_SLICED_TYPE_WSS_625;
51 case V4L2_SLICED_VPS:
52 return IVTV_SLICED_TYPE_VPS;
53 default:
54 return 0;
55 }
56}
57
58static int valid_service_line(int field, int line, int is_pal)
59{
60 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
61 (!is_pal && line >= 10 && line < 22);
62}
63
64static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
65{
66 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
67 int i;
68
69 set = set & valid_set;
70 if (set == 0 || !valid_service_line(field, line, is_pal)) {
71 return 0;
72 }
73 if (!is_pal) {
74 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
75 return V4L2_SLICED_CAPTION_525;
76 }
77 else {
78 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
79 return V4L2_SLICED_VPS;
80 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
81 return V4L2_SLICED_WSS_625;
82 if (line == 23)
83 return 0;
84 }
85 for (i = 0; i < 32; i++) {
86 if ((1 << i) & set)
87 return 1 << i;
88 }
89 return 0;
90}
91
92void expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
93{
94 u16 set = fmt->service_set;
95 int f, l;
96
97 fmt->service_set = 0;
98 for (f = 0; f < 2; f++) {
99 for (l = 0; l < 24; l++) {
100 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
101 }
102 }
103}
104
105static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
106{
107 int f, l;
108 u16 set = 0;
109
110 for (f = 0; f < 2; f++) {
111 for (l = 0; l < 24; l++) {
112 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
113 set |= fmt->service_lines[f][l];
114 }
115 }
116 return set != 0;
117}
118
119u16 get_service_set(struct v4l2_sliced_vbi_format *fmt)
120{
121 int f, l;
122 u16 set = 0;
123
124 for (f = 0; f < 2; f++) {
125 for (l = 0; l < 24; l++) {
126 set |= fmt->service_lines[f][l];
127 }
128 }
129 return set;
130}
131
132static const struct {
133 v4l2_std_id std;
134 char *name;
135} enum_stds[] = {
136 { V4L2_STD_PAL_BG | V4L2_STD_PAL_H, "PAL-BGH" },
137 { V4L2_STD_PAL_DK, "PAL-DK" },
138 { V4L2_STD_PAL_I, "PAL-I" },
139 { V4L2_STD_PAL_M, "PAL-M" },
140 { V4L2_STD_PAL_N, "PAL-N" },
141 { V4L2_STD_PAL_Nc, "PAL-Nc" },
142 { V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H, "SECAM-BGH" },
143 { V4L2_STD_SECAM_DK, "SECAM-DK" },
144 { V4L2_STD_SECAM_L, "SECAM-L" },
145 { V4L2_STD_SECAM_LC, "SECAM-L'" },
146 { V4L2_STD_NTSC_M, "NTSC-M" },
147 { V4L2_STD_NTSC_M_JP, "NTSC-J" },
148 { V4L2_STD_NTSC_M_KR, "NTSC-K" },
149};
150
151static const struct v4l2_standard ivtv_std_60hz =
152{
153 .frameperiod = {.numerator = 1001, .denominator = 30000},
154 .framelines = 525,
155};
156
157static const struct v4l2_standard ivtv_std_50hz =
158{
159 .frameperiod = {.numerator = 1, .denominator = 25},
160 .framelines = 625,
161};
162
163void ivtv_set_osd_alpha(struct ivtv *itv)
164{
165 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
166 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
167 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_color_key_state, itv->osd_color_key);
168}
169
170int ivtv_set_speed(struct ivtv *itv, int speed)
171{
172 u32 data[CX2341X_MBOX_MAX_DATA];
173 struct ivtv_stream *s;
174 int single_step = (speed == 1 || speed == -1);
175 DEFINE_WAIT(wait);
176
177 if (speed == 0) speed = 1000;
178
179 /* No change? */
180 if (speed == itv->speed && !single_step)
181 return 0;
182
183 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
184
185 if (single_step && (speed < 0) == (itv->speed < 0)) {
186 /* Single step video and no need to change direction */
187 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
188 itv->speed = speed;
189 return 0;
190 }
191 if (single_step)
192 /* Need to change direction */
193 speed = speed < 0 ? -1000 : 1000;
194
195 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
196 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
197 data[1] = (speed < 0);
198 data[2] = speed < 0 ? 3 : 7;
199 data[3] = itv->params.video_b_frames;
200 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
201 data[5] = 0;
202 data[6] = 0;
203
204 if (speed == 1500 || speed == -1500) data[0] |= 1;
205 else if (speed == 2000 || speed == -2000) data[0] |= 2;
206 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
207 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
208
209 /* If not decoding, just change speed setting */
210 if (atomic_read(&itv->decoding) > 0) {
211 int got_sig = 0;
212
213 /* Stop all DMA and decoding activity */
214 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
215
216 /* Wait for any DMA to finish */
217 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
218 while (itv->i_flags & IVTV_F_I_DMA) {
219 got_sig = signal_pending(current);
220 if (got_sig)
221 break;
222 got_sig = 0;
223 schedule();
224 }
225 finish_wait(&itv->dma_waitq, &wait);
226 if (got_sig)
227 return -EINTR;
228
229 /* Change Speed safely */
230 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
231 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
232 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
233 }
234 if (single_step) {
235 speed = (speed < 0) ? -1 : 1;
236 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
237 }
238 itv->speed = speed;
239 return 0;
240}
241
242static int ivtv_validate_speed(int cur_speed, int new_speed)
243{
244 int fact = new_speed < 0 ? -1 : 1;
245 int s;
246
247 if (new_speed < 0) new_speed = -new_speed;
248 if (cur_speed < 0) cur_speed = -cur_speed;
249
250 if (cur_speed <= new_speed) {
251 if (new_speed > 1500) return fact * 2000;
252 if (new_speed > 1000) return fact * 1500;
253 }
254 else {
255 if (new_speed >= 2000) return fact * 2000;
256 if (new_speed >= 1500) return fact * 1500;
257 if (new_speed >= 1000) return fact * 1000;
258 }
259 if (new_speed == 0) return 1000;
260 if (new_speed == 1 || new_speed == 1000) return fact * new_speed;
261
262 s = new_speed;
263 new_speed = 1000 / new_speed;
264 if (1000 / cur_speed == new_speed)
265 new_speed += (cur_speed < s) ? -1 : 1;
266 if (new_speed > 60) return 1000 / (fact * 60);
267 return 1000 / (fact * new_speed);
268}
269
270static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
271 struct video_command *vc, int try)
272{
273 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
274
275 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
276 return -EINVAL;
277
278 switch (vc->cmd) {
279 case VIDEO_CMD_PLAY: {
25415cf3 280 vc->flags = 0;
1a0adaf3
HV		 281 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
282 if (vc->play.speed < 0)
283 vc->play.format = VIDEO_PLAY_FMT_GOP;
284 if (try) break;
285
286 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
287 return -EBUSY;
ac425144
HV		 288 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
289 /* forces ivtv_set_speed to be called */
290 itv->speed = 0;
291 }
1a0adaf3
HV		 292 return ivtv_start_decoding(id, vc->play.speed);
293 }
294
295 case VIDEO_CMD_STOP:
018ba85b 296 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
1a0adaf3
HV		 297 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
298 vc->stop.pts = 0;
299 if (try) break;
300 if (atomic_read(&itv->decoding) == 0)
301 return 0;
302 if (itv->output_mode != OUT_MPG)
303 return -EBUSY;
304
305 itv->output_mode = OUT_NONE;
306 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
307
308 case VIDEO_CMD_FREEZE:
018ba85b 309 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
1a0adaf3
HV		 310 if (try) break;
311 if (itv->output_mode != OUT_MPG)
312 return -EBUSY;
313 if (atomic_read(&itv->decoding) > 0) {
314 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
315 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
ac425144 316 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
1a0adaf3
HV		 317 }
318 break;
319
320 case VIDEO_CMD_CONTINUE:
25415cf3 321 vc->flags = 0;
1a0adaf3
HV		 322 if (try) break;
323 if (itv->output_mode != OUT_MPG)
324 return -EBUSY;
ac425144
HV		 325 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
326 int speed = itv->speed;
327 itv->speed = 0;
328 return ivtv_start_decoding(id, speed);
1a0adaf3
HV		 329 }
330 break;
331
332 default:
333 return -EINVAL;
334 }
335 return 0;
336}
337
338static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
339{
340 struct v4l2_register *regs = arg;
341 unsigned long flags;
342 volatile u8 __iomem *reg_start;
343
344 if (!capable(CAP_SYS_ADMIN))
345 return -EPERM;
346 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
347 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
348 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
349 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
350 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
351 else if (regs->reg >= 0 && regs->reg < IVTV_ENCODER_SIZE)
352 reg_start = itv->enc_mem;
353 else
354 return -EINVAL;
355
356 spin_lock_irqsave(&ivtv_cards_lock, flags);
357 if (cmd == VIDIOC_DBG_G_REGISTER) {
358 regs->val = readl(regs->reg + reg_start);
359 } else {
360 writel(regs->val, regs->reg + reg_start);
361 }
362 spin_unlock_irqrestore(&ivtv_cards_lock, flags);
363 return 0;
364}
365
366static int ivtv_get_fmt(struct ivtv *itv, int streamtype, struct v4l2_format *fmt)
367{
368 switch (fmt->type) {
369 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
370 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
371 return -EINVAL;
1a0adaf3
HV		 372 fmt->fmt.pix.width = itv->main_rect.width;
373 fmt->fmt.pix.height = itv->main_rect.height;
374 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
375 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
376 if (itv->output_mode == OUT_UDMA_YUV) {
377 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
378 case IVTV_YUV_MODE_INTERLACED:
379 fmt->fmt.pix.field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
380 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
381 break;
382 case IVTV_YUV_MODE_PROGRESSIVE:
383 fmt->fmt.pix.field = V4L2_FIELD_NONE;
384 break;
385 default:
386 fmt->fmt.pix.field = V4L2_FIELD_ANY;
387 break;
388 }
389 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
390 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
391 fmt->fmt.pix.sizeimage =
392 fmt->fmt.pix.height * fmt->fmt.pix.width +
393 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
394 }
395 else if (itv->output_mode == OUT_YUV ||
396 streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
397 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
398 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
399 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
400 fmt->fmt.pix.sizeimage =
401 fmt->fmt.pix.height * fmt->fmt.pix.width +
402 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
403 } else {
404 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
405 fmt->fmt.pix.sizeimage = 128 * 1024;
406 }
407 break;
408
409 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1a0adaf3
HV		 410 fmt->fmt.pix.width = itv->params.width;
411 fmt->fmt.pix.height = itv->params.height;
412 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
413 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
414 if (streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
415 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
416 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
417 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
418 fmt->fmt.pix.sizeimage =
419 fmt->fmt.pix.height * fmt->fmt.pix.width +
420 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
421 } else {
422 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
423 fmt->fmt.pix.sizeimage = 128 * 1024;
424 }
425 break;
426
427 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
428 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
429 return -EINVAL;
430 fmt->fmt.win.chromakey = itv->osd_color_key;
431 fmt->fmt.win.global_alpha = itv->osd_global_alpha;
432 break;
433
434 case V4L2_BUF_TYPE_VBI_CAPTURE:
435 fmt->fmt.vbi.sampling_rate = 27000000;
436 fmt->fmt.vbi.offset = 248;
437 fmt->fmt.vbi.samples_per_line = itv->vbi.raw_decoder_line_size - 4;
438 fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
439 fmt->fmt.vbi.start[0] = itv->vbi.start[0];
440 fmt->fmt.vbi.start[1] = itv->vbi.start[1];
441 fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = itv->vbi.count;
442 break;
443
444 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
445 {
446 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
447
448 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
449 return -EINVAL;
450 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
451 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
452 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
453 if (itv->is_60hz) {
454 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
455 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
456 } else {
457 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
458 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
459 }
460 vbifmt->service_set = get_service_set(vbifmt);
461 break;
462 }
463
464 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
465 {
466 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
467
468 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
469 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
470 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
471
472 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
473 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
474 V4L2_SLICED_VBI_525;
475 expand_service_set(vbifmt, itv->is_50hz);
476 break;
477 }
478
479 itv->video_dec_func(itv, VIDIOC_G_FMT, fmt);
480 vbifmt->service_set = get_service_set(vbifmt);
481 break;
482 }
483 case V4L2_BUF_TYPE_VBI_OUTPUT:
484 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
485 default:
486 return -EINVAL;
487 }
488 return 0;
489}
490
491static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
492 struct v4l2_format *fmt, int set_fmt)
493{
494 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
495 u16 set;
496
497 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
498 struct v4l2_rect r;
499 int field;
500
501 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
502 return -EINVAL;
503 field = fmt->fmt.pix.field;
c74e83a8
HV		 504 r.top = 0;
505 r.left = 0;
1a0adaf3
HV		 506 r.width = fmt->fmt.pix.width;
507 r.height = fmt->fmt.pix.height;
508 ivtv_get_fmt(itv, streamtype, fmt);
509 if (itv->output_mode != OUT_UDMA_YUV) {
510 /* TODO: would setting the rect also be valid for this mode? */
1a0adaf3
HV		 511 fmt->fmt.pix.width = r.width;
512 fmt->fmt.pix.height = r.height;
513 }
514 if (itv->output_mode == OUT_UDMA_YUV) {
515 /* TODO: add checks for validity */
516 fmt->fmt.pix.field = field;
517 }
518 if (set_fmt) {
519 if (itv->output_mode == OUT_UDMA_YUV) {
520 switch (field) {
521 case V4L2_FIELD_NONE:
522 itv->yuv_info.lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
523 break;
524 case V4L2_FIELD_ANY:
525 itv->yuv_info.lace_mode = IVTV_YUV_MODE_AUTO;
526 break;
527 case V4L2_FIELD_INTERLACED_BT:
528 itv->yuv_info.lace_mode =
529 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
530 break;
531 case V4L2_FIELD_INTERLACED_TB:
532 default:
533 itv->yuv_info.lace_mode = IVTV_YUV_MODE_INTERLACED;
534 break;
535 }
536 itv->yuv_info.lace_sync_field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
537
538 /* Force update of yuv registers */
539 itv->yuv_info.yuv_forced_update = 1;
540 return 0;
541 }
1a0adaf3
HV		 542 }
543 return 0;
544 }
545
546 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY) {
547 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
548 return -EINVAL;
549 if (set_fmt) {
550 itv->osd_color_key = fmt->fmt.win.chromakey;
551 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
552 ivtv_set_osd_alpha(itv);
553 }
554 return 0;
555 }
556
557 /* set window size */
558 if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
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 || (itv->params.width == w && itv->params.height == h))
571 return 0;
572 if (atomic_read(&itv->capturing) > 0)
573 return -EBUSY;
574
575 itv->params.width = w;
576 itv->params.height = h;
577 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
578 itv->params.video_temporal_filter = 0;
579 else
580 itv->params.video_temporal_filter = 8;
581 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
582 return ivtv_get_fmt(itv, streamtype, fmt);
583 }
584
585 /* set raw VBI format */
586 if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
ea115d54 587 if (set_fmt && atomic_read(&itv->capturing) > 0) {
1a0adaf3
HV		 588 return -EBUSY;
589 }
590 if (set_fmt) {
591 itv->vbi.sliced_in->service_set = 0;
592 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
593 }
594 return ivtv_get_fmt(itv, streamtype, fmt);
595 }
596
597 /* set sliced VBI output
598 In principle the user could request that only certain
599 VBI types are output and that the others are ignored.
600 I.e., suppress CC in the even fields or only output
601 WSS and no VPS. Currently though there is no choice. */
602 if (fmt->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
603 return ivtv_get_fmt(itv, streamtype, fmt);
604
605 /* any else but sliced VBI capture is an error */
606 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
607 return -EINVAL;
608
609 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI)
610 return ivtv_get_fmt(itv, streamtype, fmt);
611
612 /* set sliced VBI capture format */
613 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
614 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
615
616 if (vbifmt->service_set)
617 expand_service_set(vbifmt, itv->is_50hz);
618 set = check_service_set(vbifmt, itv->is_50hz);
619 vbifmt->service_set = get_service_set(vbifmt);
620
621 if (!set_fmt)
622 return 0;
623 if (set == 0)
624 return -EINVAL;
ea115d54 625 if (atomic_read(&itv->capturing) > 0) {
1a0adaf3
HV		 626 return -EBUSY;
627 }
628 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
629 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
630 return 0;
631}
632
d4e7ee36 633static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
1a0adaf3
HV		 634{
635 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
636 struct ivtv *itv = id->itv;
637 struct v4l2_register *reg = arg;
638
639 switch (cmd) {
640 /* ioctls to allow direct access to the encoder registers for testing */
641 case VIDIOC_DBG_G_REGISTER:
1a0adaf3
HV		 642 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
643 return ivtv_itvc(itv, cmd, arg);
644 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
645 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
646 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
647
648 case VIDIOC_DBG_S_REGISTER:
1a0adaf3
HV		 649 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
650 return ivtv_itvc(itv, cmd, arg);
651 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
652 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
653 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
654
655 case VIDIOC_G_CHIP_IDENT: {
656 struct v4l2_chip_ident *chip = arg;
657
1a0adaf3
HV		 658 chip->ident = V4L2_IDENT_NONE;
659 chip->revision = 0;
660 if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
661 if (v4l2_chip_match_host(reg->match_type, reg->match_chip)) {
662 struct v4l2_chip_ident *chip = arg;
663
664 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
665 }
666 return 0;
667 }
668 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
669 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
670 if (reg->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
671 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
672 return -EINVAL;
673 }
674
675 case VIDIOC_INT_S_AUDIO_ROUTING: {
676 struct v4l2_routing *route = arg;
677
1a0adaf3
HV		 678 ivtv_audio_set_route(itv, route);
679 break;
680 }
681
2cc72095
HV		 682 case VIDIOC_INT_RESET: {
683 u32 val = *(u32 *)arg;
684
685 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) {
686 ivtv_reset_ir_gpio(itv);
687 }
688 if (val & 0x02) {
689 itv->video_dec_func(itv, cmd, 0);
690 }
1a0adaf3 691 break;
2cc72095 692 }
1a0adaf3
HV		 693
694 default:
695 return -EINVAL;
696 }
697 return 0;
698}
699
700int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
701{
702 struct ivtv_open_id *id = NULL;
703
704 if (filp) id = (struct ivtv_open_id *)filp->private_data;
705
706 switch (cmd) {
d46c17d7
HV		 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
1a0adaf3
HV		 722 case VIDIOC_QUERYCAP:{
723 struct v4l2_capability *vcap = arg;
724
1a0adaf3
HV		 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
1a0adaf3
HV		 741 return ivtv_get_audio_input(itv, vin->index, vin);
742 }
743
744 case VIDIOC_G_AUDIO:{
745 struct v4l2_audio *vin = arg;
746
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 778 return ivtv_get_audio_output(itv, vout->index, vout);
779 }
780
781 case VIDIOC_ENUMINPUT:{
782 struct v4l2_input *vin = arg;
783
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 805 memset(fmt, 0, sizeof(*fmt));
806 fmt->type = type;
807 return ivtv_get_fmt(itv, id->type, fmt);
808 }
809
987e00ba
HV		 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
1a0adaf3
HV		 831 case VIDIOC_S_CROP: {
832 struct v4l2_crop *crop = arg;
833
987e00ba
HV		 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 }
1a0adaf3
HV		 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
987e00ba
HV		 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 }
1a0adaf3
HV		 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:{
1a0adaf3
HV		 893 *(int *)arg = itv->active_input;
894 break;
895 }
896
897 case VIDIOC_S_INPUT:{
898 int inp = *(int *)arg;
899
1a0adaf3
HV		 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 }
3562c43b
HV		 907 if (atomic_read(&itv->capturing) > 0) {
908 return -EBUSY;
909 }
1a0adaf3
HV		 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:{
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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:{
1a0adaf3
HV		 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
1a0adaf3
HV		 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 }
c4385098 1026 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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
1a0adaf3
HV		 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
d4e7ee36
HV		 1109 case VIDIOC_G_ENC_INDEX: {
1110 struct v4l2_enc_idx *idx = arg;
5614b021
HV		 1111 struct v4l2_enc_idx_entry *e = idx->entry;
1112 int entries;
d4e7ee36
HV		 1113 int i;
1114
5614b021 1115 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
d4e7ee36 1116 IVTV_MAX_PGM_INDEX;
5614b021
HV		 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 }
d4e7ee36
HV		 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
25415cf3 1136 memset(&enc->raw, 0, sizeof(enc->raw));
d4e7ee36
HV		 1137 switch (enc->cmd) {
1138 case V4L2_ENC_CMD_START:
1aa32c2f 1139 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
25415cf3
HV		 1140 enc->flags = 0;
1141 if (try)
1142 return 0;
d4e7ee36
HV		 1143 return ivtv_start_capture(id);
1144
1145 case V4L2_ENC_CMD_STOP:
1aa32c2f 1146 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
018ba85b 1147 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
25415cf3
HV		 1148 if (try)
1149 return 0;
d4e7ee36
HV		 1150 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1151 return 0;
1152
1153 case V4L2_ENC_CMD_PAUSE:
1aa32c2f 1154 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
25415cf3
HV		 1155 enc->flags = 0;
1156 if (try)
1157 return 0;
d4e7ee36
HV		 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:
1aa32c2f 1167 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
25415cf3
HV		 1168 enc->flags = 0;
1169 if (try)
1170 return 0;
d4e7ee36
HV		 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;
25415cf3 1178 default:
1aa32c2f 1179 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
25415cf3 1180 return -EINVAL;
d4e7ee36
HV		 1181 }
1182 break;
1183 }
1184
1185 case VIDIOC_G_FBUF: {
1186 struct v4l2_framebuffer *fb = arg;
1187
1188 memset(fb, 0, sizeof(*fb));
1189 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
f5948bba 1190 return -EINVAL;
d4e7ee36
HV		 1191 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1192 V4L2_FBUF_CAP_LOCAL_ALPHA | V4L2_FBUF_CAP_GLOBAL_ALPHA;
1193 fb->fmt.pixelformat = itv->osd_pixelformat;
1194 fb->fmt.width = itv->osd_rect.width;
1195 fb->fmt.height = itv->osd_rect.height;
d4e7ee36
HV		 1196 fb->base = (void *)itv->osd_video_pbase;
1197 if (itv->osd_global_alpha_state)
1198 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1199 if (itv->osd_local_alpha_state)
1200 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1201 if (itv->osd_color_key_state)
1202 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1203 break;
1204 }
1205
1206 case VIDIOC_S_FBUF: {
1207 struct v4l2_framebuffer *fb = arg;
1208
1209 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
f5948bba 1210 return -EINVAL;
d4e7ee36
HV		 1211 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1212 itv->osd_local_alpha_state = (fb->flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) != 0;
1213 itv->osd_color_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
c3624f99 1214 ivtv_set_osd_alpha(itv);
d4e7ee36
HV		 1215 break;
1216 }
1217
7c03a448
HV		 1218 case VIDIOC_OVERLAY: {
1219 int *on = arg;
1220
1221 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1222 return -EINVAL;
1223 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1224 break;
1225 }
1226
1a0adaf3
HV		 1227 case VIDIOC_LOG_STATUS:
1228 {
1229 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
7c03a448 1230 u32 data[CX2341X_MBOX_MAX_DATA];
1a0adaf3
HV		 1231 struct v4l2_input vidin;
1232 struct v4l2_audio audin;
1233 int i;
1234
1235 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv->num);
94104aa2 1236 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1a0adaf3
HV		 1237 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1238 struct tveeprom tv;
1239
1240 ivtv_read_eeprom(itv, &tv);
1241 }
1242 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1243 ivtv_get_input(itv, itv->active_input, &vidin);
1244 ivtv_get_audio_input(itv, itv->audio_input, &audin);
7c03a448
HV		 1245 IVTV_INFO("Video Input: %s\n", vidin.name);
1246 IVTV_INFO("Audio Input: %s%s\n", audin.name,
25e3f8f4 1247 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1a0adaf3
HV		 1248 if (has_output) {
1249 struct v4l2_output vidout;
1250 struct v4l2_audioout audout;
1251 int mode = itv->output_mode;
1252 static const char * const output_modes[] = {
1253 "None",
1254 "MPEG Streaming",
1255 "YUV Streaming",
1256 "YUV Frames",
1257 "Passthrough",
1258 };
25e3f8f4
HV		 1259 static const char * const audio_modes[] = {
1260 "Stereo",
1261 "Left",
1262 "Right",
1263 "Mono",
1264 "Swapped"
1265 };
7c03a448
HV		 1266 static const char * const alpha_mode[] = {
1267 "None",
1268 "Global",
1269 "Local",
1270 "Global and Local"
1271 };
1272 static const char * const pixel_format[] = {
d2a35fb1 1273 "RGB Indexed",
7c03a448
HV		 1274 "RGB 5:6:5",
1275 "ARGB 1:5:5:5",
1276 "ARGB 1:4:4:4",
1277 "ARGB 8:8:8:8",
1278 "5",
1279 "6",
1280 "7",
d2a35fb1
HV		 1281 "YUV Indexed",
1282 "YUV 5:6:5",
1283 "AYUV 1:5:5:5",
1284 "AYUV 1:4:4:4",
1285 "AYUV 8:8:8:8",
1286 "13",
1287 "14",
1288 "15",
7c03a448 1289 };
1a0adaf3
HV		 1290
1291 ivtv_get_output(itv, itv->active_output, &vidout);
1292 ivtv_get_audio_output(itv, 0, &audout);
1293 IVTV_INFO("Video Output: %s\n", vidout.name);
25e3f8f4
HV		 1294 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1295 audio_modes[itv->audio_stereo_mode],
1296 audio_modes[itv->audio_bilingual_mode]);
1a0adaf3
HV		 1297 if (mode < 0 || mode > OUT_PASSTHROUGH)
1298 mode = OUT_NONE;
7c03a448
HV		 1299 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1300 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
d2a35fb1 1301 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
7c03a448
HV		 1302 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1303 data[0] & 1 ? "On" : "Off",
1304 alpha_mode[(data[0] >> 1) & 0x3],
d2a35fb1 1305 pixel_format[(data[0] >> 3) & 0xf]);
1a0adaf3 1306 }
7c03a448 1307 IVTV_INFO("Tuner: %s\n",
1a0adaf3
HV		 1308 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1309 cx2341x_log_status(&itv->params, itv->name);
7c03a448 1310 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1a0adaf3
HV		 1311 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1312 struct ivtv_stream *s = &itv->streams[i];
1313
1314 if (s->v4l2dev == NULL || s->buffers == 0)
1315 continue;
1316 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1317 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1318 (s->buffers * s->buf_size) / 1024, s->buffers);
1319 }
7c03a448 1320 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1a0adaf3
HV		 1321 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv->num);
1322 break;
1323 }
1324
1325 default:
1326 return -EINVAL;
1327 }
1328 return 0;
1329}
1330
d4e7ee36 1331static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1a0adaf3
HV		 1332{
1333 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1334 struct ivtv *itv = id->itv;
1335 int nonblocking = filp->f_flags & O_NONBLOCK;
1336 struct ivtv_stream *s = &itv->streams[id->type];
1337
1338 switch (cmd) {
1339 case IVTV_IOC_DMA_FRAME: {
1340 struct ivtv_dma_frame *args = arg;
1341
1342 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1343 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1344 return -EINVAL;
1345 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1346 return -EINVAL;
1347 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1348 return 0;
1349 if (ivtv_claim_stream(id, id->type)) {
1350 return -EBUSY;
1351 }
1352 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1353 ivtv_release_stream(s);
1354 return -EBUSY;
1355 }
ad8ff0f1
HV		 1356 /* Mark that this file handle started the UDMA_YUV mode */
1357 id->yuv_frames = 1;
1a0adaf3
HV		 1358 if (args->y_source == NULL)
1359 return 0;
1360 return ivtv_yuv_prep_frame(itv, args);
1361 }
1362
1363 case VIDEO_GET_PTS: {
1364 u32 data[CX2341X_MBOX_MAX_DATA];
1365 u64 *pts = arg;
1366
1367 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1368 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1369 *pts = s->dma_pts;
1370 break;
1371 }
1372 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1373 return -EINVAL;
1374
1375 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1376 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1377 (u64)itv->last_dec_timing[1];
1378 break;
1379 }
1380 *pts = 0;
1381 if (atomic_read(&itv->decoding)) {
1382 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1383 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1384 return -EIO;
1385 }
1386 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1387 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1388 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1389 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1390 }
1391 break;
1392 }
1393
1394 case VIDEO_GET_FRAME_COUNT: {
1395 u32 data[CX2341X_MBOX_MAX_DATA];
1396 u64 *frame = arg;
1397
1398 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1399 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1400 *frame = 0;
1401 break;
1402 }
1403 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1404 return -EINVAL;
1405
1406 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1407 *frame = itv->last_dec_timing[0];
1408 break;
1409 }
1410 *frame = 0;
1411 if (atomic_read(&itv->decoding)) {
1412 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1413 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1414 return -EIO;
1415 }
1416 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1417 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1418 *frame = data[0];
1419 }
1420 break;
1421 }
1422
1423 case VIDEO_PLAY: {
1424 struct video_command vc;
1425
1426 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1427 memset(&vc, 0, sizeof(vc));
1428 vc.cmd = VIDEO_CMD_PLAY;
1429 return ivtv_video_command(itv, id, &vc, 0);
1430 }
1431
1432 case VIDEO_STOP: {
1433 struct video_command vc;
1434
1435 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1436 memset(&vc, 0, sizeof(vc));
1437 vc.cmd = VIDEO_CMD_STOP;
1438 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1439 return ivtv_video_command(itv, id, &vc, 0);
1440 }
1441
1442 case VIDEO_FREEZE: {
1443 struct video_command vc;
1444
1445 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1446 memset(&vc, 0, sizeof(vc));
1447 vc.cmd = VIDEO_CMD_FREEZE;
1448 return ivtv_video_command(itv, id, &vc, 0);
1449 }
1450
1451 case VIDEO_CONTINUE: {
1452 struct video_command vc;
1453
1454 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1455 memset(&vc, 0, sizeof(vc));
1456 vc.cmd = VIDEO_CMD_CONTINUE;
1457 return ivtv_video_command(itv, id, &vc, 0);
1458 }
1459
1460 case VIDEO_COMMAND:
1461 case VIDEO_TRY_COMMAND: {
1462 struct video_command *vc = arg;
1463 int try = (cmd == VIDEO_TRY_COMMAND);
1464
1465 if (try)
1aa32c2f 1466 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1a0adaf3 1467 else
1aa32c2f 1468 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1a0adaf3
HV		 1469 return ivtv_video_command(itv, id, vc, try);
1470 }
1471
1472 case VIDEO_GET_EVENT: {
1473 struct video_event *ev = arg;
1474 DEFINE_WAIT(wait);
1475
1476 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1477 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1478 return -EINVAL;
1479 memset(ev, 0, sizeof(*ev));
1480 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1481
1482 while (1) {
1483 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1484 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1485 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1486 ev->type = VIDEO_EVENT_VSYNC;
037c86c5
HV		 1487 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1488 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1489 if (itv->output_mode == OUT_UDMA_YUV &&
1490 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1491 IVTV_YUV_MODE_PROGRESSIVE) {
1492 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1493 }
1a0adaf3
HV		 1494 }
1495 if (ev->type)
1496 return 0;
1497 if (nonblocking)
1498 return -EAGAIN;
baa4072d
HV		 1499 /* Wait for event. Note that serialize_lock is locked,
1500 so to allow other processes to access the driver while
1501 we are waiting unlock first and later lock again. */
1502 mutex_unlock(&itv->serialize_lock);
1a0adaf3
HV		 1503 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1504 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1505 schedule();
1506 finish_wait(&itv->event_waitq, &wait);
baa4072d 1507 mutex_lock(&itv->serialize_lock);
1a0adaf3
HV		 1508 if (signal_pending(current)) {
1509 /* return if a signal was received */
1510 IVTV_DEBUG_INFO("User stopped wait for event\n");
1511 return -EINTR;
1512 }
1513 }
1514 break;
1515 }
1516
1a0adaf3
HV		 1517 default:
1518 return -EINVAL;
1519 }
1520 return 0;
1521}
1522
1523static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1524 unsigned int cmd, void *arg)
1525{
1526 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1527 struct ivtv *itv = id->itv;
d46c17d7 1528 int ret;
1a0adaf3 1529
d46c17d7
HV		 1530 /* check priority */
1531 switch (cmd) {
1532 case VIDIOC_S_CTRL:
1533 case VIDIOC_S_STD:
1534 case VIDIOC_S_INPUT:
1535 case VIDIOC_S_OUTPUT:
1536 case VIDIOC_S_TUNER:
1537 case VIDIOC_S_FREQUENCY:
1538 case VIDIOC_S_FMT:
1539 case VIDIOC_S_CROP:
1540 case VIDIOC_S_AUDIO:
1541 case VIDIOC_S_AUDOUT:
1542 case VIDIOC_S_EXT_CTRLS:
1543 case VIDIOC_S_FBUF:
7c03a448 1544 case VIDIOC_OVERLAY:
d46c17d7
HV		 1545 ret = v4l2_prio_check(&itv->prio, &id->prio);
1546 if (ret)
1547 return ret;
1548 }
1549
1a0adaf3
HV		 1550 switch (cmd) {
1551 case VIDIOC_DBG_G_REGISTER:
1552 case VIDIOC_DBG_S_REGISTER:
1553 case VIDIOC_G_CHIP_IDENT:
1554 case VIDIOC_INT_S_AUDIO_ROUTING:
1555 case VIDIOC_INT_RESET:
d4e7ee36
HV		 1556 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1557 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1558 v4l_printk_ioctl(cmd);
1559 }
1560 return ivtv_debug_ioctls(filp, cmd, arg);
1a0adaf3 1561
d46c17d7
HV		 1562 case VIDIOC_G_PRIORITY:
1563 case VIDIOC_S_PRIORITY:
1a0adaf3
HV		 1564 case VIDIOC_QUERYCAP:
1565 case VIDIOC_ENUMINPUT:
1566 case VIDIOC_G_INPUT:
1567 case VIDIOC_S_INPUT:
1568 case VIDIOC_ENUMOUTPUT:
1569 case VIDIOC_G_OUTPUT:
1570 case VIDIOC_S_OUTPUT:
1571 case VIDIOC_G_FMT:
1572 case VIDIOC_S_FMT:
1573 case VIDIOC_TRY_FMT:
1574 case VIDIOC_ENUM_FMT:
987e00ba 1575 case VIDIOC_CROPCAP:
1a0adaf3
HV		 1576 case VIDIOC_G_CROP:
1577 case VIDIOC_S_CROP:
1578 case VIDIOC_G_FREQUENCY:
1579 case VIDIOC_S_FREQUENCY:
1580 case VIDIOC_ENUMSTD:
1581 case VIDIOC_G_STD:
1582 case VIDIOC_S_STD:
1583 case VIDIOC_S_TUNER:
1584 case VIDIOC_G_TUNER:
1585 case VIDIOC_ENUMAUDIO:
1586 case VIDIOC_S_AUDIO:
1587 case VIDIOC_G_AUDIO:
1588 case VIDIOC_ENUMAUDOUT:
1589 case VIDIOC_S_AUDOUT:
1590 case VIDIOC_G_AUDOUT:
1591 case VIDIOC_G_SLICED_VBI_CAP:
1592 case VIDIOC_LOG_STATUS:
d4e7ee36
HV		 1593 case VIDIOC_G_ENC_INDEX:
1594 case VIDIOC_ENCODER_CMD:
1595 case VIDIOC_TRY_ENCODER_CMD:
1596 case VIDIOC_G_FBUF:
1597 case VIDIOC_S_FBUF:
7c03a448 1598 case VIDIOC_OVERLAY:
d4e7ee36
HV		 1599 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1600 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1601 v4l_printk_ioctl(cmd);
1602 }
1a0adaf3
HV		 1603 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1604
1605 case VIDIOC_QUERYMENU:
1606 case VIDIOC_QUERYCTRL:
1607 case VIDIOC_S_CTRL:
1608 case VIDIOC_G_CTRL:
1609 case VIDIOC_S_EXT_CTRLS:
1610 case VIDIOC_G_EXT_CTRLS:
1611 case VIDIOC_TRY_EXT_CTRLS:
d4e7ee36
HV		 1612 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1613 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1614 v4l_printk_ioctl(cmd);
1615 }
1a0adaf3
HV		 1616 return ivtv_control_ioctls(itv, cmd, arg);
1617
1618 case IVTV_IOC_DMA_FRAME:
1619 case VIDEO_GET_PTS:
1620 case VIDEO_GET_FRAME_COUNT:
1621 case VIDEO_GET_EVENT:
1622 case VIDEO_PLAY:
1623 case VIDEO_STOP:
1624 case VIDEO_FREEZE:
1625 case VIDEO_CONTINUE:
1626 case VIDEO_COMMAND:
1627 case VIDEO_TRY_COMMAND:
d4e7ee36 1628 return ivtv_decoder_ioctls(filp, cmd, arg);
1a0adaf3
HV		 1629
1630 case 0x00005401: /* Handle isatty() calls */
1631 return -EINVAL;
1632 default:
1633 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1634 ivtv_v4l2_do_ioctl);
1635 }
1636 return 0;
1637}
1638
baa4072d
HV		 1639static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1640 unsigned int cmd, unsigned long arg)
1a0adaf3 1641{
1a0adaf3
HV		 1642 /* Filter dvb ioctls that cannot be handled by video_usercopy */
1643 switch (cmd) {
1644 case VIDEO_SELECT_SOURCE:
1645 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1646 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1647 return -EINVAL;
1648 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1649
1650 case AUDIO_SET_MUTE:
1651 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1652 itv->speed_mute_audio = arg;
1653 return 0;
1654
1655 case AUDIO_CHANNEL_SELECT:
1656 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1657 if (arg > AUDIO_STEREO_SWAPPED)
1658 return -EINVAL;
1659 itv->audio_stereo_mode = arg;
1660 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1661 return 0;
1662
1663 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1664 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1665 if (arg > AUDIO_STEREO_SWAPPED)
1666 return -EINVAL;
1667 itv->audio_bilingual_mode = arg;
1668 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1669 return 0;
1670
1671 default:
1672 break;
1673 }
1674 return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1675}
baa4072d
HV		 1676
1677int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1678 unsigned long arg)
1679{
1680 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1681 struct ivtv *itv = id->itv;
1682 int res;
1683
1684 mutex_lock(&itv->serialize_lock);
1685 res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1686 mutex_unlock(&itv->serialize_lock);
1687 return res;
1688}
Linux kernel - Deliverables
This page took 0.216896 seconds and 5 git commands to generate.