3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
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.
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.
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
21 #include "ivtv-driver.h"
22 #include "ivtv-version.h"
23 #include "ivtv-mailbox.h"
25 #include "ivtv-queue.h"
26 #include "ivtv-fileops.h"
28 #include "ivtv-audio.h"
29 #include "ivtv-video.h"
30 #include "ivtv-streams.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>
42 u16 service2vbi(int 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;
52 return IVTV_SLICED_TYPE_VPS;
58 static int valid_service_line(int field, int line, int is_pal)
60 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
61 (!is_pal && line >= 10 && line < 22);
64 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
66 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
69 set = set & valid_set;
70 if (set == 0 || !valid_service_line(field, line, is_pal)) {
74 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
75 return V4L2_SLICED_CAPTION_525;
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;
85 for (i = 0; i < 32; i++) {
92 void expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
94 u16 set = fmt->service_set;
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);
105 static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
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];
119 u16 get_service_set(struct v4l2_sliced_vbi_format *fmt)
124 for (f = 0; f < 2; f++) {
125 for (l = 0; l < 24; l++) {
126 set |= fmt->service_lines[f][l];
132 static const struct {
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" },
151 static const struct v4l2_standard ivtv_std_60hz =
153 .frameperiod = {.numerator = 1001, .denominator = 30000},
157 static const struct v4l2_standard ivtv_std_50hz =
159 .frameperiod = {.numerator = 1, .denominator = 25},
163 void ivtv_set_osd_alpha(struct ivtv *itv)
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);
170 int ivtv_set_speed(struct ivtv *itv, int speed)
172 u32 data[CX2341X_MBOX_MAX_DATA];
173 struct ivtv_stream *s;
174 int single_step = (speed == 1 || speed == -1);
177 if (speed == 0) speed = 1000;
180 if (speed == itv->speed && !single_step)
183 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
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);
192 /* Need to change direction */
193 speed = speed < 0 ? -1000 : 1000;
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;
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);
209 /* If not decoding, just change speed setting */
210 if (atomic_read(&itv->decoding) > 0) {
213 /* Stop all DMA and decoding activity */
214 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
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);
225 finish_wait(&itv->dma_waitq, &wait);
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]);
235 speed = (speed < 0) ? -1 : 1;
236 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
242 static int ivtv_validate_speed(int cur_speed, int new_speed)
244 int fact = new_speed < 0 ? -1 : 1;
247 if (new_speed < 0) new_speed = -new_speed;
248 if (cur_speed < 0) cur_speed = -cur_speed;
250 if (cur_speed <= new_speed) {
251 if (new_speed > 1500) return fact * 2000;
252 if (new_speed > 1000) return fact * 1500;
255 if (new_speed >= 2000) return fact * 2000;
256 if (new_speed >= 1500) return fact * 1500;
257 if (new_speed >= 1000) return fact * 1000;
259 if (new_speed == 0) return 1000;
260 if (new_speed == 1 || new_speed == 1000) return fact * 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);
270 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
271 struct video_command *vc, int try)
273 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
275 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
279 case VIDEO_CMD_PLAY: {
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;
286 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
288 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
289 /* forces ivtv_set_speed to be called */
292 return ivtv_start_decoding(id, vc->play.speed);
296 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
297 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
300 if (atomic_read(&itv->decoding) == 0)
302 if (itv->output_mode != OUT_MPG)
305 itv->output_mode = OUT_NONE;
306 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
308 case VIDEO_CMD_FREEZE:
309 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
311 if (itv->output_mode != OUT_MPG)
313 if (atomic_read(&itv->decoding) > 0) {
314 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
315 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
316 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
320 case VIDEO_CMD_CONTINUE:
323 if (itv->output_mode != OUT_MPG)
325 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
326 int speed = itv->speed;
328 return ivtv_start_decoding(id, speed);
338 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
340 struct v4l2_register *regs = arg;
342 volatile u8 __iomem *reg_start;
344 if (!capable(CAP_SYS_ADMIN))
346 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
347 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
348 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
349 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
350 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
351 else if (regs->reg >= 0 && regs->reg < IVTV_ENCODER_SIZE)
352 reg_start = itv->enc_mem;
356 spin_lock_irqsave(&ivtv_cards_lock, flags);
357 if (cmd == VIDIOC_DBG_G_REGISTER) {
358 regs->val = readl(regs->reg + reg_start);
360 writel(regs->val, regs->reg + reg_start);
362 spin_unlock_irqrestore(&ivtv_cards_lock, flags);
366 static int ivtv_get_fmt(struct ivtv *itv, int streamtype, struct v4l2_format *fmt)
369 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
370 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
372 fmt->fmt.pix.width = itv->main_rect.width;
373 fmt->fmt.pix.height = itv->main_rect.height;
374 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
375 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
376 if (itv->output_mode == OUT_UDMA_YUV) {
377 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
378 case IVTV_YUV_MODE_INTERLACED:
379 fmt->fmt.pix.field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
380 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
382 case IVTV_YUV_MODE_PROGRESSIVE:
383 fmt->fmt.pix.field = V4L2_FIELD_NONE;
386 fmt->fmt.pix.field = V4L2_FIELD_ANY;
389 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
390 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
391 fmt->fmt.pix.sizeimage =
392 fmt->fmt.pix.height * fmt->fmt.pix.width +
393 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
395 else if (itv->output_mode == OUT_YUV ||
396 streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
397 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
398 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
399 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
400 fmt->fmt.pix.sizeimage =
401 fmt->fmt.pix.height * fmt->fmt.pix.width +
402 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
404 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
405 fmt->fmt.pix.sizeimage = 128 * 1024;
409 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
410 fmt->fmt.pix.width = itv->params.width;
411 fmt->fmt.pix.height = itv->params.height;
412 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
413 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
414 if (streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
415 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
416 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
417 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
418 fmt->fmt.pix.sizeimage =
419 fmt->fmt.pix.height * fmt->fmt.pix.width +
420 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
422 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
423 fmt->fmt.pix.sizeimage = 128 * 1024;
427 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
428 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
430 fmt->fmt.win.chromakey = itv->osd_color_key;
431 fmt->fmt.win.global_alpha = itv->osd_global_alpha;
434 case V4L2_BUF_TYPE_VBI_CAPTURE:
435 fmt->fmt.vbi.sampling_rate = 27000000;
436 fmt->fmt.vbi.offset = 248;
437 fmt->fmt.vbi.samples_per_line = itv->vbi.raw_decoder_line_size - 4;
438 fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
439 fmt->fmt.vbi.start[0] = itv->vbi.start[0];
440 fmt->fmt.vbi.start[1] = itv->vbi.start[1];
441 fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = itv->vbi.count;
444 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
446 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
448 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
450 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
451 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
452 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
454 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
455 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
457 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
458 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
460 vbifmt->service_set = get_service_set(vbifmt);
464 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
466 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
468 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
469 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
470 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
472 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
473 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
475 expand_service_set(vbifmt, itv->is_50hz);
479 itv->video_dec_func(itv, VIDIOC_G_FMT, fmt);
480 vbifmt->service_set = get_service_set(vbifmt);
483 case V4L2_BUF_TYPE_VBI_OUTPUT:
484 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
491 static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
492 struct v4l2_format *fmt, int set_fmt)
494 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
497 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
501 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
503 field = fmt->fmt.pix.field;
506 r.width = fmt->fmt.pix.width;
507 r.height = fmt->fmt.pix.height;
508 ivtv_get_fmt(itv, streamtype, fmt);
509 if (itv->output_mode != OUT_UDMA_YUV) {
510 /* TODO: would setting the rect also be valid for this mode? */
511 fmt->fmt.pix.width = r.width;
512 fmt->fmt.pix.height = r.height;
514 if (itv->output_mode == OUT_UDMA_YUV) {
515 /* TODO: add checks for validity */
516 fmt->fmt.pix.field = field;
519 if (itv->output_mode == OUT_UDMA_YUV) {
521 case V4L2_FIELD_NONE:
522 itv->yuv_info.lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
525 itv->yuv_info.lace_mode = IVTV_YUV_MODE_AUTO;
527 case V4L2_FIELD_INTERLACED_BT:
528 itv->yuv_info.lace_mode =
529 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
531 case V4L2_FIELD_INTERLACED_TB:
533 itv->yuv_info.lace_mode = IVTV_YUV_MODE_INTERLACED;
536 itv->yuv_info.lace_sync_field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
538 /* Force update of yuv registers */
539 itv->yuv_info.yuv_forced_update = 1;
546 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY) {
547 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
550 itv->osd_color_key = fmt->fmt.win.chromakey;
551 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
552 ivtv_set_osd_alpha(itv);
557 /* set window size */
558 if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
559 int w = fmt->fmt.pix.width;
560 int h = fmt->fmt.pix.height;
562 if (w > 720) w = 720;
563 else if (w < 1) w = 1;
564 if (h > (itv->is_50hz ? 576 : 480)) h = (itv->is_50hz ? 576 : 480);
565 else if (h < 2) h = 2;
566 ivtv_get_fmt(itv, streamtype, fmt);
567 fmt->fmt.pix.width = w;
568 fmt->fmt.pix.height = h;
570 if (!set_fmt || (itv->params.width == w && itv->params.height == h))
572 if (atomic_read(&itv->capturing) > 0)
575 itv->params.width = w;
576 itv->params.height = h;
577 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
578 itv->params.video_temporal_filter = 0;
580 itv->params.video_temporal_filter = 8;
581 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
582 return ivtv_get_fmt(itv, streamtype, fmt);
585 /* set raw VBI format */
586 if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
587 if (set_fmt && atomic_read(&itv->capturing) > 0) {
591 itv->vbi.sliced_in->service_set = 0;
592 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
594 return ivtv_get_fmt(itv, streamtype, fmt);
597 /* set sliced VBI output
598 In principle the user could request that only certain
599 VBI types are output and that the others are ignored.
600 I.e., suppress CC in the even fields or only output
601 WSS and no VPS. Currently though there is no choice. */
602 if (fmt->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
603 return ivtv_get_fmt(itv, streamtype, fmt);
605 /* any else but sliced VBI capture is an error */
606 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
609 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI)
610 return ivtv_get_fmt(itv, streamtype, fmt);
612 /* set sliced VBI capture format */
613 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
614 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
616 if (vbifmt->service_set)
617 expand_service_set(vbifmt, itv->is_50hz);
618 set = check_service_set(vbifmt, itv->is_50hz);
619 vbifmt->service_set = get_service_set(vbifmt);
625 if (atomic_read(&itv->capturing) > 0) {
628 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
629 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
633 static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
635 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
636 struct ivtv *itv = id->itv;
637 struct v4l2_register *reg = arg;
640 /* ioctls to allow direct access to the encoder registers for testing */
641 case VIDIOC_DBG_G_REGISTER:
642 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
643 return ivtv_itvc(itv, cmd, arg);
644 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
645 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
646 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
648 case VIDIOC_DBG_S_REGISTER:
649 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
650 return ivtv_itvc(itv, cmd, arg);
651 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
652 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
653 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
655 case VIDIOC_G_CHIP_IDENT: {
656 struct v4l2_chip_ident *chip = arg;
658 chip->ident = V4L2_IDENT_NONE;
660 if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
661 if (v4l2_chip_match_host(reg->match_type, reg->match_chip)) {
662 struct v4l2_chip_ident *chip = arg;
664 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
668 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
669 return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
670 if (reg->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
671 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
675 case VIDIOC_INT_S_AUDIO_ROUTING: {
676 struct v4l2_routing *route = arg;
678 ivtv_audio_set_route(itv, route);
682 case VIDIOC_INT_RESET: {
683 u32 val = *(u32 *)arg;
685 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) {
686 ivtv_reset_ir_gpio(itv);
689 itv->video_dec_func(itv, cmd, 0);
700 int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
702 struct ivtv_open_id *id = NULL;
704 if (filp) id = (struct ivtv_open_id *)filp->private_data;
707 case VIDIOC_G_PRIORITY:
709 enum v4l2_priority *p = arg;
711 *p = v4l2_prio_max(&itv->prio);
715 case VIDIOC_S_PRIORITY:
717 enum v4l2_priority *prio = arg;
719 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
722 case VIDIOC_QUERYCAP:{
723 struct v4l2_capability *vcap = arg;
725 memset(vcap, 0, sizeof(*vcap));
726 strcpy(vcap->driver, IVTV_DRIVER_NAME); /* driver name */
727 strcpy(vcap->card, itv->card_name); /* card type */
728 strcpy(vcap->bus_info, pci_name(itv->dev)); /* bus info... */
729 vcap->version = IVTV_DRIVER_VERSION; /* version */
730 vcap->capabilities = itv->v4l2_cap; /* capabilities */
732 /* reserved.. must set to 0! */
733 vcap->reserved[0] = vcap->reserved[1] =
734 vcap->reserved[2] = vcap->reserved[3] = 0;
738 case VIDIOC_ENUMAUDIO:{
739 struct v4l2_audio *vin = arg;
741 return ivtv_get_audio_input(itv, vin->index, vin);
744 case VIDIOC_G_AUDIO:{
745 struct v4l2_audio *vin = arg;
747 vin->index = itv->audio_input;
748 return ivtv_get_audio_input(itv, vin->index, vin);
751 case VIDIOC_S_AUDIO:{
752 struct v4l2_audio *vout = arg;
754 if (vout->index >= itv->nof_audio_inputs)
756 itv->audio_input = vout->index;
757 ivtv_audio_set_io(itv);
761 case VIDIOC_ENUMAUDOUT:{
762 struct v4l2_audioout *vin = arg;
764 /* set it to defaults from our table */
765 return ivtv_get_audio_output(itv, vin->index, vin);
768 case VIDIOC_G_AUDOUT:{
769 struct v4l2_audioout *vin = arg;
772 return ivtv_get_audio_output(itv, vin->index, vin);
775 case VIDIOC_S_AUDOUT:{
776 struct v4l2_audioout *vout = arg;
778 return ivtv_get_audio_output(itv, vout->index, vout);
781 case VIDIOC_ENUMINPUT:{
782 struct v4l2_input *vin = arg;
784 /* set it to defaults from our table */
785 return ivtv_get_input(itv, vin->index, vin);
788 case VIDIOC_ENUMOUTPUT:{
789 struct v4l2_output *vout = arg;
791 return ivtv_get_output(itv, vout->index, vout);
796 struct v4l2_format *fmt = arg;
798 return ivtv_try_or_set_fmt(itv, id->type, fmt, cmd == VIDIOC_S_FMT);
802 struct v4l2_format *fmt = arg;
803 int type = fmt->type;
805 memset(fmt, 0, sizeof(*fmt));
807 return ivtv_get_fmt(itv, id->type, fmt);
810 case VIDIOC_CROPCAP: {
811 struct v4l2_cropcap *cropcap = arg;
813 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
814 cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
816 cropcap->bounds.top = cropcap->bounds.left = 0;
817 cropcap->bounds.width = 720;
818 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
819 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
820 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
821 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
823 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
824 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
825 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
827 cropcap->defrect = cropcap->bounds;
831 case VIDIOC_S_CROP: {
832 struct v4l2_crop *crop = arg;
834 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
835 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
836 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
837 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
838 itv->main_rect = crop->c;
843 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
845 return itv->video_dec_func(itv, VIDIOC_S_CROP, arg);
848 case VIDIOC_G_CROP: {
849 struct v4l2_crop *crop = arg;
851 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
852 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
853 crop->c = itv->main_rect;
856 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
858 return itv->video_dec_func(itv, VIDIOC_G_CROP, arg);
861 case VIDIOC_ENUM_FMT: {
862 static struct v4l2_fmtdesc formats[] = {
864 "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12,
867 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
868 "MPEG", V4L2_PIX_FMT_MPEG,
872 struct v4l2_fmtdesc *fmt = arg;
873 enum v4l2_buf_type type = fmt->type;
876 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
878 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
879 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
887 *fmt = formats[fmt->index];
892 case VIDIOC_G_INPUT:{
893 *(int *)arg = itv->active_input;
897 case VIDIOC_S_INPUT:{
898 int inp = *(int *)arg;
900 if (inp < 0 || inp >= itv->nof_inputs)
903 if (inp == itv->active_input) {
904 IVTV_DEBUG_INFO("Input unchanged\n");
907 if (atomic_read(&itv->capturing) > 0) {
910 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
911 itv->active_input, inp);
913 itv->active_input = inp;
914 /* Set the audio input to whatever is appropriate for the
916 itv->audio_input = itv->card->video_inputs[inp].audio_index;
918 /* prevent others from messing with the streams until
919 we're finished changing inputs. */
921 ivtv_video_set_io(itv);
922 ivtv_audio_set_io(itv);
927 case VIDIOC_G_OUTPUT:{
928 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
930 *(int *)arg = itv->active_output;
934 case VIDIOC_S_OUTPUT:{
935 int outp = *(int *)arg;
936 struct v4l2_routing route;
938 if (outp >= itv->card->nof_outputs)
941 if (outp == itv->active_output) {
942 IVTV_DEBUG_INFO("Output unchanged\n");
945 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
946 itv->active_output, outp);
948 itv->active_output = outp;
949 route.input = SAA7127_INPUT_TYPE_NORMAL;
950 route.output = itv->card->video_outputs[outp].video_output;
951 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
955 case VIDIOC_G_FREQUENCY:{
956 struct v4l2_frequency *vf = arg;
960 ivtv_call_i2c_clients(itv, cmd, arg);
964 case VIDIOC_S_FREQUENCY:{
965 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
971 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
972 ivtv_call_i2c_clients(itv, cmd, &vf);
977 case VIDIOC_ENUMSTD:{
978 struct v4l2_standard *vs = arg;
981 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
984 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
985 ivtv_std_60hz : ivtv_std_50hz;
987 vs->id = enum_stds[idx].std;
988 strcpy(vs->name, enum_stds[idx].name);
993 *(v4l2_std_id *) arg = itv->std;
998 v4l2_std_id std = *(v4l2_std_id *) arg;
1000 if ((std & V4L2_STD_ALL) == 0)
1003 if (std == itv->std)
1006 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1007 atomic_read(&itv->capturing) > 0 ||
1008 atomic_read(&itv->decoding) > 0) {
1009 /* Switching standard would turn off the radio or mess
1010 with already running streams, prevent that by
1016 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1017 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1018 itv->params.width = 720;
1019 itv->params.height = itv->is_50hz ? 576 : 480;
1020 itv->vbi.count = itv->is_50hz ? 18 : 12;
1021 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1022 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1023 if (itv->hw_flags & IVTV_HW_CX25840) {
1024 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1026 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1029 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1031 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1032 /* set display standard */
1034 itv->is_out_60hz = itv->is_60hz;
1035 itv->is_out_50hz = itv->is_50hz;
1036 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1037 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1038 itv->main_rect.left = itv->main_rect.top = 0;
1039 itv->main_rect.width = 720;
1040 itv->main_rect.height = itv->params.height;
1041 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1042 720, itv->main_rect.height, 0, 0);
1047 case VIDIOC_S_TUNER: { /* Setting tuner can only set audio mode */
1048 struct v4l2_tuner *vt = arg;
1053 ivtv_call_i2c_clients(itv, VIDIOC_S_TUNER, vt);
1057 case VIDIOC_G_TUNER: {
1058 struct v4l2_tuner *vt = arg;
1063 memset(vt, 0, sizeof(*vt));
1064 ivtv_call_i2c_clients(itv, VIDIOC_G_TUNER, vt);
1066 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1067 strcpy(vt->name, "ivtv Radio Tuner");
1068 vt->type = V4L2_TUNER_RADIO;
1070 strcpy(vt->name, "ivtv TV Tuner");
1071 vt->type = V4L2_TUNER_ANALOG_TV;
1076 case VIDIOC_G_SLICED_VBI_CAP: {
1077 struct v4l2_sliced_vbi_cap *cap = arg;
1078 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1080 enum v4l2_buf_type type = cap->type;
1082 memset(cap, 0, sizeof(*cap));
1084 if (type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1085 for (f = 0; f < 2; f++) {
1086 for (l = 0; l < 24; l++) {
1087 if (valid_service_line(f, l, itv->is_50hz)) {
1088 cap->service_lines[f][l] = set;
1094 if (type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1095 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1098 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1099 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1101 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1102 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1109 case VIDIOC_G_ENC_INDEX: {
1110 struct v4l2_enc_idx *idx = arg;
1111 struct v4l2_enc_idx_entry *e = idx->entry;
1115 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1117 if (entries > V4L2_ENC_IDX_ENTRIES)
1118 entries = V4L2_ENC_IDX_ENTRIES;
1120 for (i = 0; i < entries; i++) {
1121 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1122 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1127 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1131 case VIDIOC_ENCODER_CMD:
1132 case VIDIOC_TRY_ENCODER_CMD: {
1133 struct v4l2_encoder_cmd *enc = arg;
1134 int try = cmd == VIDIOC_TRY_ENCODER_CMD;
1136 memset(&enc->raw, 0, sizeof(enc->raw));
1138 case V4L2_ENC_CMD_START:
1139 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1143 return ivtv_start_capture(id);
1145 case V4L2_ENC_CMD_STOP:
1146 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1147 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1150 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1153 case V4L2_ENC_CMD_PAUSE:
1154 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1158 if (!atomic_read(&itv->capturing))
1160 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1163 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1166 case V4L2_ENC_CMD_RESUME:
1167 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1171 if (!atomic_read(&itv->capturing))
1173 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1175 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1179 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1185 case VIDIOC_G_FBUF: {
1186 struct v4l2_framebuffer *fb = arg;
1188 memset(fb, 0, sizeof(*fb));
1189 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1191 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1192 V4L2_FBUF_CAP_LOCAL_ALPHA | V4L2_FBUF_CAP_GLOBAL_ALPHA;
1193 fb->fmt.pixelformat = itv->osd_pixelformat;
1194 fb->fmt.width = itv->osd_rect.width;
1195 fb->fmt.height = itv->osd_rect.height;
1196 fb->base = (void *)itv->osd_video_pbase;
1197 if (itv->osd_global_alpha_state)
1198 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1199 if (itv->osd_local_alpha_state)
1200 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1201 if (itv->osd_color_key_state)
1202 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1206 case VIDIOC_S_FBUF: {
1207 struct v4l2_framebuffer *fb = arg;
1209 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1211 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1212 itv->osd_local_alpha_state = (fb->flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) != 0;
1213 itv->osd_color_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1214 ivtv_set_osd_alpha(itv);
1218 case VIDIOC_OVERLAY: {
1221 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1223 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1227 case VIDIOC_LOG_STATUS:
1229 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1230 u32 data[CX2341X_MBOX_MAX_DATA];
1231 struct v4l2_input vidin;
1232 struct v4l2_audio audin;
1235 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv->num);
1236 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1237 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1240 ivtv_read_eeprom(itv, &tv);
1242 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1243 ivtv_get_input(itv, itv->active_input, &vidin);
1244 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1245 IVTV_INFO("Video Input: %s\n", vidin.name);
1246 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1247 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1249 struct v4l2_output vidout;
1250 struct v4l2_audioout audout;
1251 int mode = itv->output_mode;
1252 static const char * const output_modes[] = {
1259 static const char * const audio_modes[] = {
1266 static const char * const alpha_mode[] = {
1272 static const char * const pixel_format[] = {
1283 ivtv_get_output(itv, itv->active_output, &vidout);
1284 ivtv_get_audio_output(itv, 0, &audout);
1285 IVTV_INFO("Video Output: %s\n", vidout.name);
1286 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1287 audio_modes[itv->audio_stereo_mode],
1288 audio_modes[itv->audio_bilingual_mode]);
1289 if (mode < 0 || mode > OUT_PASSTHROUGH)
1291 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1292 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1293 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1294 data[0] & 1 ? "On" : "Off",
1295 alpha_mode[(data[0] >> 1) & 0x3],
1296 pixel_format[(data[0] >> 3) & 0x7]);
1298 IVTV_INFO("Tuner: %s\n",
1299 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1300 cx2341x_log_status(&itv->params, itv->name);
1301 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1302 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1303 struct ivtv_stream *s = &itv->streams[i];
1305 if (s->v4l2dev == NULL || s->buffers == 0)
1307 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1308 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1309 (s->buffers * s->buf_size) / 1024, s->buffers);
1311 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1312 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv->num);
1322 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1324 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1325 struct ivtv *itv = id->itv;
1326 int nonblocking = filp->f_flags & O_NONBLOCK;
1327 struct ivtv_stream *s = &itv->streams[id->type];
1330 case IVTV_IOC_DMA_FRAME: {
1331 struct ivtv_dma_frame *args = arg;
1333 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1334 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1336 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1338 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1340 if (ivtv_claim_stream(id, id->type)) {
1343 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1344 ivtv_release_stream(s);
1347 /* Mark that this file handle started the UDMA_YUV mode */
1349 if (args->y_source == NULL)
1351 return ivtv_yuv_prep_frame(itv, args);
1354 case VIDEO_GET_PTS: {
1355 u32 data[CX2341X_MBOX_MAX_DATA];
1358 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1359 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1363 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1366 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1367 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1368 (u64)itv->last_dec_timing[1];
1372 if (atomic_read(&itv->decoding)) {
1373 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1374 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1377 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1378 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1379 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1380 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1385 case VIDEO_GET_FRAME_COUNT: {
1386 u32 data[CX2341X_MBOX_MAX_DATA];
1389 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1390 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1394 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1397 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1398 *frame = itv->last_dec_timing[0];
1402 if (atomic_read(&itv->decoding)) {
1403 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1404 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1407 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1408 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1415 struct video_command vc;
1417 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1418 memset(&vc, 0, sizeof(vc));
1419 vc.cmd = VIDEO_CMD_PLAY;
1420 return ivtv_video_command(itv, id, &vc, 0);
1424 struct video_command vc;
1426 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1427 memset(&vc, 0, sizeof(vc));
1428 vc.cmd = VIDEO_CMD_STOP;
1429 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1430 return ivtv_video_command(itv, id, &vc, 0);
1433 case VIDEO_FREEZE: {
1434 struct video_command vc;
1436 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1437 memset(&vc, 0, sizeof(vc));
1438 vc.cmd = VIDEO_CMD_FREEZE;
1439 return ivtv_video_command(itv, id, &vc, 0);
1442 case VIDEO_CONTINUE: {
1443 struct video_command vc;
1445 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1446 memset(&vc, 0, sizeof(vc));
1447 vc.cmd = VIDEO_CMD_CONTINUE;
1448 return ivtv_video_command(itv, id, &vc, 0);
1452 case VIDEO_TRY_COMMAND: {
1453 struct video_command *vc = arg;
1454 int try = (cmd == VIDEO_TRY_COMMAND);
1457 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1459 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1460 return ivtv_video_command(itv, id, vc, try);
1463 case VIDEO_GET_EVENT: {
1464 struct video_event *ev = arg;
1467 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1468 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1470 memset(ev, 0, sizeof(*ev));
1471 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1474 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1475 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1476 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1477 ev->type = VIDEO_EVENT_VSYNC;
1478 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1479 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1480 if (itv->output_mode == OUT_UDMA_YUV &&
1481 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1482 IVTV_YUV_MODE_PROGRESSIVE) {
1483 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1490 /* Wait for event. Note that serialize_lock is locked,
1491 so to allow other processes to access the driver while
1492 we are waiting unlock first and later lock again. */
1493 mutex_unlock(&itv->serialize_lock);
1494 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1495 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1497 finish_wait(&itv->event_waitq, &wait);
1498 mutex_lock(&itv->serialize_lock);
1499 if (signal_pending(current)) {
1500 /* return if a signal was received */
1501 IVTV_DEBUG_INFO("User stopped wait for event\n");
1514 static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1515 unsigned int cmd, void *arg)
1517 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1518 struct ivtv *itv = id->itv;
1521 /* check priority */
1525 case VIDIOC_S_INPUT:
1526 case VIDIOC_S_OUTPUT:
1527 case VIDIOC_S_TUNER:
1528 case VIDIOC_S_FREQUENCY:
1531 case VIDIOC_S_AUDIO:
1532 case VIDIOC_S_AUDOUT:
1533 case VIDIOC_S_EXT_CTRLS:
1535 case VIDIOC_OVERLAY:
1536 ret = v4l2_prio_check(&itv->prio, &id->prio);
1542 case VIDIOC_DBG_G_REGISTER:
1543 case VIDIOC_DBG_S_REGISTER:
1544 case VIDIOC_G_CHIP_IDENT:
1545 case VIDIOC_INT_S_AUDIO_ROUTING:
1546 case VIDIOC_INT_RESET:
1547 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1548 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1549 v4l_printk_ioctl(cmd);
1551 return ivtv_debug_ioctls(filp, cmd, arg);
1553 case VIDIOC_G_PRIORITY:
1554 case VIDIOC_S_PRIORITY:
1555 case VIDIOC_QUERYCAP:
1556 case VIDIOC_ENUMINPUT:
1557 case VIDIOC_G_INPUT:
1558 case VIDIOC_S_INPUT:
1559 case VIDIOC_ENUMOUTPUT:
1560 case VIDIOC_G_OUTPUT:
1561 case VIDIOC_S_OUTPUT:
1564 case VIDIOC_TRY_FMT:
1565 case VIDIOC_ENUM_FMT:
1566 case VIDIOC_CROPCAP:
1569 case VIDIOC_G_FREQUENCY:
1570 case VIDIOC_S_FREQUENCY:
1571 case VIDIOC_ENUMSTD:
1574 case VIDIOC_S_TUNER:
1575 case VIDIOC_G_TUNER:
1576 case VIDIOC_ENUMAUDIO:
1577 case VIDIOC_S_AUDIO:
1578 case VIDIOC_G_AUDIO:
1579 case VIDIOC_ENUMAUDOUT:
1580 case VIDIOC_S_AUDOUT:
1581 case VIDIOC_G_AUDOUT:
1582 case VIDIOC_G_SLICED_VBI_CAP:
1583 case VIDIOC_LOG_STATUS:
1584 case VIDIOC_G_ENC_INDEX:
1585 case VIDIOC_ENCODER_CMD:
1586 case VIDIOC_TRY_ENCODER_CMD:
1589 case VIDIOC_OVERLAY:
1590 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1591 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1592 v4l_printk_ioctl(cmd);
1594 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1596 case VIDIOC_QUERYMENU:
1597 case VIDIOC_QUERYCTRL:
1600 case VIDIOC_S_EXT_CTRLS:
1601 case VIDIOC_G_EXT_CTRLS:
1602 case VIDIOC_TRY_EXT_CTRLS:
1603 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1604 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1605 v4l_printk_ioctl(cmd);
1607 return ivtv_control_ioctls(itv, cmd, arg);
1609 case IVTV_IOC_DMA_FRAME:
1611 case VIDEO_GET_FRAME_COUNT:
1612 case VIDEO_GET_EVENT:
1616 case VIDEO_CONTINUE:
1618 case VIDEO_TRY_COMMAND:
1619 return ivtv_decoder_ioctls(filp, cmd, arg);
1621 case 0x00005401: /* Handle isatty() calls */
1624 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1625 ivtv_v4l2_do_ioctl);
1630 static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1631 unsigned int cmd, unsigned long arg)
1633 /* Filter dvb ioctls that cannot be handled by video_usercopy */
1635 case VIDEO_SELECT_SOURCE:
1636 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1637 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1639 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1641 case AUDIO_SET_MUTE:
1642 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1643 itv->speed_mute_audio = arg;
1646 case AUDIO_CHANNEL_SELECT:
1647 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1648 if (arg > AUDIO_STEREO_SWAPPED)
1650 itv->audio_stereo_mode = arg;
1651 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1654 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1655 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1656 if (arg > AUDIO_STEREO_SWAPPED)
1658 itv->audio_bilingual_mode = arg;
1659 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1665 return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1668 int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1671 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1672 struct ivtv *itv = id->itv;
1675 mutex_lock(&itv->serialize_lock);
1676 res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1677 mutex_unlock(&itv->serialize_lock);