projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (7757): ivtv: add autodetect for the AVermedia M104 card
[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"
33c0fcad 28#include "ivtv-routing.h"
1a0adaf3
HV		 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
41u16 service2vbi(int type)
42{
43 switch (type) {
44 case V4L2_SLICED_TELETEXT_B:
45 return IVTV_SLICED_TYPE_TELETEXT_B;
46 case V4L2_SLICED_CAPTION_525:
47 return IVTV_SLICED_TYPE_CAPTION_525;
48 case V4L2_SLICED_WSS_625:
49 return IVTV_SLICED_TYPE_WSS_625;
50 case V4L2_SLICED_VPS:
51 return IVTV_SLICED_TYPE_VPS;
52 default:
53 return 0;
54 }
55}
56
57static int valid_service_line(int field, int line, int is_pal)
58{
59 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
60 (!is_pal && line >= 10 && line < 22);
61}
62
63static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
64{
65 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
66 int i;
67
68 set = set & valid_set;
69 if (set == 0 || !valid_service_line(field, line, is_pal)) {
70 return 0;
71 }
72 if (!is_pal) {
73 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
74 return V4L2_SLICED_CAPTION_525;
75 }
76 else {
77 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
78 return V4L2_SLICED_VPS;
79 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
80 return V4L2_SLICED_WSS_625;
81 if (line == 23)
82 return 0;
83 }
84 for (i = 0; i < 32; i++) {
85 if ((1 << i) & set)
86 return 1 << i;
87 }
88 return 0;
89}
90
91void expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
92{
93 u16 set = fmt->service_set;
94 int f, l;
95
96 fmt->service_set = 0;
97 for (f = 0; f < 2; f++) {
98 for (l = 0; l < 24; l++) {
99 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
100 }
101 }
102}
103
104static 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
118u16 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
131static 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
150static const struct v4l2_standard ivtv_std_60hz =
151{
152 .frameperiod = {.numerator = 1001, .denominator = 30000},
153 .framelines = 525,
154};
155
156static const struct v4l2_standard ivtv_std_50hz =
157{
158 .frameperiod = {.numerator = 1, .denominator = 25},
159 .framelines = 625,
160};
161
162void 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);
fd8b281a 166 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
1a0adaf3
HV		 167}
168
169int 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
241static 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
269static 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: {
25415cf3 279 vc->flags = 0;
1a0adaf3
HV		 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;
ac425144
HV		 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 }
1a0adaf3
HV		 291 return ivtv_start_decoding(id, vc->play.speed);
292 }
293
294 case VIDEO_CMD_STOP:
018ba85b 295 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
1a0adaf3
HV		 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:
018ba85b 308 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
1a0adaf3
HV		 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);
ac425144 315 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
1a0adaf3
HV		 316 }
317 break;
318
319 case VIDEO_CMD_CONTINUE:
25415cf3 320 vc->flags = 0;
1a0adaf3
HV		 321 if (try) break;
322 if (itv->output_mode != OUT_MPG)
323 return -EBUSY;
ac425144
HV		 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);
1a0adaf3
HV		 328 }
329 break;
330
331 default:
332 return -EINVAL;
333 }
334 return 0;
335}
336
337static 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
365static 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;
1a0adaf3
HV		 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;
77aded6b 375 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
1a0adaf3
HV		 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;
77aded6b
IA		 389 fmt->fmt.pix.bytesperline = 720;
390 fmt->fmt.pix.width = itv->yuv_info.v4l2_src_w;
391 fmt->fmt.pix.height = itv->yuv_info.v4l2_src_h;
1a0adaf3
HV		 392 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
393 fmt->fmt.pix.sizeimage =
77aded6b
IA		 394 1080 * ((fmt->fmt.pix.height + 31) & ~31);
395 } else if (streamtype == IVTV_ENC_STREAM_TYPE_YUV) {
1a0adaf3
HV		 396 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
397 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
398 fmt->fmt.pix.sizeimage =
399 fmt->fmt.pix.height * fmt->fmt.pix.width +
400 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
401 } else {
402 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
403 fmt->fmt.pix.sizeimage = 128 * 1024;
404 }
405 break;
406
407 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1a0adaf3
HV		 408 fmt->fmt.pix.width = itv->params.width;
409 fmt->fmt.pix.height = itv->params.height;
410 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
411 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
412 if (streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
413 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
414 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
415 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
416 fmt->fmt.pix.sizeimage =
417 fmt->fmt.pix.height * fmt->fmt.pix.width +
418 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
419 } else {
420 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
421 fmt->fmt.pix.sizeimage = 128 * 1024;
422 }
423 break;
424
425 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
426 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
427 return -EINVAL;
fd8b281a 428 fmt->fmt.win.chromakey = itv->osd_chroma_key;
1a0adaf3
HV		 429 fmt->fmt.win.global_alpha = itv->osd_global_alpha;
430 break;
431
432 case V4L2_BUF_TYPE_VBI_CAPTURE:
433 fmt->fmt.vbi.sampling_rate = 27000000;
434 fmt->fmt.vbi.offset = 248;
435 fmt->fmt.vbi.samples_per_line = itv->vbi.raw_decoder_line_size - 4;
436 fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
437 fmt->fmt.vbi.start[0] = itv->vbi.start[0];
438 fmt->fmt.vbi.start[1] = itv->vbi.start[1];
439 fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = itv->vbi.count;
440 break;
441
442 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
443 {
444 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
445
446 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
447 return -EINVAL;
448 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
449 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
450 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
451 if (itv->is_60hz) {
452 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
453 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
454 } else {
455 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
456 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
457 }
458 vbifmt->service_set = get_service_set(vbifmt);
459 break;
460 }
461
462 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
463 {
464 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
465
466 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
467 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
468 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
469
470 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
471 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
472 V4L2_SLICED_VBI_525;
473 expand_service_set(vbifmt, itv->is_50hz);
474 break;
475 }
476
477 itv->video_dec_func(itv, VIDIOC_G_FMT, fmt);
478 vbifmt->service_set = get_service_set(vbifmt);
479 break;
480 }
481 case V4L2_BUF_TYPE_VBI_OUTPUT:
482 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
483 default:
484 return -EINVAL;
485 }
486 return 0;
487}
488
489static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
490 struct v4l2_format *fmt, int set_fmt)
491{
77aded6b 492 struct yuv_playback_info *yi = &itv->yuv_info;
1a0adaf3
HV		 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;
c74e83a8
HV		 503 r.top = 0;
504 r.left = 0;
1a0adaf3
HV		 505 r.width = fmt->fmt.pix.width;
506 r.height = fmt->fmt.pix.height;
507 ivtv_get_fmt(itv, streamtype, fmt);
77aded6b
IA		 508 fmt->fmt.pix.width = r.width;
509 fmt->fmt.pix.height = r.height;
510 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
1a0adaf3 511 fmt->fmt.pix.field = field;
77aded6b
IA		 512 if (fmt->fmt.pix.width < 2)
513 fmt->fmt.pix.width = 2;
514 if (fmt->fmt.pix.width > 720)
515 fmt->fmt.pix.width = 720;
516 if (fmt->fmt.pix.height < 2)
517 fmt->fmt.pix.height = 2;
518 if (fmt->fmt.pix.height > 576)
519 fmt->fmt.pix.height = 576;
1a0adaf3 520 }
77aded6b
IA		 521 if (set_fmt && streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
522 /* Return now if we already have some frame data */
523 if (yi->stream_size)
524 return -EBUSY;
1a0adaf3 525
77aded6b
IA		 526 yi->v4l2_src_w = r.width;
527 yi->v4l2_src_h = r.height;
528
529 switch (field) {
530 case V4L2_FIELD_NONE:
531 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
532 break;
533 case V4L2_FIELD_ANY:
534 yi->lace_mode = IVTV_YUV_MODE_AUTO;
535 break;
536 case V4L2_FIELD_INTERLACED_BT:
537 yi->lace_mode =
538 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
539 break;
540 case V4L2_FIELD_INTERLACED_TB:
541 default:
542 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
543 break;
1a0adaf3 544 }
77aded6b
IA		 545 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
546
547 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
548 itv->dma_data_req_size =
549 1080 * ((yi->v4l2_src_h + 31) & ~31);
550
551 /* Force update of yuv registers */
552 yi->yuv_forced_update = 1;
553 return 0;
1a0adaf3
HV		 554 }
555 return 0;
556 }
557
558 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY) {
559 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
560 return -EINVAL;
561 if (set_fmt) {
fd8b281a 562 itv->osd_chroma_key = fmt->fmt.win.chromakey;
1a0adaf3
HV		 563 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
564 ivtv_set_osd_alpha(itv);
565 }
566 return 0;
567 }
568
569 /* set window size */
570 if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
34ca7d37 571 struct cx2341x_mpeg_params *p = &itv->params;
1a0adaf3
HV		 572 int w = fmt->fmt.pix.width;
573 int h = fmt->fmt.pix.height;
574
575 if (w > 720) w = 720;
576 else if (w < 1) w = 1;
577 if (h > (itv->is_50hz ? 576 : 480)) h = (itv->is_50hz ? 576 : 480);
578 else if (h < 2) h = 2;
579 ivtv_get_fmt(itv, streamtype, fmt);
580 fmt->fmt.pix.width = w;
581 fmt->fmt.pix.height = h;
582
34ca7d37 583 if (!set_fmt || (p->width == w && p->height == h))
1a0adaf3
HV		 584 return 0;
585 if (atomic_read(&itv->capturing) > 0)
586 return -EBUSY;
587
34ca7d37
HV		 588 p->width = w;
589 p->height = h;
1a0adaf3 590 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
34ca7d37 591 p->video_temporal_filter = 0;
1a0adaf3 592 else
34ca7d37
HV		 593 p->video_temporal_filter = 8;
594 if (p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
595 fmt->fmt.pix.width /= 2;
1a0adaf3
HV		 596 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
597 return ivtv_get_fmt(itv, streamtype, fmt);
598 }
599
600 /* set raw VBI format */
601 if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
ea115d54 602 if (set_fmt && atomic_read(&itv->capturing) > 0) {
1a0adaf3
HV		 603 return -EBUSY;
604 }
605 if (set_fmt) {
606 itv->vbi.sliced_in->service_set = 0;
607 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
608 }
609 return ivtv_get_fmt(itv, streamtype, fmt);
610 }
611
612 /* set sliced VBI output
613 In principle the user could request that only certain
614 VBI types are output and that the others are ignored.
615 I.e., suppress CC in the even fields or only output
616 WSS and no VPS. Currently though there is no choice. */
617 if (fmt->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
618 return ivtv_get_fmt(itv, streamtype, fmt);
619
620 /* any else but sliced VBI capture is an error */
621 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
622 return -EINVAL;
623
624 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI)
625 return ivtv_get_fmt(itv, streamtype, fmt);
626
627 /* set sliced VBI capture format */
628 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
629 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
630
631 if (vbifmt->service_set)
632 expand_service_set(vbifmt, itv->is_50hz);
633 set = check_service_set(vbifmt, itv->is_50hz);
634 vbifmt->service_set = get_service_set(vbifmt);
635
636 if (!set_fmt)
637 return 0;
638 if (set == 0)
639 return -EINVAL;
ea115d54 640 if (atomic_read(&itv->capturing) > 0) {
1a0adaf3
HV		 641 return -EBUSY;
642 }
643 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
644 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
645 return 0;
646}
647
d4e7ee36 648static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
1a0adaf3
HV		 649{
650 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
651 struct ivtv *itv = id->itv;
652 struct v4l2_register *reg = arg;
653
654 switch (cmd) {
655 /* ioctls to allow direct access to the encoder registers for testing */
656 case VIDIOC_DBG_G_REGISTER:
1a0adaf3
HV		 657 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
658 return ivtv_itvc(itv, cmd, arg);
659 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
660 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
661 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
662
663 case VIDIOC_DBG_S_REGISTER:
1a0adaf3
HV		 664 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
665 return ivtv_itvc(itv, cmd, arg);
666 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
667 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
668 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
669
670 case VIDIOC_G_CHIP_IDENT: {
671 struct v4l2_chip_ident *chip = arg;
672
1a0adaf3
HV		 673 chip->ident = V4L2_IDENT_NONE;
674 chip->revision = 0;
675 if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
e1ba33df 676 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
1a0adaf3 677 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
1a0adaf3
HV		 678 return 0;
679 }
680 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
681 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
682 if (reg->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
683 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
684 return -EINVAL;
685 }
686
687 case VIDIOC_INT_S_AUDIO_ROUTING: {
688 struct v4l2_routing *route = arg;
689
33c0fcad 690 ivtv_i2c_hw(itv, itv->card->hw_audio, VIDIOC_INT_S_AUDIO_ROUTING, route);
1a0adaf3
HV		 691 break;
692 }
693
2cc72095
HV		 694 case VIDIOC_INT_RESET: {
695 u32 val = *(u32 *)arg;
696
697 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) {
698 ivtv_reset_ir_gpio(itv);
699 }
700 if (val & 0x02) {
14d5deba 701 itv->video_dec_func(itv, cmd, NULL);
2cc72095 702 }
1a0adaf3 703 break;
2cc72095 704 }
1a0adaf3
HV		 705
706 default:
707 return -EINVAL;
708 }
709 return 0;
710}
711
712int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
713{
714 struct ivtv_open_id *id = NULL;
88ab075a 715 struct yuv_playback_info *yi = &itv->yuv_info;
2d4d5f11 716 u32 data[CX2341X_MBOX_MAX_DATA];
77aded6b 717 int streamtype = 0;
1a0adaf3 718
77aded6b
IA		 719 if (filp) {
720 id = (struct ivtv_open_id *)filp->private_data;
721 streamtype = id->type;
722 }
1a0adaf3
HV		 723
724 switch (cmd) {
d46c17d7
HV		 725 case VIDIOC_G_PRIORITY:
726 {
727 enum v4l2_priority *p = arg;
728
729 *p = v4l2_prio_max(&itv->prio);
730 break;
731 }
732
733 case VIDIOC_S_PRIORITY:
734 {
735 enum v4l2_priority *prio = arg;
736
737 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
738 }
739
1a0adaf3
HV		 740 case VIDIOC_QUERYCAP:{
741 struct v4l2_capability *vcap = arg;
742
1a0adaf3 743 memset(vcap, 0, sizeof(*vcap));
cebfadff
HV		 744 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
745 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
746 strlcpy(vcap->bus_info, pci_name(itv->dev), sizeof(vcap->bus_info));
1a0adaf3
HV		 747 vcap->version = IVTV_DRIVER_VERSION; /* version */
748 vcap->capabilities = itv->v4l2_cap; /* capabilities */
749
750 /* reserved.. must set to 0! */
751 vcap->reserved[0] = vcap->reserved[1] =
752 vcap->reserved[2] = vcap->reserved[3] = 0;
753 break;
754 }
755
756 case VIDIOC_ENUMAUDIO:{
757 struct v4l2_audio *vin = arg;
758
1a0adaf3
HV		 759 return ivtv_get_audio_input(itv, vin->index, vin);
760 }
761
762 case VIDIOC_G_AUDIO:{
763 struct v4l2_audio *vin = arg;
764
1a0adaf3
HV		 765 vin->index = itv->audio_input;
766 return ivtv_get_audio_input(itv, vin->index, vin);
767 }
768
769 case VIDIOC_S_AUDIO:{
770 struct v4l2_audio *vout = arg;
771
1a0adaf3
HV		 772 if (vout->index >= itv->nof_audio_inputs)
773 return -EINVAL;
774 itv->audio_input = vout->index;
775 ivtv_audio_set_io(itv);
776 break;
777 }
778
779 case VIDIOC_ENUMAUDOUT:{
780 struct v4l2_audioout *vin = arg;
781
1a0adaf3
HV		 782 /* set it to defaults from our table */
783 return ivtv_get_audio_output(itv, vin->index, vin);
784 }
785
786 case VIDIOC_G_AUDOUT:{
787 struct v4l2_audioout *vin = arg;
788
1a0adaf3
HV		 789 vin->index = 0;
790 return ivtv_get_audio_output(itv, vin->index, vin);
791 }
792
793 case VIDIOC_S_AUDOUT:{
794 struct v4l2_audioout *vout = arg;
795
1a0adaf3
HV		 796 return ivtv_get_audio_output(itv, vout->index, vout);
797 }
798
799 case VIDIOC_ENUMINPUT:{
800 struct v4l2_input *vin = arg;
801
1a0adaf3
HV		 802 /* set it to defaults from our table */
803 return ivtv_get_input(itv, vin->index, vin);
804 }
805
806 case VIDIOC_ENUMOUTPUT:{
807 struct v4l2_output *vout = arg;
808
1a0adaf3
HV		 809 return ivtv_get_output(itv, vout->index, vout);
810 }
811
812 case VIDIOC_TRY_FMT:
813 case VIDIOC_S_FMT: {
814 struct v4l2_format *fmt = arg;
815
1a0adaf3
HV		 816 return ivtv_try_or_set_fmt(itv, id->type, fmt, cmd == VIDIOC_S_FMT);
817 }
818
819 case VIDIOC_G_FMT: {
820 struct v4l2_format *fmt = arg;
821 int type = fmt->type;
822
1a0adaf3
HV		 823 memset(fmt, 0, sizeof(*fmt));
824 fmt->type = type;
825 return ivtv_get_fmt(itv, id->type, fmt);
826 }
827
987e00ba
HV		 828 case VIDIOC_CROPCAP: {
829 struct v4l2_cropcap *cropcap = arg;
830
c9aec06f 831 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
987e00ba
HV		 832 return -EINVAL;
833 cropcap->bounds.top = cropcap->bounds.left = 0;
834 cropcap->bounds.width = 720;
835 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
836 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
837 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
838 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
77aded6b 839 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
88ab075a
IA		 840 if (yi->track_osd) {
841 cropcap->bounds.width = yi->osd_full_w;
842 cropcap->bounds.height = yi->osd_full_h;
843 } else {
844 cropcap->bounds.width = 720;
845 cropcap->bounds.height =
846 itv->is_out_50hz ? 576 : 480;
847 }
77aded6b
IA		 848 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
849 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
987e00ba
HV		 850 } else {
851 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
852 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
853 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
854 }
855 cropcap->defrect = cropcap->bounds;
856 return 0;
857 }
858
1a0adaf3
HV		 859 case VIDIOC_S_CROP: {
860 struct v4l2_crop *crop = arg;
861
987e00ba
HV		 862 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
863 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
77aded6b 864 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
88ab075a 865 yi->main_rect = crop->c;
987e00ba 866 return 0;
77aded6b
IA		 867 } else {
868 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
869 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
870 itv->main_rect = crop->c;
871 return 0;
872 }
987e00ba
HV		 873 }
874 return -EINVAL;
875 }
c9aec06f 876 return -EINVAL;
1a0adaf3
HV		 877 }
878
879 case VIDIOC_G_CROP: {
880 struct v4l2_crop *crop = arg;
881
987e00ba
HV		 882 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
883 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
77aded6b 884 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
88ab075a 885 crop->c = yi->main_rect;
77aded6b
IA		 886 else
887 crop->c = itv->main_rect;
987e00ba
HV		 888 return 0;
889 }
c9aec06f 890 return -EINVAL;
1a0adaf3
HV		 891 }
892
893 case VIDIOC_ENUM_FMT: {
894 static struct v4l2_fmtdesc formats[] = {
895 { 0, 0, 0,
368f080b 896 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
1a0adaf3
HV		 897 { 0, 0, 0, 0 }
898 },
899 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
900 "MPEG", V4L2_PIX_FMT_MPEG,
901 { 0, 0, 0, 0 }
902 }
903 };
904 struct v4l2_fmtdesc *fmt = arg;
905 enum v4l2_buf_type type = fmt->type;
906
907 switch (type) {
908 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
909 break;
910 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
911 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
912 return -EINVAL;
913 break;
914 default:
915 return -EINVAL;
916 }
917 if (fmt->index > 1)
918 return -EINVAL;
919 *fmt = formats[fmt->index];
920 fmt->type = type;
921 return 0;
922 }
923
924 case VIDIOC_G_INPUT:{
1a0adaf3
HV		 925 *(int *)arg = itv->active_input;
926 break;
927 }
928
929 case VIDIOC_S_INPUT:{
930 int inp = *(int *)arg;
931
1a0adaf3
HV		 932 if (inp < 0 || inp >= itv->nof_inputs)
933 return -EINVAL;
934
935 if (inp == itv->active_input) {
936 IVTV_DEBUG_INFO("Input unchanged\n");
937 break;
938 }
3562c43b
HV		 939 if (atomic_read(&itv->capturing) > 0) {
940 return -EBUSY;
941 }
1a0adaf3
HV		 942 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
943 itv->active_input, inp);
944
945 itv->active_input = inp;
946 /* Set the audio input to whatever is appropriate for the
947 input type. */
948 itv->audio_input = itv->card->video_inputs[inp].audio_index;
949
950 /* prevent others from messing with the streams until
951 we're finished changing inputs. */
952 ivtv_mute(itv);
953 ivtv_video_set_io(itv);
954 ivtv_audio_set_io(itv);
955 ivtv_unmute(itv);
956 break;
957 }
958
959 case VIDIOC_G_OUTPUT:{
1a0adaf3
HV		 960 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
961 return -EINVAL;
962 *(int *)arg = itv->active_output;
963 break;
964 }
965
966 case VIDIOC_S_OUTPUT:{
967 int outp = *(int *)arg;
968 struct v4l2_routing route;
969
1a0adaf3
HV		 970 if (outp >= itv->card->nof_outputs)
971 return -EINVAL;
972
973 if (outp == itv->active_output) {
974 IVTV_DEBUG_INFO("Output unchanged\n");
975 break;
976 }
977 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
978 itv->active_output, outp);
979
980 itv->active_output = outp;
981 route.input = SAA7127_INPUT_TYPE_NORMAL;
982 route.output = itv->card->video_outputs[outp].video_output;
983 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
984 break;
985 }
986
987 case VIDIOC_G_FREQUENCY:{
988 struct v4l2_frequency *vf = arg;
989
1a0adaf3
HV		 990 if (vf->tuner != 0)
991 return -EINVAL;
992 ivtv_call_i2c_clients(itv, cmd, arg);
993 break;
994 }
995
996 case VIDIOC_S_FREQUENCY:{
997 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
998
1a0adaf3
HV		 999 if (vf.tuner != 0)
1000 return -EINVAL;
1001
1002 ivtv_mute(itv);
1003 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
1004 ivtv_call_i2c_clients(itv, cmd, &vf);
1005 ivtv_unmute(itv);
1006 break;
1007 }
1008
1009 case VIDIOC_ENUMSTD:{
1010 struct v4l2_standard *vs = arg;
1011 int idx = vs->index;
1012
1a0adaf3
HV		 1013 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
1014 return -EINVAL;
1015
1016 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
1017 ivtv_std_60hz : ivtv_std_50hz;
1018 vs->index = idx;
1019 vs->id = enum_stds[idx].std;
cebfadff 1020 strlcpy(vs->name, enum_stds[idx].name, sizeof(vs->name));
1a0adaf3
HV		 1021 break;
1022 }
1023
1024 case VIDIOC_G_STD:{
1a0adaf3
HV		 1025 *(v4l2_std_id *) arg = itv->std;
1026 break;
1027 }
1028
1029 case VIDIOC_S_STD: {
1030 v4l2_std_id std = *(v4l2_std_id *) arg;
1031
1a0adaf3
HV		 1032 if ((std & V4L2_STD_ALL) == 0)
1033 return -EINVAL;
1034
1035 if (std == itv->std)
1036 break;
1037
1038 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1039 atomic_read(&itv->capturing) > 0 ||
1040 atomic_read(&itv->decoding) > 0) {
1041 /* Switching standard would turn off the radio or mess
1042 with already running streams, prevent that by
1043 returning EBUSY. */
1044 return -EBUSY;
1045 }
1046
1047 itv->std = std;
1048 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1049 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1050 itv->params.width = 720;
1051 itv->params.height = itv->is_50hz ? 576 : 480;
1052 itv->vbi.count = itv->is_50hz ? 18 : 12;
1053 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1054 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1055 if (itv->hw_flags & IVTV_HW_CX25840) {
1056 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1057 }
c4385098 1058 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1a0adaf3
HV		 1059
1060 /* Tuner */
1061 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1062
1063 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1064 /* set display standard */
1065 itv->std_out = std;
1066 itv->is_out_60hz = itv->is_60hz;
1067 itv->is_out_50hz = itv->is_50hz;
1068 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1069 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1070 itv->main_rect.left = itv->main_rect.top = 0;
1071 itv->main_rect.width = 720;
1072 itv->main_rect.height = itv->params.height;
1073 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1074 720, itv->main_rect.height, 0, 0);
88ab075a 1075 yi->main_rect = itv->main_rect;
77aded6b 1076 if (!itv->osd_info) {
88ab075a
IA		 1077 yi->osd_full_w = 720;
1078 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
77aded6b 1079 }
1a0adaf3
HV		 1080 }
1081 break;
1082 }
1083
1084 case VIDIOC_S_TUNER: { /* Setting tuner can only set audio mode */
1085 struct v4l2_tuner *vt = arg;
1086
1a0adaf3
HV		 1087 if (vt->index != 0)
1088 return -EINVAL;
1089
1090 ivtv_call_i2c_clients(itv, VIDIOC_S_TUNER, vt);
1091 break;
1092 }
1093
1094 case VIDIOC_G_TUNER: {
1095 struct v4l2_tuner *vt = arg;
1096
1a0adaf3
HV		 1097 if (vt->index != 0)
1098 return -EINVAL;
1099
1100 memset(vt, 0, sizeof(*vt));
1101 ivtv_call_i2c_clients(itv, VIDIOC_G_TUNER, vt);
1102
1103 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
cebfadff 1104 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1a0adaf3
HV		 1105 vt->type = V4L2_TUNER_RADIO;
1106 } else {
cebfadff 1107 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1a0adaf3
HV		 1108 vt->type = V4L2_TUNER_ANALOG_TV;
1109 }
1110 break;
1111 }
1112
1113 case VIDIOC_G_SLICED_VBI_CAP: {
1114 struct v4l2_sliced_vbi_cap *cap = arg;
1115 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1116 int f, l;
1117 enum v4l2_buf_type type = cap->type;
1118
1a0adaf3
HV		 1119 memset(cap, 0, sizeof(*cap));
1120 cap->type = type;
1121 if (type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1122 for (f = 0; f < 2; f++) {
1123 for (l = 0; l < 24; l++) {
1124 if (valid_service_line(f, l, itv->is_50hz)) {
1125 cap->service_lines[f][l] = set;
1126 }
1127 }
1128 }
1129 return 0;
1130 }
1131 if (type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1132 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1133 return -EINVAL;
1134 if (itv->is_60hz) {
1135 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1136 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1137 } else {
1138 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1139 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1140 }
1141 return 0;
1142 }
1143 return -EINVAL;
1144 }
1145
d4e7ee36
HV		 1146 case VIDIOC_G_ENC_INDEX: {
1147 struct v4l2_enc_idx *idx = arg;
5614b021
HV		 1148 struct v4l2_enc_idx_entry *e = idx->entry;
1149 int entries;
d4e7ee36
HV		 1150 int i;
1151
5614b021 1152 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
d4e7ee36 1153 IVTV_MAX_PGM_INDEX;
5614b021
HV		 1154 if (entries > V4L2_ENC_IDX_ENTRIES)
1155 entries = V4L2_ENC_IDX_ENTRIES;
1156 idx->entries = 0;
1157 for (i = 0; i < entries; i++) {
1158 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1159 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1160 idx->entries++;
1161 e++;
1162 }
d4e7ee36
HV		 1163 }
1164 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1165 break;
1166 }
1167
1168 case VIDIOC_ENCODER_CMD:
1169 case VIDIOC_TRY_ENCODER_CMD: {
1170 struct v4l2_encoder_cmd *enc = arg;
1171 int try = cmd == VIDIOC_TRY_ENCODER_CMD;
1172
25415cf3 1173 memset(&enc->raw, 0, sizeof(enc->raw));
d4e7ee36
HV		 1174 switch (enc->cmd) {
1175 case V4L2_ENC_CMD_START:
1aa32c2f 1176 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
25415cf3
HV		 1177 enc->flags = 0;
1178 if (try)
1179 return 0;
d4e7ee36
HV		 1180 return ivtv_start_capture(id);
1181
1182 case V4L2_ENC_CMD_STOP:
1aa32c2f 1183 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
018ba85b 1184 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
25415cf3
HV		 1185 if (try)
1186 return 0;
d4e7ee36
HV		 1187 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1188 return 0;
1189
1190 case V4L2_ENC_CMD_PAUSE:
1aa32c2f 1191 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
25415cf3
HV		 1192 enc->flags = 0;
1193 if (try)
1194 return 0;
d4e7ee36
HV		 1195 if (!atomic_read(&itv->capturing))
1196 return -EPERM;
1197 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1198 return 0;
1199 ivtv_mute(itv);
1200 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1201 break;
1202
1203 case V4L2_ENC_CMD_RESUME:
1aa32c2f 1204 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
25415cf3
HV		 1205 enc->flags = 0;
1206 if (try)
1207 return 0;
d4e7ee36
HV		 1208 if (!atomic_read(&itv->capturing))
1209 return -EPERM;
1210 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1211 return 0;
1212 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1213 ivtv_unmute(itv);
1214 break;
25415cf3 1215 default:
1aa32c2f 1216 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
25415cf3 1217 return -EINVAL;
d4e7ee36
HV		 1218 }
1219 break;
1220 }
1221
1222 case VIDIOC_G_FBUF: {
1223 struct v4l2_framebuffer *fb = arg;
2d4d5f11
HV		 1224 int pixfmt;
1225 static u32 pixel_format[16] = {
3eaeef57 1226 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
2d4d5f11
HV		 1227 V4L2_PIX_FMT_RGB565,
1228 V4L2_PIX_FMT_RGB555,
1229 V4L2_PIX_FMT_RGB444,
1230 V4L2_PIX_FMT_RGB32,
1231 0,
1232 0,
1233 0,
3eaeef57
HV		 1234 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1235 V4L2_PIX_FMT_YUV565,
1236 V4L2_PIX_FMT_YUV555,
1237 V4L2_PIX_FMT_YUV444,
1238 V4L2_PIX_FMT_YUV32,
2d4d5f11
HV		 1239 0,
1240 0,
1241 0,
1242 };
d4e7ee36
HV		 1243
1244 memset(fb, 0, sizeof(*fb));
1245 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
f5948bba 1246 return -EINVAL;
d4e7ee36 1247 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
2d4d5f11
HV		 1248 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1249 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1250 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1251 pixfmt = (data[0] >> 3) & 0xf;
1252 fb->fmt.pixelformat = pixel_format[pixfmt];
d4e7ee36
HV		 1253 fb->fmt.width = itv->osd_rect.width;
1254 fb->fmt.height = itv->osd_rect.height;
d4e7ee36 1255 fb->base = (void *)itv->osd_video_pbase;
fd8b281a 1256 if (itv->osd_chroma_key_state)
d4e7ee36 1257 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
2d4d5f11
HV		 1258 if (itv->osd_global_alpha_state)
1259 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1260 pixfmt &= 7;
1261 /* no local alpha for RGB565 or unknown formats */
1262 if (pixfmt == 1 || pixfmt > 4)
1263 break;
1264 /* 16-bit formats have inverted local alpha */
1265 if (pixfmt == 2 || pixfmt == 3)
1266 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1267 else
1268 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1269 if (itv->osd_local_alpha_state) {
1270 /* 16-bit formats have inverted local alpha */
1271 if (pixfmt == 2 || pixfmt == 3)
1272 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1273 else
1274 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1275 }
88ab075a
IA		 1276 if (yi->track_osd)
1277 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
d4e7ee36
HV		 1278 break;
1279 }
1280
1281 case VIDIOC_S_FBUF: {
1282 struct v4l2_framebuffer *fb = arg;
1283
1284 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
f5948bba 1285 return -EINVAL;
d4e7ee36 1286 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
2d4d5f11
HV		 1287 itv->osd_local_alpha_state =
1288 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
fd8b281a 1289 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
c3624f99 1290 ivtv_set_osd_alpha(itv);
88ab075a 1291 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
d4e7ee36
HV		 1292 break;
1293 }
1294
7c03a448
HV		 1295 case VIDIOC_OVERLAY: {
1296 int *on = arg;
1297
1298 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1299 return -EINVAL;
1300 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1301 break;
1302 }
1303
1a0adaf3
HV		 1304 case VIDIOC_LOG_STATUS:
1305 {
1306 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1307 struct v4l2_input vidin;
1308 struct v4l2_audio audin;
1309 int i;
1310
1311 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv->num);
94104aa2 1312 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1a0adaf3
HV		 1313 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1314 struct tveeprom tv;
1315
1316 ivtv_read_eeprom(itv, &tv);
1317 }
1318 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1319 ivtv_get_input(itv, itv->active_input, &vidin);
1320 ivtv_get_audio_input(itv, itv->audio_input, &audin);
7c03a448
HV		 1321 IVTV_INFO("Video Input: %s\n", vidin.name);
1322 IVTV_INFO("Audio Input: %s%s\n", audin.name,
25e3f8f4 1323 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1a0adaf3
HV		 1324 if (has_output) {
1325 struct v4l2_output vidout;
1326 struct v4l2_audioout audout;
1327 int mode = itv->output_mode;
2d4d5f11 1328 static const char * const output_modes[5] = {
1a0adaf3
HV		 1329 "None",
1330 "MPEG Streaming",
1331 "YUV Streaming",
1332 "YUV Frames",
1333 "Passthrough",
1334 };
2d4d5f11 1335 static const char * const audio_modes[5] = {
25e3f8f4
HV		 1336 "Stereo",
1337 "Left",
1338 "Right",
1339 "Mono",
1340 "Swapped"
1341 };
2d4d5f11 1342 static const char * const alpha_mode[4] = {
7c03a448
HV		 1343 "None",
1344 "Global",
1345 "Local",
1346 "Global and Local"
1347 };
2d4d5f11
HV		 1348 static const char * const pixel_format[16] = {
1349 "ARGB Indexed",
7c03a448
HV		 1350 "RGB 5:6:5",
1351 "ARGB 1:5:5:5",
1352 "ARGB 1:4:4:4",
1353 "ARGB 8:8:8:8",
1354 "5",
1355 "6",
1356 "7",
2d4d5f11 1357 "AYUV Indexed",
d2a35fb1
HV		 1358 "YUV 5:6:5",
1359 "AYUV 1:5:5:5",
1360 "AYUV 1:4:4:4",
1361 "AYUV 8:8:8:8",
1362 "13",
1363 "14",
1364 "15",
7c03a448 1365 };
1a0adaf3
HV		 1366
1367 ivtv_get_output(itv, itv->active_output, &vidout);
1368 ivtv_get_audio_output(itv, 0, &audout);
1369 IVTV_INFO("Video Output: %s\n", vidout.name);
25e3f8f4
HV		 1370 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1371 audio_modes[itv->audio_stereo_mode],
1372 audio_modes[itv->audio_bilingual_mode]);
1a0adaf3
HV		 1373 if (mode < 0 || mode > OUT_PASSTHROUGH)
1374 mode = OUT_NONE;
7c03a448
HV		 1375 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1376 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
d2a35fb1 1377 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
7c03a448
HV		 1378 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1379 data[0] & 1 ? "On" : "Off",
1380 alpha_mode[(data[0] >> 1) & 0x3],
d2a35fb1 1381 pixel_format[(data[0] >> 3) & 0xf]);
1a0adaf3 1382 }
7c03a448 1383 IVTV_INFO("Tuner: %s\n",
1a0adaf3
HV		 1384 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1385 cx2341x_log_status(&itv->params, itv->name);
7c03a448 1386 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1a0adaf3
HV		 1387 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1388 struct ivtv_stream *s = &itv->streams[i];
1389
1390 if (s->v4l2dev == NULL || s->buffers == 0)
1391 continue;
1392 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1393 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1394 (s->buffers * s->buf_size) / 1024, s->buffers);
1395 }
7c03a448 1396 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1a0adaf3
HV		 1397 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv->num);
1398 break;
1399 }
1400
1401 default:
1402 return -EINVAL;
1403 }
1404 return 0;
1405}
1406
d4e7ee36 1407static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1a0adaf3
HV		 1408{
1409 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1410 struct ivtv *itv = id->itv;
1411 int nonblocking = filp->f_flags & O_NONBLOCK;
1412 struct ivtv_stream *s = &itv->streams[id->type];
1413
1414 switch (cmd) {
1415 case IVTV_IOC_DMA_FRAME: {
1416 struct ivtv_dma_frame *args = arg;
1417
1418 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1419 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1420 return -EINVAL;
1421 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1422 return -EINVAL;
1423 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1424 return 0;
1425 if (ivtv_claim_stream(id, id->type)) {
1426 return -EBUSY;
1427 }
1428 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1429 ivtv_release_stream(s);
1430 return -EBUSY;
1431 }
ad8ff0f1
HV		 1432 /* Mark that this file handle started the UDMA_YUV mode */
1433 id->yuv_frames = 1;
1a0adaf3
HV		 1434 if (args->y_source == NULL)
1435 return 0;
1436 return ivtv_yuv_prep_frame(itv, args);
1437 }
1438
1439 case VIDEO_GET_PTS: {
1440 u32 data[CX2341X_MBOX_MAX_DATA];
1441 u64 *pts = arg;
1442
1443 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1444 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1445 *pts = s->dma_pts;
1446 break;
1447 }
1448 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1449 return -EINVAL;
1450
1451 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1452 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1453 (u64)itv->last_dec_timing[1];
1454 break;
1455 }
1456 *pts = 0;
1457 if (atomic_read(&itv->decoding)) {
1458 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1459 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1460 return -EIO;
1461 }
1462 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1463 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1464 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1465 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1466 }
1467 break;
1468 }
1469
1470 case VIDEO_GET_FRAME_COUNT: {
1471 u32 data[CX2341X_MBOX_MAX_DATA];
1472 u64 *frame = arg;
1473
1474 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1475 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1476 *frame = 0;
1477 break;
1478 }
1479 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1480 return -EINVAL;
1481
1482 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1483 *frame = itv->last_dec_timing[0];
1484 break;
1485 }
1486 *frame = 0;
1487 if (atomic_read(&itv->decoding)) {
1488 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1489 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1490 return -EIO;
1491 }
1492 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1493 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1494 *frame = data[0];
1495 }
1496 break;
1497 }
1498
1499 case VIDEO_PLAY: {
1500 struct video_command vc;
1501
1502 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1503 memset(&vc, 0, sizeof(vc));
1504 vc.cmd = VIDEO_CMD_PLAY;
1505 return ivtv_video_command(itv, id, &vc, 0);
1506 }
1507
1508 case VIDEO_STOP: {
1509 struct video_command vc;
1510
1511 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1512 memset(&vc, 0, sizeof(vc));
1513 vc.cmd = VIDEO_CMD_STOP;
1514 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1515 return ivtv_video_command(itv, id, &vc, 0);
1516 }
1517
1518 case VIDEO_FREEZE: {
1519 struct video_command vc;
1520
1521 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1522 memset(&vc, 0, sizeof(vc));
1523 vc.cmd = VIDEO_CMD_FREEZE;
1524 return ivtv_video_command(itv, id, &vc, 0);
1525 }
1526
1527 case VIDEO_CONTINUE: {
1528 struct video_command vc;
1529
1530 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1531 memset(&vc, 0, sizeof(vc));
1532 vc.cmd = VIDEO_CMD_CONTINUE;
1533 return ivtv_video_command(itv, id, &vc, 0);
1534 }
1535
1536 case VIDEO_COMMAND:
1537 case VIDEO_TRY_COMMAND: {
1538 struct video_command *vc = arg;
1539 int try = (cmd == VIDEO_TRY_COMMAND);
1540
1541 if (try)
1aa32c2f 1542 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1a0adaf3 1543 else
1aa32c2f 1544 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1a0adaf3
HV		 1545 return ivtv_video_command(itv, id, vc, try);
1546 }
1547
1548 case VIDEO_GET_EVENT: {
1549 struct video_event *ev = arg;
1550 DEFINE_WAIT(wait);
1551
1552 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1553 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1554 return -EINVAL;
1555 memset(ev, 0, sizeof(*ev));
1556 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1557
1558 while (1) {
1559 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1560 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1561 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1562 ev->type = VIDEO_EVENT_VSYNC;
037c86c5
HV		 1563 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1564 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1565 if (itv->output_mode == OUT_UDMA_YUV &&
1566 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1567 IVTV_YUV_MODE_PROGRESSIVE) {
1568 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1569 }
1a0adaf3
HV		 1570 }
1571 if (ev->type)
1572 return 0;
1573 if (nonblocking)
1574 return -EAGAIN;
baa4072d
HV		 1575 /* Wait for event. Note that serialize_lock is locked,
1576 so to allow other processes to access the driver while
1577 we are waiting unlock first and later lock again. */
1578 mutex_unlock(&itv->serialize_lock);
1a0adaf3
HV		 1579 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1580 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1581 schedule();
1582 finish_wait(&itv->event_waitq, &wait);
baa4072d 1583 mutex_lock(&itv->serialize_lock);
1a0adaf3
HV		 1584 if (signal_pending(current)) {
1585 /* return if a signal was received */
1586 IVTV_DEBUG_INFO("User stopped wait for event\n");
1587 return -EINTR;
1588 }
1589 }
1590 break;
1591 }
1592
1a0adaf3
HV		 1593 default:
1594 return -EINVAL;
1595 }
1596 return 0;
1597}
1598
1599static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1600 unsigned int cmd, void *arg)
1601{
1602 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1603 struct ivtv *itv = id->itv;
d46c17d7 1604 int ret;
1a0adaf3 1605
d46c17d7
HV		 1606 /* check priority */
1607 switch (cmd) {
1608 case VIDIOC_S_CTRL:
1609 case VIDIOC_S_STD:
1610 case VIDIOC_S_INPUT:
1611 case VIDIOC_S_OUTPUT:
1612 case VIDIOC_S_TUNER:
1613 case VIDIOC_S_FREQUENCY:
1614 case VIDIOC_S_FMT:
1615 case VIDIOC_S_CROP:
1616 case VIDIOC_S_AUDIO:
1617 case VIDIOC_S_AUDOUT:
1618 case VIDIOC_S_EXT_CTRLS:
1619 case VIDIOC_S_FBUF:
7c03a448 1620 case VIDIOC_OVERLAY:
d46c17d7
HV		 1621 ret = v4l2_prio_check(&itv->prio, &id->prio);
1622 if (ret)
1623 return ret;
1624 }
1625
1a0adaf3
HV		 1626 switch (cmd) {
1627 case VIDIOC_DBG_G_REGISTER:
1628 case VIDIOC_DBG_S_REGISTER:
1629 case VIDIOC_G_CHIP_IDENT:
1630 case VIDIOC_INT_S_AUDIO_ROUTING:
1631 case VIDIOC_INT_RESET:
d4e7ee36
HV		 1632 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1633 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1634 v4l_printk_ioctl(cmd);
5e28e009 1635 printk("\n");
d4e7ee36
HV		 1636 }
1637 return ivtv_debug_ioctls(filp, cmd, arg);
1a0adaf3 1638
d46c17d7
HV		 1639 case VIDIOC_G_PRIORITY:
1640 case VIDIOC_S_PRIORITY:
1a0adaf3
HV		 1641 case VIDIOC_QUERYCAP:
1642 case VIDIOC_ENUMINPUT:
1643 case VIDIOC_G_INPUT:
1644 case VIDIOC_S_INPUT:
1645 case VIDIOC_ENUMOUTPUT:
1646 case VIDIOC_G_OUTPUT:
1647 case VIDIOC_S_OUTPUT:
1648 case VIDIOC_G_FMT:
1649 case VIDIOC_S_FMT:
1650 case VIDIOC_TRY_FMT:
1651 case VIDIOC_ENUM_FMT:
987e00ba 1652 case VIDIOC_CROPCAP:
1a0adaf3
HV		 1653 case VIDIOC_G_CROP:
1654 case VIDIOC_S_CROP:
1655 case VIDIOC_G_FREQUENCY:
1656 case VIDIOC_S_FREQUENCY:
1657 case VIDIOC_ENUMSTD:
1658 case VIDIOC_G_STD:
1659 case VIDIOC_S_STD:
1660 case VIDIOC_S_TUNER:
1661 case VIDIOC_G_TUNER:
1662 case VIDIOC_ENUMAUDIO:
1663 case VIDIOC_S_AUDIO:
1664 case VIDIOC_G_AUDIO:
1665 case VIDIOC_ENUMAUDOUT:
1666 case VIDIOC_S_AUDOUT:
1667 case VIDIOC_G_AUDOUT:
1668 case VIDIOC_G_SLICED_VBI_CAP:
1669 case VIDIOC_LOG_STATUS:
d4e7ee36
HV		 1670 case VIDIOC_G_ENC_INDEX:
1671 case VIDIOC_ENCODER_CMD:
1672 case VIDIOC_TRY_ENCODER_CMD:
1673 case VIDIOC_G_FBUF:
1674 case VIDIOC_S_FBUF:
7c03a448 1675 case VIDIOC_OVERLAY:
d4e7ee36
HV		 1676 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1677 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1678 v4l_printk_ioctl(cmd);
5e28e009 1679 printk("\n");
d4e7ee36 1680 }
1a0adaf3
HV		 1681 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1682
1683 case VIDIOC_QUERYMENU:
1684 case VIDIOC_QUERYCTRL:
1685 case VIDIOC_S_CTRL:
1686 case VIDIOC_G_CTRL:
1687 case VIDIOC_S_EXT_CTRLS:
1688 case VIDIOC_G_EXT_CTRLS:
1689 case VIDIOC_TRY_EXT_CTRLS:
d4e7ee36
HV		 1690 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1691 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1692 v4l_printk_ioctl(cmd);
5e28e009 1693 printk("\n");
d4e7ee36 1694 }
1a0adaf3
HV		 1695 return ivtv_control_ioctls(itv, cmd, arg);
1696
1697 case IVTV_IOC_DMA_FRAME:
1698 case VIDEO_GET_PTS:
1699 case VIDEO_GET_FRAME_COUNT:
1700 case VIDEO_GET_EVENT:
1701 case VIDEO_PLAY:
1702 case VIDEO_STOP:
1703 case VIDEO_FREEZE:
1704 case VIDEO_CONTINUE:
1705 case VIDEO_COMMAND:
1706 case VIDEO_TRY_COMMAND:
d4e7ee36 1707 return ivtv_decoder_ioctls(filp, cmd, arg);
1a0adaf3
HV		 1708
1709 case 0x00005401: /* Handle isatty() calls */
1710 return -EINVAL;
1711 default:
1712 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1713 ivtv_v4l2_do_ioctl);
1714 }
1715 return 0;
1716}
1717
baa4072d
HV		 1718static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1719 unsigned int cmd, unsigned long arg)
1a0adaf3 1720{
1a0adaf3
HV		 1721 /* Filter dvb ioctls that cannot be handled by video_usercopy */
1722 switch (cmd) {
1723 case VIDEO_SELECT_SOURCE:
1724 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1725 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1726 return -EINVAL;
1727 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1728
1729 case AUDIO_SET_MUTE:
1730 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1731 itv->speed_mute_audio = arg;
1732 return 0;
1733
1734 case AUDIO_CHANNEL_SELECT:
1735 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1736 if (arg > AUDIO_STEREO_SWAPPED)
1737 return -EINVAL;
1738 itv->audio_stereo_mode = arg;
1739 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1740 return 0;
1741
1742 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1743 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1744 if (arg > AUDIO_STEREO_SWAPPED)
1745 return -EINVAL;
1746 itv->audio_bilingual_mode = arg;
1747 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1748 return 0;
1749
1750 default:
1751 break;
1752 }
1753 return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1754}
baa4072d
HV		 1755
1756int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1757 unsigned long arg)
1758{
1759 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1760 struct ivtv *itv = id->itv;
1761 int res;
1762
1763 mutex_lock(&itv->serialize_lock);
1764 res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1765 mutex_unlock(&itv->serialize_lock);
1766 return res;
1767}
Linux kernel - Deliverables
This page took 0.255396 seconds and 5 git commands to generate.