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-event.h>
38 #include <linux/dvb/audio.h>
40 u16 ivtv_service2vbi(int type)
43 case V4L2_SLICED_TELETEXT_B:
44 return IVTV_SLICED_TYPE_TELETEXT_B;
45 case V4L2_SLICED_CAPTION_525:
46 return IVTV_SLICED_TYPE_CAPTION_525;
47 case V4L2_SLICED_WSS_625:
48 return IVTV_SLICED_TYPE_WSS_625;
50 return IVTV_SLICED_TYPE_VPS;
56 static int valid_service_line(int field, int line, int is_pal)
58 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
59 (!is_pal && line >= 10 && line < 22);
62 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
64 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
67 set = set & valid_set;
68 if (set == 0 || !valid_service_line(field, line, is_pal)) {
72 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
73 return V4L2_SLICED_CAPTION_525;
76 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
77 return V4L2_SLICED_VPS;
78 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
79 return V4L2_SLICED_WSS_625;
83 for (i = 0; i < 32; i++) {
90 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
92 u16 set = fmt->service_set;
96 for (f = 0; f < 2; f++) {
97 for (l = 0; l < 24; l++) {
98 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
103 static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
107 for (f = 0; f < 2; f++) {
108 for (l = 0; l < 24; l++) {
109 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
114 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
119 for (f = 0; f < 2; f++) {
120 for (l = 0; l < 24; l++) {
121 set |= fmt->service_lines[f][l];
127 void ivtv_set_osd_alpha(struct ivtv *itv)
129 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
130 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
131 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
134 int ivtv_set_speed(struct ivtv *itv, int speed)
136 u32 data[CX2341X_MBOX_MAX_DATA];
137 int single_step = (speed == 1 || speed == -1);
140 if (speed == 0) speed = 1000;
143 if (speed == itv->speed && !single_step)
146 if (single_step && (speed < 0) == (itv->speed < 0)) {
147 /* Single step video and no need to change direction */
148 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
153 /* Need to change direction */
154 speed = speed < 0 ? -1000 : 1000;
156 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
157 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
158 data[1] = (speed < 0);
159 data[2] = speed < 0 ? 3 : 7;
160 data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
161 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
165 if (speed == 1500 || speed == -1500) data[0] |= 1;
166 else if (speed == 2000 || speed == -2000) data[0] |= 2;
167 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
168 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
170 /* If not decoding, just change speed setting */
171 if (atomic_read(&itv->decoding) > 0) {
174 /* Stop all DMA and decoding activity */
175 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
177 /* Wait for any DMA to finish */
178 mutex_unlock(&itv->serialize_lock);
179 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
180 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
181 got_sig = signal_pending(current);
187 finish_wait(&itv->dma_waitq, &wait);
188 mutex_lock(&itv->serialize_lock);
192 /* Change Speed safely */
193 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
194 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
195 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
198 speed = (speed < 0) ? -1 : 1;
199 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
205 static int ivtv_validate_speed(int cur_speed, int new_speed)
207 int fact = new_speed < 0 ? -1 : 1;
213 new_speed = -new_speed;
215 cur_speed = -cur_speed;
217 if (cur_speed <= new_speed) {
218 if (new_speed > 1500)
220 if (new_speed > 1000)
224 if (new_speed >= 2000)
226 if (new_speed >= 1500)
228 if (new_speed >= 1000)
233 if (new_speed == 1 || new_speed == 1000)
234 return fact * new_speed;
237 new_speed = 1000 / new_speed;
238 if (1000 / cur_speed == new_speed)
239 new_speed += (cur_speed < s) ? -1 : 1;
240 if (new_speed > 60) return 1000 / (fact * 60);
241 return 1000 / (fact * new_speed);
244 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
245 struct v4l2_decoder_cmd *dc, int try)
247 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
249 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
253 case V4L2_DEC_CMD_START: {
254 dc->flags &= V4L2_DEC_CMD_START_MUTE_AUDIO;
255 dc->start.speed = ivtv_validate_speed(itv->speed, dc->start.speed);
256 if (dc->start.speed < 0)
257 dc->start.format = V4L2_DEC_START_FMT_GOP;
259 dc->start.format = V4L2_DEC_START_FMT_NONE;
260 if (dc->start.speed != 500 && dc->start.speed != 1500)
261 dc->flags = dc->start.speed == 1000 ? 0 :
262 V4L2_DEC_CMD_START_MUTE_AUDIO;
265 itv->speed_mute_audio = dc->flags & V4L2_DEC_CMD_START_MUTE_AUDIO;
266 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
268 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
269 /* forces ivtv_set_speed to be called */
272 return ivtv_start_decoding(id, dc->start.speed);
275 case V4L2_DEC_CMD_STOP:
276 dc->flags &= V4L2_DEC_CMD_STOP_IMMEDIATELY | V4L2_DEC_CMD_STOP_TO_BLACK;
277 if (dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY)
280 if (atomic_read(&itv->decoding) == 0)
282 if (itv->output_mode != OUT_MPG)
285 itv->output_mode = OUT_NONE;
286 return ivtv_stop_v4l2_decode_stream(s, dc->flags, dc->stop.pts);
288 case V4L2_DEC_CMD_PAUSE:
289 dc->flags &= V4L2_DEC_CMD_PAUSE_TO_BLACK;
291 if (!atomic_read(&itv->decoding))
293 if (itv->output_mode != OUT_MPG)
295 if (atomic_read(&itv->decoding) > 0) {
296 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
297 (dc->flags & V4L2_DEC_CMD_PAUSE_TO_BLACK) ? 1 : 0);
298 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
302 case V4L2_DEC_CMD_RESUME:
305 if (!atomic_read(&itv->decoding))
307 if (itv->output_mode != OUT_MPG)
309 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
310 int speed = itv->speed;
312 return ivtv_start_decoding(id, speed);
322 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
324 struct ivtv *itv = fh2id(fh)->itv;
325 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
327 vbifmt->reserved[0] = 0;
328 vbifmt->reserved[1] = 0;
329 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
331 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
332 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
334 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
335 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
337 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
338 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
340 vbifmt->service_set = ivtv_get_service_set(vbifmt);
344 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
346 struct ivtv_open_id *id = fh2id(fh);
347 struct ivtv *itv = id->itv;
348 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
350 pixfmt->width = itv->cxhdl.width;
351 pixfmt->height = itv->cxhdl.height;
352 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
353 pixfmt->field = V4L2_FIELD_INTERLACED;
355 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
356 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
357 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
358 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
359 pixfmt->bytesperline = 720;
361 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
362 pixfmt->sizeimage = 128 * 1024;
363 pixfmt->bytesperline = 0;
368 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
370 struct ivtv *itv = fh2id(fh)->itv;
371 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
373 vbifmt->sampling_rate = 27000000;
374 vbifmt->offset = 248;
375 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
376 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
377 vbifmt->start[0] = itv->vbi.start[0];
378 vbifmt->start[1] = itv->vbi.start[1];
379 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
381 vbifmt->reserved[0] = 0;
382 vbifmt->reserved[1] = 0;
386 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
388 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
389 struct ivtv_open_id *id = fh2id(fh);
390 struct ivtv *itv = id->itv;
392 vbifmt->reserved[0] = 0;
393 vbifmt->reserved[1] = 0;
394 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
396 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
397 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
399 ivtv_expand_service_set(vbifmt, itv->is_50hz);
400 vbifmt->service_set = ivtv_get_service_set(vbifmt);
404 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
405 vbifmt->service_set = ivtv_get_service_set(vbifmt);
409 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
411 struct ivtv_open_id *id = fh2id(fh);
412 struct ivtv *itv = id->itv;
413 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
415 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
417 pixfmt->width = itv->main_rect.width;
418 pixfmt->height = itv->main_rect.height;
419 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
420 pixfmt->field = V4L2_FIELD_INTERLACED;
422 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
423 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
424 case IVTV_YUV_MODE_INTERLACED:
425 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
426 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
428 case IVTV_YUV_MODE_PROGRESSIVE:
429 pixfmt->field = V4L2_FIELD_NONE;
432 pixfmt->field = V4L2_FIELD_ANY;
435 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
436 pixfmt->bytesperline = 720;
437 pixfmt->width = itv->yuv_info.v4l2_src_w;
438 pixfmt->height = itv->yuv_info.v4l2_src_h;
439 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
441 1080 * ((pixfmt->height + 31) & ~31);
443 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
444 pixfmt->sizeimage = 128 * 1024;
445 pixfmt->bytesperline = 0;
450 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
452 struct ivtv *itv = fh2id(fh)->itv;
453 struct v4l2_window *winfmt = &fmt->fmt.win;
455 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
457 winfmt->chromakey = itv->osd_chroma_key;
458 winfmt->global_alpha = itv->osd_global_alpha;
459 winfmt->field = V4L2_FIELD_INTERLACED;
460 winfmt->clips = NULL;
461 winfmt->clipcount = 0;
462 winfmt->bitmap = NULL;
463 winfmt->w.top = winfmt->w.left = 0;
464 winfmt->w.width = itv->osd_rect.width;
465 winfmt->w.height = itv->osd_rect.height;
469 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
471 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
474 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
476 struct ivtv_open_id *id = fh2id(fh);
477 struct ivtv *itv = id->itv;
478 int w = fmt->fmt.pix.width;
479 int h = fmt->fmt.pix.height;
484 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
485 /* YUV height must be a multiple of 32 */
489 h = min(h, itv->is_50hz ? 576 : 480);
491 ivtv_g_fmt_vid_cap(file, fh, fmt);
492 fmt->fmt.pix.width = w;
493 fmt->fmt.pix.height = h;
497 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
499 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
502 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
504 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
505 struct ivtv_open_id *id = fh2id(fh);
506 struct ivtv *itv = id->itv;
508 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
509 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
511 /* set sliced VBI capture format */
512 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
513 vbifmt->reserved[0] = 0;
514 vbifmt->reserved[1] = 0;
516 if (vbifmt->service_set)
517 ivtv_expand_service_set(vbifmt, itv->is_50hz);
518 check_service_set(vbifmt, itv->is_50hz);
519 vbifmt->service_set = ivtv_get_service_set(vbifmt);
523 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
525 struct ivtv_open_id *id = fh2id(fh);
526 s32 w = fmt->fmt.pix.width;
527 s32 h = fmt->fmt.pix.height;
528 int field = fmt->fmt.pix.field;
529 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
533 /* Why can the height be 576 even when the output is NTSC?
535 Internally the buffers of the PVR350 are always set to 720x576. The
536 decoded video frame will always be placed in the top left corner of
537 this buffer. For any video which is not 720x576, the buffer will
538 then be cropped to remove the unused right and lower areas, with
539 the remaining image being scaled by the hardware to fit the display
540 area. The video can be scaled both up and down, so a 720x480 video
541 can be displayed full-screen on PAL and a 720x576 video can be
542 displayed without cropping on NTSC.
544 Note that the scaling only occurs on the video stream, the osd
545 resolution is locked to the broadcast standard and not scaled.
547 Thanks to Ian Armstrong for this explanation. */
550 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
551 fmt->fmt.pix.field = field;
552 fmt->fmt.pix.width = w;
553 fmt->fmt.pix.height = h;
557 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
559 struct ivtv *itv = fh2id(fh)->itv;
560 u32 chromakey = fmt->fmt.win.chromakey;
561 u8 global_alpha = fmt->fmt.win.global_alpha;
563 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
565 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
566 fmt->fmt.win.chromakey = chromakey;
567 fmt->fmt.win.global_alpha = global_alpha;
571 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
573 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
576 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
578 struct ivtv_open_id *id = fh2id(fh);
579 struct ivtv *itv = id->itv;
580 struct v4l2_mbus_framefmt mbus_fmt;
581 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
582 int w = fmt->fmt.pix.width;
583 int h = fmt->fmt.pix.height;
588 if (itv->cxhdl.width == w && itv->cxhdl.height == h)
591 if (atomic_read(&itv->capturing) > 0)
594 itv->cxhdl.width = w;
595 itv->cxhdl.height = h;
596 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
597 fmt->fmt.pix.width /= 2;
598 mbus_fmt.width = fmt->fmt.pix.width;
600 mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
601 v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
602 return ivtv_g_fmt_vid_cap(file, fh, fmt);
605 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
607 struct ivtv *itv = fh2id(fh)->itv;
609 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
611 itv->vbi.sliced_in->service_set = 0;
612 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
613 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
614 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
617 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
619 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
620 struct ivtv_open_id *id = fh2id(fh);
621 struct ivtv *itv = id->itv;
622 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
624 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
627 check_service_set(vbifmt, itv->is_50hz);
628 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
630 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
631 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
632 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
636 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
638 struct ivtv_open_id *id = fh2id(fh);
639 struct ivtv *itv = id->itv;
640 struct yuv_playback_info *yi = &itv->yuv_info;
641 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
646 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
649 /* Return now if we already have some frame data */
653 yi->v4l2_src_w = fmt->fmt.pix.width;
654 yi->v4l2_src_h = fmt->fmt.pix.height;
656 switch (fmt->fmt.pix.field) {
657 case V4L2_FIELD_NONE:
658 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
661 yi->lace_mode = IVTV_YUV_MODE_AUTO;
663 case V4L2_FIELD_INTERLACED_BT:
665 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
667 case V4L2_FIELD_INTERLACED_TB:
669 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
672 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
674 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
675 itv->dma_data_req_size =
676 1080 * ((yi->v4l2_src_h + 31) & ~31);
681 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
683 struct ivtv *itv = fh2id(fh)->itv;
684 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
687 itv->osd_chroma_key = fmt->fmt.win.chromakey;
688 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
689 ivtv_set_osd_alpha(itv);
694 #ifdef CONFIG_VIDEO_ADV_DEBUG
695 static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val)
697 volatile u8 __iomem *reg_start;
701 if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
702 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
703 else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET &&
704 reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
705 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
706 else if (reg < IVTV_ENCODER_SIZE)
707 reg_start = itv->enc_mem;
712 *val = readl(reg + reg_start);
714 writel(*val, reg + reg_start);
718 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
720 struct ivtv *itv = fh2id(fh)->itv;
723 return ivtv_itvc(itv, true, reg->reg, ®->val);
726 static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg)
728 struct ivtv *itv = fh2id(fh)->itv;
731 return ivtv_itvc(itv, false, reg->reg, &val);
735 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
737 struct ivtv_open_id *id = fh2id(file->private_data);
738 struct ivtv *itv = id->itv;
739 struct ivtv_stream *s = &itv->streams[id->type];
741 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
742 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
743 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
744 vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
745 vcap->device_caps = s->caps;
749 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
751 struct ivtv *itv = fh2id(fh)->itv;
753 return ivtv_get_audio_input(itv, vin->index, vin);
756 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
758 struct ivtv *itv = fh2id(fh)->itv;
760 vin->index = itv->audio_input;
761 return ivtv_get_audio_input(itv, vin->index, vin);
764 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
766 struct ivtv *itv = fh2id(fh)->itv;
768 if (vout->index >= itv->nof_audio_inputs)
771 itv->audio_input = vout->index;
772 ivtv_audio_set_io(itv);
777 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
779 struct ivtv *itv = fh2id(fh)->itv;
781 /* set it to defaults from our table */
782 return ivtv_get_audio_output(itv, vin->index, vin);
785 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
787 struct ivtv *itv = fh2id(fh)->itv;
790 return ivtv_get_audio_output(itv, vin->index, vin);
793 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
795 struct ivtv *itv = fh2id(fh)->itv;
797 if (itv->card->video_outputs == NULL || vout->index != 0)
802 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
804 struct ivtv *itv = fh2id(fh)->itv;
806 /* set it to defaults from our table */
807 return ivtv_get_input(itv, vin->index, vin);
810 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
812 struct ivtv *itv = fh2id(fh)->itv;
814 return ivtv_get_output(itv, vout->index, vout);
817 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
819 struct ivtv_open_id *id = fh2id(fh);
820 struct ivtv *itv = id->itv;
821 struct yuv_playback_info *yi = &itv->yuv_info;
824 streamtype = id->type;
826 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
828 cropcap->bounds.top = cropcap->bounds.left = 0;
829 cropcap->bounds.width = 720;
830 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
831 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
832 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
833 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
834 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
836 cropcap->bounds.width = yi->osd_full_w;
837 cropcap->bounds.height = yi->osd_full_h;
839 cropcap->bounds.width = 720;
840 cropcap->bounds.height =
841 itv->is_out_50hz ? 576 : 480;
843 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
844 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
846 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
847 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
848 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
850 cropcap->defrect = cropcap->bounds;
854 static int ivtv_s_crop(struct file *file, void *fh, const struct v4l2_crop *crop)
856 struct ivtv_open_id *id = fh2id(fh);
857 struct ivtv *itv = id->itv;
858 struct yuv_playback_info *yi = &itv->yuv_info;
861 streamtype = id->type;
863 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
864 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
865 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
866 yi->main_rect = crop->c;
869 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
870 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
871 itv->main_rect = crop->c;
880 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
882 struct ivtv_open_id *id = fh2id(fh);
883 struct ivtv *itv = id->itv;
884 struct yuv_playback_info *yi = &itv->yuv_info;
887 streamtype = id->type;
889 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
890 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
891 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
892 crop->c = yi->main_rect;
894 crop->c = itv->main_rect;
900 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
902 static const struct v4l2_fmtdesc hm12 = {
903 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
904 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
907 static const struct v4l2_fmtdesc mpeg = {
908 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
909 "MPEG", V4L2_PIX_FMT_MPEG,
912 struct ivtv *itv = fh2id(fh)->itv;
913 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
917 if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
919 else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
926 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
928 static const struct v4l2_fmtdesc hm12 = {
929 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0,
930 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
933 static const struct v4l2_fmtdesc mpeg = {
934 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED,
935 "MPEG", V4L2_PIX_FMT_MPEG,
938 struct ivtv *itv = fh2id(fh)->itv;
939 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
943 if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
945 else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
952 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
954 struct ivtv *itv = fh2id(fh)->itv;
956 *i = itv->active_input;
961 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
963 struct ivtv *itv = fh2id(fh)->itv;
967 if (inp >= itv->nof_inputs)
970 if (inp == itv->active_input) {
971 IVTV_DEBUG_INFO("Input unchanged\n");
975 if (atomic_read(&itv->capturing) > 0) {
979 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
980 itv->active_input, inp);
982 itv->active_input = inp;
983 /* Set the audio input to whatever is appropriate for the
985 itv->audio_input = itv->card->video_inputs[inp].audio_index;
987 if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
988 std = itv->tuner_std;
991 for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
992 itv->streams[i].vdev->tvnorms = std;
994 /* prevent others from messing with the streams until
995 we're finished changing inputs. */
997 ivtv_video_set_io(itv);
998 ivtv_audio_set_io(itv);
1004 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1006 struct ivtv *itv = fh2id(fh)->itv;
1008 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1011 *i = itv->active_output;
1016 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1018 struct ivtv *itv = fh2id(fh)->itv;
1020 if (outp >= itv->card->nof_outputs)
1023 if (outp == itv->active_output) {
1024 IVTV_DEBUG_INFO("Output unchanged\n");
1027 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1028 itv->active_output, outp);
1030 itv->active_output = outp;
1031 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1032 SAA7127_INPUT_TYPE_NORMAL,
1033 itv->card->video_outputs[outp].video_output, 0);
1038 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1040 struct ivtv *itv = fh2id(fh)->itv;
1041 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1043 if (s->vdev->vfl_dir)
1048 ivtv_call_all(itv, tuner, g_frequency, vf);
1052 int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1054 struct ivtv *itv = fh2id(fh)->itv;
1055 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1057 if (s->vdev->vfl_dir)
1063 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1064 ivtv_call_all(itv, tuner, s_frequency, vf);
1069 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1071 struct ivtv *itv = fh2id(fh)->itv;
1077 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1080 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1081 itv->is_50hz = !itv->is_60hz;
1082 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1083 itv->cxhdl.width = 720;
1084 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1085 itv->vbi.count = itv->is_50hz ? 18 : 12;
1086 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1087 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1089 if (itv->hw_flags & IVTV_HW_CX25840)
1090 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1093 ivtv_call_all(itv, core, s_std, itv->std);
1096 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1098 struct yuv_playback_info *yi = &itv->yuv_info;
1102 /* set display standard */
1104 itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1105 itv->is_out_50hz = !itv->is_out_60hz;
1106 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1109 * The next firmware call is time sensitive. Time it to
1110 * avoid risk of a hard lock, by trying to ensure the call
1111 * happens within the first 100 lines of the top field.
1112 * Make 4 attempts to sync to the decoder before giving up.
1114 mutex_unlock(&itv->serialize_lock);
1115 for (f = 0; f < 4; f++) {
1116 prepare_to_wait(&itv->vsync_waitq, &wait,
1117 TASK_UNINTERRUPTIBLE);
1118 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1120 schedule_timeout(msecs_to_jiffies(25));
1122 finish_wait(&itv->vsync_waitq, &wait);
1123 mutex_lock(&itv->serialize_lock);
1126 IVTV_WARN("Mode change failed to sync to decoder\n");
1128 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1129 itv->main_rect.left = 0;
1130 itv->main_rect.top = 0;
1131 itv->main_rect.width = 720;
1132 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1133 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1134 720, itv->main_rect.height, 0, 0);
1135 yi->main_rect = itv->main_rect;
1136 if (!itv->osd_info) {
1137 yi->osd_full_w = 720;
1138 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1142 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1144 struct ivtv *itv = fh2id(fh)->itv;
1146 if ((std & V4L2_STD_ALL) == 0)
1149 if (std == itv->std)
1152 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1153 atomic_read(&itv->capturing) > 0 ||
1154 atomic_read(&itv->decoding) > 0) {
1155 /* Switching standard would mess with already running
1156 streams, prevent that by returning EBUSY. */
1160 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1161 (unsigned long long)itv->std);
1163 ivtv_s_std_enc(itv, std);
1164 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1165 ivtv_s_std_dec(itv, std);
1170 static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1172 struct ivtv_open_id *id = fh2id(fh);
1173 struct ivtv *itv = id->itv;
1178 ivtv_call_all(itv, tuner, s_tuner, vt);
1183 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1185 struct ivtv *itv = fh2id(fh)->itv;
1190 ivtv_call_all(itv, tuner, g_tuner, vt);
1192 if (vt->type == V4L2_TUNER_RADIO)
1193 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1195 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1199 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1201 struct ivtv *itv = fh2id(fh)->itv;
1202 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1205 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1206 for (f = 0; f < 2; f++) {
1207 for (l = 0; l < 24; l++) {
1208 if (valid_service_line(f, l, itv->is_50hz))
1209 cap->service_lines[f][l] = set;
1212 } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1213 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1216 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1217 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1219 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1220 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1227 for (f = 0; f < 2; f++)
1228 for (l = 0; l < 24; l++)
1229 set |= cap->service_lines[f][l];
1230 cap->service_set = set;
1234 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1236 struct ivtv *itv = fh2id(fh)->itv;
1237 struct v4l2_enc_idx_entry *e = idx->entry;
1241 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1243 if (entries > V4L2_ENC_IDX_ENTRIES)
1244 entries = V4L2_ENC_IDX_ENTRIES;
1246 idx->entries_cap = IVTV_MAX_PGM_INDEX;
1247 if (!atomic_read(&itv->capturing))
1249 for (i = 0; i < entries; i++) {
1250 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1251 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1256 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1260 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1262 struct ivtv_open_id *id = fh2id(fh);
1263 struct ivtv *itv = id->itv;
1267 case V4L2_ENC_CMD_START:
1268 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1270 return ivtv_start_capture(id);
1272 case V4L2_ENC_CMD_STOP:
1273 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1274 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1275 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1278 case V4L2_ENC_CMD_PAUSE:
1279 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1282 if (!atomic_read(&itv->capturing))
1284 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1288 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1291 case V4L2_ENC_CMD_RESUME:
1292 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1295 if (!atomic_read(&itv->capturing))
1298 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1301 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1305 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1312 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1314 struct ivtv *itv = fh2id(fh)->itv;
1317 case V4L2_ENC_CMD_START:
1318 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1322 case V4L2_ENC_CMD_STOP:
1323 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1324 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1327 case V4L2_ENC_CMD_PAUSE:
1328 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1332 case V4L2_ENC_CMD_RESUME:
1333 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1337 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1342 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1344 struct ivtv *itv = fh2id(fh)->itv;
1345 u32 data[CX2341X_MBOX_MAX_DATA];
1346 struct yuv_playback_info *yi = &itv->yuv_info;
1349 static u32 pixel_format[16] = {
1350 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1351 V4L2_PIX_FMT_RGB565,
1352 V4L2_PIX_FMT_RGB555,
1353 V4L2_PIX_FMT_RGB444,
1358 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1359 V4L2_PIX_FMT_YUV565,
1360 V4L2_PIX_FMT_YUV555,
1361 V4L2_PIX_FMT_YUV444,
1368 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1370 if (!itv->osd_video_pbase)
1373 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1374 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1376 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1377 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1378 pixfmt = (data[0] >> 3) & 0xf;
1380 fb->fmt.pixelformat = pixel_format[pixfmt];
1381 fb->fmt.width = itv->osd_rect.width;
1382 fb->fmt.height = itv->osd_rect.height;
1383 fb->fmt.field = V4L2_FIELD_INTERLACED;
1384 fb->fmt.bytesperline = fb->fmt.width;
1385 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1386 fb->fmt.field = V4L2_FIELD_INTERLACED;
1388 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1389 fb->fmt.bytesperline *= 2;
1390 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1391 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1392 fb->fmt.bytesperline *= 2;
1393 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1394 fb->base = (void *)itv->osd_video_pbase;
1397 if (itv->osd_chroma_key_state)
1398 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1400 if (itv->osd_global_alpha_state)
1401 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1404 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1408 /* no local alpha for RGB565 or unknown formats */
1409 if (pixfmt == 1 || pixfmt > 4)
1412 /* 16-bit formats have inverted local alpha */
1413 if (pixfmt == 2 || pixfmt == 3)
1414 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1416 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1418 if (itv->osd_local_alpha_state) {
1419 /* 16-bit formats have inverted local alpha */
1420 if (pixfmt == 2 || pixfmt == 3)
1421 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1423 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1429 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1431 struct ivtv_open_id *id = fh2id(fh);
1432 struct ivtv *itv = id->itv;
1433 struct yuv_playback_info *yi = &itv->yuv_info;
1435 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1437 if (!itv->osd_video_pbase)
1440 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1441 itv->osd_local_alpha_state =
1442 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1443 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1444 ivtv_set_osd_alpha(itv);
1445 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1449 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1451 struct ivtv_open_id *id = fh2id(fh);
1452 struct ivtv *itv = id->itv;
1454 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1457 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1462 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1464 switch (sub->type) {
1465 case V4L2_EVENT_VSYNC:
1466 case V4L2_EVENT_EOS:
1467 return v4l2_event_subscribe(fh, sub, 0, NULL);
1468 case V4L2_EVENT_CTRL:
1469 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
1475 static int ivtv_log_status(struct file *file, void *fh)
1477 struct ivtv *itv = fh2id(fh)->itv;
1478 u32 data[CX2341X_MBOX_MAX_DATA];
1480 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1481 struct v4l2_input vidin;
1482 struct v4l2_audio audin;
1485 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1486 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1489 ivtv_read_eeprom(itv, &tv);
1491 ivtv_call_all(itv, core, log_status);
1492 ivtv_get_input(itv, itv->active_input, &vidin);
1493 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1494 IVTV_INFO("Video Input: %s\n", vidin.name);
1495 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1496 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1498 struct v4l2_output vidout;
1499 struct v4l2_audioout audout;
1500 int mode = itv->output_mode;
1501 static const char * const output_modes[5] = {
1508 static const char * const alpha_mode[4] = {
1514 static const char * const pixel_format[16] = {
1533 ivtv_get_output(itv, itv->active_output, &vidout);
1534 ivtv_get_audio_output(itv, 0, &audout);
1535 IVTV_INFO("Video Output: %s\n", vidout.name);
1536 if (mode < 0 || mode > OUT_PASSTHROUGH)
1538 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1539 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1540 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1541 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1542 data[0] & 1 ? "On" : "Off",
1543 alpha_mode[(data[0] >> 1) & 0x3],
1544 pixel_format[(data[0] >> 3) & 0xf]);
1546 IVTV_INFO("Tuner: %s\n",
1547 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1548 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1549 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1550 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1551 struct ivtv_stream *s = &itv->streams[i];
1553 if (s->vdev == NULL || s->buffers == 0)
1555 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1556 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1557 (s->buffers * s->buf_size) / 1024, s->buffers);
1560 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1561 (long long)itv->mpg_data_received,
1562 (long long)itv->vbi_data_inserted);
1566 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1568 struct ivtv_open_id *id = fh2id(file->private_data);
1569 struct ivtv *itv = id->itv;
1571 IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1572 return ivtv_video_command(itv, id, dec, false);
1575 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1577 struct ivtv_open_id *id = fh2id(file->private_data);
1578 struct ivtv *itv = id->itv;
1580 IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1581 return ivtv_video_command(itv, id, dec, true);
1584 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1586 struct ivtv_open_id *id = fh2id(filp->private_data);
1587 struct ivtv *itv = id->itv;
1588 int nonblocking = filp->f_flags & O_NONBLOCK;
1589 struct ivtv_stream *s = &itv->streams[id->type];
1590 unsigned long iarg = (unsigned long)arg;
1593 case IVTV_IOC_DMA_FRAME: {
1594 struct ivtv_dma_frame *args = arg;
1596 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1597 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1599 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1601 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1603 if (ivtv_start_decoding(id, id->type)) {
1606 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1607 ivtv_release_stream(s);
1610 /* Mark that this file handle started the UDMA_YUV mode */
1612 if (args->y_source == NULL)
1614 return ivtv_yuv_prep_frame(itv, args);
1617 case IVTV_IOC_PASSTHROUGH_MODE:
1618 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1619 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1621 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1623 case VIDEO_GET_PTS: {
1627 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1628 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1632 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1634 return ivtv_g_pts_frame(itv, pts, &frame);
1637 case VIDEO_GET_FRAME_COUNT: {
1641 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1642 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1646 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1648 return ivtv_g_pts_frame(itv, &pts, frame);
1652 struct v4l2_decoder_cmd dc;
1654 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1655 memset(&dc, 0, sizeof(dc));
1656 dc.cmd = V4L2_DEC_CMD_START;
1657 return ivtv_video_command(itv, id, &dc, 0);
1661 struct v4l2_decoder_cmd dc;
1663 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1664 memset(&dc, 0, sizeof(dc));
1665 dc.cmd = V4L2_DEC_CMD_STOP;
1666 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1667 return ivtv_video_command(itv, id, &dc, 0);
1670 case VIDEO_FREEZE: {
1671 struct v4l2_decoder_cmd dc;
1673 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1674 memset(&dc, 0, sizeof(dc));
1675 dc.cmd = V4L2_DEC_CMD_PAUSE;
1676 return ivtv_video_command(itv, id, &dc, 0);
1679 case VIDEO_CONTINUE: {
1680 struct v4l2_decoder_cmd dc;
1682 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1683 memset(&dc, 0, sizeof(dc));
1684 dc.cmd = V4L2_DEC_CMD_RESUME;
1685 return ivtv_video_command(itv, id, &dc, 0);
1689 case VIDEO_TRY_COMMAND: {
1690 /* Note: struct v4l2_decoder_cmd has the same layout as
1691 struct video_command */
1692 struct v4l2_decoder_cmd *dc = arg;
1693 int try = (cmd == VIDEO_TRY_COMMAND);
1696 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd);
1698 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd);
1699 return ivtv_video_command(itv, id, dc, 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");
1748 case VIDEO_SELECT_SOURCE:
1749 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1750 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1752 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1754 case AUDIO_SET_MUTE:
1755 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1756 itv->speed_mute_audio = iarg;
1759 case AUDIO_CHANNEL_SELECT:
1760 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1761 if (iarg > AUDIO_STEREO_SWAPPED)
1763 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1765 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1766 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1767 if (iarg > AUDIO_STEREO_SWAPPED)
1769 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1777 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1778 unsigned int cmd, void *arg)
1780 struct ivtv *itv = fh2id(fh)->itv;
1784 case IVTV_IOC_PASSTHROUGH_MODE:
1788 case VIDEO_CONTINUE:
1790 case VIDEO_SELECT_SOURCE:
1791 case AUDIO_SET_MUTE:
1792 case AUDIO_CHANNEL_SELECT:
1793 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1799 case VIDIOC_INT_RESET: {
1800 u32 val = *(u32 *)arg;
1802 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1803 ivtv_reset_ir_gpio(itv);
1805 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1809 case IVTV_IOC_DMA_FRAME:
1810 case IVTV_IOC_PASSTHROUGH_MODE:
1812 case VIDEO_GET_FRAME_COUNT:
1813 case VIDEO_GET_EVENT:
1817 case VIDEO_CONTINUE:
1819 case VIDEO_TRY_COMMAND:
1820 case VIDEO_SELECT_SOURCE:
1821 case AUDIO_SET_MUTE:
1822 case AUDIO_CHANNEL_SELECT:
1823 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1824 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1832 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1833 .vidioc_querycap = ivtv_querycap,
1834 .vidioc_s_audio = ivtv_s_audio,
1835 .vidioc_g_audio = ivtv_g_audio,
1836 .vidioc_enumaudio = ivtv_enumaudio,
1837 .vidioc_s_audout = ivtv_s_audout,
1838 .vidioc_g_audout = ivtv_g_audout,
1839 .vidioc_enum_input = ivtv_enum_input,
1840 .vidioc_enum_output = ivtv_enum_output,
1841 .vidioc_enumaudout = ivtv_enumaudout,
1842 .vidioc_cropcap = ivtv_cropcap,
1843 .vidioc_s_crop = ivtv_s_crop,
1844 .vidioc_g_crop = ivtv_g_crop,
1845 .vidioc_g_input = ivtv_g_input,
1846 .vidioc_s_input = ivtv_s_input,
1847 .vidioc_g_output = ivtv_g_output,
1848 .vidioc_s_output = ivtv_s_output,
1849 .vidioc_g_frequency = ivtv_g_frequency,
1850 .vidioc_s_frequency = ivtv_s_frequency,
1851 .vidioc_s_tuner = ivtv_s_tuner,
1852 .vidioc_g_tuner = ivtv_g_tuner,
1853 .vidioc_g_enc_index = ivtv_g_enc_index,
1854 .vidioc_g_fbuf = ivtv_g_fbuf,
1855 .vidioc_s_fbuf = ivtv_s_fbuf,
1856 .vidioc_g_std = ivtv_g_std,
1857 .vidioc_s_std = ivtv_s_std,
1858 .vidioc_overlay = ivtv_overlay,
1859 .vidioc_log_status = ivtv_log_status,
1860 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1861 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1862 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1863 .vidioc_decoder_cmd = ivtv_decoder_cmd,
1864 .vidioc_try_decoder_cmd = ivtv_try_decoder_cmd,
1865 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1866 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1867 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1868 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1869 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1870 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1871 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1872 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1873 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1874 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1875 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1876 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1877 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1878 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1879 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1880 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1881 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1882 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1883 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1884 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1885 #ifdef CONFIG_VIDEO_ADV_DEBUG
1886 .vidioc_g_register = ivtv_g_register,
1887 .vidioc_s_register = ivtv_s_register,
1889 .vidioc_default = ivtv_default,
1890 .vidioc_subscribe_event = ivtv_subscribe_event,
1891 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1894 void ivtv_set_funcs(struct video_device *vdev)
1896 vdev->ioctl_ops = &ivtv_ioctl_ops;