1 /*
2 ioctl system call
3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "ivtv-driver.h"
22 #include "ivtv-version.h"
23 #include "ivtv-mailbox.h"
24 #include "ivtv-i2c.h"
25 #include "ivtv-queue.h"
26 #include "ivtv-fileops.h"
27 #include "ivtv-vbi.h"
28 #include "ivtv-routing.h"
29 #include "ivtv-streams.h"
30 #include "ivtv-yuv.h"
31 #include "ivtv-ioctl.h"
32 #include "ivtv-gpio.h"
33 #include "ivtv-controls.h"
34 #include "ivtv-cards.h"
35 #include <media/saa7127.h>
36 #include <media/tveeprom.h>
37 #include <media/v4l2-chip-ident.h>
38 #include <linux/dvb/audio.h>
39 #include <linux/i2c-id.h>
40
41 u16 service2vbi(int type)
42 {
43 switch (type) {
44 case V4L2_SLICED_TELETEXT_B:
45 return IVTV_SLICED_TYPE_TELETEXT_B;
46 case V4L2_SLICED_CAPTION_525:
47 return IVTV_SLICED_TYPE_CAPTION_525;
48 case V4L2_SLICED_WSS_625:
49 return IVTV_SLICED_TYPE_WSS_625;
50 case V4L2_SLICED_VPS:
51 return IVTV_SLICED_TYPE_VPS;
52 default:
53 return 0;
54 }
55 }
56
57 static int valid_service_line(int field, int line, int is_pal)
58 {
59 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
60 (!is_pal && line >= 10 && line < 22);
61 }
62
63 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
64 {
65 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
66 int i;
67
68 set = set & valid_set;
69 if (set == 0 || !valid_service_line(field, line, is_pal)) {
70 return 0;
71 }
72 if (!is_pal) {
73 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
74 return V4L2_SLICED_CAPTION_525;
75 }
76 else {
77 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
78 return V4L2_SLICED_VPS;
79 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
80 return V4L2_SLICED_WSS_625;
81 if (line == 23)
82 return 0;
83 }
84 for (i = 0; i < 32; i++) {
85 if ((1 << i) & set)
86 return 1 << i;
87 }
88 return 0;
89 }
90
91 void expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
92 {
93 u16 set = fmt->service_set;
94 int f, l;
95
96 fmt->service_set = 0;
97 for (f = 0; f < 2; f++) {
98 for (l = 0; l < 24; l++) {
99 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
100 }
101 }
102 }
103
104 static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
105 {
106 int f, l;
107 u16 set = 0;
108
109 for (f = 0; f < 2; f++) {
110 for (l = 0; l < 24; l++) {
111 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
112 set |= fmt->service_lines[f][l];
113 }
114 }
115 return set != 0;
116 }
117
118 u16 get_service_set(struct v4l2_sliced_vbi_format *fmt)
119 {
120 int f, l;
121 u16 set = 0;
122
123 for (f = 0; f < 2; f++) {
124 for (l = 0; l < 24; l++) {
125 set |= fmt->service_lines[f][l];
126 }
127 }
128 return set;
129 }
130
131 static const struct {
132 v4l2_std_id std;
133 char *name;
134 } enum_stds[] = {
135 { V4L2_STD_PAL_BG | V4L2_STD_PAL_H, "PAL-BGH" },
136 { V4L2_STD_PAL_DK, "PAL-DK" },
137 { V4L2_STD_PAL_I, "PAL-I" },
138 { V4L2_STD_PAL_M, "PAL-M" },
139 { V4L2_STD_PAL_N, "PAL-N" },
140 { V4L2_STD_PAL_Nc, "PAL-Nc" },
141 { V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H, "SECAM-BGH" },
142 { V4L2_STD_SECAM_DK, "SECAM-DK" },
143 { V4L2_STD_SECAM_L, "SECAM-L" },
144 { V4L2_STD_SECAM_LC, "SECAM-L'" },
145 { V4L2_STD_NTSC_M, "NTSC-M" },
146 { V4L2_STD_NTSC_M_JP, "NTSC-J" },
147 { V4L2_STD_NTSC_M_KR, "NTSC-K" },
148 };
149
150 static const struct v4l2_standard ivtv_std_60hz =
151 {
152 .frameperiod = {.numerator = 1001, .denominator = 30000},
153 .framelines = 525,
154 };
155
156 static const struct v4l2_standard ivtv_std_50hz =
157 {
158 .frameperiod = {.numerator = 1, .denominator = 25},
159 .framelines = 625,
160 };
161
162 void ivtv_set_osd_alpha(struct ivtv *itv)
163 {
164 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
165 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
166 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
167 }
168
169 int ivtv_set_speed(struct ivtv *itv, int speed)
170 {
171 u32 data[CX2341X_MBOX_MAX_DATA];
172 struct ivtv_stream *s;
173 int single_step = (speed == 1 || speed == -1);
174 DEFINE_WAIT(wait);
175
176 if (speed == 0) speed = 1000;
177
178 /* No change? */
179 if (speed == itv->speed && !single_step)
180 return 0;
181
182 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
183
184 if (single_step && (speed < 0) == (itv->speed < 0)) {
185 /* Single step video and no need to change direction */
186 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
187 itv->speed = speed;
188 return 0;
189 }
190 if (single_step)
191 /* Need to change direction */
192 speed = speed < 0 ? -1000 : 1000;
193
194 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
195 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
196 data[1] = (speed < 0);
197 data[2] = speed < 0 ? 3 : 7;
198 data[3] = itv->params.video_b_frames;
199 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
200 data[5] = 0;
201 data[6] = 0;
202
203 if (speed == 1500 || speed == -1500) data[0] |= 1;
204 else if (speed == 2000 || speed == -2000) data[0] |= 2;
205 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
206 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
207
208 /* If not decoding, just change speed setting */
209 if (atomic_read(&itv->decoding) > 0) {
210 int got_sig = 0;
211
212 /* Stop all DMA and decoding activity */
213 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
214
215 /* Wait for any DMA to finish */
216 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
217 while (itv->i_flags & IVTV_F_I_DMA) {
218 got_sig = signal_pending(current);
219 if (got_sig)
220 break;
221 got_sig = 0;
222 schedule();
223 }
224 finish_wait(&itv->dma_waitq, &wait);
225 if (got_sig)
226 return -EINTR;
227
228 /* Change Speed safely */
229 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
230 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
231 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
232 }
233 if (single_step) {
234 speed = (speed < 0) ? -1 : 1;
235 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
236 }
237 itv->speed = speed;
238 return 0;
239 }
240
241 static int ivtv_validate_speed(int cur_speed, int new_speed)
242 {
243 int fact = new_speed < 0 ? -1 : 1;
244 int s;
245
246 if (new_speed < 0) new_speed = -new_speed;
247 if (cur_speed < 0) cur_speed = -cur_speed;
248
249 if (cur_speed <= new_speed) {
250 if (new_speed > 1500) return fact * 2000;
251 if (new_speed > 1000) return fact * 1500;
252 }
253 else {
254 if (new_speed >= 2000) return fact * 2000;
255 if (new_speed >= 1500) return fact * 1500;
256 if (new_speed >= 1000) return fact * 1000;
257 }
258 if (new_speed == 0) return 1000;
259 if (new_speed == 1 || new_speed == 1000) return fact * new_speed;
260
261 s = new_speed;
262 new_speed = 1000 / new_speed;
263 if (1000 / cur_speed == new_speed)
264 new_speed += (cur_speed < s) ? -1 : 1;
265 if (new_speed > 60) return 1000 / (fact * 60);
266 return 1000 / (fact * new_speed);
267 }
268
269 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
270 struct video_command *vc, int try)
271 {
272 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
273
274 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
275 return -EINVAL;
276
277 switch (vc->cmd) {
278 case VIDEO_CMD_PLAY: {
279 vc->flags = 0;
280 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
281 if (vc->play.speed < 0)
282 vc->play.format = VIDEO_PLAY_FMT_GOP;
283 if (try) break;
284
285 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
286 return -EBUSY;
287 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
288 /* forces ivtv_set_speed to be called */
289 itv->speed = 0;
290 }
291 return ivtv_start_decoding(id, vc->play.speed);
292 }
293
294 case VIDEO_CMD_STOP:
295 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
296 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
297 vc->stop.pts = 0;
298 if (try) break;
299 if (atomic_read(&itv->decoding) == 0)
300 return 0;
301 if (itv->output_mode != OUT_MPG)
302 return -EBUSY;
303
304 itv->output_mode = OUT_NONE;
305 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
306
307 case VIDEO_CMD_FREEZE:
308 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
309 if (try) break;
310 if (itv->output_mode != OUT_MPG)
311 return -EBUSY;
312 if (atomic_read(&itv->decoding) > 0) {
313 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
314 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
315 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
316 }
317 break;
318
319 case VIDEO_CMD_CONTINUE:
320 vc->flags = 0;
321 if (try) break;
322 if (itv->output_mode != OUT_MPG)
323 return -EBUSY;
324 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
325 int speed = itv->speed;
326 itv->speed = 0;
327 return ivtv_start_decoding(id, speed);
328 }
329 break;
330
331 default:
332 return -EINVAL;
333 }
334 return 0;
335 }
336
337 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
338 {
339 struct v4l2_register *regs = arg;
340 unsigned long flags;
341 volatile u8 __iomem *reg_start;
342
343 if (!capable(CAP_SYS_ADMIN))
344 return -EPERM;
345 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
346 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
347 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
348 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
349 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
350 else if (regs->reg >= 0 && regs->reg < IVTV_ENCODER_SIZE)
351 reg_start = itv->enc_mem;
352 else
353 return -EINVAL;
354
355 spin_lock_irqsave(&ivtv_cards_lock, flags);
356 if (cmd == VIDIOC_DBG_G_REGISTER) {
357 regs->val = readl(regs->reg + reg_start);
358 } else {
359 writel(regs->val, regs->reg + reg_start);
360 }
361 spin_unlock_irqrestore(&ivtv_cards_lock, flags);
362 return 0;
363 }
364
365 static int ivtv_get_fmt(struct ivtv *itv, int streamtype, struct v4l2_format *fmt)
366 {
367 switch (fmt->type) {
368 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
369 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
370 return -EINVAL;
371 fmt->fmt.pix.width = itv->main_rect.width;
372 fmt->fmt.pix.height = itv->main_rect.height;
373 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
374 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
375 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
376 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
377 case IVTV_YUV_MODE_INTERLACED:
378 fmt->fmt.pix.field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
379 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
380 break;
381 case IVTV_YUV_MODE_PROGRESSIVE:
382 fmt->fmt.pix.field = V4L2_FIELD_NONE;
383 break;
384 default:
385 fmt->fmt.pix.field = V4L2_FIELD_ANY;
386 break;
387 }
388 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
389 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;
392 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
393 fmt->fmt.pix.sizeimage =
394 1080 * ((fmt->fmt.pix.height + 31) & ~31);
395 } else if (streamtype == IVTV_ENC_STREAM_TYPE_YUV) {
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:
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;
428 fmt->fmt.win.chromakey = itv->osd_chroma_key;
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
489 static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
490 struct v4l2_format *fmt, int set_fmt)
491 {
492 struct yuv_playback_info *yi = &itv->yuv_info;
493 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
494 u16 set;
495
496 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
497 struct v4l2_rect r;
498 int field;
499
500 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
501 return -EINVAL;
502 field = fmt->fmt.pix.field;
503 r.top = 0;
504 r.left = 0;
505 r.width = fmt->fmt.pix.width;
506 r.height = fmt->fmt.pix.height;
507 ivtv_get_fmt(itv, streamtype, fmt);
508 fmt->fmt.pix.width = r.width;
509 fmt->fmt.pix.height = r.height;
510 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
511 fmt->fmt.pix.field = field;
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;
520 }
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;
525
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;
544 }
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;
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) {
562 itv->osd_chroma_key = fmt->fmt.win.chromakey;
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) {
571 struct cx2341x_mpeg_params *p = &itv->params;
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
583 if (!set_fmt || (p->width == w && p->height == h))
584 return 0;
585 if (atomic_read(&itv->capturing) > 0)
586 return -EBUSY;
587
588 p->width = w;
589 p->height = h;
590 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
591 p->video_temporal_filter = 0;
592 else
593 p->video_temporal_filter = 8;
594 if (p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
595 fmt->fmt.pix.width /= 2;
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) {
602 if (set_fmt && atomic_read(&itv->capturing) > 0) {
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;
640 if (atomic_read(&itv->capturing) > 0) {
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
648 static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
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:
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:
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
673 chip->ident = V4L2_IDENT_NONE;
674 chip->revision = 0;
675 if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
676 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
677 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
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
690 ivtv_i2c_hw(itv, itv->card->hw_audio, VIDIOC_INT_S_AUDIO_ROUTING, route);
691 break;
692 }
693
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) {
701 itv->video_dec_func(itv, cmd, NULL);
702 }
703 break;
704 }
705
706 default:
707 return -EINVAL;
708 }
709 return 0;
710 }
711
712 int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
713 {
714 struct ivtv_open_id *id = NULL;
715 u32 data[CX2341X_MBOX_MAX_DATA];
716 int streamtype = 0;
717
718 if (filp) {
719 id = (struct ivtv_open_id *)filp->private_data;
720 streamtype = id->type;
721 }
722
723 switch (cmd) {
724 case VIDIOC_G_PRIORITY:
725 {
726 enum v4l2_priority *p = arg;
727
728 *p = v4l2_prio_max(&itv->prio);
729 break;
730 }
731
732 case VIDIOC_S_PRIORITY:
733 {
734 enum v4l2_priority *prio = arg;
735
736 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
737 }
738
739 case VIDIOC_QUERYCAP:{
740 struct v4l2_capability *vcap = arg;
741
742 memset(vcap, 0, sizeof(*vcap));
743 strcpy(vcap->driver, IVTV_DRIVER_NAME); /* driver name */
744 strncpy(vcap->card, itv->card_name,
745 sizeof(vcap->card)-1); /* card type */
746 strcpy(vcap->bus_info, pci_name(itv->dev)); /* bus info... */
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
759 return ivtv_get_audio_input(itv, vin->index, vin);
760 }
761
762 case VIDIOC_G_AUDIO:{
763 struct v4l2_audio *vin = arg;
764
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
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
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
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
796 return ivtv_get_audio_output(itv, vout->index, vout);
797 }
798
799 case VIDIOC_ENUMINPUT:{
800 struct v4l2_input *vin = arg;
801
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
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
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
823 memset(fmt, 0, sizeof(*fmt));
824 fmt->type = type;
825 return ivtv_get_fmt(itv, id->type, fmt);
826 }
827
828 case VIDIOC_CROPCAP: {
829 struct v4l2_cropcap *cropcap = arg;
830
831 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
832 cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
833 return -EINVAL;
834 cropcap->bounds.top = cropcap->bounds.left = 0;
835 cropcap->bounds.width = 720;
836 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
837 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
838 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
839 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
840 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
841 cropcap->bounds.width = itv->yuv_info.osd_full_w;
842 cropcap->bounds.height = itv->yuv_info.osd_full_h;
843 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
844 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
845 } else {
846 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
847 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
848 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
849 }
850 cropcap->defrect = cropcap->bounds;
851 return 0;
852 }
853
854 case VIDIOC_S_CROP: {
855 struct v4l2_crop *crop = arg;
856
857 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
858 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
859 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
860 itv->yuv_info.main_rect = crop->c;
861 return 0;
862 } else {
863 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
864 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
865 itv->main_rect = crop->c;
866 return 0;
867 }
868 }
869 return -EINVAL;
870 }
871 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
872 return -EINVAL;
873 return itv->video_dec_func(itv, VIDIOC_S_CROP, arg);
874 }
875
876 case VIDIOC_G_CROP: {
877 struct v4l2_crop *crop = arg;
878
879 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
880 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
881 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
882 crop->c = itv->yuv_info.main_rect;
883 else
884 crop->c = itv->main_rect;
885 return 0;
886 }
887 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
888 return -EINVAL;
889 return itv->video_dec_func(itv, VIDIOC_G_CROP, arg);
890 }
891
892 case VIDIOC_ENUM_FMT: {
893 static struct v4l2_fmtdesc formats[] = {
894 { 0, 0, 0,
895 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
896 { 0, 0, 0, 0 }
897 },
898 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
899 "MPEG", V4L2_PIX_FMT_MPEG,
900 { 0, 0, 0, 0 }
901 }
902 };
903 struct v4l2_fmtdesc *fmt = arg;
904 enum v4l2_buf_type type = fmt->type;
905
906 switch (type) {
907 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
908 break;
909 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
910 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
911 return -EINVAL;
912 break;
913 default:
914 return -EINVAL;
915 }
916 if (fmt->index > 1)
917 return -EINVAL;
918 *fmt = formats[fmt->index];
919 fmt->type = type;
920 return 0;
921 }
922
923 case VIDIOC_G_INPUT:{
924 *(int *)arg = itv->active_input;
925 break;
926 }
927
928 case VIDIOC_S_INPUT:{
929 int inp = *(int *)arg;
930
931 if (inp < 0 || inp >= itv->nof_inputs)
932 return -EINVAL;
933
934 if (inp == itv->active_input) {
935 IVTV_DEBUG_INFO("Input unchanged\n");
936 break;
937 }
938 if (atomic_read(&itv->capturing) > 0) {
939 return -EBUSY;
940 }
941 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
942 itv->active_input, inp);
943
944 itv->active_input = inp;
945 /* Set the audio input to whatever is appropriate for the
946 input type. */
947 itv->audio_input = itv->card->video_inputs[inp].audio_index;
948
949 /* prevent others from messing with the streams until
950 we're finished changing inputs. */
951 ivtv_mute(itv);
952 ivtv_video_set_io(itv);
953 ivtv_audio_set_io(itv);
954 ivtv_unmute(itv);
955 break;
956 }
957
958 case VIDIOC_G_OUTPUT:{
959 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
960 return -EINVAL;
961 *(int *)arg = itv->active_output;
962 break;
963 }
964
965 case VIDIOC_S_OUTPUT:{
966 int outp = *(int *)arg;
967 struct v4l2_routing route;
968
969 if (outp >= itv->card->nof_outputs)
970 return -EINVAL;
971
972 if (outp == itv->active_output) {
973 IVTV_DEBUG_INFO("Output unchanged\n");
974 break;
975 }
976 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
977 itv->active_output, outp);
978
979 itv->active_output = outp;
980 route.input = SAA7127_INPUT_TYPE_NORMAL;
981 route.output = itv->card->video_outputs[outp].video_output;
982 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
983 break;
984 }
985
986 case VIDIOC_G_FREQUENCY:{
987 struct v4l2_frequency *vf = arg;
988
989 if (vf->tuner != 0)
990 return -EINVAL;
991 ivtv_call_i2c_clients(itv, cmd, arg);
992 break;
993 }
994
995 case VIDIOC_S_FREQUENCY:{
996 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
997
998 if (vf.tuner != 0)
999 return -EINVAL;
1000
1001 ivtv_mute(itv);
1002 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
1003 ivtv_call_i2c_clients(itv, cmd, &vf);
1004 ivtv_unmute(itv);
1005 break;
1006 }
1007
1008 case VIDIOC_ENUMSTD:{
1009 struct v4l2_standard *vs = arg;
1010 int idx = vs->index;
1011
1012 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
1013 return -EINVAL;
1014
1015 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
1016 ivtv_std_60hz : ivtv_std_50hz;
1017 vs->index = idx;
1018 vs->id = enum_stds[idx].std;
1019 strcpy(vs->name, enum_stds[idx].name);
1020 break;
1021 }
1022
1023 case VIDIOC_G_STD:{
1024 *(v4l2_std_id *) arg = itv->std;
1025 break;
1026 }
1027
1028 case VIDIOC_S_STD: {
1029 v4l2_std_id std = *(v4l2_std_id *) arg;
1030
1031 if ((std & V4L2_STD_ALL) == 0)
1032 return -EINVAL;
1033
1034 if (std == itv->std)
1035 break;
1036
1037 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1038 atomic_read(&itv->capturing) > 0 ||
1039 atomic_read(&itv->decoding) > 0) {
1040 /* Switching standard would turn off the radio or mess
1041 with already running streams, prevent that by
1042 returning EBUSY. */
1043 return -EBUSY;
1044 }
1045
1046 itv->std = std;
1047 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1048 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1049 itv->params.width = 720;
1050 itv->params.height = itv->is_50hz ? 576 : 480;
1051 itv->vbi.count = itv->is_50hz ? 18 : 12;
1052 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1053 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1054 if (itv->hw_flags & IVTV_HW_CX25840) {
1055 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1056 }
1057 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1058
1059 /* Tuner */
1060 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1061
1062 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1063 /* set display standard */
1064 itv->std_out = std;
1065 itv->is_out_60hz = itv->is_60hz;
1066 itv->is_out_50hz = itv->is_50hz;
1067 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1068 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1069 itv->main_rect.left = itv->main_rect.top = 0;
1070 itv->main_rect.width = 720;
1071 itv->main_rect.height = itv->params.height;
1072 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1073 720, itv->main_rect.height, 0, 0);
1074 itv->yuv_info.main_rect = itv->main_rect;
1075 if (!itv->osd_info) {
1076 itv->yuv_info.osd_full_w = 720;
1077 itv->yuv_info.osd_full_h =
1078 itv->is_out_50hz ? 576 : 480;
1079 }
1080 }
1081 break;
1082 }
1083
1084 case VIDIOC_S_TUNER: { /* Setting tuner can only set audio mode */
1085 struct v4l2_tuner *vt = arg;
1086
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
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)) {
1104 strcpy(vt->name, "ivtv Radio Tuner");
1105 vt->type = V4L2_TUNER_RADIO;
1106 } else {
1107 strcpy(vt->name, "ivtv TV Tuner");
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
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
1146 case VIDIOC_G_ENC_INDEX: {
1147 struct v4l2_enc_idx *idx = arg;
1148 struct v4l2_enc_idx_entry *e = idx->entry;
1149 int entries;
1150 int i;
1151
1152 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1153 IVTV_MAX_PGM_INDEX;
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 }
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
1173 memset(&enc->raw, 0, sizeof(enc->raw));
1174 switch (enc->cmd) {
1175 case V4L2_ENC_CMD_START:
1176 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1177 enc->flags = 0;
1178 if (try)
1179 return 0;
1180 return ivtv_start_capture(id);
1181
1182 case V4L2_ENC_CMD_STOP:
1183 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1184 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1185 if (try)
1186 return 0;
1187 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1188 return 0;
1189
1190 case V4L2_ENC_CMD_PAUSE:
1191 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1192 enc->flags = 0;
1193 if (try)
1194 return 0;
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:
1204 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1205 enc->flags = 0;
1206 if (try)
1207 return 0;
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;
1215 default:
1216 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1217 return -EINVAL;
1218 }
1219 break;
1220 }
1221
1222 case VIDIOC_G_FBUF: {
1223 struct v4l2_framebuffer *fb = arg;
1224 int pixfmt;
1225 static u32 pixel_format[16] = {
1226 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
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,
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,
1239 0,
1240 0,
1241 0,
1242 };
1243
1244 memset(fb, 0, sizeof(*fb));
1245 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1246 return -EINVAL;
1247 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
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];
1253 fb->fmt.width = itv->osd_rect.width;
1254 fb->fmt.height = itv->osd_rect.height;
1255 fb->base = (void *)itv->osd_video_pbase;
1256 if (itv->osd_chroma_key_state)
1257 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
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 }
1276 break;
1277 }
1278
1279 case VIDIOC_S_FBUF: {
1280 struct v4l2_framebuffer *fb = arg;
1281
1282 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1283 return -EINVAL;
1284 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1285 itv->osd_local_alpha_state =
1286 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1287 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1288 ivtv_set_osd_alpha(itv);
1289 break;
1290 }
1291
1292 case VIDIOC_OVERLAY: {
1293 int *on = arg;
1294
1295 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1296 return -EINVAL;
1297 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1298 break;
1299 }
1300
1301 case VIDIOC_LOG_STATUS:
1302 {
1303 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1304 struct v4l2_input vidin;
1305 struct v4l2_audio audin;
1306 int i;
1307
1308 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv->num);
1309 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1310 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1311 struct tveeprom tv;
1312
1313 ivtv_read_eeprom(itv, &tv);
1314 }
1315 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1316 ivtv_get_input(itv, itv->active_input, &vidin);
1317 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1318 IVTV_INFO("Video Input: %s\n", vidin.name);
1319 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1320 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1321 if (has_output) {
1322 struct v4l2_output vidout;
1323 struct v4l2_audioout audout;
1324 int mode = itv->output_mode;
1325 static const char * const output_modes[5] = {
1326 "None",
1327 "MPEG Streaming",
1328 "YUV Streaming",
1329 "YUV Frames",
1330 "Passthrough",
1331 };
1332 static const char * const audio_modes[5] = {
1333 "Stereo",
1334 "Left",
1335 "Right",
1336 "Mono",
1337 "Swapped"
1338 };
1339 static const char * const alpha_mode[4] = {
1340 "None",
1341 "Global",
1342 "Local",
1343 "Global and Local"
1344 };
1345 static const char * const pixel_format[16] = {
1346 "ARGB Indexed",
1347 "RGB 5:6:5",
1348 "ARGB 1:5:5:5",
1349 "ARGB 1:4:4:4",
1350 "ARGB 8:8:8:8",
1351 "5",
1352 "6",
1353 "7",
1354 "AYUV Indexed",
1355 "YUV 5:6:5",
1356 "AYUV 1:5:5:5",
1357 "AYUV 1:4:4:4",
1358 "AYUV 8:8:8:8",
1359 "13",
1360 "14",
1361 "15",
1362 };
1363
1364 ivtv_get_output(itv, itv->active_output, &vidout);
1365 ivtv_get_audio_output(itv, 0, &audout);
1366 IVTV_INFO("Video Output: %s\n", vidout.name);
1367 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1368 audio_modes[itv->audio_stereo_mode],
1369 audio_modes[itv->audio_bilingual_mode]);
1370 if (mode < 0 || mode > OUT_PASSTHROUGH)
1371 mode = OUT_NONE;
1372 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1373 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1374 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1375 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1376 data[0] & 1 ? "On" : "Off",
1377 alpha_mode[(data[0] >> 1) & 0x3],
1378 pixel_format[(data[0] >> 3) & 0xf]);
1379 }
1380 IVTV_INFO("Tuner: %s\n",
1381 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1382 cx2341x_log_status(&itv->params, itv->name);
1383 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1384 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1385 struct ivtv_stream *s = &itv->streams[i];
1386
1387 if (s->v4l2dev == NULL || s->buffers == 0)
1388 continue;
1389 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1390 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1391 (s->buffers * s->buf_size) / 1024, s->buffers);
1392 }
1393 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1394 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv->num);
1395 break;
1396 }
1397
1398 default:
1399 return -EINVAL;
1400 }
1401 return 0;
1402 }
1403
1404 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1405 {
1406 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1407 struct ivtv *itv = id->itv;
1408 int nonblocking = filp->f_flags & O_NONBLOCK;
1409 struct ivtv_stream *s = &itv->streams[id->type];
1410
1411 switch (cmd) {
1412 case IVTV_IOC_DMA_FRAME: {
1413 struct ivtv_dma_frame *args = arg;
1414
1415 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1416 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1417 return -EINVAL;
1418 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1419 return -EINVAL;
1420 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1421 return 0;
1422 if (ivtv_claim_stream(id, id->type)) {
1423 return -EBUSY;
1424 }
1425 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1426 ivtv_release_stream(s);
1427 return -EBUSY;
1428 }
1429 /* Mark that this file handle started the UDMA_YUV mode */
1430 id->yuv_frames = 1;
1431 if (args->y_source == NULL)
1432 return 0;
1433 return ivtv_yuv_prep_frame(itv, args);
1434 }
1435
1436 case VIDEO_GET_PTS: {
1437 u32 data[CX2341X_MBOX_MAX_DATA];
1438 u64 *pts = arg;
1439
1440 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1441 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1442 *pts = s->dma_pts;
1443 break;
1444 }
1445 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1446 return -EINVAL;
1447
1448 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1449 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1450 (u64)itv->last_dec_timing[1];
1451 break;
1452 }
1453 *pts = 0;
1454 if (atomic_read(&itv->decoding)) {
1455 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1456 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1457 return -EIO;
1458 }
1459 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1460 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1461 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1462 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1463 }
1464 break;
1465 }
1466
1467 case VIDEO_GET_FRAME_COUNT: {
1468 u32 data[CX2341X_MBOX_MAX_DATA];
1469 u64 *frame = arg;
1470
1471 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1472 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1473 *frame = 0;
1474 break;
1475 }
1476 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1477 return -EINVAL;
1478
1479 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1480 *frame = itv->last_dec_timing[0];
1481 break;
1482 }
1483 *frame = 0;
1484 if (atomic_read(&itv->decoding)) {
1485 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1486 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1487 return -EIO;
1488 }
1489 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1490 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1491 *frame = data[0];
1492 }
1493 break;
1494 }
1495
1496 case VIDEO_PLAY: {
1497 struct video_command vc;
1498
1499 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1500 memset(&vc, 0, sizeof(vc));
1501 vc.cmd = VIDEO_CMD_PLAY;
1502 return ivtv_video_command(itv, id, &vc, 0);
1503 }
1504
1505 case VIDEO_STOP: {
1506 struct video_command vc;
1507
1508 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1509 memset(&vc, 0, sizeof(vc));
1510 vc.cmd = VIDEO_CMD_STOP;
1511 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1512 return ivtv_video_command(itv, id, &vc, 0);
1513 }
1514
1515 case VIDEO_FREEZE: {
1516 struct video_command vc;
1517
1518 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1519 memset(&vc, 0, sizeof(vc));
1520 vc.cmd = VIDEO_CMD_FREEZE;
1521 return ivtv_video_command(itv, id, &vc, 0);
1522 }
1523
1524 case VIDEO_CONTINUE: {
1525 struct video_command vc;
1526
1527 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1528 memset(&vc, 0, sizeof(vc));
1529 vc.cmd = VIDEO_CMD_CONTINUE;
1530 return ivtv_video_command(itv, id, &vc, 0);
1531 }
1532
1533 case VIDEO_COMMAND:
1534 case VIDEO_TRY_COMMAND: {
1535 struct video_command *vc = arg;
1536 int try = (cmd == VIDEO_TRY_COMMAND);
1537
1538 if (try)
1539 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1540 else
1541 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1542 return ivtv_video_command(itv, id, vc, try);
1543 }
1544
1545 case VIDEO_GET_EVENT: {
1546 struct video_event *ev = arg;
1547 DEFINE_WAIT(wait);
1548
1549 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1550 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1551 return -EINVAL;
1552 memset(ev, 0, sizeof(*ev));
1553 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1554
1555 while (1) {
1556 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1557 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1558 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1559 ev->type = VIDEO_EVENT_VSYNC;
1560 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1561 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1562 if (itv->output_mode == OUT_UDMA_YUV &&
1563 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1564 IVTV_YUV_MODE_PROGRESSIVE) {
1565 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1566 }
1567 }
1568 if (ev->type)
1569 return 0;
1570 if (nonblocking)
1571 return -EAGAIN;
1572 /* Wait for event. Note that serialize_lock is locked,
1573 so to allow other processes to access the driver while
1574 we are waiting unlock first and later lock again. */
1575 mutex_unlock(&itv->serialize_lock);
1576 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1577 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1578 schedule();
1579 finish_wait(&itv->event_waitq, &wait);
1580 mutex_lock(&itv->serialize_lock);
1581 if (signal_pending(current)) {
1582 /* return if a signal was received */
1583 IVTV_DEBUG_INFO("User stopped wait for event\n");
1584 return -EINTR;
1585 }
1586 }
1587 break;
1588 }
1589
1590 default:
1591 return -EINVAL;
1592 }
1593 return 0;
1594 }
1595
1596 static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1597 unsigned int cmd, void *arg)
1598 {
1599 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1600 struct ivtv *itv = id->itv;
1601 int ret;
1602
1603 /* check priority */
1604 switch (cmd) {
1605 case VIDIOC_S_CTRL:
1606 case VIDIOC_S_STD:
1607 case VIDIOC_S_INPUT:
1608 case VIDIOC_S_OUTPUT:
1609 case VIDIOC_S_TUNER:
1610 case VIDIOC_S_FREQUENCY:
1611 case VIDIOC_S_FMT:
1612 case VIDIOC_S_CROP:
1613 case VIDIOC_S_AUDIO:
1614 case VIDIOC_S_AUDOUT:
1615 case VIDIOC_S_EXT_CTRLS:
1616 case VIDIOC_S_FBUF:
1617 case VIDIOC_OVERLAY:
1618 ret = v4l2_prio_check(&itv->prio, &id->prio);
1619 if (ret)
1620 return ret;
1621 }
1622
1623 switch (cmd) {
1624 case VIDIOC_DBG_G_REGISTER:
1625 case VIDIOC_DBG_S_REGISTER:
1626 case VIDIOC_G_CHIP_IDENT:
1627 case VIDIOC_INT_S_AUDIO_ROUTING:
1628 case VIDIOC_INT_RESET:
1629 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1630 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1631 v4l_printk_ioctl(cmd);
1632 }
1633 return ivtv_debug_ioctls(filp, cmd, arg);
1634
1635 case VIDIOC_G_PRIORITY:
1636 case VIDIOC_S_PRIORITY:
1637 case VIDIOC_QUERYCAP:
1638 case VIDIOC_ENUMINPUT:
1639 case VIDIOC_G_INPUT:
1640 case VIDIOC_S_INPUT:
1641 case VIDIOC_ENUMOUTPUT:
1642 case VIDIOC_G_OUTPUT:
1643 case VIDIOC_S_OUTPUT:
1644 case VIDIOC_G_FMT:
1645 case VIDIOC_S_FMT:
1646 case VIDIOC_TRY_FMT:
1647 case VIDIOC_ENUM_FMT:
1648 case VIDIOC_CROPCAP:
1649 case VIDIOC_G_CROP:
1650 case VIDIOC_S_CROP:
1651 case VIDIOC_G_FREQUENCY:
1652 case VIDIOC_S_FREQUENCY:
1653 case VIDIOC_ENUMSTD:
1654 case VIDIOC_G_STD:
1655 case VIDIOC_S_STD:
1656 case VIDIOC_S_TUNER:
1657 case VIDIOC_G_TUNER:
1658 case VIDIOC_ENUMAUDIO:
1659 case VIDIOC_S_AUDIO:
1660 case VIDIOC_G_AUDIO:
1661 case VIDIOC_ENUMAUDOUT:
1662 case VIDIOC_S_AUDOUT:
1663 case VIDIOC_G_AUDOUT:
1664 case VIDIOC_G_SLICED_VBI_CAP:
1665 case VIDIOC_LOG_STATUS:
1666 case VIDIOC_G_ENC_INDEX:
1667 case VIDIOC_ENCODER_CMD:
1668 case VIDIOC_TRY_ENCODER_CMD:
1669 case VIDIOC_G_FBUF:
1670 case VIDIOC_S_FBUF:
1671 case VIDIOC_OVERLAY:
1672 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1673 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1674 v4l_printk_ioctl(cmd);
1675 }
1676 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1677
1678 case VIDIOC_QUERYMENU:
1679 case VIDIOC_QUERYCTRL:
1680 case VIDIOC_S_CTRL:
1681 case VIDIOC_G_CTRL:
1682 case VIDIOC_S_EXT_CTRLS:
1683 case VIDIOC_G_EXT_CTRLS:
1684 case VIDIOC_TRY_EXT_CTRLS:
1685 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1686 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1687 v4l_printk_ioctl(cmd);
1688 }
1689 return ivtv_control_ioctls(itv, cmd, arg);
1690
1691 case IVTV_IOC_DMA_FRAME:
1692 case VIDEO_GET_PTS:
1693 case VIDEO_GET_FRAME_COUNT:
1694 case VIDEO_GET_EVENT:
1695 case VIDEO_PLAY:
1696 case VIDEO_STOP:
1697 case VIDEO_FREEZE:
1698 case VIDEO_CONTINUE:
1699 case VIDEO_COMMAND:
1700 case VIDEO_TRY_COMMAND:
1701 return ivtv_decoder_ioctls(filp, cmd, arg);
1702
1703 case 0x00005401: /* Handle isatty() calls */
1704 return -EINVAL;
1705 default:
1706 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1707 ivtv_v4l2_do_ioctl);
1708 }
1709 return 0;
1710 }
1711
1712 static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1713 unsigned int cmd, unsigned long arg)
1714 {
1715 /* Filter dvb ioctls that cannot be handled by video_usercopy */
1716 switch (cmd) {
1717 case VIDEO_SELECT_SOURCE:
1718 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1719 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1720 return -EINVAL;
1721 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1722
1723 case AUDIO_SET_MUTE:
1724 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1725 itv->speed_mute_audio = arg;
1726 return 0;
1727
1728 case AUDIO_CHANNEL_SELECT:
1729 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1730 if (arg > AUDIO_STEREO_SWAPPED)
1731 return -EINVAL;
1732 itv->audio_stereo_mode = arg;
1733 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1734 return 0;
1735
1736 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1737 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1738 if (arg > AUDIO_STEREO_SWAPPED)
1739 return -EINVAL;
1740 itv->audio_bilingual_mode = arg;
1741 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1742 return 0;
1743
1744 default:
1745 break;
1746 }
1747 return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1748 }
1749
1750 int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1751 unsigned long arg)
1752 {
1753 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1754 struct ivtv *itv = id->itv;
1755 int res;
1756
1757 mutex_lock(&itv->serialize_lock);
1758 res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1759 mutex_unlock(&itv->serialize_lock);
1760 return res;
1761 }
1762
|
This page was automatically generated by the
LXR engine.
|