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-routing.h"
29 #include "ivtv-streams.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>
41 u16 service2vbi(int 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;
51 return IVTV_SLICED_TYPE_VPS;
57 static int valid_service_line(int field, int line, int is_pal)
59 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
60 (!is_pal && line >= 10 && line < 22);
63 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
65 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
68 set = set & valid_set;
69 if (set == 0 || !valid_service_line(field, line, is_pal)) {
73 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
74 return V4L2_SLICED_CAPTION_525;
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;
84 for (i = 0; i < 32; i++) {
91 void expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
93 u16 set = fmt->service_set;
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);
104 static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
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];
118 u16 get_service_set(struct v4l2_sliced_vbi_format *fmt)
123 for (f = 0; f < 2; f++) {
124 for (l = 0; l < 24; l++) {
125 set |= fmt->service_lines[f][l];
131 static const struct {
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" },
150 static const struct v4l2_standard ivtv_std_60hz =
152 .frameperiod = {.numerator = 1001, .denominator = 30000},
156 static const struct v4l2_standard ivtv_std_50hz =
158 .frameperiod = {.numerator = 1, .denominator = 25},
162 void ivtv_set_osd_alpha(struct ivtv *itv)
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);
169 int ivtv_set_speed(struct ivtv *itv, int speed)
171 u32 data[CX2341X_MBOX_MAX_DATA];
172 struct ivtv_stream *s;
173 int single_step = (speed == 1 || speed == -1);
176 if (speed == 0) speed = 1000;
179 if (speed == itv->speed && !single_step)
182 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
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);
191 /* Need to change direction */
192 speed = speed < 0 ? -1000 : 1000;
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;
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);
208 /* If not decoding, just change speed setting */
209 if (atomic_read(&itv->decoding) > 0) {
212 /* Stop all DMA and decoding activity */
213 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
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);
224 finish_wait(&itv->dma_waitq, &wait);
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]);
234 speed = (speed < 0) ? -1 : 1;
235 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
241 static int ivtv_validate_speed(int cur_speed, int new_speed)
243 int fact = new_speed < 0 ? -1 : 1;
246 if (new_speed < 0) new_speed = -new_speed;
247 if (cur_speed < 0) cur_speed = -cur_speed;
249 if (cur_speed <= new_speed) {
250 if (new_speed > 1500) return fact * 2000;
251 if (new_speed > 1000) return fact * 1500;
254 if (new_speed >= 2000) return fact * 2000;
255 if (new_speed >= 1500) return fact * 1500;
256 if (new_speed >= 1000) return fact * 1000;
258 if (new_speed == 0) return 1000;
259 if (new_speed == 1 || new_speed == 1000) return fact * 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);
269 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
270 struct video_command *vc, int try)
272 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
274 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
278 case VIDEO_CMD_PLAY: {
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;
285 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
287 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
288 /* forces ivtv_set_speed to be called */
291 return ivtv_start_decoding(id, vc->play.speed);
295 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
296 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
299 if (atomic_read(&itv->decoding) == 0)
301 if (itv->output_mode != OUT_MPG)
304 itv->output_mode = OUT_NONE;
305 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
307 case VIDEO_CMD_FREEZE:
308 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
310 if (itv->output_mode != OUT_MPG)
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);
319 case VIDEO_CMD_CONTINUE:
322 if (itv->output_mode != OUT_MPG)
324 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
325 int speed = itv->speed;
327 return ivtv_start_decoding(id, speed);
337 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
339 struct v4l2_register *regs = arg;
341 volatile u8 __iomem *reg_start;
343 if (!capable(CAP_SYS_ADMIN))
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;
355 spin_lock_irqsave(&ivtv_cards_lock, flags);
356 if (cmd == VIDIOC_DBG_G_REGISTER) {
357 regs->val = readl(regs->reg + reg_start);
359 writel(regs->val, regs->reg + reg_start);
361 spin_unlock_irqrestore(&ivtv_cards_lock, flags);
365 static int ivtv_get_fmt(struct ivtv *itv, int streamtype, struct v4l2_format *fmt)
368 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
369 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
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;
381 case IVTV_YUV_MODE_PROGRESSIVE:
382 fmt->fmt.pix.field = V4L2_FIELD_NONE;
385 fmt->fmt.pix.field = V4L2_FIELD_ANY;
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);
402 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
403 fmt->fmt.pix.sizeimage = 128 * 1024;
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);
420 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
421 fmt->fmt.pix.sizeimage = 128 * 1024;
425 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
426 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
428 fmt->fmt.win.chromakey = itv->osd_chroma_key;
429 fmt->fmt.win.global_alpha = itv->osd_global_alpha;
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;
442 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
444 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
446 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
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));
452 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
453 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
455 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
456 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
458 vbifmt->service_set = get_service_set(vbifmt);
462 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
464 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
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));
470 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
471 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
473 expand_service_set(vbifmt, itv->is_50hz);
477 itv->video_dec_func(itv, VIDIOC_G_FMT, fmt);
478 vbifmt->service_set = get_service_set(vbifmt);
481 case V4L2_BUF_TYPE_VBI_OUTPUT:
482 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
489 static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
490 struct v4l2_format *fmt, int set_fmt)
492 struct yuv_playback_info *yi = &itv->yuv_info;
493 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
496 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
500 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
502 field = fmt->fmt.pix.field;
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;
521 if (set_fmt && streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
522 /* Return now if we already have some frame data */
526 yi->v4l2_src_w = r.width;
527 yi->v4l2_src_h = r.height;
530 case V4L2_FIELD_NONE:
531 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
534 yi->lace_mode = IVTV_YUV_MODE_AUTO;
536 case V4L2_FIELD_INTERLACED_BT:
538 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
540 case V4L2_FIELD_INTERLACED_TB:
542 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
545 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
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);
551 /* Force update of yuv registers */
552 yi->yuv_forced_update = 1;
558 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY) {
559 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
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);
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;
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;
583 if (!set_fmt || (p->width == w && p->height == h))
585 if (atomic_read(&itv->capturing) > 0)
590 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
591 p->video_temporal_filter = 0;
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);
600 /* set raw VBI format */
601 if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
602 if (set_fmt && atomic_read(&itv->capturing) > 0) {
606 itv->vbi.sliced_in->service_set = 0;
607 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
609 return ivtv_get_fmt(itv, streamtype, fmt);
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);
620 /* any else but sliced VBI capture is an error */
621 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
624 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI)
625 return ivtv_get_fmt(itv, streamtype, fmt);
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));
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);
640 if (atomic_read(&itv->capturing) > 0) {
643 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
644 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
648 static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
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;
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);
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);
670 case VIDIOC_G_CHIP_IDENT: {
671 struct v4l2_chip_ident *chip = arg;
673 chip->ident = V4L2_IDENT_NONE;
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;
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);
687 case VIDIOC_INT_S_AUDIO_ROUTING: {
688 struct v4l2_routing *route = arg;
690 ivtv_i2c_hw(itv, itv->card->hw_audio, VIDIOC_INT_S_AUDIO_ROUTING, route);
694 case VIDIOC_INT_RESET: {
695 u32 val = *(u32 *)arg;
697 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) {
698 ivtv_reset_ir_gpio(itv);
701 itv->video_dec_func(itv, cmd, NULL);
712 int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
714 struct ivtv_open_id *id = NULL;
715 struct yuv_playback_info *yi = &itv->yuv_info;
716 u32 data[CX2341X_MBOX_MAX_DATA];
720 id = (struct ivtv_open_id *)filp->private_data;
721 streamtype = id->type;
725 case VIDIOC_G_PRIORITY:
727 enum v4l2_priority *p = arg;
729 *p = v4l2_prio_max(&itv->prio);
733 case VIDIOC_S_PRIORITY:
735 enum v4l2_priority *prio = arg;
737 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
740 case VIDIOC_QUERYCAP:{
741 struct v4l2_capability *vcap = arg;
743 memset(vcap, 0, sizeof(*vcap));
744 strcpy(vcap->driver, IVTV_DRIVER_NAME); /* driver name */
745 strcpy(vcap->card, itv->card_name); /* 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 */
750 /* reserved.. must set to 0! */
751 vcap->reserved[0] = vcap->reserved[1] =
752 vcap->reserved[2] = vcap->reserved[3] = 0;
756 case VIDIOC_ENUMAUDIO:{
757 struct v4l2_audio *vin = arg;
759 return ivtv_get_audio_input(itv, vin->index, vin);
762 case VIDIOC_G_AUDIO:{
763 struct v4l2_audio *vin = arg;
765 vin->index = itv->audio_input;
766 return ivtv_get_audio_input(itv, vin->index, vin);
769 case VIDIOC_S_AUDIO:{
770 struct v4l2_audio *vout = arg;
772 if (vout->index >= itv->nof_audio_inputs)
774 itv->audio_input = vout->index;
775 ivtv_audio_set_io(itv);
779 case VIDIOC_ENUMAUDOUT:{
780 struct v4l2_audioout *vin = arg;
782 /* set it to defaults from our table */
783 return ivtv_get_audio_output(itv, vin->index, vin);
786 case VIDIOC_G_AUDOUT:{
787 struct v4l2_audioout *vin = arg;
790 return ivtv_get_audio_output(itv, vin->index, vin);
793 case VIDIOC_S_AUDOUT:{
794 struct v4l2_audioout *vout = arg;
796 return ivtv_get_audio_output(itv, vout->index, vout);
799 case VIDIOC_ENUMINPUT:{
800 struct v4l2_input *vin = arg;
802 /* set it to defaults from our table */
803 return ivtv_get_input(itv, vin->index, vin);
806 case VIDIOC_ENUMOUTPUT:{
807 struct v4l2_output *vout = arg;
809 return ivtv_get_output(itv, vout->index, vout);
814 struct v4l2_format *fmt = arg;
816 return ivtv_try_or_set_fmt(itv, id->type, fmt, cmd == VIDIOC_S_FMT);
820 struct v4l2_format *fmt = arg;
821 int type = fmt->type;
823 memset(fmt, 0, sizeof(*fmt));
825 return ivtv_get_fmt(itv, id->type, fmt);
828 case VIDIOC_CROPCAP: {
829 struct v4l2_cropcap *cropcap = arg;
831 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
833 cropcap->bounds.top = cropcap->bounds.left = 0;
834 cropcap->bounds.width = 720;
835 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
836 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
837 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
838 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
839 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
841 cropcap->bounds.width = yi->osd_full_w;
842 cropcap->bounds.height = yi->osd_full_h;
844 cropcap->bounds.width = 720;
845 cropcap->bounds.height =
846 itv->is_out_50hz ? 576 : 480;
848 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
849 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
851 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
852 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
853 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
855 cropcap->defrect = cropcap->bounds;
859 case VIDIOC_S_CROP: {
860 struct v4l2_crop *crop = arg;
862 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
863 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
864 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
865 yi->main_rect = crop->c;
868 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
869 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
870 itv->main_rect = crop->c;
879 case VIDIOC_G_CROP: {
880 struct v4l2_crop *crop = arg;
882 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
883 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
884 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
885 crop->c = yi->main_rect;
887 crop->c = itv->main_rect;
893 case VIDIOC_ENUM_FMT: {
894 static struct v4l2_fmtdesc formats[] = {
896 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
899 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
900 "MPEG", V4L2_PIX_FMT_MPEG,
904 struct v4l2_fmtdesc *fmt = arg;
905 enum v4l2_buf_type type = fmt->type;
908 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
910 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
911 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
919 *fmt = formats[fmt->index];
924 case VIDIOC_G_INPUT:{
925 *(int *)arg = itv->active_input;
929 case VIDIOC_S_INPUT:{
930 int inp = *(int *)arg;
932 if (inp < 0 || inp >= itv->nof_inputs)
935 if (inp == itv->active_input) {
936 IVTV_DEBUG_INFO("Input unchanged\n");
939 if (atomic_read(&itv->capturing) > 0) {
942 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
943 itv->active_input, inp);
945 itv->active_input = inp;
946 /* Set the audio input to whatever is appropriate for the
948 itv->audio_input = itv->card->video_inputs[inp].audio_index;
950 /* prevent others from messing with the streams until
951 we're finished changing inputs. */
953 ivtv_video_set_io(itv);
954 ivtv_audio_set_io(itv);
959 case VIDIOC_G_OUTPUT:{
960 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
962 *(int *)arg = itv->active_output;
966 case VIDIOC_S_OUTPUT:{
967 int outp = *(int *)arg;
968 struct v4l2_routing route;
970 if (outp >= itv->card->nof_outputs)
973 if (outp == itv->active_output) {
974 IVTV_DEBUG_INFO("Output unchanged\n");
977 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
978 itv->active_output, outp);
980 itv->active_output = outp;
981 route.input = SAA7127_INPUT_TYPE_NORMAL;
982 route.output = itv->card->video_outputs[outp].video_output;
983 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
987 case VIDIOC_G_FREQUENCY:{
988 struct v4l2_frequency *vf = arg;
992 ivtv_call_i2c_clients(itv, cmd, arg);
996 case VIDIOC_S_FREQUENCY:{
997 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
1003 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
1004 ivtv_call_i2c_clients(itv, cmd, &vf);
1009 case VIDIOC_ENUMSTD:{
1010 struct v4l2_standard *vs = arg;
1011 int idx = vs->index;
1013 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
1016 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
1017 ivtv_std_60hz : ivtv_std_50hz;
1019 vs->id = enum_stds[idx].std;
1020 strcpy(vs->name, enum_stds[idx].name);
1025 *(v4l2_std_id *) arg = itv->std;
1029 case VIDIOC_S_STD: {
1030 v4l2_std_id std = *(v4l2_std_id *) arg;
1032 if ((std & V4L2_STD_ALL) == 0)
1035 if (std == itv->std)
1038 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1039 atomic_read(&itv->capturing) > 0 ||
1040 atomic_read(&itv->decoding) > 0) {
1041 /* Switching standard would turn off the radio or mess
1042 with already running streams, prevent that by
1048 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1049 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1050 itv->params.width = 720;
1051 itv->params.height = itv->is_50hz ? 576 : 480;
1052 itv->vbi.count = itv->is_50hz ? 18 : 12;
1053 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1054 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1055 if (itv->hw_flags & IVTV_HW_CX25840) {
1056 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1058 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1061 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1063 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1064 /* set display standard */
1066 itv->is_out_60hz = itv->is_60hz;
1067 itv->is_out_50hz = itv->is_50hz;
1068 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1069 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1070 itv->main_rect.left = itv->main_rect.top = 0;
1071 itv->main_rect.width = 720;
1072 itv->main_rect.height = itv->params.height;
1073 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1074 720, itv->main_rect.height, 0, 0);
1075 yi->main_rect = itv->main_rect;
1076 if (!itv->osd_info) {
1077 yi->osd_full_w = 720;
1078 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1084 case VIDIOC_S_TUNER: { /* Setting tuner can only set audio mode */
1085 struct v4l2_tuner *vt = arg;
1090 ivtv_call_i2c_clients(itv, VIDIOC_S_TUNER, vt);
1094 case VIDIOC_G_TUNER: {
1095 struct v4l2_tuner *vt = arg;
1100 memset(vt, 0, sizeof(*vt));
1101 ivtv_call_i2c_clients(itv, VIDIOC_G_TUNER, vt);
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;
1107 strcpy(vt->name, "ivtv TV Tuner");
1108 vt->type = V4L2_TUNER_ANALOG_TV;
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;
1117 enum v4l2_buf_type type = cap->type;
1119 memset(cap, 0, sizeof(*cap));
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;
1131 if (type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1132 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1135 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1136 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1138 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1139 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1146 case VIDIOC_G_ENC_INDEX: {
1147 struct v4l2_enc_idx *idx = arg;
1148 struct v4l2_enc_idx_entry *e = idx->entry;
1152 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1154 if (entries > V4L2_ENC_IDX_ENTRIES)
1155 entries = V4L2_ENC_IDX_ENTRIES;
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) {
1164 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
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;
1173 memset(&enc->raw, 0, sizeof(enc->raw));
1175 case V4L2_ENC_CMD_START:
1176 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1180 return ivtv_start_capture(id);
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;
1187 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1190 case V4L2_ENC_CMD_PAUSE:
1191 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1195 if (!atomic_read(&itv->capturing))
1197 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1200 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1203 case V4L2_ENC_CMD_RESUME:
1204 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1208 if (!atomic_read(&itv->capturing))
1210 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1212 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1216 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1222 case VIDIOC_G_FBUF: {
1223 struct v4l2_framebuffer *fb = arg;
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,
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,
1244 memset(fb, 0, sizeof(*fb));
1245 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
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;
1261 /* no local alpha for RGB565 or unknown formats */
1262 if (pixfmt == 1 || pixfmt > 4)
1264 /* 16-bit formats have inverted local alpha */
1265 if (pixfmt == 2 || pixfmt == 3)
1266 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
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;
1274 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1277 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1281 case VIDIOC_S_FBUF: {
1282 struct v4l2_framebuffer *fb = arg;
1284 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1286 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1287 itv->osd_local_alpha_state =
1288 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1289 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1290 ivtv_set_osd_alpha(itv);
1291 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1295 case VIDIOC_OVERLAY: {
1298 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1300 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1304 case VIDIOC_LOG_STATUS:
1306 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1307 struct v4l2_input vidin;
1308 struct v4l2_audio audin;
1311 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv->num);
1312 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1313 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1316 ivtv_read_eeprom(itv, &tv);
1318 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1319 ivtv_get_input(itv, itv->active_input, &vidin);
1320 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1321 IVTV_INFO("Video Input: %s\n", vidin.name);
1322 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1323 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1325 struct v4l2_output vidout;
1326 struct v4l2_audioout audout;
1327 int mode = itv->output_mode;
1328 static const char * const output_modes[5] = {
1335 static const char * const audio_modes[5] = {
1342 static const char * const alpha_mode[4] = {
1348 static const char * const pixel_format[16] = {
1367 ivtv_get_output(itv, itv->active_output, &vidout);
1368 ivtv_get_audio_output(itv, 0, &audout);
1369 IVTV_INFO("Video Output: %s\n", vidout.name);
1370 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1371 audio_modes[itv->audio_stereo_mode],
1372 audio_modes[itv->audio_bilingual_mode]);
1373 if (mode < 0 || mode > OUT_PASSTHROUGH)
1375 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1376 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1377 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1378 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1379 data[0] & 1 ? "On" : "Off",
1380 alpha_mode[(data[0] >> 1) & 0x3],
1381 pixel_format[(data[0] >> 3) & 0xf]);
1383 IVTV_INFO("Tuner: %s\n",
1384 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1385 cx2341x_log_status(&itv->params, itv->name);
1386 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1387 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1388 struct ivtv_stream *s = &itv->streams[i];
1390 if (s->v4l2dev == NULL || s->buffers == 0)
1392 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1393 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1394 (s->buffers * s->buf_size) / 1024, s->buffers);
1396 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1397 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv->num);
1407 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1409 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1410 struct ivtv *itv = id->itv;
1411 int nonblocking = filp->f_flags & O_NONBLOCK;
1412 struct ivtv_stream *s = &itv->streams[id->type];
1415 case IVTV_IOC_DMA_FRAME: {
1416 struct ivtv_dma_frame *args = arg;
1418 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1419 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1421 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1423 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1425 if (ivtv_claim_stream(id, id->type)) {
1428 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1429 ivtv_release_stream(s);
1432 /* Mark that this file handle started the UDMA_YUV mode */
1434 if (args->y_source == NULL)
1436 return ivtv_yuv_prep_frame(itv, args);
1439 case VIDEO_GET_PTS: {
1440 u32 data[CX2341X_MBOX_MAX_DATA];
1443 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1444 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1448 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1451 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1452 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1453 (u64)itv->last_dec_timing[1];
1457 if (atomic_read(&itv->decoding)) {
1458 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1459 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1462 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1463 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1464 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1465 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1470 case VIDEO_GET_FRAME_COUNT: {
1471 u32 data[CX2341X_MBOX_MAX_DATA];
1474 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1475 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1479 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1482 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1483 *frame = itv->last_dec_timing[0];
1487 if (atomic_read(&itv->decoding)) {
1488 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1489 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1492 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1493 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1500 struct video_command vc;
1502 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1503 memset(&vc, 0, sizeof(vc));
1504 vc.cmd = VIDEO_CMD_PLAY;
1505 return ivtv_video_command(itv, id, &vc, 0);
1509 struct video_command vc;
1511 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1512 memset(&vc, 0, sizeof(vc));
1513 vc.cmd = VIDEO_CMD_STOP;
1514 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1515 return ivtv_video_command(itv, id, &vc, 0);
1518 case VIDEO_FREEZE: {
1519 struct video_command vc;
1521 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1522 memset(&vc, 0, sizeof(vc));
1523 vc.cmd = VIDEO_CMD_FREEZE;
1524 return ivtv_video_command(itv, id, &vc, 0);
1527 case VIDEO_CONTINUE: {
1528 struct video_command vc;
1530 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1531 memset(&vc, 0, sizeof(vc));
1532 vc.cmd = VIDEO_CMD_CONTINUE;
1533 return ivtv_video_command(itv, id, &vc, 0);
1537 case VIDEO_TRY_COMMAND: {
1538 struct video_command *vc = arg;
1539 int try = (cmd == VIDEO_TRY_COMMAND);
1542 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1544 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1545 return ivtv_video_command(itv, id, vc, try);
1548 case VIDEO_GET_EVENT: {
1549 struct video_event *ev = arg;
1552 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1553 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1555 memset(ev, 0, sizeof(*ev));
1556 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1559 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1560 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1561 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1562 ev->type = VIDEO_EVENT_VSYNC;
1563 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1564 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1565 if (itv->output_mode == OUT_UDMA_YUV &&
1566 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1567 IVTV_YUV_MODE_PROGRESSIVE) {
1568 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1575 /* Wait for event. Note that serialize_lock is locked,
1576 so to allow other processes to access the driver while
1577 we are waiting unlock first and later lock again. */
1578 mutex_unlock(&itv->serialize_lock);
1579 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1580 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1582 finish_wait(&itv->event_waitq, &wait);
1583 mutex_lock(&itv->serialize_lock);
1584 if (signal_pending(current)) {
1585 /* return if a signal was received */
1586 IVTV_DEBUG_INFO("User stopped wait for event\n");
1599 static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1600 unsigned int cmd, void *arg)
1602 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1603 struct ivtv *itv = id->itv;
1606 /* check priority */
1610 case VIDIOC_S_INPUT:
1611 case VIDIOC_S_OUTPUT:
1612 case VIDIOC_S_TUNER:
1613 case VIDIOC_S_FREQUENCY:
1616 case VIDIOC_S_AUDIO:
1617 case VIDIOC_S_AUDOUT:
1618 case VIDIOC_S_EXT_CTRLS:
1620 case VIDIOC_OVERLAY:
1621 ret = v4l2_prio_check(&itv->prio, &id->prio);
1627 case VIDIOC_DBG_G_REGISTER:
1628 case VIDIOC_DBG_S_REGISTER:
1629 case VIDIOC_G_CHIP_IDENT:
1630 case VIDIOC_INT_S_AUDIO_ROUTING:
1631 case VIDIOC_INT_RESET:
1632 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1633 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1634 v4l_printk_ioctl(cmd);
1636 return ivtv_debug_ioctls(filp, cmd, arg);
1638 case VIDIOC_G_PRIORITY:
1639 case VIDIOC_S_PRIORITY:
1640 case VIDIOC_QUERYCAP:
1641 case VIDIOC_ENUMINPUT:
1642 case VIDIOC_G_INPUT:
1643 case VIDIOC_S_INPUT:
1644 case VIDIOC_ENUMOUTPUT:
1645 case VIDIOC_G_OUTPUT:
1646 case VIDIOC_S_OUTPUT:
1649 case VIDIOC_TRY_FMT:
1650 case VIDIOC_ENUM_FMT:
1651 case VIDIOC_CROPCAP:
1654 case VIDIOC_G_FREQUENCY:
1655 case VIDIOC_S_FREQUENCY:
1656 case VIDIOC_ENUMSTD:
1659 case VIDIOC_S_TUNER:
1660 case VIDIOC_G_TUNER:
1661 case VIDIOC_ENUMAUDIO:
1662 case VIDIOC_S_AUDIO:
1663 case VIDIOC_G_AUDIO:
1664 case VIDIOC_ENUMAUDOUT:
1665 case VIDIOC_S_AUDOUT:
1666 case VIDIOC_G_AUDOUT:
1667 case VIDIOC_G_SLICED_VBI_CAP:
1668 case VIDIOC_LOG_STATUS:
1669 case VIDIOC_G_ENC_INDEX:
1670 case VIDIOC_ENCODER_CMD:
1671 case VIDIOC_TRY_ENCODER_CMD:
1674 case VIDIOC_OVERLAY:
1675 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1676 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1677 v4l_printk_ioctl(cmd);
1679 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1681 case VIDIOC_QUERYMENU:
1682 case VIDIOC_QUERYCTRL:
1685 case VIDIOC_S_EXT_CTRLS:
1686 case VIDIOC_G_EXT_CTRLS:
1687 case VIDIOC_TRY_EXT_CTRLS:
1688 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1689 printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1690 v4l_printk_ioctl(cmd);
1692 return ivtv_control_ioctls(itv, cmd, arg);
1694 case IVTV_IOC_DMA_FRAME:
1696 case VIDEO_GET_FRAME_COUNT:
1697 case VIDEO_GET_EVENT:
1701 case VIDEO_CONTINUE:
1703 case VIDEO_TRY_COMMAND:
1704 return ivtv_decoder_ioctls(filp, cmd, arg);
1706 case 0x00005401: /* Handle isatty() calls */
1709 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1710 ivtv_v4l2_do_ioctl);
1715 static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1716 unsigned int cmd, unsigned long arg)
1718 /* Filter dvb ioctls that cannot be handled by video_usercopy */
1720 case VIDEO_SELECT_SOURCE:
1721 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1722 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1724 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1726 case AUDIO_SET_MUTE:
1727 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1728 itv->speed_mute_audio = arg;
1731 case AUDIO_CHANNEL_SELECT:
1732 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1733 if (arg > AUDIO_STEREO_SWAPPED)
1735 itv->audio_stereo_mode = arg;
1736 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1739 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1740 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1741 if (arg > AUDIO_STEREO_SWAPPED)
1743 itv->audio_bilingual_mode = arg;
1744 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1750 return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1753 int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1756 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1757 struct ivtv *itv = id->itv;
1760 mutex_lock(&itv->serialize_lock);
1761 res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1762 mutex_unlock(&itv->serialize_lock);