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 <media/v4l2-event.h>
39 #include <linux/dvb/audio.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 int single_step = (speed == 1 || speed == -1);
141 if (speed == 0) speed = 1000;
144 if (speed == itv->speed && !single_step)
147 if (single_step && (speed < 0) == (itv->speed < 0)) {
148 /* Single step video and no need to change direction */
149 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
154 /* Need to change direction */
155 speed = speed < 0 ? -1000 : 1000;
157 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
158 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
159 data[1] = (speed < 0);
160 data[2] = speed < 0 ? 3 : 7;
161 data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
162 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
166 if (speed == 1500 || speed == -1500) data[0] |= 1;
167 else if (speed == 2000 || speed == -2000) data[0] |= 2;
168 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
169 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
171 /* If not decoding, just change speed setting */
172 if (atomic_read(&itv->decoding) > 0) {
175 /* Stop all DMA and decoding activity */
176 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
178 /* Wait for any DMA to finish */
179 mutex_unlock(&itv->serialize_lock);
180 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
181 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
182 got_sig = signal_pending(current);
188 finish_wait(&itv->dma_waitq, &wait);
189 mutex_lock(&itv->serialize_lock);
193 /* Change Speed safely */
194 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
195 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
196 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
199 speed = (speed < 0) ? -1 : 1;
200 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
206 static int ivtv_validate_speed(int cur_speed, int new_speed)
208 int fact = new_speed < 0 ? -1 : 1;
214 new_speed = -new_speed;
216 cur_speed = -cur_speed;
218 if (cur_speed <= new_speed) {
219 if (new_speed > 1500)
221 if (new_speed > 1000)
225 if (new_speed >= 2000)
227 if (new_speed >= 1500)
229 if (new_speed >= 1000)
234 if (new_speed == 1 || new_speed == 1000)
235 return fact * new_speed;
238 new_speed = 1000 / new_speed;
239 if (1000 / cur_speed == new_speed)
240 new_speed += (cur_speed < s) ? -1 : 1;
241 if (new_speed > 60) return 1000 / (fact * 60);
242 return 1000 / (fact * new_speed);
245 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
246 struct v4l2_decoder_cmd *dc, int try)
248 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
250 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
254 case V4L2_DEC_CMD_START: {
255 dc->flags &= V4L2_DEC_CMD_START_MUTE_AUDIO;
256 dc->start.speed = ivtv_validate_speed(itv->speed, dc->start.speed);
257 if (dc->start.speed < 0)
258 dc->start.format = V4L2_DEC_START_FMT_GOP;
260 dc->start.format = V4L2_DEC_START_FMT_NONE;
261 if (dc->start.speed != 500 && dc->start.speed != 1500)
262 dc->flags = dc->start.speed == 1000 ? 0 :
263 V4L2_DEC_CMD_START_MUTE_AUDIO;
266 itv->speed_mute_audio = dc->flags & V4L2_DEC_CMD_START_MUTE_AUDIO;
267 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
269 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
270 /* forces ivtv_set_speed to be called */
273 return ivtv_start_decoding(id, dc->start.speed);
276 case V4L2_DEC_CMD_STOP:
277 dc->flags &= V4L2_DEC_CMD_STOP_IMMEDIATELY | V4L2_DEC_CMD_STOP_TO_BLACK;
278 if (dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY)
281 if (atomic_read(&itv->decoding) == 0)
283 if (itv->output_mode != OUT_MPG)
286 itv->output_mode = OUT_NONE;
287 return ivtv_stop_v4l2_decode_stream(s, dc->flags, dc->stop.pts);
289 case V4L2_DEC_CMD_PAUSE:
290 dc->flags &= V4L2_DEC_CMD_PAUSE_TO_BLACK;
292 if (!atomic_read(&itv->decoding))
294 if (itv->output_mode != OUT_MPG)
296 if (atomic_read(&itv->decoding) > 0) {
297 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
298 (dc->flags & V4L2_DEC_CMD_PAUSE_TO_BLACK) ? 1 : 0);
299 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
303 case V4L2_DEC_CMD_RESUME:
306 if (!atomic_read(&itv->decoding))
308 if (itv->output_mode != OUT_MPG)
310 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
311 int speed = itv->speed;
313 return ivtv_start_decoding(id, speed);
323 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
325 struct ivtv *itv = fh2id(fh)->itv;
326 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
328 vbifmt->reserved[0] = 0;
329 vbifmt->reserved[1] = 0;
330 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
332 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
333 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
335 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
336 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
338 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
339 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
341 vbifmt->service_set = ivtv_get_service_set(vbifmt);
345 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
347 struct ivtv_open_id *id = fh2id(fh);
348 struct ivtv *itv = id->itv;
349 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
351 pixfmt->width = itv->cxhdl.width;
352 pixfmt->height = itv->cxhdl.height;
353 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
354 pixfmt->field = V4L2_FIELD_INTERLACED;
356 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
357 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
358 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
359 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
360 pixfmt->bytesperline = 720;
362 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
363 pixfmt->sizeimage = 128 * 1024;
364 pixfmt->bytesperline = 0;
369 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
371 struct ivtv *itv = fh2id(fh)->itv;
372 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
374 vbifmt->sampling_rate = 27000000;
375 vbifmt->offset = 248;
376 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
377 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
378 vbifmt->start[0] = itv->vbi.start[0];
379 vbifmt->start[1] = itv->vbi.start[1];
380 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
382 vbifmt->reserved[0] = 0;
383 vbifmt->reserved[1] = 0;
387 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
389 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
390 struct ivtv_open_id *id = fh2id(fh);
391 struct ivtv *itv = id->itv;
393 vbifmt->reserved[0] = 0;
394 vbifmt->reserved[1] = 0;
395 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
397 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
398 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
400 ivtv_expand_service_set(vbifmt, itv->is_50hz);
401 vbifmt->service_set = ivtv_get_service_set(vbifmt);
405 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
406 vbifmt->service_set = ivtv_get_service_set(vbifmt);
410 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
412 struct ivtv_open_id *id = fh2id(fh);
413 struct ivtv *itv = id->itv;
414 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
416 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
418 pixfmt->width = itv->main_rect.width;
419 pixfmt->height = itv->main_rect.height;
420 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
421 pixfmt->field = V4L2_FIELD_INTERLACED;
423 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
424 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
425 case IVTV_YUV_MODE_INTERLACED:
426 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
427 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
429 case IVTV_YUV_MODE_PROGRESSIVE:
430 pixfmt->field = V4L2_FIELD_NONE;
433 pixfmt->field = V4L2_FIELD_ANY;
436 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
437 pixfmt->bytesperline = 720;
438 pixfmt->width = itv->yuv_info.v4l2_src_w;
439 pixfmt->height = itv->yuv_info.v4l2_src_h;
440 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
442 1080 * ((pixfmt->height + 31) & ~31);
444 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
445 pixfmt->sizeimage = 128 * 1024;
446 pixfmt->bytesperline = 0;
451 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
453 struct ivtv *itv = fh2id(fh)->itv;
454 struct v4l2_window *winfmt = &fmt->fmt.win;
456 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
458 winfmt->chromakey = itv->osd_chroma_key;
459 winfmt->global_alpha = itv->osd_global_alpha;
460 winfmt->field = V4L2_FIELD_INTERLACED;
461 winfmt->clips = NULL;
462 winfmt->clipcount = 0;
463 winfmt->bitmap = NULL;
464 winfmt->w.top = winfmt->w.left = 0;
465 winfmt->w.width = itv->osd_rect.width;
466 winfmt->w.height = itv->osd_rect.height;
470 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
472 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
475 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
477 struct ivtv_open_id *id = fh2id(fh);
478 struct ivtv *itv = id->itv;
479 int w = fmt->fmt.pix.width;
480 int h = fmt->fmt.pix.height;
485 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
486 /* YUV height must be a multiple of 32 */
490 h = min(h, itv->is_50hz ? 576 : 480);
492 ivtv_g_fmt_vid_cap(file, fh, fmt);
493 fmt->fmt.pix.width = w;
494 fmt->fmt.pix.height = h;
498 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
500 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
503 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
505 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
506 struct ivtv_open_id *id = fh2id(fh);
507 struct ivtv *itv = id->itv;
509 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
510 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
512 /* set sliced VBI capture format */
513 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
514 vbifmt->reserved[0] = 0;
515 vbifmt->reserved[1] = 0;
517 if (vbifmt->service_set)
518 ivtv_expand_service_set(vbifmt, itv->is_50hz);
519 check_service_set(vbifmt, itv->is_50hz);
520 vbifmt->service_set = ivtv_get_service_set(vbifmt);
524 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
526 struct ivtv_open_id *id = fh2id(fh);
527 s32 w = fmt->fmt.pix.width;
528 s32 h = fmt->fmt.pix.height;
529 int field = fmt->fmt.pix.field;
530 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
534 /* Why can the height be 576 even when the output is NTSC?
536 Internally the buffers of the PVR350 are always set to 720x576. The
537 decoded video frame will always be placed in the top left corner of
538 this buffer. For any video which is not 720x576, the buffer will
539 then be cropped to remove the unused right and lower areas, with
540 the remaining image being scaled by the hardware to fit the display
541 area. The video can be scaled both up and down, so a 720x480 video
542 can be displayed full-screen on PAL and a 720x576 video can be
543 displayed without cropping on NTSC.
545 Note that the scaling only occurs on the video stream, the osd
546 resolution is locked to the broadcast standard and not scaled.
548 Thanks to Ian Armstrong for this explanation. */
551 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
552 fmt->fmt.pix.field = field;
553 fmt->fmt.pix.width = w;
554 fmt->fmt.pix.height = h;
558 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
560 struct ivtv *itv = fh2id(fh)->itv;
561 u32 chromakey = fmt->fmt.win.chromakey;
562 u8 global_alpha = fmt->fmt.win.global_alpha;
564 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
566 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
567 fmt->fmt.win.chromakey = chromakey;
568 fmt->fmt.win.global_alpha = global_alpha;
572 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
574 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
577 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
579 struct ivtv_open_id *id = fh2id(fh);
580 struct ivtv *itv = id->itv;
581 struct v4l2_mbus_framefmt mbus_fmt;
582 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
583 int w = fmt->fmt.pix.width;
584 int h = fmt->fmt.pix.height;
589 if (itv->cxhdl.width == w && itv->cxhdl.height == h)
592 if (atomic_read(&itv->capturing) > 0)
595 itv->cxhdl.width = w;
596 itv->cxhdl.height = h;
597 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
598 fmt->fmt.pix.width /= 2;
599 mbus_fmt.width = fmt->fmt.pix.width;
601 mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
602 v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
603 return ivtv_g_fmt_vid_cap(file, fh, fmt);
606 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
608 struct ivtv *itv = fh2id(fh)->itv;
610 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
612 itv->vbi.sliced_in->service_set = 0;
613 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
614 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
615 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
618 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
620 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
621 struct ivtv_open_id *id = fh2id(fh);
622 struct ivtv *itv = id->itv;
623 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
625 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
628 check_service_set(vbifmt, itv->is_50hz);
629 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
631 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
632 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
633 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
637 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
639 struct ivtv_open_id *id = fh2id(fh);
640 struct ivtv *itv = id->itv;
641 struct yuv_playback_info *yi = &itv->yuv_info;
642 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
647 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
650 /* Return now if we already have some frame data */
654 yi->v4l2_src_w = fmt->fmt.pix.width;
655 yi->v4l2_src_h = fmt->fmt.pix.height;
657 switch (fmt->fmt.pix.field) {
658 case V4L2_FIELD_NONE:
659 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
662 yi->lace_mode = IVTV_YUV_MODE_AUTO;
664 case V4L2_FIELD_INTERLACED_BT:
666 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
668 case V4L2_FIELD_INTERLACED_TB:
670 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
673 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
675 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
676 itv->dma_data_req_size =
677 1080 * ((yi->v4l2_src_h + 31) & ~31);
682 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
684 struct ivtv *itv = fh2id(fh)->itv;
685 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
688 itv->osd_chroma_key = fmt->fmt.win.chromakey;
689 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
690 ivtv_set_osd_alpha(itv);
695 static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip)
697 struct ivtv *itv = fh2id(fh)->itv;
699 chip->ident = V4L2_IDENT_NONE;
701 if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
702 if (v4l2_chip_match_host(&chip->match))
703 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
706 if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
707 chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
709 /* TODO: is this correct? */
710 return ivtv_call_all_err(itv, core, g_chip_ident, chip);
713 #ifdef CONFIG_VIDEO_ADV_DEBUG
714 static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val)
716 volatile u8 __iomem *reg_start;
718 if (!capable(CAP_SYS_ADMIN))
720 if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
721 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
722 else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET &&
723 reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
724 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
725 else if (reg < IVTV_ENCODER_SIZE)
726 reg_start = itv->enc_mem;
731 *val = readl(reg + reg_start);
733 writel(*val, reg + reg_start);
737 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
739 struct ivtv *itv = fh2id(fh)->itv;
741 if (v4l2_chip_match_host(®->match)) {
743 return ivtv_itvc(itv, true, reg->reg, ®->val);
745 /* TODO: subdev errors should not be ignored, this should become a
746 subdev helper function. */
747 ivtv_call_all(itv, core, g_register, reg);
751 static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg)
753 struct ivtv *itv = fh2id(fh)->itv;
755 if (v4l2_chip_match_host(®->match)) {
758 return ivtv_itvc(itv, false, reg->reg, &val);
760 /* TODO: subdev errors should not be ignored, this should become a
761 subdev helper function. */
762 ivtv_call_all(itv, core, s_register, reg);
767 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
769 struct ivtv_open_id *id = fh2id(file->private_data);
770 struct ivtv *itv = id->itv;
771 struct ivtv_stream *s = &itv->streams[id->type];
773 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
774 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
775 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
776 vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
777 vcap->device_caps = s->caps;
781 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
783 struct ivtv *itv = fh2id(fh)->itv;
785 return ivtv_get_audio_input(itv, vin->index, vin);
788 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
790 struct ivtv *itv = fh2id(fh)->itv;
792 vin->index = itv->audio_input;
793 return ivtv_get_audio_input(itv, vin->index, vin);
796 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
798 struct ivtv *itv = fh2id(fh)->itv;
800 if (vout->index >= itv->nof_audio_inputs)
803 itv->audio_input = vout->index;
804 ivtv_audio_set_io(itv);
809 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
811 struct ivtv *itv = fh2id(fh)->itv;
813 /* set it to defaults from our table */
814 return ivtv_get_audio_output(itv, vin->index, vin);
817 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
819 struct ivtv *itv = fh2id(fh)->itv;
822 return ivtv_get_audio_output(itv, vin->index, vin);
825 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
827 struct ivtv *itv = fh2id(fh)->itv;
829 if (itv->card->video_outputs == NULL || vout->index != 0)
834 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
836 struct ivtv *itv = fh2id(fh)->itv;
838 /* set it to defaults from our table */
839 return ivtv_get_input(itv, vin->index, vin);
842 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
844 struct ivtv *itv = fh2id(fh)->itv;
846 return ivtv_get_output(itv, vout->index, vout);
849 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
851 struct ivtv_open_id *id = fh2id(fh);
852 struct ivtv *itv = id->itv;
853 struct yuv_playback_info *yi = &itv->yuv_info;
856 streamtype = id->type;
858 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
860 cropcap->bounds.top = cropcap->bounds.left = 0;
861 cropcap->bounds.width = 720;
862 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
863 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
864 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
865 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
866 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
868 cropcap->bounds.width = yi->osd_full_w;
869 cropcap->bounds.height = yi->osd_full_h;
871 cropcap->bounds.width = 720;
872 cropcap->bounds.height =
873 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->bounds.height = itv->is_out_50hz ? 576 : 480;
879 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
880 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
882 cropcap->defrect = cropcap->bounds;
886 static int ivtv_s_crop(struct file *file, void *fh, const struct v4l2_crop *crop)
888 struct ivtv_open_id *id = fh2id(fh);
889 struct ivtv *itv = id->itv;
890 struct yuv_playback_info *yi = &itv->yuv_info;
893 streamtype = id->type;
895 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
896 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
897 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
898 yi->main_rect = crop->c;
901 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
902 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
903 itv->main_rect = crop->c;
912 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
914 struct ivtv_open_id *id = fh2id(fh);
915 struct ivtv *itv = id->itv;
916 struct yuv_playback_info *yi = &itv->yuv_info;
919 streamtype = id->type;
921 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
922 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
923 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
924 crop->c = yi->main_rect;
926 crop->c = itv->main_rect;
932 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
934 static const struct v4l2_fmtdesc hm12 = {
935 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
936 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
939 static const struct v4l2_fmtdesc mpeg = {
940 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
941 "MPEG", V4L2_PIX_FMT_MPEG,
944 struct ivtv *itv = fh2id(fh)->itv;
945 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
949 if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
951 else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
958 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
960 static const struct v4l2_fmtdesc hm12 = {
961 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0,
962 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
965 static const struct v4l2_fmtdesc mpeg = {
966 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED,
967 "MPEG", V4L2_PIX_FMT_MPEG,
970 struct ivtv *itv = fh2id(fh)->itv;
971 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
975 if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
977 else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
984 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
986 struct ivtv *itv = fh2id(fh)->itv;
988 *i = itv->active_input;
993 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
995 struct ivtv *itv = fh2id(fh)->itv;
999 if (inp >= itv->nof_inputs)
1002 if (inp == itv->active_input) {
1003 IVTV_DEBUG_INFO("Input unchanged\n");
1007 if (atomic_read(&itv->capturing) > 0) {
1011 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1012 itv->active_input, inp);
1014 itv->active_input = inp;
1015 /* Set the audio input to whatever is appropriate for the
1017 itv->audio_input = itv->card->video_inputs[inp].audio_index;
1019 if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
1020 std = itv->tuner_std;
1023 for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
1024 itv->streams[i].vdev->tvnorms = std;
1026 /* prevent others from messing with the streams until
1027 we're finished changing inputs. */
1029 ivtv_video_set_io(itv);
1030 ivtv_audio_set_io(itv);
1036 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1038 struct ivtv *itv = fh2id(fh)->itv;
1040 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1043 *i = itv->active_output;
1048 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1050 struct ivtv *itv = fh2id(fh)->itv;
1052 if (outp >= itv->card->nof_outputs)
1055 if (outp == itv->active_output) {
1056 IVTV_DEBUG_INFO("Output unchanged\n");
1059 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1060 itv->active_output, outp);
1062 itv->active_output = outp;
1063 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1064 SAA7127_INPUT_TYPE_NORMAL,
1065 itv->card->video_outputs[outp].video_output, 0);
1070 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1072 struct ivtv *itv = fh2id(fh)->itv;
1073 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1075 if (s->vdev->vfl_dir)
1080 ivtv_call_all(itv, tuner, g_frequency, vf);
1084 int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1086 struct ivtv *itv = fh2id(fh)->itv;
1087 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1089 if (s->vdev->vfl_dir)
1095 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1096 ivtv_call_all(itv, tuner, s_frequency, vf);
1101 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1103 struct ivtv *itv = fh2id(fh)->itv;
1109 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1112 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1113 itv->is_50hz = !itv->is_60hz;
1114 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1115 itv->cxhdl.width = 720;
1116 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1117 itv->vbi.count = itv->is_50hz ? 18 : 12;
1118 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1119 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1121 if (itv->hw_flags & IVTV_HW_CX25840)
1122 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1125 ivtv_call_all(itv, core, s_std, itv->std);
1128 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1130 struct yuv_playback_info *yi = &itv->yuv_info;
1134 /* set display standard */
1136 itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1137 itv->is_out_50hz = !itv->is_out_60hz;
1138 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1141 * The next firmware call is time sensitive. Time it to
1142 * avoid risk of a hard lock, by trying to ensure the call
1143 * happens within the first 100 lines of the top field.
1144 * Make 4 attempts to sync to the decoder before giving up.
1146 mutex_unlock(&itv->serialize_lock);
1147 for (f = 0; f < 4; f++) {
1148 prepare_to_wait(&itv->vsync_waitq, &wait,
1149 TASK_UNINTERRUPTIBLE);
1150 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1152 schedule_timeout(msecs_to_jiffies(25));
1154 finish_wait(&itv->vsync_waitq, &wait);
1155 mutex_lock(&itv->serialize_lock);
1158 IVTV_WARN("Mode change failed to sync to decoder\n");
1160 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1161 itv->main_rect.left = 0;
1162 itv->main_rect.top = 0;
1163 itv->main_rect.width = 720;
1164 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1165 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1166 720, itv->main_rect.height, 0, 0);
1167 yi->main_rect = itv->main_rect;
1168 if (!itv->osd_info) {
1169 yi->osd_full_w = 720;
1170 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1174 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1176 struct ivtv *itv = fh2id(fh)->itv;
1178 if ((std & V4L2_STD_ALL) == 0)
1181 if (std == itv->std)
1184 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1185 atomic_read(&itv->capturing) > 0 ||
1186 atomic_read(&itv->decoding) > 0) {
1187 /* Switching standard would mess with already running
1188 streams, prevent that by returning EBUSY. */
1192 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1193 (unsigned long long)itv->std);
1195 ivtv_s_std_enc(itv, std);
1196 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1197 ivtv_s_std_dec(itv, std);
1202 static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1204 struct ivtv_open_id *id = fh2id(fh);
1205 struct ivtv *itv = id->itv;
1210 ivtv_call_all(itv, tuner, s_tuner, vt);
1215 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1217 struct ivtv *itv = fh2id(fh)->itv;
1222 ivtv_call_all(itv, tuner, g_tuner, vt);
1224 if (vt->type == V4L2_TUNER_RADIO)
1225 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1227 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1231 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1233 struct ivtv *itv = fh2id(fh)->itv;
1234 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1237 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1238 for (f = 0; f < 2; f++) {
1239 for (l = 0; l < 24; l++) {
1240 if (valid_service_line(f, l, itv->is_50hz))
1241 cap->service_lines[f][l] = set;
1244 } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1245 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1248 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1249 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1251 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1252 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1259 for (f = 0; f < 2; f++)
1260 for (l = 0; l < 24; l++)
1261 set |= cap->service_lines[f][l];
1262 cap->service_set = set;
1266 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1268 struct ivtv *itv = fh2id(fh)->itv;
1269 struct v4l2_enc_idx_entry *e = idx->entry;
1273 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1275 if (entries > V4L2_ENC_IDX_ENTRIES)
1276 entries = V4L2_ENC_IDX_ENTRIES;
1278 idx->entries_cap = IVTV_MAX_PGM_INDEX;
1279 if (!atomic_read(&itv->capturing))
1281 for (i = 0; i < entries; i++) {
1282 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1283 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1288 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1292 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1294 struct ivtv_open_id *id = fh2id(fh);
1295 struct ivtv *itv = id->itv;
1299 case V4L2_ENC_CMD_START:
1300 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1302 return ivtv_start_capture(id);
1304 case V4L2_ENC_CMD_STOP:
1305 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1306 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1307 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1310 case V4L2_ENC_CMD_PAUSE:
1311 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1314 if (!atomic_read(&itv->capturing))
1316 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1320 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1323 case V4L2_ENC_CMD_RESUME:
1324 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1327 if (!atomic_read(&itv->capturing))
1330 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1333 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1337 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1344 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1346 struct ivtv *itv = fh2id(fh)->itv;
1349 case V4L2_ENC_CMD_START:
1350 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1354 case V4L2_ENC_CMD_STOP:
1355 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1356 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1359 case V4L2_ENC_CMD_PAUSE:
1360 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1364 case V4L2_ENC_CMD_RESUME:
1365 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1369 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1374 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1376 struct ivtv *itv = fh2id(fh)->itv;
1377 u32 data[CX2341X_MBOX_MAX_DATA];
1378 struct yuv_playback_info *yi = &itv->yuv_info;
1381 static u32 pixel_format[16] = {
1382 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1383 V4L2_PIX_FMT_RGB565,
1384 V4L2_PIX_FMT_RGB555,
1385 V4L2_PIX_FMT_RGB444,
1390 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1391 V4L2_PIX_FMT_YUV565,
1392 V4L2_PIX_FMT_YUV555,
1393 V4L2_PIX_FMT_YUV444,
1400 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1402 if (!itv->osd_video_pbase)
1405 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1406 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1408 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1409 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1410 pixfmt = (data[0] >> 3) & 0xf;
1412 fb->fmt.pixelformat = pixel_format[pixfmt];
1413 fb->fmt.width = itv->osd_rect.width;
1414 fb->fmt.height = itv->osd_rect.height;
1415 fb->fmt.field = V4L2_FIELD_INTERLACED;
1416 fb->fmt.bytesperline = fb->fmt.width;
1417 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1418 fb->fmt.field = V4L2_FIELD_INTERLACED;
1420 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1421 fb->fmt.bytesperline *= 2;
1422 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1423 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1424 fb->fmt.bytesperline *= 2;
1425 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1426 fb->base = (void *)itv->osd_video_pbase;
1429 if (itv->osd_chroma_key_state)
1430 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1432 if (itv->osd_global_alpha_state)
1433 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1436 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1440 /* no local alpha for RGB565 or unknown formats */
1441 if (pixfmt == 1 || pixfmt > 4)
1444 /* 16-bit formats have inverted local alpha */
1445 if (pixfmt == 2 || pixfmt == 3)
1446 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1448 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1450 if (itv->osd_local_alpha_state) {
1451 /* 16-bit formats have inverted local alpha */
1452 if (pixfmt == 2 || pixfmt == 3)
1453 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1455 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1461 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1463 struct ivtv_open_id *id = fh2id(fh);
1464 struct ivtv *itv = id->itv;
1465 struct yuv_playback_info *yi = &itv->yuv_info;
1467 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1469 if (!itv->osd_video_pbase)
1472 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1473 itv->osd_local_alpha_state =
1474 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1475 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1476 ivtv_set_osd_alpha(itv);
1477 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1481 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1483 struct ivtv_open_id *id = fh2id(fh);
1484 struct ivtv *itv = id->itv;
1486 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1489 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1494 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1496 switch (sub->type) {
1497 case V4L2_EVENT_VSYNC:
1498 case V4L2_EVENT_EOS:
1499 return v4l2_event_subscribe(fh, sub, 0, NULL);
1500 case V4L2_EVENT_CTRL:
1501 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
1507 static int ivtv_log_status(struct file *file, void *fh)
1509 struct ivtv *itv = fh2id(fh)->itv;
1510 u32 data[CX2341X_MBOX_MAX_DATA];
1512 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1513 struct v4l2_input vidin;
1514 struct v4l2_audio audin;
1517 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1518 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1521 ivtv_read_eeprom(itv, &tv);
1523 ivtv_call_all(itv, core, log_status);
1524 ivtv_get_input(itv, itv->active_input, &vidin);
1525 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1526 IVTV_INFO("Video Input: %s\n", vidin.name);
1527 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1528 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1530 struct v4l2_output vidout;
1531 struct v4l2_audioout audout;
1532 int mode = itv->output_mode;
1533 static const char * const output_modes[5] = {
1540 static const char * const alpha_mode[4] = {
1546 static const char * const pixel_format[16] = {
1565 ivtv_get_output(itv, itv->active_output, &vidout);
1566 ivtv_get_audio_output(itv, 0, &audout);
1567 IVTV_INFO("Video Output: %s\n", vidout.name);
1568 if (mode < 0 || mode > OUT_PASSTHROUGH)
1570 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1571 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1572 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1573 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1574 data[0] & 1 ? "On" : "Off",
1575 alpha_mode[(data[0] >> 1) & 0x3],
1576 pixel_format[(data[0] >> 3) & 0xf]);
1578 IVTV_INFO("Tuner: %s\n",
1579 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1580 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1581 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1582 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1583 struct ivtv_stream *s = &itv->streams[i];
1585 if (s->vdev == NULL || s->buffers == 0)
1587 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1588 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1589 (s->buffers * s->buf_size) / 1024, s->buffers);
1592 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1593 (long long)itv->mpg_data_received,
1594 (long long)itv->vbi_data_inserted);
1598 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1600 struct ivtv_open_id *id = fh2id(file->private_data);
1601 struct ivtv *itv = id->itv;
1603 IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1604 return ivtv_video_command(itv, id, dec, false);
1607 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1609 struct ivtv_open_id *id = fh2id(file->private_data);
1610 struct ivtv *itv = id->itv;
1612 IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1613 return ivtv_video_command(itv, id, dec, true);
1616 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1618 struct ivtv_open_id *id = fh2id(filp->private_data);
1619 struct ivtv *itv = id->itv;
1620 int nonblocking = filp->f_flags & O_NONBLOCK;
1621 struct ivtv_stream *s = &itv->streams[id->type];
1622 unsigned long iarg = (unsigned long)arg;
1625 case IVTV_IOC_DMA_FRAME: {
1626 struct ivtv_dma_frame *args = arg;
1628 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1629 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1631 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1633 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1635 if (ivtv_start_decoding(id, id->type)) {
1638 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1639 ivtv_release_stream(s);
1642 /* Mark that this file handle started the UDMA_YUV mode */
1644 if (args->y_source == NULL)
1646 return ivtv_yuv_prep_frame(itv, args);
1649 case IVTV_IOC_PASSTHROUGH_MODE:
1650 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1651 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1653 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1655 case VIDEO_GET_PTS: {
1659 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1660 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1664 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1666 return ivtv_g_pts_frame(itv, pts, &frame);
1669 case VIDEO_GET_FRAME_COUNT: {
1673 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1674 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1678 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1680 return ivtv_g_pts_frame(itv, &pts, frame);
1684 struct v4l2_decoder_cmd dc;
1686 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1687 memset(&dc, 0, sizeof(dc));
1688 dc.cmd = V4L2_DEC_CMD_START;
1689 return ivtv_video_command(itv, id, &dc, 0);
1693 struct v4l2_decoder_cmd dc;
1695 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1696 memset(&dc, 0, sizeof(dc));
1697 dc.cmd = V4L2_DEC_CMD_STOP;
1698 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1699 return ivtv_video_command(itv, id, &dc, 0);
1702 case VIDEO_FREEZE: {
1703 struct v4l2_decoder_cmd dc;
1705 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1706 memset(&dc, 0, sizeof(dc));
1707 dc.cmd = V4L2_DEC_CMD_PAUSE;
1708 return ivtv_video_command(itv, id, &dc, 0);
1711 case VIDEO_CONTINUE: {
1712 struct v4l2_decoder_cmd dc;
1714 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1715 memset(&dc, 0, sizeof(dc));
1716 dc.cmd = V4L2_DEC_CMD_RESUME;
1717 return ivtv_video_command(itv, id, &dc, 0);
1721 case VIDEO_TRY_COMMAND: {
1722 /* Note: struct v4l2_decoder_cmd has the same layout as
1723 struct video_command */
1724 struct v4l2_decoder_cmd *dc = arg;
1725 int try = (cmd == VIDEO_TRY_COMMAND);
1728 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd);
1730 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd);
1731 return ivtv_video_command(itv, id, dc, try);
1734 case VIDEO_GET_EVENT: {
1735 struct video_event *ev = arg;
1738 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1739 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1741 memset(ev, 0, sizeof(*ev));
1742 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1745 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1746 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1747 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1748 ev->type = VIDEO_EVENT_VSYNC;
1749 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1750 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1751 if (itv->output_mode == OUT_UDMA_YUV &&
1752 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1753 IVTV_YUV_MODE_PROGRESSIVE) {
1754 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1761 /* Wait for event. Note that serialize_lock is locked,
1762 so to allow other processes to access the driver while
1763 we are waiting unlock first and later lock again. */
1764 mutex_unlock(&itv->serialize_lock);
1765 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1766 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1767 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1769 finish_wait(&itv->event_waitq, &wait);
1770 mutex_lock(&itv->serialize_lock);
1771 if (signal_pending(current)) {
1772 /* return if a signal was received */
1773 IVTV_DEBUG_INFO("User stopped wait for event\n");
1780 case VIDEO_SELECT_SOURCE:
1781 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1782 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1784 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1786 case AUDIO_SET_MUTE:
1787 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1788 itv->speed_mute_audio = iarg;
1791 case AUDIO_CHANNEL_SELECT:
1792 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1793 if (iarg > AUDIO_STEREO_SWAPPED)
1795 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1797 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1798 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1799 if (iarg > AUDIO_STEREO_SWAPPED)
1801 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1809 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1810 unsigned int cmd, void *arg)
1812 struct ivtv *itv = fh2id(fh)->itv;
1816 case IVTV_IOC_PASSTHROUGH_MODE:
1820 case VIDEO_CONTINUE:
1822 case VIDEO_SELECT_SOURCE:
1823 case AUDIO_SET_MUTE:
1824 case AUDIO_CHANNEL_SELECT:
1825 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1831 case VIDIOC_INT_RESET: {
1832 u32 val = *(u32 *)arg;
1834 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1835 ivtv_reset_ir_gpio(itv);
1837 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1841 case IVTV_IOC_DMA_FRAME:
1842 case IVTV_IOC_PASSTHROUGH_MODE:
1844 case VIDEO_GET_FRAME_COUNT:
1845 case VIDEO_GET_EVENT:
1849 case VIDEO_CONTINUE:
1851 case VIDEO_TRY_COMMAND:
1852 case VIDEO_SELECT_SOURCE:
1853 case AUDIO_SET_MUTE:
1854 case AUDIO_CHANNEL_SELECT:
1855 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1856 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1864 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1865 .vidioc_querycap = ivtv_querycap,
1866 .vidioc_s_audio = ivtv_s_audio,
1867 .vidioc_g_audio = ivtv_g_audio,
1868 .vidioc_enumaudio = ivtv_enumaudio,
1869 .vidioc_s_audout = ivtv_s_audout,
1870 .vidioc_g_audout = ivtv_g_audout,
1871 .vidioc_enum_input = ivtv_enum_input,
1872 .vidioc_enum_output = ivtv_enum_output,
1873 .vidioc_enumaudout = ivtv_enumaudout,
1874 .vidioc_cropcap = ivtv_cropcap,
1875 .vidioc_s_crop = ivtv_s_crop,
1876 .vidioc_g_crop = ivtv_g_crop,
1877 .vidioc_g_input = ivtv_g_input,
1878 .vidioc_s_input = ivtv_s_input,
1879 .vidioc_g_output = ivtv_g_output,
1880 .vidioc_s_output = ivtv_s_output,
1881 .vidioc_g_frequency = ivtv_g_frequency,
1882 .vidioc_s_frequency = ivtv_s_frequency,
1883 .vidioc_s_tuner = ivtv_s_tuner,
1884 .vidioc_g_tuner = ivtv_g_tuner,
1885 .vidioc_g_enc_index = ivtv_g_enc_index,
1886 .vidioc_g_fbuf = ivtv_g_fbuf,
1887 .vidioc_s_fbuf = ivtv_s_fbuf,
1888 .vidioc_g_std = ivtv_g_std,
1889 .vidioc_s_std = ivtv_s_std,
1890 .vidioc_overlay = ivtv_overlay,
1891 .vidioc_log_status = ivtv_log_status,
1892 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1893 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1894 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1895 .vidioc_decoder_cmd = ivtv_decoder_cmd,
1896 .vidioc_try_decoder_cmd = ivtv_try_decoder_cmd,
1897 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1898 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1899 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1900 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1901 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1902 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1903 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1904 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1905 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1906 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1907 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1908 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1909 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1910 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1911 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1912 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1913 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1914 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1915 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1916 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1917 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1918 #ifdef CONFIG_VIDEO_ADV_DEBUG
1919 .vidioc_g_register = ivtv_g_register,
1920 .vidioc_s_register = ivtv_s_register,
1922 .vidioc_default = ivtv_default,
1923 .vidioc_subscribe_event = ivtv_subscribe_event,
1924 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1927 void ivtv_set_funcs(struct video_device *vdev)
1929 vdev->ioctl_ops = &ivtv_ioctl_ops;