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 ivtv_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 ivtv_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 void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
108 for (f = 0; f < 2; f++) {
109 for (l = 0; l < 24; l++) {
110 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
115 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
120 for (f = 0; f < 2; f++) {
121 for (l = 0; l < 24; l++) {
122 set |= fmt->service_lines[f][l];
128 void ivtv_set_osd_alpha(struct ivtv *itv)
130 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
131 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
132 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
135 int ivtv_set_speed(struct ivtv *itv, int speed)
137 u32 data[CX2341X_MBOX_MAX_DATA];
138 struct ivtv_stream *s;
139 int single_step = (speed == 1 || speed == -1);
142 if (speed == 0) speed = 1000;
145 if (speed == itv->speed && !single_step)
148 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
150 if (single_step && (speed < 0) == (itv->speed < 0)) {
151 /* Single step video and no need to change direction */
152 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
157 /* Need to change direction */
158 speed = speed < 0 ? -1000 : 1000;
160 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
161 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
162 data[1] = (speed < 0);
163 data[2] = speed < 0 ? 3 : 7;
164 data[3] = itv->params.video_b_frames;
165 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
169 if (speed == 1500 || speed == -1500) data[0] |= 1;
170 else if (speed == 2000 || speed == -2000) data[0] |= 2;
171 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
172 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
174 /* If not decoding, just change speed setting */
175 if (atomic_read(&itv->decoding) > 0) {
178 /* Stop all DMA and decoding activity */
179 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
181 /* Wait for any DMA to finish */
182 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
183 while (itv->i_flags & IVTV_F_I_DMA) {
184 got_sig = signal_pending(current);
190 finish_wait(&itv->dma_waitq, &wait);
194 /* Change Speed safely */
195 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
196 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
197 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
200 speed = (speed < 0) ? -1 : 1;
201 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
207 static int ivtv_validate_speed(int cur_speed, int new_speed)
209 int fact = new_speed < 0 ? -1 : 1;
215 new_speed = -new_speed;
217 cur_speed = -cur_speed;
219 if (cur_speed <= new_speed) {
220 if (new_speed > 1500)
222 if (new_speed > 1000)
226 if (new_speed >= 2000)
228 if (new_speed >= 1500)
230 if (new_speed >= 1000)
235 if (new_speed == 1 || new_speed == 1000)
236 return fact * new_speed;
239 new_speed = 1000 / new_speed;
240 if (1000 / cur_speed == new_speed)
241 new_speed += (cur_speed < s) ? -1 : 1;
242 if (new_speed > 60) return 1000 / (fact * 60);
243 return 1000 / (fact * new_speed);
246 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
247 struct video_command *vc, int try)
249 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
251 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
255 case VIDEO_CMD_PLAY: {
257 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
258 if (vc->play.speed < 0)
259 vc->play.format = VIDEO_PLAY_FMT_GOP;
262 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
264 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
265 /* forces ivtv_set_speed to be called */
268 return ivtv_start_decoding(id, vc->play.speed);
272 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
273 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
276 if (atomic_read(&itv->decoding) == 0)
278 if (itv->output_mode != OUT_MPG)
281 itv->output_mode = OUT_NONE;
282 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
284 case VIDEO_CMD_FREEZE:
285 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
287 if (itv->output_mode != OUT_MPG)
289 if (atomic_read(&itv->decoding) > 0) {
290 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
291 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
292 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
296 case VIDEO_CMD_CONTINUE:
299 if (itv->output_mode != OUT_MPG)
301 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
302 int speed = itv->speed;
304 return ivtv_start_decoding(id, speed);
314 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
316 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
317 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
319 vbifmt->reserved[0] = 0;
320 vbifmt->reserved[1] = 0;
321 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
323 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
325 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
326 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
328 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
329 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
331 vbifmt->service_set = ivtv_get_service_set(vbifmt);
335 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
337 struct ivtv_open_id *id = fh;
338 struct ivtv *itv = id->itv;
339 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
341 pixfmt->width = itv->params.width;
342 pixfmt->height = itv->params.height;
343 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
344 pixfmt->field = V4L2_FIELD_INTERLACED;
346 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
347 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
348 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
350 pixfmt->height * pixfmt->width +
351 pixfmt->height * (pixfmt->width / 2);
352 pixfmt->bytesperline = 720;
354 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
355 pixfmt->sizeimage = 128 * 1024;
356 pixfmt->bytesperline = 0;
361 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
363 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
364 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
366 vbifmt->sampling_rate = 27000000;
367 vbifmt->offset = 248;
368 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
369 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
370 vbifmt->start[0] = itv->vbi.start[0];
371 vbifmt->start[1] = itv->vbi.start[1];
372 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
374 vbifmt->reserved[0] = 0;
375 vbifmt->reserved[1] = 0;
379 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
381 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
382 struct ivtv_open_id *id = fh;
383 struct ivtv *itv = id->itv;
385 vbifmt->reserved[0] = 0;
386 vbifmt->reserved[1] = 0;
387 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
389 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
390 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
392 ivtv_expand_service_set(vbifmt, itv->is_50hz);
396 v4l2_subdev_call(itv->sd_video, video, s_fmt, fmt);
397 vbifmt->service_set = ivtv_get_service_set(vbifmt);
401 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
403 struct ivtv_open_id *id = fh;
404 struct ivtv *itv = id->itv;
405 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
407 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
409 pixfmt->width = itv->main_rect.width;
410 pixfmt->height = itv->main_rect.height;
411 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
412 pixfmt->field = V4L2_FIELD_INTERLACED;
414 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
415 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
416 case IVTV_YUV_MODE_INTERLACED:
417 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
418 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
420 case IVTV_YUV_MODE_PROGRESSIVE:
421 pixfmt->field = V4L2_FIELD_NONE;
424 pixfmt->field = V4L2_FIELD_ANY;
427 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
428 pixfmt->bytesperline = 720;
429 pixfmt->width = itv->yuv_info.v4l2_src_w;
430 pixfmt->height = itv->yuv_info.v4l2_src_h;
431 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
433 1080 * ((pixfmt->height + 31) & ~31);
435 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
436 pixfmt->sizeimage = 128 * 1024;
437 pixfmt->bytesperline = 0;
442 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
444 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
445 struct v4l2_window *winfmt = &fmt->fmt.win;
447 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
449 winfmt->chromakey = itv->osd_chroma_key;
450 winfmt->global_alpha = itv->osd_global_alpha;
451 winfmt->field = V4L2_FIELD_INTERLACED;
452 winfmt->clips = NULL;
453 winfmt->clipcount = 0;
454 winfmt->bitmap = NULL;
455 winfmt->w.top = winfmt->w.left = 0;
456 winfmt->w.width = itv->osd_rect.width;
457 winfmt->w.height = itv->osd_rect.height;
461 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
463 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
466 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
468 struct ivtv_open_id *id = fh;
469 struct ivtv *itv = id->itv;
470 int w = fmt->fmt.pix.width;
471 int h = fmt->fmt.pix.height;
475 h = min(h, itv->is_50hz ? 576 : 480);
477 ivtv_g_fmt_vid_cap(file, fh, fmt);
478 fmt->fmt.pix.width = w;
479 fmt->fmt.pix.height = h;
483 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
485 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
488 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
490 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
491 struct ivtv_open_id *id = fh;
492 struct ivtv *itv = id->itv;
494 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
495 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
497 /* set sliced VBI capture format */
498 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
499 vbifmt->reserved[0] = 0;
500 vbifmt->reserved[1] = 0;
502 if (vbifmt->service_set)
503 ivtv_expand_service_set(vbifmt, itv->is_50hz);
504 check_service_set(vbifmt, itv->is_50hz);
505 vbifmt->service_set = ivtv_get_service_set(vbifmt);
509 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
511 struct ivtv_open_id *id = fh;
512 s32 w = fmt->fmt.pix.width;
513 s32 h = fmt->fmt.pix.height;
514 int field = fmt->fmt.pix.field;
515 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
519 /* Why can the height be 576 even when the output is NTSC?
521 Internally the buffers of the PVR350 are always set to 720x576. The
522 decoded video frame will always be placed in the top left corner of
523 this buffer. For any video which is not 720x576, the buffer will
524 then be cropped to remove the unused right and lower areas, with
525 the remaining image being scaled by the hardware to fit the display
526 area. The video can be scaled both up and down, so a 720x480 video
527 can be displayed full-screen on PAL and a 720x576 video can be
528 displayed without cropping on NTSC.
530 Note that the scaling only occurs on the video stream, the osd
531 resolution is locked to the broadcast standard and not scaled.
533 Thanks to Ian Armstrong for this explanation. */
536 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
537 fmt->fmt.pix.field = field;
538 fmt->fmt.pix.width = w;
539 fmt->fmt.pix.height = h;
543 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
545 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
546 u32 chromakey = fmt->fmt.win.chromakey;
547 u8 global_alpha = fmt->fmt.win.global_alpha;
549 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
551 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
552 fmt->fmt.win.chromakey = chromakey;
553 fmt->fmt.win.global_alpha = global_alpha;
557 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
559 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
562 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
564 struct ivtv_open_id *id = fh;
565 struct ivtv *itv = id->itv;
566 struct cx2341x_mpeg_params *p = &itv->params;
567 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
568 int w = fmt->fmt.pix.width;
569 int h = fmt->fmt.pix.height;
574 if (p->width == w && p->height == h)
577 if (atomic_read(&itv->capturing) > 0)
582 if (p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
583 fmt->fmt.pix.width /= 2;
584 v4l2_subdev_call(itv->sd_video, video, s_fmt, fmt);
585 return ivtv_g_fmt_vid_cap(file, fh, fmt);
588 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
590 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
592 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
594 itv->vbi.sliced_in->service_set = 0;
595 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
596 v4l2_subdev_call(itv->sd_video, video, s_fmt, fmt);
597 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
600 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
602 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
603 struct ivtv_open_id *id = fh;
604 struct ivtv *itv = id->itv;
605 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
607 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
610 check_service_set(vbifmt, itv->is_50hz);
611 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
613 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
614 v4l2_subdev_call(itv->sd_video, video, s_fmt, fmt);
615 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
619 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
621 struct ivtv_open_id *id = fh;
622 struct ivtv *itv = id->itv;
623 struct yuv_playback_info *yi = &itv->yuv_info;
624 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
629 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
632 /* Return now if we already have some frame data */
636 yi->v4l2_src_w = fmt->fmt.pix.width;
637 yi->v4l2_src_h = fmt->fmt.pix.height;
639 switch (fmt->fmt.pix.field) {
640 case V4L2_FIELD_NONE:
641 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
644 yi->lace_mode = IVTV_YUV_MODE_AUTO;
646 case V4L2_FIELD_INTERLACED_BT:
648 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
650 case V4L2_FIELD_INTERLACED_TB:
652 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
655 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
657 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
658 itv->dma_data_req_size =
659 1080 * ((yi->v4l2_src_h + 31) & ~31);
664 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
666 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
667 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
670 itv->osd_chroma_key = fmt->fmt.win.chromakey;
671 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
672 ivtv_set_osd_alpha(itv);
677 static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_chip_ident *chip)
679 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
681 chip->ident = V4L2_IDENT_NONE;
683 if (chip->match_type == V4L2_CHIP_MATCH_HOST) {
684 if (v4l2_chip_match_host(chip->match_type, chip->match_chip))
685 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
688 if (chip->match_type != V4L2_CHIP_MATCH_I2C_DRIVER &&
689 chip->match_type != V4L2_CHIP_MATCH_I2C_ADDR)
691 /* TODO: is this correct? */
692 return ivtv_call_all_err(itv, core, g_chip_ident, chip);
695 #ifdef CONFIG_VIDEO_ADV_DEBUG
696 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
698 struct v4l2_register *regs = arg;
699 volatile u8 __iomem *reg_start;
701 if (!capable(CAP_SYS_ADMIN))
703 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
704 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
705 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
706 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
707 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
708 else if (regs->reg >= 0 && regs->reg < IVTV_ENCODER_SIZE)
709 reg_start = itv->enc_mem;
713 if (cmd == VIDIOC_DBG_G_REGISTER)
714 regs->val = readl(regs->reg + reg_start);
716 writel(regs->val, regs->reg + reg_start);
720 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_register *reg)
722 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
724 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
725 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
726 /* TODO: subdev errors should not be ignored, this should become a
727 subdev helper function. */
728 ivtv_call_all(itv, core, g_register, reg);
732 static int ivtv_s_register(struct file *file, void *fh, struct v4l2_register *reg)
734 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
736 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
737 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
738 /* TODO: subdev errors should not be ignored, this should become a
739 subdev helper function. */
740 ivtv_call_all(itv, core, s_register, reg);
745 static int ivtv_g_priority(struct file *file, void *fh, enum v4l2_priority *p)
747 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
749 *p = v4l2_prio_max(&itv->prio);
754 static int ivtv_s_priority(struct file *file, void *fh, enum v4l2_priority prio)
756 struct ivtv_open_id *id = fh;
757 struct ivtv *itv = id->itv;
759 return v4l2_prio_change(&itv->prio, &id->prio, prio);
762 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
764 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
766 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
767 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
768 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->dev));
769 vcap->version = IVTV_DRIVER_VERSION; /* version */
770 vcap->capabilities = itv->v4l2_cap; /* capabilities */
774 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
776 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
778 return ivtv_get_audio_input(itv, vin->index, vin);
781 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
783 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
785 vin->index = itv->audio_input;
786 return ivtv_get_audio_input(itv, vin->index, vin);
789 static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
791 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
793 if (vout->index >= itv->nof_audio_inputs)
796 itv->audio_input = vout->index;
797 ivtv_audio_set_io(itv);
802 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
804 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
806 /* set it to defaults from our table */
807 return ivtv_get_audio_output(itv, vin->index, vin);
810 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
812 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
815 return ivtv_get_audio_output(itv, vin->index, vin);
818 static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
820 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
822 return ivtv_get_audio_output(itv, vout->index, vout);
825 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
827 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
829 /* set it to defaults from our table */
830 return ivtv_get_input(itv, vin->index, vin);
833 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
835 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
837 return ivtv_get_output(itv, vout->index, vout);
840 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
842 struct ivtv_open_id *id = fh;
843 struct ivtv *itv = id->itv;
844 struct yuv_playback_info *yi = &itv->yuv_info;
847 streamtype = id->type;
849 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
851 cropcap->bounds.top = cropcap->bounds.left = 0;
852 cropcap->bounds.width = 720;
853 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
854 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
855 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
856 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
857 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
859 cropcap->bounds.width = yi->osd_full_w;
860 cropcap->bounds.height = yi->osd_full_h;
862 cropcap->bounds.width = 720;
863 cropcap->bounds.height =
864 itv->is_out_50hz ? 576 : 480;
866 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
867 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
869 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
870 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
871 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
873 cropcap->defrect = cropcap->bounds;
877 static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
879 struct ivtv_open_id *id = fh;
880 struct ivtv *itv = id->itv;
881 struct yuv_playback_info *yi = &itv->yuv_info;
884 streamtype = id->type;
886 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
887 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
888 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
889 yi->main_rect = crop->c;
892 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
893 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
894 itv->main_rect = crop->c;
903 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
905 struct ivtv_open_id *id = fh;
906 struct ivtv *itv = id->itv;
907 struct yuv_playback_info *yi = &itv->yuv_info;
910 streamtype = id->type;
912 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
913 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
914 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
915 crop->c = yi->main_rect;
917 crop->c = itv->main_rect;
923 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
925 static struct v4l2_fmtdesc formats[] = {
927 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
930 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
931 "MPEG", V4L2_PIX_FMT_MPEG,
935 enum v4l2_buf_type type = fmt->type;
940 *fmt = formats[fmt->index];
945 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
947 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
949 static struct v4l2_fmtdesc formats[] = {
951 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
954 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
955 "MPEG", V4L2_PIX_FMT_MPEG,
959 enum v4l2_buf_type type = fmt->type;
961 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
967 *fmt = formats[fmt->index];
973 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
975 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
977 *i = itv->active_input;
982 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
984 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
986 if (inp < 0 || inp >= itv->nof_inputs)
989 if (inp == itv->active_input) {
990 IVTV_DEBUG_INFO("Input unchanged\n");
994 if (atomic_read(&itv->capturing) > 0) {
998 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
999 itv->active_input, inp);
1001 itv->active_input = inp;
1002 /* Set the audio input to whatever is appropriate for the
1004 itv->audio_input = itv->card->video_inputs[inp].audio_index;
1006 /* prevent others from messing with the streams until
1007 we're finished changing inputs. */
1009 ivtv_video_set_io(itv);
1010 ivtv_audio_set_io(itv);
1016 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1018 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1020 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1023 *i = itv->active_output;
1028 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1030 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1031 struct v4l2_routing route;
1033 if (outp >= itv->card->nof_outputs)
1036 if (outp == itv->active_output) {
1037 IVTV_DEBUG_INFO("Output unchanged\n");
1040 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1041 itv->active_output, outp);
1043 itv->active_output = outp;
1044 route.input = SAA7127_INPUT_TYPE_NORMAL;
1045 route.output = itv->card->video_outputs[outp].video_output;
1046 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing, &route);
1051 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1053 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1058 ivtv_call_all(itv, tuner, g_frequency, vf);
1062 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1064 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1070 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1071 ivtv_call_all(itv, tuner, s_frequency, vf);
1076 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1078 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1084 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1086 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1087 struct yuv_playback_info *yi = &itv->yuv_info;
1089 if ((*std & V4L2_STD_ALL) == 0)
1092 if (*std == itv->std)
1095 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1096 atomic_read(&itv->capturing) > 0 ||
1097 atomic_read(&itv->decoding) > 0) {
1098 /* Switching standard would turn off the radio or mess
1099 with already running streams, prevent that by
1105 itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1106 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1107 itv->params.width = 720;
1108 itv->params.height = itv->is_50hz ? 576 : 480;
1109 itv->vbi.count = itv->is_50hz ? 18 : 12;
1110 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1111 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1113 if (itv->hw_flags & IVTV_HW_CX25840)
1114 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1116 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1119 ivtv_call_all(itv, tuner, s_std, itv->std);
1121 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1122 /* set display standard */
1123 itv->std_out = *std;
1124 itv->is_out_60hz = itv->is_60hz;
1125 itv->is_out_50hz = itv->is_50hz;
1126 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1127 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1128 itv->main_rect.left = itv->main_rect.top = 0;
1129 itv->main_rect.width = 720;
1130 itv->main_rect.height = itv->params.height;
1131 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1132 720, itv->main_rect.height, 0, 0);
1133 yi->main_rect = itv->main_rect;
1134 if (!itv->osd_info) {
1135 yi->osd_full_w = 720;
1136 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1142 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1144 struct ivtv_open_id *id = fh;
1145 struct ivtv *itv = id->itv;
1150 ivtv_call_all(itv, tuner, s_tuner, vt);
1155 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1157 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1162 ivtv_call_all(itv, tuner, g_tuner, vt);
1164 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1165 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1166 vt->type = V4L2_TUNER_RADIO;
1168 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1169 vt->type = V4L2_TUNER_ANALOG_TV;
1175 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1177 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1178 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1181 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1182 for (f = 0; f < 2; f++) {
1183 for (l = 0; l < 24; l++) {
1184 if (valid_service_line(f, l, itv->is_50hz))
1185 cap->service_lines[f][l] = set;
1190 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1191 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1194 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1195 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1197 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1198 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1205 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1207 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1208 struct v4l2_enc_idx_entry *e = idx->entry;
1212 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1214 if (entries > V4L2_ENC_IDX_ENTRIES)
1215 entries = V4L2_ENC_IDX_ENTRIES;
1217 for (i = 0; i < entries; i++) {
1218 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1219 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1224 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1228 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1230 struct ivtv_open_id *id = fh;
1231 struct ivtv *itv = id->itv;
1235 case V4L2_ENC_CMD_START:
1236 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1238 return ivtv_start_capture(id);
1240 case V4L2_ENC_CMD_STOP:
1241 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1242 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1243 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1246 case V4L2_ENC_CMD_PAUSE:
1247 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1250 if (!atomic_read(&itv->capturing))
1252 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1256 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1259 case V4L2_ENC_CMD_RESUME:
1260 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1263 if (!atomic_read(&itv->capturing))
1266 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1269 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1273 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1280 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1282 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1285 case V4L2_ENC_CMD_START:
1286 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1290 case V4L2_ENC_CMD_STOP:
1291 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1292 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1295 case V4L2_ENC_CMD_PAUSE:
1296 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1300 case V4L2_ENC_CMD_RESUME:
1301 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1305 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1310 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1312 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1313 u32 data[CX2341X_MBOX_MAX_DATA];
1314 struct yuv_playback_info *yi = &itv->yuv_info;
1317 static u32 pixel_format[16] = {
1318 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1319 V4L2_PIX_FMT_RGB565,
1320 V4L2_PIX_FMT_RGB555,
1321 V4L2_PIX_FMT_RGB444,
1326 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1327 V4L2_PIX_FMT_YUV565,
1328 V4L2_PIX_FMT_YUV555,
1329 V4L2_PIX_FMT_YUV444,
1336 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1338 if (!itv->osd_video_pbase)
1341 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1342 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1344 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1345 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1346 pixfmt = (data[0] >> 3) & 0xf;
1348 fb->fmt.pixelformat = pixel_format[pixfmt];
1349 fb->fmt.width = itv->osd_rect.width;
1350 fb->fmt.height = itv->osd_rect.height;
1351 fb->fmt.field = V4L2_FIELD_INTERLACED;
1352 fb->fmt.bytesperline = fb->fmt.width;
1353 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1354 fb->fmt.field = V4L2_FIELD_INTERLACED;
1356 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1357 fb->fmt.bytesperline *= 2;
1358 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1359 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1360 fb->fmt.bytesperline *= 2;
1361 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1362 fb->base = (void *)itv->osd_video_pbase;
1365 if (itv->osd_chroma_key_state)
1366 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1368 if (itv->osd_global_alpha_state)
1369 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1372 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1376 /* no local alpha for RGB565 or unknown formats */
1377 if (pixfmt == 1 || pixfmt > 4)
1380 /* 16-bit formats have inverted local alpha */
1381 if (pixfmt == 2 || pixfmt == 3)
1382 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1384 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1386 if (itv->osd_local_alpha_state) {
1387 /* 16-bit formats have inverted local alpha */
1388 if (pixfmt == 2 || pixfmt == 3)
1389 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1391 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1397 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1399 struct ivtv_open_id *id = fh;
1400 struct ivtv *itv = id->itv;
1401 struct yuv_playback_info *yi = &itv->yuv_info;
1403 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1405 if (!itv->osd_video_pbase)
1408 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1409 itv->osd_local_alpha_state =
1410 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1411 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1412 ivtv_set_osd_alpha(itv);
1413 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1414 return ivtv_g_fbuf(file, fh, fb);
1417 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1419 struct ivtv_open_id *id = fh;
1420 struct ivtv *itv = id->itv;
1422 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1425 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1430 static int ivtv_log_status(struct file *file, void *fh)
1432 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1433 u32 data[CX2341X_MBOX_MAX_DATA];
1435 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1436 struct v4l2_input vidin;
1437 struct v4l2_audio audin;
1440 IVTV_INFO("================= START STATUS CARD #%d =================\n",
1442 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1443 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1446 ivtv_read_eeprom(itv, &tv);
1448 ivtv_call_all(itv, core, log_status);
1449 ivtv_get_input(itv, itv->active_input, &vidin);
1450 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1451 IVTV_INFO("Video Input: %s\n", vidin.name);
1452 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1453 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1455 struct v4l2_output vidout;
1456 struct v4l2_audioout audout;
1457 int mode = itv->output_mode;
1458 static const char * const output_modes[5] = {
1465 static const char * const audio_modes[5] = {
1472 static const char * const alpha_mode[4] = {
1478 static const char * const pixel_format[16] = {
1497 ivtv_get_output(itv, itv->active_output, &vidout);
1498 ivtv_get_audio_output(itv, 0, &audout);
1499 IVTV_INFO("Video Output: %s\n", vidout.name);
1500 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1501 audio_modes[itv->audio_stereo_mode],
1502 audio_modes[itv->audio_bilingual_mode]);
1503 if (mode < 0 || mode > OUT_PASSTHROUGH)
1505 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1506 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1507 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1508 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1509 data[0] & 1 ? "On" : "Off",
1510 alpha_mode[(data[0] >> 1) & 0x3],
1511 pixel_format[(data[0] >> 3) & 0xf]);
1513 IVTV_INFO("Tuner: %s\n",
1514 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1515 cx2341x_log_status(&itv->params, itv->device.name);
1516 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1517 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1518 struct ivtv_stream *s = &itv->streams[i];
1520 if (s->v4l2dev == NULL || s->buffers == 0)
1522 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1523 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1524 (s->buffers * s->buf_size) / 1024, s->buffers);
1527 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1528 (long long)itv->mpg_data_received,
1529 (long long)itv->vbi_data_inserted);
1530 IVTV_INFO("================== END STATUS CARD #%d ==================\n",
1536 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1538 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1539 struct ivtv *itv = id->itv;
1540 int nonblocking = filp->f_flags & O_NONBLOCK;
1541 struct ivtv_stream *s = &itv->streams[id->type];
1544 case IVTV_IOC_DMA_FRAME: {
1545 struct ivtv_dma_frame *args = arg;
1547 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1548 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1550 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1552 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1554 if (ivtv_start_decoding(id, id->type)) {
1557 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1558 ivtv_release_stream(s);
1561 /* Mark that this file handle started the UDMA_YUV mode */
1563 if (args->y_source == NULL)
1565 return ivtv_yuv_prep_frame(itv, args);
1568 case VIDEO_GET_PTS: {
1569 u32 data[CX2341X_MBOX_MAX_DATA];
1572 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1573 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1577 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1580 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1581 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1582 (u64)itv->last_dec_timing[1];
1586 if (atomic_read(&itv->decoding)) {
1587 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1588 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1591 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1592 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1593 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1594 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1599 case VIDEO_GET_FRAME_COUNT: {
1600 u32 data[CX2341X_MBOX_MAX_DATA];
1603 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1604 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1608 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1611 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1612 *frame = itv->last_dec_timing[0];
1616 if (atomic_read(&itv->decoding)) {
1617 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1618 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1621 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1622 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1629 struct video_command vc;
1631 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1632 memset(&vc, 0, sizeof(vc));
1633 vc.cmd = VIDEO_CMD_PLAY;
1634 return ivtv_video_command(itv, id, &vc, 0);
1638 struct video_command vc;
1640 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1641 memset(&vc, 0, sizeof(vc));
1642 vc.cmd = VIDEO_CMD_STOP;
1643 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1644 return ivtv_video_command(itv, id, &vc, 0);
1647 case VIDEO_FREEZE: {
1648 struct video_command vc;
1650 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1651 memset(&vc, 0, sizeof(vc));
1652 vc.cmd = VIDEO_CMD_FREEZE;
1653 return ivtv_video_command(itv, id, &vc, 0);
1656 case VIDEO_CONTINUE: {
1657 struct video_command vc;
1659 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1660 memset(&vc, 0, sizeof(vc));
1661 vc.cmd = VIDEO_CMD_CONTINUE;
1662 return ivtv_video_command(itv, id, &vc, 0);
1666 case VIDEO_TRY_COMMAND: {
1667 struct video_command *vc = arg;
1668 int try = (cmd == VIDEO_TRY_COMMAND);
1671 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1673 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1674 return ivtv_video_command(itv, id, vc, try);
1677 case VIDEO_GET_EVENT: {
1678 struct video_event *ev = arg;
1681 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1682 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1684 memset(ev, 0, sizeof(*ev));
1685 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1688 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1689 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1690 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1691 ev->type = VIDEO_EVENT_VSYNC;
1692 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1693 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1694 if (itv->output_mode == OUT_UDMA_YUV &&
1695 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1696 IVTV_YUV_MODE_PROGRESSIVE) {
1697 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1704 /* Wait for event. Note that serialize_lock is locked,
1705 so to allow other processes to access the driver while
1706 we are waiting unlock first and later lock again. */
1707 mutex_unlock(&itv->serialize_lock);
1708 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1709 if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1711 finish_wait(&itv->event_waitq, &wait);
1712 mutex_lock(&itv->serialize_lock);
1713 if (signal_pending(current)) {
1714 /* return if a signal was received */
1715 IVTV_DEBUG_INFO("User stopped wait for event\n");
1728 static int ivtv_default(struct file *file, void *fh, int cmd, void *arg)
1730 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1733 case VIDIOC_INT_S_AUDIO_ROUTING: {
1734 struct v4l2_routing *route = arg;
1736 ivtv_call_hw(itv, itv->card->hw_audio, audio, s_routing, route);
1740 case VIDIOC_INT_RESET: {
1741 u32 val = *(u32 *)arg;
1743 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1744 ivtv_reset_ir_gpio(itv);
1746 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1756 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1757 unsigned int cmd, unsigned long arg)
1759 struct video_device *vfd = video_devdata(filp);
1760 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1763 /* Filter dvb ioctls that cannot be handled by the v4l ioctl framework */
1765 case VIDEO_SELECT_SOURCE:
1766 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1767 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1769 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1771 case AUDIO_SET_MUTE:
1772 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1773 itv->speed_mute_audio = arg;
1776 case AUDIO_CHANNEL_SELECT:
1777 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1778 if (arg > AUDIO_STEREO_SWAPPED)
1780 itv->audio_stereo_mode = arg;
1781 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1784 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1785 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1786 if (arg > AUDIO_STEREO_SWAPPED)
1788 itv->audio_bilingual_mode = arg;
1789 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1792 case IVTV_IOC_DMA_FRAME:
1794 case VIDEO_GET_FRAME_COUNT:
1795 case VIDEO_GET_EVENT:
1799 case VIDEO_CONTINUE:
1801 case VIDEO_TRY_COMMAND:
1802 return ivtv_decoder_ioctls(filp, cmd, (void *)arg);
1808 /* check priority */
1812 case VIDIOC_S_INPUT:
1813 case VIDIOC_S_OUTPUT:
1814 case VIDIOC_S_TUNER:
1815 case VIDIOC_S_FREQUENCY:
1818 case VIDIOC_S_AUDIO:
1819 case VIDIOC_S_AUDOUT:
1820 case VIDIOC_S_EXT_CTRLS:
1822 case VIDIOC_OVERLAY:
1823 ret = v4l2_prio_check(&itv->prio, &id->prio);
1828 if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1829 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1830 ret = __video_ioctl2(filp, cmd, arg);
1835 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1837 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1838 struct ivtv *itv = id->itv;
1841 mutex_lock(&itv->serialize_lock);
1842 res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1843 mutex_unlock(&itv->serialize_lock);
1847 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1848 .vidioc_querycap = ivtv_querycap,
1849 .vidioc_g_priority = ivtv_g_priority,
1850 .vidioc_s_priority = ivtv_s_priority,
1851 .vidioc_s_audio = ivtv_s_audio,
1852 .vidioc_g_audio = ivtv_g_audio,
1853 .vidioc_enumaudio = ivtv_enumaudio,
1854 .vidioc_s_audout = ivtv_s_audout,
1855 .vidioc_g_audout = ivtv_g_audout,
1856 .vidioc_enum_input = ivtv_enum_input,
1857 .vidioc_enum_output = ivtv_enum_output,
1858 .vidioc_enumaudout = ivtv_enumaudout,
1859 .vidioc_cropcap = ivtv_cropcap,
1860 .vidioc_s_crop = ivtv_s_crop,
1861 .vidioc_g_crop = ivtv_g_crop,
1862 .vidioc_g_input = ivtv_g_input,
1863 .vidioc_s_input = ivtv_s_input,
1864 .vidioc_g_output = ivtv_g_output,
1865 .vidioc_s_output = ivtv_s_output,
1866 .vidioc_g_frequency = ivtv_g_frequency,
1867 .vidioc_s_frequency = ivtv_s_frequency,
1868 .vidioc_s_tuner = ivtv_s_tuner,
1869 .vidioc_g_tuner = ivtv_g_tuner,
1870 .vidioc_g_enc_index = ivtv_g_enc_index,
1871 .vidioc_g_fbuf = ivtv_g_fbuf,
1872 .vidioc_s_fbuf = ivtv_s_fbuf,
1873 .vidioc_g_std = ivtv_g_std,
1874 .vidioc_s_std = ivtv_s_std,
1875 .vidioc_overlay = ivtv_overlay,
1876 .vidioc_log_status = ivtv_log_status,
1877 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1878 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1879 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1880 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1881 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1882 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1883 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1884 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1885 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1886 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1887 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1888 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1889 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1890 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1891 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1892 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1893 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1894 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1895 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1896 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1897 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1898 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1899 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1900 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1901 #ifdef CONFIG_VIDEO_ADV_DEBUG
1902 .vidioc_g_register = ivtv_g_register,
1903 .vidioc_s_register = ivtv_s_register,
1905 .vidioc_default = ivtv_default,
1906 .vidioc_queryctrl = ivtv_queryctrl,
1907 .vidioc_querymenu = ivtv_querymenu,
1908 .vidioc_g_ext_ctrls = ivtv_g_ext_ctrls,
1909 .vidioc_s_ext_ctrls = ivtv_s_ext_ctrls,
1910 .vidioc_try_ext_ctrls = ivtv_try_ext_ctrls,
1913 void ivtv_set_funcs(struct video_device *vdev)
1915 vdev->ioctl_ops = &ivtv_ioctl_ops;