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;
354 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
355 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
356 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
357 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
358 pixfmt->bytesperline = 720;
360 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
361 pixfmt->sizeimage = 128 * 1024;
362 pixfmt->bytesperline = 0;
367 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
369 struct ivtv *itv = fh2id(fh)->itv;
370 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
372 vbifmt->sampling_rate = 27000000;
373 vbifmt->offset = 248;
374 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
375 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
376 vbifmt->start[0] = itv->vbi.start[0];
377 vbifmt->start[1] = itv->vbi.start[1];
378 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
380 vbifmt->reserved[0] = 0;
381 vbifmt->reserved[1] = 0;
385 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
387 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
388 struct ivtv_open_id *id = fh2id(fh);
389 struct ivtv *itv = id->itv;
391 vbifmt->reserved[0] = 0;
392 vbifmt->reserved[1] = 0;
393 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
395 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
396 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
398 ivtv_expand_service_set(vbifmt, itv->is_50hz);
399 vbifmt->service_set = ivtv_get_service_set(vbifmt);
403 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
404 vbifmt->service_set = ivtv_get_service_set(vbifmt);
408 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
410 struct ivtv_open_id *id = fh2id(fh);
411 struct ivtv *itv = id->itv;
412 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
414 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
416 pixfmt->width = itv->main_rect.width;
417 pixfmt->height = itv->main_rect.height;
418 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
419 pixfmt->field = V4L2_FIELD_INTERLACED;
420 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
421 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
422 case IVTV_YUV_MODE_INTERLACED:
423 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
424 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
426 case IVTV_YUV_MODE_PROGRESSIVE:
427 pixfmt->field = V4L2_FIELD_NONE;
430 pixfmt->field = V4L2_FIELD_ANY;
433 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
434 pixfmt->bytesperline = 720;
435 pixfmt->width = itv->yuv_info.v4l2_src_w;
436 pixfmt->height = itv->yuv_info.v4l2_src_h;
437 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
439 1080 * ((pixfmt->height + 31) & ~31);
441 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
442 pixfmt->sizeimage = 128 * 1024;
443 pixfmt->bytesperline = 0;
448 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
450 struct ivtv *itv = fh2id(fh)->itv;
451 struct v4l2_window *winfmt = &fmt->fmt.win;
453 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
455 winfmt->chromakey = itv->osd_chroma_key;
456 winfmt->global_alpha = itv->osd_global_alpha;
457 winfmt->field = V4L2_FIELD_INTERLACED;
458 winfmt->clips = NULL;
459 winfmt->clipcount = 0;
460 winfmt->bitmap = NULL;
461 winfmt->w.top = winfmt->w.left = 0;
462 winfmt->w.width = itv->osd_rect.width;
463 winfmt->w.height = itv->osd_rect.height;
467 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
469 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
472 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
474 struct ivtv_open_id *id = fh2id(fh);
475 struct ivtv *itv = id->itv;
476 int w = fmt->fmt.pix.width;
477 int h = fmt->fmt.pix.height;
482 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
483 /* YUV height must be a multiple of 32 */
487 h = min(h, itv->is_50hz ? 576 : 480);
489 ivtv_g_fmt_vid_cap(file, fh, fmt);
490 fmt->fmt.pix.width = w;
491 fmt->fmt.pix.height = h;
495 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
497 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
500 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
502 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
503 struct ivtv_open_id *id = fh2id(fh);
504 struct ivtv *itv = id->itv;
506 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
507 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
509 /* set sliced VBI capture format */
510 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
511 vbifmt->reserved[0] = 0;
512 vbifmt->reserved[1] = 0;
514 if (vbifmt->service_set)
515 ivtv_expand_service_set(vbifmt, itv->is_50hz);
516 check_service_set(vbifmt, itv->is_50hz);
517 vbifmt->service_set = ivtv_get_service_set(vbifmt);
521 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
523 struct ivtv_open_id *id = fh2id(fh);
524 s32 w = fmt->fmt.pix.width;
525 s32 h = fmt->fmt.pix.height;
526 int field = fmt->fmt.pix.field;
527 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
531 /* Why can the height be 576 even when the output is NTSC?
533 Internally the buffers of the PVR350 are always set to 720x576. The
534 decoded video frame will always be placed in the top left corner of
535 this buffer. For any video which is not 720x576, the buffer will
536 then be cropped to remove the unused right and lower areas, with
537 the remaining image being scaled by the hardware to fit the display
538 area. The video can be scaled both up and down, so a 720x480 video
539 can be displayed full-screen on PAL and a 720x576 video can be
540 displayed without cropping on NTSC.
542 Note that the scaling only occurs on the video stream, the osd
543 resolution is locked to the broadcast standard and not scaled.
545 Thanks to Ian Armstrong for this explanation. */
548 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
549 fmt->fmt.pix.field = field;
550 fmt->fmt.pix.width = w;
551 fmt->fmt.pix.height = h;
555 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
557 struct ivtv *itv = fh2id(fh)->itv;
558 u32 chromakey = fmt->fmt.win.chromakey;
559 u8 global_alpha = fmt->fmt.win.global_alpha;
561 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
563 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
564 fmt->fmt.win.chromakey = chromakey;
565 fmt->fmt.win.global_alpha = global_alpha;
569 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
571 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
574 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
576 struct ivtv_open_id *id = fh2id(fh);
577 struct ivtv *itv = id->itv;
578 struct v4l2_mbus_framefmt mbus_fmt;
579 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
580 int w = fmt->fmt.pix.width;
581 int h = fmt->fmt.pix.height;
586 if (itv->cxhdl.width == w && itv->cxhdl.height == h)
589 if (atomic_read(&itv->capturing) > 0)
592 itv->cxhdl.width = w;
593 itv->cxhdl.height = h;
594 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
595 fmt->fmt.pix.width /= 2;
596 mbus_fmt.width = fmt->fmt.pix.width;
598 mbus_fmt.code = MEDIA_BUS_FMT_FIXED;
599 v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
600 return ivtv_g_fmt_vid_cap(file, fh, fmt);
603 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
605 struct ivtv *itv = fh2id(fh)->itv;
607 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
609 itv->vbi.sliced_in->service_set = 0;
610 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
611 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
612 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
615 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
617 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
618 struct ivtv_open_id *id = fh2id(fh);
619 struct ivtv *itv = id->itv;
620 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
622 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
625 check_service_set(vbifmt, itv->is_50hz);
626 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
628 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
629 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
630 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
634 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
636 struct ivtv_open_id *id = fh2id(fh);
637 struct ivtv *itv = id->itv;
638 struct yuv_playback_info *yi = &itv->yuv_info;
639 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
644 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
647 /* Return now if we already have some frame data */
651 yi->v4l2_src_w = fmt->fmt.pix.width;
652 yi->v4l2_src_h = fmt->fmt.pix.height;
654 switch (fmt->fmt.pix.field) {
655 case V4L2_FIELD_NONE:
656 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
659 yi->lace_mode = IVTV_YUV_MODE_AUTO;
661 case V4L2_FIELD_INTERLACED_BT:
663 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
665 case V4L2_FIELD_INTERLACED_TB:
667 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
670 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
672 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
673 itv->dma_data_req_size =
674 1080 * ((yi->v4l2_src_h + 31) & ~31);
679 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
681 struct ivtv *itv = fh2id(fh)->itv;
682 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
685 itv->osd_chroma_key = fmt->fmt.win.chromakey;
686 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
687 ivtv_set_osd_alpha(itv);
692 #ifdef CONFIG_VIDEO_ADV_DEBUG
693 static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val)
695 volatile u8 __iomem *reg_start;
699 if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
700 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
701 else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET &&
702 reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
703 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
704 else if (reg < IVTV_ENCODER_SIZE)
705 reg_start = itv->enc_mem;
710 *val = readl(reg + reg_start);
712 writel(*val, reg + reg_start);
716 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
718 struct ivtv *itv = fh2id(fh)->itv;
721 return ivtv_itvc(itv, true, reg->reg, ®->val);
724 static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg)
726 struct ivtv *itv = fh2id(fh)->itv;
729 return ivtv_itvc(itv, false, reg->reg, &val);
733 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
735 struct ivtv_open_id *id = fh2id(file->private_data);
736 struct ivtv *itv = id->itv;
737 struct ivtv_stream *s = &itv->streams[id->type];
739 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
740 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
741 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
742 vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
743 vcap->device_caps = s->caps;
747 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
749 struct ivtv *itv = fh2id(fh)->itv;
751 return ivtv_get_audio_input(itv, vin->index, vin);
754 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
756 struct ivtv *itv = fh2id(fh)->itv;
758 vin->index = itv->audio_input;
759 return ivtv_get_audio_input(itv, vin->index, vin);
762 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
764 struct ivtv *itv = fh2id(fh)->itv;
766 if (vout->index >= itv->nof_audio_inputs)
769 itv->audio_input = vout->index;
770 ivtv_audio_set_io(itv);
775 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
777 struct ivtv *itv = fh2id(fh)->itv;
779 /* set it to defaults from our table */
780 return ivtv_get_audio_output(itv, vin->index, vin);
783 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
785 struct ivtv *itv = fh2id(fh)->itv;
788 return ivtv_get_audio_output(itv, vin->index, vin);
791 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
793 struct ivtv *itv = fh2id(fh)->itv;
795 if (itv->card->video_outputs == NULL || vout->index != 0)
800 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
802 struct ivtv *itv = fh2id(fh)->itv;
804 /* set it to defaults from our table */
805 return ivtv_get_input(itv, vin->index, vin);
808 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
810 struct ivtv *itv = fh2id(fh)->itv;
812 return ivtv_get_output(itv, vout->index, vout);
815 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
817 struct ivtv_open_id *id = fh2id(fh);
818 struct ivtv *itv = id->itv;
819 struct yuv_playback_info *yi = &itv->yuv_info;
822 streamtype = id->type;
824 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
826 cropcap->bounds.top = cropcap->bounds.left = 0;
827 cropcap->bounds.width = 720;
828 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
829 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
830 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
831 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
832 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
834 cropcap->bounds.width = yi->osd_full_w;
835 cropcap->bounds.height = yi->osd_full_h;
837 cropcap->bounds.width = 720;
838 cropcap->bounds.height =
839 itv->is_out_50hz ? 576 : 480;
841 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
842 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
844 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
845 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
846 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
848 cropcap->defrect = cropcap->bounds;
852 static int ivtv_s_crop(struct file *file, void *fh, const struct v4l2_crop *crop)
854 struct ivtv_open_id *id = fh2id(fh);
855 struct ivtv *itv = id->itv;
856 struct yuv_playback_info *yi = &itv->yuv_info;
859 streamtype = id->type;
861 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
862 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
863 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
864 yi->main_rect = crop->c;
867 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
868 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
869 itv->main_rect = crop->c;
878 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
880 struct ivtv_open_id *id = fh2id(fh);
881 struct ivtv *itv = id->itv;
882 struct yuv_playback_info *yi = &itv->yuv_info;
885 streamtype = id->type;
887 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
888 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
889 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
890 crop->c = yi->main_rect;
892 crop->c = itv->main_rect;
898 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
900 static const struct v4l2_fmtdesc hm12 = {
901 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
902 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
905 static const struct v4l2_fmtdesc mpeg = {
906 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
907 "MPEG", V4L2_PIX_FMT_MPEG,
910 struct ivtv *itv = fh2id(fh)->itv;
911 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
915 if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
917 else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
924 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
926 static const struct v4l2_fmtdesc hm12 = {
927 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0,
928 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
931 static const struct v4l2_fmtdesc mpeg = {
932 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED,
933 "MPEG", V4L2_PIX_FMT_MPEG,
936 struct ivtv *itv = fh2id(fh)->itv;
937 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
941 if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
943 else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
950 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
952 struct ivtv *itv = fh2id(fh)->itv;
954 *i = itv->active_input;
959 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
961 struct ivtv *itv = fh2id(fh)->itv;
965 if (inp >= itv->nof_inputs)
968 if (inp == itv->active_input) {
969 IVTV_DEBUG_INFO("Input unchanged\n");
973 if (atomic_read(&itv->capturing) > 0) {
977 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
978 itv->active_input, inp);
980 itv->active_input = inp;
981 /* Set the audio input to whatever is appropriate for the
983 itv->audio_input = itv->card->video_inputs[inp].audio_index;
985 if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
986 std = itv->tuner_std;
989 for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
990 itv->streams[i].vdev.tvnorms = std;
992 /* prevent others from messing with the streams until
993 we're finished changing inputs. */
995 ivtv_video_set_io(itv);
996 ivtv_audio_set_io(itv);
1002 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1004 struct ivtv *itv = fh2id(fh)->itv;
1006 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1009 *i = itv->active_output;
1014 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1016 struct ivtv *itv = fh2id(fh)->itv;
1018 if (outp >= itv->card->nof_outputs)
1021 if (outp == itv->active_output) {
1022 IVTV_DEBUG_INFO("Output unchanged\n");
1025 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1026 itv->active_output, outp);
1028 itv->active_output = outp;
1029 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1030 SAA7127_INPUT_TYPE_NORMAL,
1031 itv->card->video_outputs[outp].video_output, 0);
1036 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1038 struct ivtv *itv = fh2id(fh)->itv;
1039 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1041 if (s->vdev.vfl_dir)
1046 ivtv_call_all(itv, tuner, g_frequency, vf);
1050 int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1052 struct ivtv *itv = fh2id(fh)->itv;
1053 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1055 if (s->vdev.vfl_dir)
1061 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1062 ivtv_call_all(itv, tuner, s_frequency, vf);
1067 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1069 struct ivtv *itv = fh2id(fh)->itv;
1075 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1078 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1079 itv->is_50hz = !itv->is_60hz;
1080 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1081 itv->cxhdl.width = 720;
1082 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1083 itv->vbi.count = itv->is_50hz ? 18 : 12;
1084 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1085 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1087 if (itv->hw_flags & IVTV_HW_CX25840)
1088 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1091 ivtv_call_all(itv, video, s_std, itv->std);
1094 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1096 struct yuv_playback_info *yi = &itv->yuv_info;
1100 /* set display standard */
1102 itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1103 itv->is_out_50hz = !itv->is_out_60hz;
1104 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1107 * The next firmware call is time sensitive. Time it to
1108 * avoid risk of a hard lock, by trying to ensure the call
1109 * happens within the first 100 lines of the top field.
1110 * Make 4 attempts to sync to the decoder before giving up.
1112 mutex_unlock(&itv->serialize_lock);
1113 for (f = 0; f < 4; f++) {
1114 prepare_to_wait(&itv->vsync_waitq, &wait,
1115 TASK_UNINTERRUPTIBLE);
1116 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1118 schedule_timeout(msecs_to_jiffies(25));
1120 finish_wait(&itv->vsync_waitq, &wait);
1121 mutex_lock(&itv->serialize_lock);
1124 IVTV_WARN("Mode change failed to sync to decoder\n");
1126 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1127 itv->main_rect.left = 0;
1128 itv->main_rect.top = 0;
1129 itv->main_rect.width = 720;
1130 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1131 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1132 720, itv->main_rect.height, 0, 0);
1133 yi->main_rect = itv->main_rect;
1134 if (!itv->osd_info) {
1135 yi->osd_full_w = 720;
1136 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1140 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1142 struct ivtv *itv = fh2id(fh)->itv;
1144 if ((std & V4L2_STD_ALL) == 0)
1147 if (std == itv->std)
1150 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1151 atomic_read(&itv->capturing) > 0 ||
1152 atomic_read(&itv->decoding) > 0) {
1153 /* Switching standard would mess with already running
1154 streams, prevent that by returning EBUSY. */
1158 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1159 (unsigned long long)itv->std);
1161 ivtv_s_std_enc(itv, std);
1162 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1163 ivtv_s_std_dec(itv, std);
1168 static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1170 struct ivtv_open_id *id = fh2id(fh);
1171 struct ivtv *itv = id->itv;
1176 ivtv_call_all(itv, tuner, s_tuner, vt);
1181 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1183 struct ivtv *itv = fh2id(fh)->itv;
1188 ivtv_call_all(itv, tuner, g_tuner, vt);
1190 if (vt->type == V4L2_TUNER_RADIO)
1191 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1193 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1197 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1199 struct ivtv *itv = fh2id(fh)->itv;
1200 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1203 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1204 for (f = 0; f < 2; f++) {
1205 for (l = 0; l < 24; l++) {
1206 if (valid_service_line(f, l, itv->is_50hz))
1207 cap->service_lines[f][l] = set;
1210 } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1211 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1214 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1215 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1217 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1218 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1225 for (f = 0; f < 2; f++)
1226 for (l = 0; l < 24; l++)
1227 set |= cap->service_lines[f][l];
1228 cap->service_set = set;
1232 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1234 struct ivtv *itv = fh2id(fh)->itv;
1235 struct v4l2_enc_idx_entry *e = idx->entry;
1239 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1241 if (entries > V4L2_ENC_IDX_ENTRIES)
1242 entries = V4L2_ENC_IDX_ENTRIES;
1244 idx->entries_cap = IVTV_MAX_PGM_INDEX;
1245 if (!atomic_read(&itv->capturing))
1247 for (i = 0; i < entries; i++) {
1248 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1249 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1254 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1258 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1260 struct ivtv_open_id *id = fh2id(fh);
1261 struct ivtv *itv = id->itv;
1265 case V4L2_ENC_CMD_START:
1266 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1268 return ivtv_start_capture(id);
1270 case V4L2_ENC_CMD_STOP:
1271 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1272 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1273 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1276 case V4L2_ENC_CMD_PAUSE:
1277 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1280 if (!atomic_read(&itv->capturing))
1282 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1286 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1289 case V4L2_ENC_CMD_RESUME:
1290 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1293 if (!atomic_read(&itv->capturing))
1296 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1299 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1303 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1310 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1312 struct ivtv *itv = fh2id(fh)->itv;
1315 case V4L2_ENC_CMD_START:
1316 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1320 case V4L2_ENC_CMD_STOP:
1321 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1322 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1325 case V4L2_ENC_CMD_PAUSE:
1326 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1330 case V4L2_ENC_CMD_RESUME:
1331 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1335 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1340 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1342 struct ivtv *itv = fh2id(fh)->itv;
1343 u32 data[CX2341X_MBOX_MAX_DATA];
1344 struct yuv_playback_info *yi = &itv->yuv_info;
1347 static u32 pixel_format[16] = {
1348 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1349 V4L2_PIX_FMT_RGB565,
1350 V4L2_PIX_FMT_RGB555,
1351 V4L2_PIX_FMT_RGB444,
1356 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1357 V4L2_PIX_FMT_YUV565,
1358 V4L2_PIX_FMT_YUV555,
1359 V4L2_PIX_FMT_YUV444,
1366 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1368 if (!itv->osd_video_pbase)
1371 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1372 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1374 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1375 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1376 pixfmt = (data[0] >> 3) & 0xf;
1378 fb->fmt.pixelformat = pixel_format[pixfmt];
1379 fb->fmt.width = itv->osd_rect.width;
1380 fb->fmt.height = itv->osd_rect.height;
1381 fb->fmt.field = V4L2_FIELD_INTERLACED;
1382 fb->fmt.bytesperline = fb->fmt.width;
1383 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1384 fb->fmt.field = V4L2_FIELD_INTERLACED;
1385 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1386 fb->fmt.bytesperline *= 2;
1387 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1388 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1389 fb->fmt.bytesperline *= 2;
1390 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1391 fb->base = (void *)itv->osd_video_pbase;
1394 if (itv->osd_chroma_key_state)
1395 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1397 if (itv->osd_global_alpha_state)
1398 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1401 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1405 /* no local alpha for RGB565 or unknown formats */
1406 if (pixfmt == 1 || pixfmt > 4)
1409 /* 16-bit formats have inverted local alpha */
1410 if (pixfmt == 2 || pixfmt == 3)
1411 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1413 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1415 if (itv->osd_local_alpha_state) {
1416 /* 16-bit formats have inverted local alpha */
1417 if (pixfmt == 2 || pixfmt == 3)
1418 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1420 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1426 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1428 struct ivtv_open_id *id = fh2id(fh);
1429 struct ivtv *itv = id->itv;
1430 struct yuv_playback_info *yi = &itv->yuv_info;
1432 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1434 if (!itv->osd_video_pbase)
1437 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1438 itv->osd_local_alpha_state =
1439 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1440 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1441 ivtv_set_osd_alpha(itv);
1442 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1446 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1448 struct ivtv_open_id *id = fh2id(fh);
1449 struct ivtv *itv = id->itv;
1451 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1454 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1459 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1461 switch (sub->type) {
1462 case V4L2_EVENT_VSYNC:
1463 case V4L2_EVENT_EOS:
1464 return v4l2_event_subscribe(fh, sub, 0, NULL);
1465 case V4L2_EVENT_CTRL:
1466 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
1472 static int ivtv_log_status(struct file *file, void *fh)
1474 struct ivtv *itv = fh2id(fh)->itv;
1475 u32 data[CX2341X_MBOX_MAX_DATA];
1477 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1478 struct v4l2_input vidin;
1479 struct v4l2_audio audin;
1482 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1483 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1486 ivtv_read_eeprom(itv, &tv);
1488 ivtv_call_all(itv, core, log_status);
1489 ivtv_get_input(itv, itv->active_input, &vidin);
1490 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1491 IVTV_INFO("Video Input: %s\n", vidin.name);
1492 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1493 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1495 struct v4l2_output vidout;
1496 struct v4l2_audioout audout;
1497 int mode = itv->output_mode;
1498 static const char * const output_modes[5] = {
1505 static const char * const alpha_mode[4] = {
1511 static const char * const pixel_format[16] = {
1530 ivtv_get_output(itv, itv->active_output, &vidout);
1531 ivtv_get_audio_output(itv, 0, &audout);
1532 IVTV_INFO("Video Output: %s\n", vidout.name);
1533 if (mode < 0 || mode > OUT_PASSTHROUGH)
1535 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1536 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1537 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1538 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1539 data[0] & 1 ? "On" : "Off",
1540 alpha_mode[(data[0] >> 1) & 0x3],
1541 pixel_format[(data[0] >> 3) & 0xf]);
1543 IVTV_INFO("Tuner: %s\n",
1544 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1545 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1546 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1547 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1548 struct ivtv_stream *s = &itv->streams[i];
1550 if (s->vdev.v4l2_dev == NULL || s->buffers == 0)
1552 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1553 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1554 (s->buffers * s->buf_size) / 1024, s->buffers);
1557 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1558 (long long)itv->mpg_data_received,
1559 (long long)itv->vbi_data_inserted);
1563 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1565 struct ivtv_open_id *id = fh2id(file->private_data);
1566 struct ivtv *itv = id->itv;
1568 IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1569 return ivtv_video_command(itv, id, dec, false);
1572 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1574 struct ivtv_open_id *id = fh2id(file->private_data);
1575 struct ivtv *itv = id->itv;
1577 IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1578 return ivtv_video_command(itv, id, dec, true);
1581 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1583 struct ivtv_open_id *id = fh2id(filp->private_data);
1584 struct ivtv *itv = id->itv;
1585 int nonblocking = filp->f_flags & O_NONBLOCK;
1586 struct ivtv_stream *s = &itv->streams[id->type];
1587 unsigned long iarg = (unsigned long)arg;
1590 case IVTV_IOC_DMA_FRAME: {
1591 struct ivtv_dma_frame *args = arg;
1593 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1594 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1596 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1598 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1600 if (ivtv_start_decoding(id, id->type)) {
1603 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1604 ivtv_release_stream(s);
1607 /* Mark that this file handle started the UDMA_YUV mode */
1609 if (args->y_source == NULL)
1611 return ivtv_yuv_prep_frame(itv, args);
1614 case IVTV_IOC_PASSTHROUGH_MODE:
1615 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1616 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1618 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1620 case VIDEO_GET_PTS: {
1624 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1625 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1629 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1631 return ivtv_g_pts_frame(itv, pts, &frame);
1634 case VIDEO_GET_FRAME_COUNT: {
1638 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1639 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1643 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1645 return ivtv_g_pts_frame(itv, &pts, frame);
1649 struct v4l2_decoder_cmd dc;
1651 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1652 memset(&dc, 0, sizeof(dc));
1653 dc.cmd = V4L2_DEC_CMD_START;
1654 return ivtv_video_command(itv, id, &dc, 0);
1658 struct v4l2_decoder_cmd dc;
1660 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1661 memset(&dc, 0, sizeof(dc));
1662 dc.cmd = V4L2_DEC_CMD_STOP;
1663 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1664 return ivtv_video_command(itv, id, &dc, 0);
1667 case VIDEO_FREEZE: {
1668 struct v4l2_decoder_cmd dc;
1670 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1671 memset(&dc, 0, sizeof(dc));
1672 dc.cmd = V4L2_DEC_CMD_PAUSE;
1673 return ivtv_video_command(itv, id, &dc, 0);
1676 case VIDEO_CONTINUE: {
1677 struct v4l2_decoder_cmd dc;
1679 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1680 memset(&dc, 0, sizeof(dc));
1681 dc.cmd = V4L2_DEC_CMD_RESUME;
1682 return ivtv_video_command(itv, id, &dc, 0);
1686 case VIDEO_TRY_COMMAND: {
1687 /* Note: struct v4l2_decoder_cmd has the same layout as
1688 struct video_command */
1689 struct v4l2_decoder_cmd *dc = arg;
1690 int try = (cmd == VIDEO_TRY_COMMAND);
1693 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd);
1695 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd);
1696 return ivtv_video_command(itv, id, dc, try);
1699 case VIDEO_GET_EVENT: {
1700 struct video_event *ev = arg;
1703 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1704 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1706 memset(ev, 0, sizeof(*ev));
1707 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1710 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1711 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1712 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1713 ev->type = VIDEO_EVENT_VSYNC;
1714 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1715 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1716 if (itv->output_mode == OUT_UDMA_YUV &&
1717 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1718 IVTV_YUV_MODE_PROGRESSIVE) {
1719 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1726 /* Wait for event. Note that serialize_lock is locked,
1727 so to allow other processes to access the driver while
1728 we are waiting unlock first and later lock again. */
1729 mutex_unlock(&itv->serialize_lock);
1730 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1731 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1732 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1734 finish_wait(&itv->event_waitq, &wait);
1735 mutex_lock(&itv->serialize_lock);
1736 if (signal_pending(current)) {
1737 /* return if a signal was received */
1738 IVTV_DEBUG_INFO("User stopped wait for event\n");
1745 case VIDEO_SELECT_SOURCE:
1746 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1747 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1749 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1751 case AUDIO_SET_MUTE:
1752 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1753 itv->speed_mute_audio = iarg;
1756 case AUDIO_CHANNEL_SELECT:
1757 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1758 if (iarg > AUDIO_STEREO_SWAPPED)
1760 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1762 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1763 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1764 if (iarg > AUDIO_STEREO_SWAPPED)
1766 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1774 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1775 unsigned int cmd, void *arg)
1777 struct ivtv *itv = fh2id(fh)->itv;
1781 case IVTV_IOC_PASSTHROUGH_MODE:
1785 case VIDEO_CONTINUE:
1787 case VIDEO_SELECT_SOURCE:
1788 case AUDIO_SET_MUTE:
1789 case AUDIO_CHANNEL_SELECT:
1790 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1796 case VIDIOC_INT_RESET: {
1797 u32 val = *(u32 *)arg;
1799 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1800 ivtv_reset_ir_gpio(itv);
1802 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1806 case IVTV_IOC_DMA_FRAME:
1807 case IVTV_IOC_PASSTHROUGH_MODE:
1809 case VIDEO_GET_FRAME_COUNT:
1810 case VIDEO_GET_EVENT:
1814 case VIDEO_CONTINUE:
1816 case VIDEO_TRY_COMMAND:
1817 case VIDEO_SELECT_SOURCE:
1818 case AUDIO_SET_MUTE:
1819 case AUDIO_CHANNEL_SELECT:
1820 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1821 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1829 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1830 .vidioc_querycap = ivtv_querycap,
1831 .vidioc_s_audio = ivtv_s_audio,
1832 .vidioc_g_audio = ivtv_g_audio,
1833 .vidioc_enumaudio = ivtv_enumaudio,
1834 .vidioc_s_audout = ivtv_s_audout,
1835 .vidioc_g_audout = ivtv_g_audout,
1836 .vidioc_enum_input = ivtv_enum_input,
1837 .vidioc_enum_output = ivtv_enum_output,
1838 .vidioc_enumaudout = ivtv_enumaudout,
1839 .vidioc_cropcap = ivtv_cropcap,
1840 .vidioc_s_crop = ivtv_s_crop,
1841 .vidioc_g_crop = ivtv_g_crop,
1842 .vidioc_g_input = ivtv_g_input,
1843 .vidioc_s_input = ivtv_s_input,
1844 .vidioc_g_output = ivtv_g_output,
1845 .vidioc_s_output = ivtv_s_output,
1846 .vidioc_g_frequency = ivtv_g_frequency,
1847 .vidioc_s_frequency = ivtv_s_frequency,
1848 .vidioc_s_tuner = ivtv_s_tuner,
1849 .vidioc_g_tuner = ivtv_g_tuner,
1850 .vidioc_g_enc_index = ivtv_g_enc_index,
1851 .vidioc_g_fbuf = ivtv_g_fbuf,
1852 .vidioc_s_fbuf = ivtv_s_fbuf,
1853 .vidioc_g_std = ivtv_g_std,
1854 .vidioc_s_std = ivtv_s_std,
1855 .vidioc_overlay = ivtv_overlay,
1856 .vidioc_log_status = ivtv_log_status,
1857 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1858 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1859 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1860 .vidioc_decoder_cmd = ivtv_decoder_cmd,
1861 .vidioc_try_decoder_cmd = ivtv_try_decoder_cmd,
1862 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1863 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1864 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1865 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1866 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1867 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1868 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1869 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1870 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1871 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1872 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1873 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1874 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1875 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1876 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1877 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1878 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1879 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1880 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1881 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1882 #ifdef CONFIG_VIDEO_ADV_DEBUG
1883 .vidioc_g_register = ivtv_g_register,
1884 .vidioc_s_register = ivtv_s_register,
1886 .vidioc_default = ivtv_default,
1887 .vidioc_subscribe_event = ivtv_subscribe_event,
1888 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1891 void ivtv_set_funcs(struct video_device *vdev)
1893 vdev->ioctl_ops = &ivtv_ioctl_ops;