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