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 (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
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*720) + UV=(h*(720/2))) */
349 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
350 pixfmt->bytesperline = 720;
352 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
353 pixfmt->sizeimage = 128 * 1024;
354 pixfmt->bytesperline = 0;
359 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
361 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
362 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
364 vbifmt->sampling_rate = 27000000;
365 vbifmt->offset = 248;
366 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
367 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
368 vbifmt->start[0] = itv->vbi.start[0];
369 vbifmt->start[1] = itv->vbi.start[1];
370 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
372 vbifmt->reserved[0] = 0;
373 vbifmt->reserved[1] = 0;
377 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
379 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
380 struct ivtv_open_id *id = fh;
381 struct ivtv *itv = id->itv;
383 vbifmt->reserved[0] = 0;
384 vbifmt->reserved[1] = 0;
385 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
387 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
388 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
390 ivtv_expand_service_set(vbifmt, itv->is_50hz);
394 v4l2_subdev_call(itv->sd_video, video, g_fmt, fmt);
395 vbifmt->service_set = ivtv_get_service_set(vbifmt);
399 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
401 struct ivtv_open_id *id = fh;
402 struct ivtv *itv = id->itv;
403 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
405 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
407 pixfmt->width = itv->main_rect.width;
408 pixfmt->height = itv->main_rect.height;
409 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
410 pixfmt->field = V4L2_FIELD_INTERLACED;
412 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
413 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
414 case IVTV_YUV_MODE_INTERLACED:
415 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
416 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
418 case IVTV_YUV_MODE_PROGRESSIVE:
419 pixfmt->field = V4L2_FIELD_NONE;
422 pixfmt->field = V4L2_FIELD_ANY;
425 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
426 pixfmt->bytesperline = 720;
427 pixfmt->width = itv->yuv_info.v4l2_src_w;
428 pixfmt->height = itv->yuv_info.v4l2_src_h;
429 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
431 1080 * ((pixfmt->height + 31) & ~31);
433 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
434 pixfmt->sizeimage = 128 * 1024;
435 pixfmt->bytesperline = 0;
440 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
442 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
443 struct v4l2_window *winfmt = &fmt->fmt.win;
445 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
447 winfmt->chromakey = itv->osd_chroma_key;
448 winfmt->global_alpha = itv->osd_global_alpha;
449 winfmt->field = V4L2_FIELD_INTERLACED;
450 winfmt->clips = NULL;
451 winfmt->clipcount = 0;
452 winfmt->bitmap = NULL;
453 winfmt->w.top = winfmt->w.left = 0;
454 winfmt->w.width = itv->osd_rect.width;
455 winfmt->w.height = itv->osd_rect.height;
459 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
461 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
464 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
466 struct ivtv_open_id *id = fh;
467 struct ivtv *itv = id->itv;
468 int w = fmt->fmt.pix.width;
469 int h = fmt->fmt.pix.height;
474 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
475 /* YUV height must be a multiple of 32 */
479 h = min(h, itv->is_50hz ? 576 : 480);
481 ivtv_g_fmt_vid_cap(file, fh, fmt);
482 fmt->fmt.pix.width = w;
483 fmt->fmt.pix.height = h;
487 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
489 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
492 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
494 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
495 struct ivtv_open_id *id = fh;
496 struct ivtv *itv = id->itv;
498 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
499 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
501 /* set sliced VBI capture format */
502 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
503 vbifmt->reserved[0] = 0;
504 vbifmt->reserved[1] = 0;
506 if (vbifmt->service_set)
507 ivtv_expand_service_set(vbifmt, itv->is_50hz);
508 check_service_set(vbifmt, itv->is_50hz);
509 vbifmt->service_set = ivtv_get_service_set(vbifmt);
513 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
515 struct ivtv_open_id *id = fh;
516 s32 w = fmt->fmt.pix.width;
517 s32 h = fmt->fmt.pix.height;
518 int field = fmt->fmt.pix.field;
519 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
523 /* Why can the height be 576 even when the output is NTSC?
525 Internally the buffers of the PVR350 are always set to 720x576. The
526 decoded video frame will always be placed in the top left corner of
527 this buffer. For any video which is not 720x576, the buffer will
528 then be cropped to remove the unused right and lower areas, with
529 the remaining image being scaled by the hardware to fit the display
530 area. The video can be scaled both up and down, so a 720x480 video
531 can be displayed full-screen on PAL and a 720x576 video can be
532 displayed without cropping on NTSC.
534 Note that the scaling only occurs on the video stream, the osd
535 resolution is locked to the broadcast standard and not scaled.
537 Thanks to Ian Armstrong for this explanation. */
540 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
541 fmt->fmt.pix.field = field;
542 fmt->fmt.pix.width = w;
543 fmt->fmt.pix.height = h;
547 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
549 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
550 u32 chromakey = fmt->fmt.win.chromakey;
551 u8 global_alpha = fmt->fmt.win.global_alpha;
553 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
555 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
556 fmt->fmt.win.chromakey = chromakey;
557 fmt->fmt.win.global_alpha = global_alpha;
561 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
563 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
566 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
568 struct ivtv_open_id *id = fh;
569 struct ivtv *itv = id->itv;
570 struct cx2341x_mpeg_params *p = &itv->params;
571 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
572 int w = fmt->fmt.pix.width;
573 int h = fmt->fmt.pix.height;
578 if (p->width == w && p->height == h)
581 if (atomic_read(&itv->capturing) > 0)
586 if (p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
587 fmt->fmt.pix.width /= 2;
588 v4l2_subdev_call(itv->sd_video, video, s_fmt, fmt);
589 return ivtv_g_fmt_vid_cap(file, fh, fmt);
592 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
594 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
596 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
598 itv->vbi.sliced_in->service_set = 0;
599 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
600 v4l2_subdev_call(itv->sd_video, video, s_fmt, fmt);
601 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
604 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
606 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
607 struct ivtv_open_id *id = fh;
608 struct ivtv *itv = id->itv;
609 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
611 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
614 check_service_set(vbifmt, itv->is_50hz);
615 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
617 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
618 v4l2_subdev_call(itv->sd_video, video, s_fmt, fmt);
619 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
623 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
625 struct ivtv_open_id *id = fh;
626 struct ivtv *itv = id->itv;
627 struct yuv_playback_info *yi = &itv->yuv_info;
628 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
633 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
636 /* Return now if we already have some frame data */
640 yi->v4l2_src_w = fmt->fmt.pix.width;
641 yi->v4l2_src_h = fmt->fmt.pix.height;
643 switch (fmt->fmt.pix.field) {
644 case V4L2_FIELD_NONE:
645 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
648 yi->lace_mode = IVTV_YUV_MODE_AUTO;
650 case V4L2_FIELD_INTERLACED_BT:
652 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
654 case V4L2_FIELD_INTERLACED_TB:
656 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
659 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
661 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
662 itv->dma_data_req_size =
663 1080 * ((yi->v4l2_src_h + 31) & ~31);
668 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
670 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
671 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
674 itv->osd_chroma_key = fmt->fmt.win.chromakey;
675 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
676 ivtv_set_osd_alpha(itv);
681 static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip)
683 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
685 chip->ident = V4L2_IDENT_NONE;
687 if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
688 if (v4l2_chip_match_host(&chip->match))
689 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
692 if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
693 chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
695 /* TODO: is this correct? */
696 return ivtv_call_all_err(itv, core, g_chip_ident, chip);
699 #ifdef CONFIG_VIDEO_ADV_DEBUG
700 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
702 struct v4l2_dbg_register *regs = arg;
703 volatile u8 __iomem *reg_start;
705 if (!capable(CAP_SYS_ADMIN))
707 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
708 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
709 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
710 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
711 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
712 else if (regs->reg < IVTV_ENCODER_SIZE)
713 reg_start = itv->enc_mem;
718 if (cmd == VIDIOC_DBG_G_REGISTER)
719 regs->val = readl(regs->reg + reg_start);
721 writel(regs->val, regs->reg + reg_start);
725 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
727 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
729 if (v4l2_chip_match_host(®->match))
730 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
731 /* TODO: subdev errors should not be ignored, this should become a
732 subdev helper function. */
733 ivtv_call_all(itv, core, g_register, reg);
737 static int ivtv_s_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
739 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
741 if (v4l2_chip_match_host(®->match))
742 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
743 /* TODO: subdev errors should not be ignored, this should become a
744 subdev helper function. */
745 ivtv_call_all(itv, core, s_register, reg);
750 static int ivtv_g_priority(struct file *file, void *fh, enum v4l2_priority *p)
752 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
754 *p = v4l2_prio_max(&itv->prio);
759 static int ivtv_s_priority(struct file *file, void *fh, enum v4l2_priority prio)
761 struct ivtv_open_id *id = fh;
762 struct ivtv *itv = id->itv;
764 return v4l2_prio_change(&itv->prio, &id->prio, prio);
767 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
769 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
771 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
772 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
773 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
774 vcap->version = IVTV_DRIVER_VERSION; /* version */
775 vcap->capabilities = itv->v4l2_cap; /* capabilities */
779 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
781 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
783 return ivtv_get_audio_input(itv, vin->index, vin);
786 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
788 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
790 vin->index = itv->audio_input;
791 return ivtv_get_audio_input(itv, vin->index, vin);
794 static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
796 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
798 if (vout->index >= itv->nof_audio_inputs)
801 itv->audio_input = vout->index;
802 ivtv_audio_set_io(itv);
807 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
809 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
811 /* set it to defaults from our table */
812 return ivtv_get_audio_output(itv, vin->index, vin);
815 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
817 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
820 return ivtv_get_audio_output(itv, vin->index, vin);
823 static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
825 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
827 return ivtv_get_audio_output(itv, vout->index, vout);
830 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
832 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
834 /* set it to defaults from our table */
835 return ivtv_get_input(itv, vin->index, vin);
838 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
840 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
842 return ivtv_get_output(itv, vout->index, vout);
845 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
847 struct ivtv_open_id *id = fh;
848 struct ivtv *itv = id->itv;
849 struct yuv_playback_info *yi = &itv->yuv_info;
852 streamtype = id->type;
854 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
856 cropcap->bounds.top = cropcap->bounds.left = 0;
857 cropcap->bounds.width = 720;
858 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
859 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
860 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
861 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
862 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
864 cropcap->bounds.width = yi->osd_full_w;
865 cropcap->bounds.height = yi->osd_full_h;
867 cropcap->bounds.width = 720;
868 cropcap->bounds.height =
869 itv->is_out_50hz ? 576 : 480;
871 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
872 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
874 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
875 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
876 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
878 cropcap->defrect = cropcap->bounds;
882 static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
884 struct ivtv_open_id *id = fh;
885 struct ivtv *itv = id->itv;
886 struct yuv_playback_info *yi = &itv->yuv_info;
889 streamtype = id->type;
891 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
892 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
893 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
894 yi->main_rect = crop->c;
897 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
898 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
899 itv->main_rect = crop->c;
908 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
910 struct ivtv_open_id *id = fh;
911 struct ivtv *itv = id->itv;
912 struct yuv_playback_info *yi = &itv->yuv_info;
915 streamtype = id->type;
917 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
918 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
919 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
920 crop->c = yi->main_rect;
922 crop->c = itv->main_rect;
928 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
930 static struct v4l2_fmtdesc formats[] = {
932 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
935 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
936 "MPEG", V4L2_PIX_FMT_MPEG,
940 enum v4l2_buf_type type = fmt->type;
945 *fmt = formats[fmt->index];
950 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
952 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
954 static struct v4l2_fmtdesc formats[] = {
956 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
959 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
960 "MPEG", V4L2_PIX_FMT_MPEG,
964 enum v4l2_buf_type type = fmt->type;
966 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
972 *fmt = formats[fmt->index];
978 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
980 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
982 *i = itv->active_input;
987 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
989 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
991 if (inp < 0 || inp >= itv->nof_inputs)
994 if (inp == itv->active_input) {
995 IVTV_DEBUG_INFO("Input unchanged\n");
999 if (atomic_read(&itv->capturing) > 0) {
1003 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1004 itv->active_input, inp);
1006 itv->active_input = inp;
1007 /* Set the audio input to whatever is appropriate for the
1009 itv->audio_input = itv->card->video_inputs[inp].audio_index;
1011 /* prevent others from messing with the streams until
1012 we're finished changing inputs. */
1014 ivtv_video_set_io(itv);
1015 ivtv_audio_set_io(itv);
1021 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1023 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1025 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1028 *i = itv->active_output;
1033 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1035 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1037 if (outp >= itv->card->nof_outputs)
1040 if (outp == itv->active_output) {
1041 IVTV_DEBUG_INFO("Output unchanged\n");
1044 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1045 itv->active_output, outp);
1047 itv->active_output = outp;
1048 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1049 SAA7127_INPUT_TYPE_NORMAL,
1050 itv->card->video_outputs[outp].video_output, 0);
1055 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1057 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1062 ivtv_call_all(itv, tuner, g_frequency, vf);
1066 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1068 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1074 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1075 ivtv_call_all(itv, tuner, s_frequency, vf);
1080 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1082 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1088 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1091 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1092 struct yuv_playback_info *yi = &itv->yuv_info;
1095 if ((*std & V4L2_STD_ALL) == 0)
1098 if (*std == itv->std)
1101 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1102 atomic_read(&itv->capturing) > 0 ||
1103 atomic_read(&itv->decoding) > 0) {
1104 /* Switching standard would turn off the radio or mess
1105 with already running streams, prevent that by
1111 itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1112 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1113 itv->params.width = 720;
1114 itv->params.height = itv->is_50hz ? 576 : 480;
1115 itv->vbi.count = itv->is_50hz ? 18 : 12;
1116 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1117 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1119 if (itv->hw_flags & IVTV_HW_CX25840)
1120 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1122 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1125 ivtv_call_all(itv, core, s_std, itv->std);
1127 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1128 /* set display standard */
1129 itv->std_out = *std;
1130 itv->is_out_60hz = itv->is_60hz;
1131 itv->is_out_50hz = itv->is_50hz;
1132 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1135 * The next firmware call is time sensitive. Time it to
1136 * avoid risk of a hard lock, by trying to ensure the call
1137 * happens within the first 100 lines of the top field.
1138 * Make 4 attempts to sync to the decoder before giving up.
1140 for (f = 0; f < 4; f++) {
1141 prepare_to_wait(&itv->vsync_waitq, &wait,
1142 TASK_UNINTERRUPTIBLE);
1143 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1145 schedule_timeout(msecs_to_jiffies(25));
1147 finish_wait(&itv->vsync_waitq, &wait);
1150 IVTV_WARN("Mode change failed to sync to decoder\n");
1152 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1153 itv->main_rect.left = itv->main_rect.top = 0;
1154 itv->main_rect.width = 720;
1155 itv->main_rect.height = itv->params.height;
1156 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1157 720, itv->main_rect.height, 0, 0);
1158 yi->main_rect = itv->main_rect;
1159 if (!itv->osd_info) {
1160 yi->osd_full_w = 720;
1161 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1167 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1169 struct ivtv_open_id *id = fh;
1170 struct ivtv *itv = id->itv;
1175 ivtv_call_all(itv, tuner, s_tuner, vt);
1180 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1182 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1187 ivtv_call_all(itv, tuner, g_tuner, vt);
1189 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1190 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1191 vt->type = V4L2_TUNER_RADIO;
1193 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1194 vt->type = V4L2_TUNER_ANALOG_TV;
1200 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1202 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1203 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1206 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1207 for (f = 0; f < 2; f++) {
1208 for (l = 0; l < 24; l++) {
1209 if (valid_service_line(f, l, itv->is_50hz))
1210 cap->service_lines[f][l] = set;
1215 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1216 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1219 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1220 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1222 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1223 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1230 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1232 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1233 struct v4l2_enc_idx_entry *e = idx->entry;
1237 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1239 if (entries > V4L2_ENC_IDX_ENTRIES)
1240 entries = V4L2_ENC_IDX_ENTRIES;
1242 for (i = 0; i < entries; i++) {
1243 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1244 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1249 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1253 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1255 struct ivtv_open_id *id = fh;
1256 struct ivtv *itv = id->itv;
1260 case V4L2_ENC_CMD_START:
1261 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1263 return ivtv_start_capture(id);
1265 case V4L2_ENC_CMD_STOP:
1266 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1267 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1268 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1271 case V4L2_ENC_CMD_PAUSE:
1272 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1275 if (!atomic_read(&itv->capturing))
1277 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1281 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1284 case V4L2_ENC_CMD_RESUME:
1285 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1288 if (!atomic_read(&itv->capturing))
1291 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1294 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1298 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1305 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1307 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1310 case V4L2_ENC_CMD_START:
1311 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1315 case V4L2_ENC_CMD_STOP:
1316 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1317 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1320 case V4L2_ENC_CMD_PAUSE:
1321 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1325 case V4L2_ENC_CMD_RESUME:
1326 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1330 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1335 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1337 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1338 u32 data[CX2341X_MBOX_MAX_DATA];
1339 struct yuv_playback_info *yi = &itv->yuv_info;
1342 static u32 pixel_format[16] = {
1343 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1344 V4L2_PIX_FMT_RGB565,
1345 V4L2_PIX_FMT_RGB555,
1346 V4L2_PIX_FMT_RGB444,
1351 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1352 V4L2_PIX_FMT_YUV565,
1353 V4L2_PIX_FMT_YUV555,
1354 V4L2_PIX_FMT_YUV444,
1361 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1363 if (!itv->osd_video_pbase)
1366 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1367 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1369 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1370 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1371 pixfmt = (data[0] >> 3) & 0xf;
1373 fb->fmt.pixelformat = pixel_format[pixfmt];
1374 fb->fmt.width = itv->osd_rect.width;
1375 fb->fmt.height = itv->osd_rect.height;
1376 fb->fmt.field = V4L2_FIELD_INTERLACED;
1377 fb->fmt.bytesperline = fb->fmt.width;
1378 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1379 fb->fmt.field = V4L2_FIELD_INTERLACED;
1381 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1382 fb->fmt.bytesperline *= 2;
1383 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1384 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1385 fb->fmt.bytesperline *= 2;
1386 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1387 fb->base = (void *)itv->osd_video_pbase;
1390 if (itv->osd_chroma_key_state)
1391 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1393 if (itv->osd_global_alpha_state)
1394 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1397 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1401 /* no local alpha for RGB565 or unknown formats */
1402 if (pixfmt == 1 || pixfmt > 4)
1405 /* 16-bit formats have inverted local alpha */
1406 if (pixfmt == 2 || pixfmt == 3)
1407 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1409 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1411 if (itv->osd_local_alpha_state) {
1412 /* 16-bit formats have inverted local alpha */
1413 if (pixfmt == 2 || pixfmt == 3)
1414 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1416 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1422 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1424 struct ivtv_open_id *id = fh;
1425 struct ivtv *itv = id->itv;
1426 struct yuv_playback_info *yi = &itv->yuv_info;
1428 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1430 if (!itv->osd_video_pbase)
1433 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1434 itv->osd_local_alpha_state =
1435 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1436 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1437 ivtv_set_osd_alpha(itv);
1438 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1439 return ivtv_g_fbuf(file, fh, fb);
1442 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1444 struct ivtv_open_id *id = fh;
1445 struct ivtv *itv = id->itv;
1447 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1450 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1455 static int ivtv_log_status(struct file *file, void *fh)
1457 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1458 u32 data[CX2341X_MBOX_MAX_DATA];
1460 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1461 struct v4l2_input vidin;
1462 struct v4l2_audio audin;
1465 IVTV_INFO("================= START STATUS CARD #%d =================\n",
1467 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1468 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1471 ivtv_read_eeprom(itv, &tv);
1473 ivtv_call_all(itv, core, log_status);
1474 ivtv_get_input(itv, itv->active_input, &vidin);
1475 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1476 IVTV_INFO("Video Input: %s\n", vidin.name);
1477 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1478 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1480 struct v4l2_output vidout;
1481 struct v4l2_audioout audout;
1482 int mode = itv->output_mode;
1483 static const char * const output_modes[5] = {
1490 static const char * const audio_modes[5] = {
1497 static const char * const alpha_mode[4] = {
1503 static const char * const pixel_format[16] = {
1522 ivtv_get_output(itv, itv->active_output, &vidout);
1523 ivtv_get_audio_output(itv, 0, &audout);
1524 IVTV_INFO("Video Output: %s\n", vidout.name);
1525 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1526 audio_modes[itv->audio_stereo_mode],
1527 audio_modes[itv->audio_bilingual_mode]);
1528 if (mode < 0 || mode > OUT_PASSTHROUGH)
1530 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1531 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1532 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1533 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1534 data[0] & 1 ? "On" : "Off",
1535 alpha_mode[(data[0] >> 1) & 0x3],
1536 pixel_format[(data[0] >> 3) & 0xf]);
1538 IVTV_INFO("Tuner: %s\n",
1539 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1540 cx2341x_log_status(&itv->params, itv->v4l2_dev.name);
1541 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1542 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1543 struct ivtv_stream *s = &itv->streams[i];
1545 if (s->vdev == NULL || s->buffers == 0)
1547 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1548 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1549 (s->buffers * s->buf_size) / 1024, s->buffers);
1552 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1553 (long long)itv->mpg_data_received,
1554 (long long)itv->vbi_data_inserted);
1555 IVTV_INFO("================== END STATUS CARD #%d ==================\n",
1561 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1563 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1564 struct ivtv *itv = id->itv;
1565 int nonblocking = filp->f_flags & O_NONBLOCK;
1566 struct ivtv_stream *s = &itv->streams[id->type];
1569 case IVTV_IOC_DMA_FRAME: {
1570 struct ivtv_dma_frame *args = arg;
1572 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1573 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1575 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1577 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1579 if (ivtv_start_decoding(id, id->type)) {
1582 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1583 ivtv_release_stream(s);
1586 /* Mark that this file handle started the UDMA_YUV mode */
1588 if (args->y_source == NULL)
1590 return ivtv_yuv_prep_frame(itv, args);
1593 case VIDEO_GET_PTS: {
1594 u32 data[CX2341X_MBOX_MAX_DATA];
1597 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1598 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1602 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1605 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1606 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1607 (u64)itv->last_dec_timing[1];
1611 if (atomic_read(&itv->decoding)) {
1612 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1613 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1616 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1617 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1618 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1619 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1624 case VIDEO_GET_FRAME_COUNT: {
1625 u32 data[CX2341X_MBOX_MAX_DATA];
1628 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1629 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1633 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1636 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1637 *frame = itv->last_dec_timing[0];
1641 if (atomic_read(&itv->decoding)) {
1642 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1643 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1646 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1647 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1654 struct video_command vc;
1656 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1657 memset(&vc, 0, sizeof(vc));
1658 vc.cmd = VIDEO_CMD_PLAY;
1659 return ivtv_video_command(itv, id, &vc, 0);
1663 struct video_command vc;
1665 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1666 memset(&vc, 0, sizeof(vc));
1667 vc.cmd = VIDEO_CMD_STOP;
1668 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1669 return ivtv_video_command(itv, id, &vc, 0);
1672 case VIDEO_FREEZE: {
1673 struct video_command vc;
1675 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1676 memset(&vc, 0, sizeof(vc));
1677 vc.cmd = VIDEO_CMD_FREEZE;
1678 return ivtv_video_command(itv, id, &vc, 0);
1681 case VIDEO_CONTINUE: {
1682 struct video_command vc;
1684 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1685 memset(&vc, 0, sizeof(vc));
1686 vc.cmd = VIDEO_CMD_CONTINUE;
1687 return ivtv_video_command(itv, id, &vc, 0);
1691 case VIDEO_TRY_COMMAND: {
1692 struct video_command *vc = arg;
1693 int try = (cmd == VIDEO_TRY_COMMAND);
1696 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1698 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1699 return ivtv_video_command(itv, id, vc, try);
1702 case VIDEO_GET_EVENT: {
1703 struct video_event *ev = arg;
1706 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1707 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1709 memset(ev, 0, sizeof(*ev));
1710 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1713 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1714 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1715 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1716 ev->type = VIDEO_EVENT_VSYNC;
1717 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1718 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1719 if (itv->output_mode == OUT_UDMA_YUV &&
1720 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1721 IVTV_YUV_MODE_PROGRESSIVE) {
1722 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1729 /* Wait for event. Note that serialize_lock is locked,
1730 so to allow other processes to access the driver while
1731 we are waiting unlock first and later lock again. */
1732 mutex_unlock(&itv->serialize_lock);
1733 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1734 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1735 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1737 finish_wait(&itv->event_waitq, &wait);
1738 mutex_lock(&itv->serialize_lock);
1739 if (signal_pending(current)) {
1740 /* return if a signal was received */
1741 IVTV_DEBUG_INFO("User stopped wait for event\n");
1754 static long ivtv_default(struct file *file, void *fh, int cmd, void *arg)
1756 struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1759 case VIDIOC_INT_RESET: {
1760 u32 val = *(u32 *)arg;
1762 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1763 ivtv_reset_ir_gpio(itv);
1765 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1769 case IVTV_IOC_DMA_FRAME:
1771 case VIDEO_GET_FRAME_COUNT:
1772 case VIDEO_GET_EVENT:
1776 case VIDEO_CONTINUE:
1778 case VIDEO_TRY_COMMAND:
1779 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1787 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1788 unsigned int cmd, unsigned long arg)
1790 struct video_device *vfd = video_devdata(filp);
1791 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1794 /* Filter dvb ioctls that cannot be handled by the v4l ioctl framework */
1796 case VIDEO_SELECT_SOURCE:
1797 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1798 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1800 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1802 case AUDIO_SET_MUTE:
1803 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1804 itv->speed_mute_audio = arg;
1807 case AUDIO_CHANNEL_SELECT:
1808 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1809 if (arg > AUDIO_STEREO_SWAPPED)
1811 itv->audio_stereo_mode = arg;
1812 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1815 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1816 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1817 if (arg > AUDIO_STEREO_SWAPPED)
1819 itv->audio_bilingual_mode = arg;
1820 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1827 /* check priority */
1831 case VIDIOC_S_INPUT:
1832 case VIDIOC_S_OUTPUT:
1833 case VIDIOC_S_TUNER:
1834 case VIDIOC_S_FREQUENCY:
1837 case VIDIOC_S_AUDIO:
1838 case VIDIOC_S_AUDOUT:
1839 case VIDIOC_S_EXT_CTRLS:
1841 case VIDIOC_OVERLAY:
1842 ret = v4l2_prio_check(&itv->prio, &id->prio);
1847 if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1848 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1849 ret = video_ioctl2(filp, cmd, arg);
1854 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1856 struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1857 struct ivtv *itv = id->itv;
1860 mutex_lock(&itv->serialize_lock);
1861 res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1862 mutex_unlock(&itv->serialize_lock);
1866 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1867 .vidioc_querycap = ivtv_querycap,
1868 .vidioc_g_priority = ivtv_g_priority,
1869 .vidioc_s_priority = ivtv_s_priority,
1870 .vidioc_s_audio = ivtv_s_audio,
1871 .vidioc_g_audio = ivtv_g_audio,
1872 .vidioc_enumaudio = ivtv_enumaudio,
1873 .vidioc_s_audout = ivtv_s_audout,
1874 .vidioc_g_audout = ivtv_g_audout,
1875 .vidioc_enum_input = ivtv_enum_input,
1876 .vidioc_enum_output = ivtv_enum_output,
1877 .vidioc_enumaudout = ivtv_enumaudout,
1878 .vidioc_cropcap = ivtv_cropcap,
1879 .vidioc_s_crop = ivtv_s_crop,
1880 .vidioc_g_crop = ivtv_g_crop,
1881 .vidioc_g_input = ivtv_g_input,
1882 .vidioc_s_input = ivtv_s_input,
1883 .vidioc_g_output = ivtv_g_output,
1884 .vidioc_s_output = ivtv_s_output,
1885 .vidioc_g_frequency = ivtv_g_frequency,
1886 .vidioc_s_frequency = ivtv_s_frequency,
1887 .vidioc_s_tuner = ivtv_s_tuner,
1888 .vidioc_g_tuner = ivtv_g_tuner,
1889 .vidioc_g_enc_index = ivtv_g_enc_index,
1890 .vidioc_g_fbuf = ivtv_g_fbuf,
1891 .vidioc_s_fbuf = ivtv_s_fbuf,
1892 .vidioc_g_std = ivtv_g_std,
1893 .vidioc_s_std = ivtv_s_std,
1894 .vidioc_overlay = ivtv_overlay,
1895 .vidioc_log_status = ivtv_log_status,
1896 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1897 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1898 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1899 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1900 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1901 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1902 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1903 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1904 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1905 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1906 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1907 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1908 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1909 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1910 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1911 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1912 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1913 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1914 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1915 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1916 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1917 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1918 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1919 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1920 #ifdef CONFIG_VIDEO_ADV_DEBUG
1921 .vidioc_g_register = ivtv_g_register,
1922 .vidioc_s_register = ivtv_s_register,
1924 .vidioc_default = ivtv_default,
1925 .vidioc_queryctrl = ivtv_queryctrl,
1926 .vidioc_querymenu = ivtv_querymenu,
1927 .vidioc_g_ext_ctrls = ivtv_g_ext_ctrls,
1928 .vidioc_s_ext_ctrls = ivtv_s_ext_ctrls,
1929 .vidioc_try_ext_ctrls = ivtv_try_ext_ctrls,
1932 void ivtv_set_funcs(struct video_device *vdev)
1934 vdev->ioctl_ops = &ivtv_ioctl_ops;