3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "ivtv-driver.h"
22 #include "ivtv-version.h"
23 #include "ivtv-mailbox.h"
25 #include "ivtv-queue.h"
26 #include "ivtv-fileops.h"
28 #include "ivtv-routing.h"
29 #include "ivtv-streams.h"
31 #include "ivtv-ioctl.h"
32 #include "ivtv-gpio.h"
33 #include "ivtv-controls.h"
34 #include "ivtv-cards.h"
35 #include <media/saa7127.h>
36 #include <media/tveeprom.h>
37 #include <media/v4l2-chip-ident.h>
38 #include <media/v4l2-event.h>
39 #include <linux/dvb/audio.h>
41 u16 ivtv_service2vbi(int type)
44 case V4L2_SLICED_TELETEXT_B:
45 return IVTV_SLICED_TYPE_TELETEXT_B;
46 case V4L2_SLICED_CAPTION_525:
47 return IVTV_SLICED_TYPE_CAPTION_525;
48 case V4L2_SLICED_WSS_625:
49 return IVTV_SLICED_TYPE_WSS_625;
51 return IVTV_SLICED_TYPE_VPS;
57 static int valid_service_line(int field, int line, int is_pal)
59 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
60 (!is_pal && line >= 10 && line < 22);
63 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
65 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
68 set = set & valid_set;
69 if (set == 0 || !valid_service_line(field, line, is_pal)) {
73 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
74 return V4L2_SLICED_CAPTION_525;
77 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
78 return V4L2_SLICED_VPS;
79 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
80 return V4L2_SLICED_WSS_625;
84 for (i = 0; i < 32; i++) {
91 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
93 u16 set = fmt->service_set;
97 for (f = 0; f < 2; f++) {
98 for (l = 0; l < 24; l++) {
99 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
104 static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
108 for (f = 0; f < 2; f++) {
109 for (l = 0; l < 24; l++) {
110 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
115 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
120 for (f = 0; f < 2; f++) {
121 for (l = 0; l < 24; l++) {
122 set |= fmt->service_lines[f][l];
128 void ivtv_set_osd_alpha(struct ivtv *itv)
130 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
131 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
132 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
135 int ivtv_set_speed(struct ivtv *itv, int speed)
137 u32 data[CX2341X_MBOX_MAX_DATA];
138 struct ivtv_stream *s;
139 int single_step = (speed == 1 || speed == -1);
142 if (speed == 0) speed = 1000;
145 if (speed == itv->speed && !single_step)
148 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
150 if (single_step && (speed < 0) == (itv->speed < 0)) {
151 /* Single step video and no need to change direction */
152 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
157 /* Need to change direction */
158 speed = speed < 0 ? -1000 : 1000;
160 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
161 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
162 data[1] = (speed < 0);
163 data[2] = speed < 0 ? 3 : 7;
164 data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
165 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
169 if (speed == 1500 || speed == -1500) data[0] |= 1;
170 else if (speed == 2000 || speed == -2000) data[0] |= 2;
171 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
172 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
174 /* If not decoding, just change speed setting */
175 if (atomic_read(&itv->decoding) > 0) {
178 /* Stop all DMA and decoding activity */
179 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
181 /* Wait for any DMA to finish */
182 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
183 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
184 got_sig = signal_pending(current);
190 finish_wait(&itv->dma_waitq, &wait);
194 /* Change Speed safely */
195 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
196 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
197 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
200 speed = (speed < 0) ? -1 : 1;
201 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
207 static int ivtv_validate_speed(int cur_speed, int new_speed)
209 int fact = new_speed < 0 ? -1 : 1;
215 new_speed = -new_speed;
217 cur_speed = -cur_speed;
219 if (cur_speed <= new_speed) {
220 if (new_speed > 1500)
222 if (new_speed > 1000)
226 if (new_speed >= 2000)
228 if (new_speed >= 1500)
230 if (new_speed >= 1000)
235 if (new_speed == 1 || new_speed == 1000)
236 return fact * new_speed;
239 new_speed = 1000 / new_speed;
240 if (1000 / cur_speed == new_speed)
241 new_speed += (cur_speed < s) ? -1 : 1;
242 if (new_speed > 60) return 1000 / (fact * 60);
243 return 1000 / (fact * new_speed);
246 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
247 struct video_command *vc, int try)
249 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
251 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
255 case VIDEO_CMD_PLAY: {
257 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
258 if (vc->play.speed < 0)
259 vc->play.format = VIDEO_PLAY_FMT_GOP;
262 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
264 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
265 /* forces ivtv_set_speed to be called */
268 return ivtv_start_decoding(id, vc->play.speed);
272 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
273 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
276 if (atomic_read(&itv->decoding) == 0)
278 if (itv->output_mode != OUT_MPG)
281 itv->output_mode = OUT_NONE;
282 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
284 case VIDEO_CMD_FREEZE:
285 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
287 if (itv->output_mode != OUT_MPG)
289 if (atomic_read(&itv->decoding) > 0) {
290 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
291 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
292 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
296 case VIDEO_CMD_CONTINUE:
299 if (itv->output_mode != OUT_MPG)
301 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
302 int speed = itv->speed;
304 return ivtv_start_decoding(id, speed);
314 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
316 struct ivtv *itv = fh2id(fh)->itv;
317 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
319 vbifmt->reserved[0] = 0;
320 vbifmt->reserved[1] = 0;
321 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
323 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
325 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
326 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
328 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
329 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
331 vbifmt->service_set = ivtv_get_service_set(vbifmt);
335 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
337 struct ivtv_open_id *id = fh2id(fh);
338 struct ivtv *itv = id->itv;
339 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
341 pixfmt->width = itv->cxhdl.width;
342 pixfmt->height = itv->cxhdl.height;
343 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
344 pixfmt->field = V4L2_FIELD_INTERLACED;
346 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
347 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
348 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
349 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
350 pixfmt->bytesperline = 720;
352 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
353 pixfmt->sizeimage = 128 * 1024;
354 pixfmt->bytesperline = 0;
359 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
361 struct ivtv *itv = fh2id(fh)->itv;
362 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
364 vbifmt->sampling_rate = 27000000;
365 vbifmt->offset = 248;
366 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
367 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
368 vbifmt->start[0] = itv->vbi.start[0];
369 vbifmt->start[1] = itv->vbi.start[1];
370 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
372 vbifmt->reserved[0] = 0;
373 vbifmt->reserved[1] = 0;
377 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
379 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
380 struct ivtv_open_id *id = fh2id(fh);
381 struct ivtv *itv = id->itv;
383 vbifmt->reserved[0] = 0;
384 vbifmt->reserved[1] = 0;
385 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
387 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
388 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
390 ivtv_expand_service_set(vbifmt, itv->is_50hz);
394 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
395 vbifmt->service_set = ivtv_get_service_set(vbifmt);
399 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
401 struct ivtv_open_id *id = fh2id(fh);
402 struct ivtv *itv = id->itv;
403 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
405 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
407 pixfmt->width = itv->main_rect.width;
408 pixfmt->height = itv->main_rect.height;
409 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
410 pixfmt->field = V4L2_FIELD_INTERLACED;
412 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
413 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
414 case IVTV_YUV_MODE_INTERLACED:
415 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
416 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
418 case IVTV_YUV_MODE_PROGRESSIVE:
419 pixfmt->field = V4L2_FIELD_NONE;
422 pixfmt->field = V4L2_FIELD_ANY;
425 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
426 pixfmt->bytesperline = 720;
427 pixfmt->width = itv->yuv_info.v4l2_src_w;
428 pixfmt->height = itv->yuv_info.v4l2_src_h;
429 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
431 1080 * ((pixfmt->height + 31) & ~31);
433 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
434 pixfmt->sizeimage = 128 * 1024;
435 pixfmt->bytesperline = 0;
440 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
442 struct ivtv *itv = fh2id(fh)->itv;
443 struct v4l2_window *winfmt = &fmt->fmt.win;
445 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
447 winfmt->chromakey = itv->osd_chroma_key;
448 winfmt->global_alpha = itv->osd_global_alpha;
449 winfmt->field = V4L2_FIELD_INTERLACED;
450 winfmt->clips = NULL;
451 winfmt->clipcount = 0;
452 winfmt->bitmap = NULL;
453 winfmt->w.top = winfmt->w.left = 0;
454 winfmt->w.width = itv->osd_rect.width;
455 winfmt->w.height = itv->osd_rect.height;
459 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
461 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
464 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
466 struct ivtv_open_id *id = fh2id(fh);
467 struct ivtv *itv = id->itv;
468 int w = fmt->fmt.pix.width;
469 int h = fmt->fmt.pix.height;
474 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
475 /* YUV height must be a multiple of 32 */
479 h = min(h, itv->is_50hz ? 576 : 480);
481 ivtv_g_fmt_vid_cap(file, fh, fmt);
482 fmt->fmt.pix.width = w;
483 fmt->fmt.pix.height = h;
487 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
489 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
492 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
494 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
495 struct ivtv_open_id *id = fh2id(fh);
496 struct ivtv *itv = id->itv;
498 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
499 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
501 /* set sliced VBI capture format */
502 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
503 vbifmt->reserved[0] = 0;
504 vbifmt->reserved[1] = 0;
506 if (vbifmt->service_set)
507 ivtv_expand_service_set(vbifmt, itv->is_50hz);
508 check_service_set(vbifmt, itv->is_50hz);
509 vbifmt->service_set = ivtv_get_service_set(vbifmt);
513 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
515 struct ivtv_open_id *id = fh2id(fh);
516 s32 w = fmt->fmt.pix.width;
517 s32 h = fmt->fmt.pix.height;
518 int field = fmt->fmt.pix.field;
519 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
523 /* Why can the height be 576 even when the output is NTSC?
525 Internally the buffers of the PVR350 are always set to 720x576. The
526 decoded video frame will always be placed in the top left corner of
527 this buffer. For any video which is not 720x576, the buffer will
528 then be cropped to remove the unused right and lower areas, with
529 the remaining image being scaled by the hardware to fit the display
530 area. The video can be scaled both up and down, so a 720x480 video
531 can be displayed full-screen on PAL and a 720x576 video can be
532 displayed without cropping on NTSC.
534 Note that the scaling only occurs on the video stream, the osd
535 resolution is locked to the broadcast standard and not scaled.
537 Thanks to Ian Armstrong for this explanation. */
540 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
541 fmt->fmt.pix.field = field;
542 fmt->fmt.pix.width = w;
543 fmt->fmt.pix.height = h;
547 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
549 struct ivtv *itv = fh2id(fh)->itv;
550 u32 chromakey = fmt->fmt.win.chromakey;
551 u8 global_alpha = fmt->fmt.win.global_alpha;
553 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
555 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
556 fmt->fmt.win.chromakey = chromakey;
557 fmt->fmt.win.global_alpha = global_alpha;
561 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
563 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
566 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
568 struct ivtv_open_id *id = fh2id(fh);
569 struct ivtv *itv = id->itv;
570 struct v4l2_mbus_framefmt mbus_fmt;
571 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
572 int w = fmt->fmt.pix.width;
573 int h = fmt->fmt.pix.height;
578 if (itv->cxhdl.width == w && itv->cxhdl.height == h)
581 if (atomic_read(&itv->capturing) > 0)
584 itv->cxhdl.width = w;
585 itv->cxhdl.height = h;
586 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
587 fmt->fmt.pix.width /= 2;
588 mbus_fmt.width = fmt->fmt.pix.width;
590 mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
591 v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
592 return ivtv_g_fmt_vid_cap(file, fh, fmt);
595 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
597 struct ivtv *itv = fh2id(fh)->itv;
599 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
601 itv->vbi.sliced_in->service_set = 0;
602 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
603 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
604 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
607 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
609 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
610 struct ivtv_open_id *id = fh2id(fh);
611 struct ivtv *itv = id->itv;
612 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
614 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
617 check_service_set(vbifmt, itv->is_50hz);
618 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
620 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
621 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
622 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
626 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
628 struct ivtv_open_id *id = fh2id(fh);
629 struct ivtv *itv = id->itv;
630 struct yuv_playback_info *yi = &itv->yuv_info;
631 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
636 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
639 /* Return now if we already have some frame data */
643 yi->v4l2_src_w = fmt->fmt.pix.width;
644 yi->v4l2_src_h = fmt->fmt.pix.height;
646 switch (fmt->fmt.pix.field) {
647 case V4L2_FIELD_NONE:
648 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
651 yi->lace_mode = IVTV_YUV_MODE_AUTO;
653 case V4L2_FIELD_INTERLACED_BT:
655 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
657 case V4L2_FIELD_INTERLACED_TB:
659 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
662 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
664 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
665 itv->dma_data_req_size =
666 1080 * ((yi->v4l2_src_h + 31) & ~31);
671 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
673 struct ivtv *itv = fh2id(fh)->itv;
674 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
677 itv->osd_chroma_key = fmt->fmt.win.chromakey;
678 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
679 ivtv_set_osd_alpha(itv);
684 static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip)
686 struct ivtv *itv = fh2id(fh)->itv;
688 chip->ident = V4L2_IDENT_NONE;
690 if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
691 if (v4l2_chip_match_host(&chip->match))
692 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
695 if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
696 chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
698 /* TODO: is this correct? */
699 return ivtv_call_all_err(itv, core, g_chip_ident, chip);
702 #ifdef CONFIG_VIDEO_ADV_DEBUG
703 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
705 struct v4l2_dbg_register *regs = arg;
706 volatile u8 __iomem *reg_start;
708 if (!capable(CAP_SYS_ADMIN))
710 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
711 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
712 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
713 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
714 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
715 else if (regs->reg < IVTV_ENCODER_SIZE)
716 reg_start = itv->enc_mem;
721 if (cmd == VIDIOC_DBG_G_REGISTER)
722 regs->val = readl(regs->reg + reg_start);
724 writel(regs->val, regs->reg + reg_start);
728 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
730 struct ivtv *itv = fh2id(fh)->itv;
732 if (v4l2_chip_match_host(®->match))
733 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
734 /* TODO: subdev errors should not be ignored, this should become a
735 subdev helper function. */
736 ivtv_call_all(itv, core, g_register, reg);
740 static int ivtv_s_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
742 struct ivtv *itv = fh2id(fh)->itv;
744 if (v4l2_chip_match_host(®->match))
745 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
746 /* TODO: subdev errors should not be ignored, this should become a
747 subdev helper function. */
748 ivtv_call_all(itv, core, s_register, reg);
753 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
755 struct ivtv *itv = fh2id(fh)->itv;
757 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
758 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
759 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
760 vcap->version = IVTV_DRIVER_VERSION; /* version */
761 vcap->capabilities = itv->v4l2_cap; /* capabilities */
765 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
767 struct ivtv *itv = fh2id(fh)->itv;
769 return ivtv_get_audio_input(itv, vin->index, vin);
772 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
774 struct ivtv *itv = fh2id(fh)->itv;
776 vin->index = itv->audio_input;
777 return ivtv_get_audio_input(itv, vin->index, vin);
780 static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
782 struct ivtv *itv = fh2id(fh)->itv;
784 if (vout->index >= itv->nof_audio_inputs)
787 itv->audio_input = vout->index;
788 ivtv_audio_set_io(itv);
793 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
795 struct ivtv *itv = fh2id(fh)->itv;
797 /* set it to defaults from our table */
798 return ivtv_get_audio_output(itv, vin->index, vin);
801 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
803 struct ivtv *itv = fh2id(fh)->itv;
806 return ivtv_get_audio_output(itv, vin->index, vin);
809 static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
811 struct ivtv *itv = fh2id(fh)->itv;
813 return ivtv_get_audio_output(itv, vout->index, vout);
816 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
818 struct ivtv *itv = fh2id(fh)->itv;
820 /* set it to defaults from our table */
821 return ivtv_get_input(itv, vin->index, vin);
824 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
826 struct ivtv *itv = fh2id(fh)->itv;
828 return ivtv_get_output(itv, vout->index, vout);
831 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
833 struct ivtv_open_id *id = fh2id(fh);
834 struct ivtv *itv = id->itv;
835 struct yuv_playback_info *yi = &itv->yuv_info;
838 streamtype = id->type;
840 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
842 cropcap->bounds.top = cropcap->bounds.left = 0;
843 cropcap->bounds.width = 720;
844 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
845 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
846 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
847 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
848 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
850 cropcap->bounds.width = yi->osd_full_w;
851 cropcap->bounds.height = yi->osd_full_h;
853 cropcap->bounds.width = 720;
854 cropcap->bounds.height =
855 itv->is_out_50hz ? 576 : 480;
857 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
858 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
860 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
861 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
862 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
864 cropcap->defrect = cropcap->bounds;
868 static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
870 struct ivtv_open_id *id = fh2id(fh);
871 struct ivtv *itv = id->itv;
872 struct yuv_playback_info *yi = &itv->yuv_info;
875 streamtype = id->type;
877 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
878 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
879 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
880 yi->main_rect = crop->c;
883 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
884 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
885 itv->main_rect = crop->c;
894 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
896 struct ivtv_open_id *id = fh2id(fh);
897 struct ivtv *itv = id->itv;
898 struct yuv_playback_info *yi = &itv->yuv_info;
901 streamtype = id->type;
903 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
904 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
905 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
906 crop->c = yi->main_rect;
908 crop->c = itv->main_rect;
914 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
916 static struct v4l2_fmtdesc formats[] = {
918 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
921 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
922 "MPEG", V4L2_PIX_FMT_MPEG,
926 enum v4l2_buf_type type = fmt->type;
931 *fmt = formats[fmt->index];
936 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
938 struct ivtv *itv = fh2id(fh)->itv;
940 static struct v4l2_fmtdesc formats[] = {
942 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
945 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
946 "MPEG", V4L2_PIX_FMT_MPEG,
950 enum v4l2_buf_type type = fmt->type;
952 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
958 *fmt = formats[fmt->index];
964 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
966 struct ivtv *itv = fh2id(fh)->itv;
968 *i = itv->active_input;
973 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
975 struct ivtv *itv = fh2id(fh)->itv;
977 if (inp < 0 || inp >= itv->nof_inputs)
980 if (inp == itv->active_input) {
981 IVTV_DEBUG_INFO("Input unchanged\n");
985 if (atomic_read(&itv->capturing) > 0) {
989 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
990 itv->active_input, inp);
992 itv->active_input = inp;
993 /* Set the audio input to whatever is appropriate for the
995 itv->audio_input = itv->card->video_inputs[inp].audio_index;
997 /* prevent others from messing with the streams until
998 we're finished changing inputs. */
1000 ivtv_video_set_io(itv);
1001 ivtv_audio_set_io(itv);
1007 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1009 struct ivtv *itv = fh2id(fh)->itv;
1011 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1014 *i = itv->active_output;
1019 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1021 struct ivtv *itv = fh2id(fh)->itv;
1023 if (outp >= itv->card->nof_outputs)
1026 if (outp == itv->active_output) {
1027 IVTV_DEBUG_INFO("Output unchanged\n");
1030 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1031 itv->active_output, outp);
1033 itv->active_output = outp;
1034 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1035 SAA7127_INPUT_TYPE_NORMAL,
1036 itv->card->video_outputs[outp].video_output, 0);
1041 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1043 struct ivtv *itv = fh2id(fh)->itv;
1048 ivtv_call_all(itv, tuner, g_frequency, vf);
1052 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1054 struct ivtv *itv = fh2id(fh)->itv;
1060 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1061 ivtv_call_all(itv, tuner, s_frequency, vf);
1066 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1068 struct ivtv *itv = fh2id(fh)->itv;
1074 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id *std)
1077 itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1078 itv->is_50hz = !itv->is_60hz;
1079 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1080 itv->cxhdl.width = 720;
1081 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1082 itv->vbi.count = itv->is_50hz ? 18 : 12;
1083 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1084 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1086 if (itv->hw_flags & IVTV_HW_CX25840)
1087 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1090 ivtv_call_all(itv, core, s_std, itv->std);
1093 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
1095 struct yuv_playback_info *yi = &itv->yuv_info;
1099 /* set display standard */
1100 itv->std_out = *std;
1101 itv->is_out_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1102 itv->is_out_50hz = !itv->is_out_60hz;
1103 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1106 * The next firmware call is time sensitive. Time it to
1107 * avoid risk of a hard lock, by trying to ensure the call
1108 * happens within the first 100 lines of the top field.
1109 * Make 4 attempts to sync to the decoder before giving up.
1111 for (f = 0; f < 4; f++) {
1112 prepare_to_wait(&itv->vsync_waitq, &wait,
1113 TASK_UNINTERRUPTIBLE);
1114 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1116 schedule_timeout(msecs_to_jiffies(25));
1118 finish_wait(&itv->vsync_waitq, &wait);
1121 IVTV_WARN("Mode change failed to sync to decoder\n");
1123 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1124 itv->main_rect.left = 0;
1125 itv->main_rect.top = 0;
1126 itv->main_rect.width = 720;
1127 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1128 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1129 720, itv->main_rect.height, 0, 0);
1130 yi->main_rect = itv->main_rect;
1131 if (!itv->osd_info) {
1132 yi->osd_full_w = 720;
1133 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1137 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1139 struct ivtv *itv = fh2id(fh)->itv;
1141 if ((*std & V4L2_STD_ALL) == 0)
1144 if (*std == itv->std)
1147 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1148 atomic_read(&itv->capturing) > 0 ||
1149 atomic_read(&itv->decoding) > 0) {
1150 /* Switching standard would mess with already running
1151 streams, prevent that by returning EBUSY. */
1155 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1156 (unsigned long long)itv->std);
1158 ivtv_s_std_enc(itv, std);
1159 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1160 ivtv_s_std_dec(itv, std);
1165 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1167 struct ivtv_open_id *id = fh2id(fh);
1168 struct ivtv *itv = id->itv;
1173 ivtv_call_all(itv, tuner, s_tuner, vt);
1178 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1180 struct ivtv *itv = fh2id(fh)->itv;
1185 ivtv_call_all(itv, tuner, g_tuner, vt);
1187 if (vt->type == V4L2_TUNER_RADIO)
1188 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1190 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1194 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1196 struct ivtv *itv = fh2id(fh)->itv;
1197 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1200 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1201 for (f = 0; f < 2; f++) {
1202 for (l = 0; l < 24; l++) {
1203 if (valid_service_line(f, l, itv->is_50hz))
1204 cap->service_lines[f][l] = set;
1209 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1210 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1213 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1214 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1216 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1217 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1224 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1226 struct ivtv *itv = fh2id(fh)->itv;
1227 struct v4l2_enc_idx_entry *e = idx->entry;
1231 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1233 if (entries > V4L2_ENC_IDX_ENTRIES)
1234 entries = V4L2_ENC_IDX_ENTRIES;
1236 for (i = 0; i < entries; i++) {
1237 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1238 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1243 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1247 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1249 struct ivtv_open_id *id = fh2id(fh);
1250 struct ivtv *itv = id->itv;
1254 case V4L2_ENC_CMD_START:
1255 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1257 return ivtv_start_capture(id);
1259 case V4L2_ENC_CMD_STOP:
1260 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1261 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1262 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1265 case V4L2_ENC_CMD_PAUSE:
1266 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1269 if (!atomic_read(&itv->capturing))
1271 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1275 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1278 case V4L2_ENC_CMD_RESUME:
1279 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1282 if (!atomic_read(&itv->capturing))
1285 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1288 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1292 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1299 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1301 struct ivtv *itv = fh2id(fh)->itv;
1304 case V4L2_ENC_CMD_START:
1305 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1309 case V4L2_ENC_CMD_STOP:
1310 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1311 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1314 case V4L2_ENC_CMD_PAUSE:
1315 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1319 case V4L2_ENC_CMD_RESUME:
1320 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1324 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1329 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1331 struct ivtv *itv = fh2id(fh)->itv;
1332 u32 data[CX2341X_MBOX_MAX_DATA];
1333 struct yuv_playback_info *yi = &itv->yuv_info;
1336 static u32 pixel_format[16] = {
1337 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1338 V4L2_PIX_FMT_RGB565,
1339 V4L2_PIX_FMT_RGB555,
1340 V4L2_PIX_FMT_RGB444,
1345 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1346 V4L2_PIX_FMT_YUV565,
1347 V4L2_PIX_FMT_YUV555,
1348 V4L2_PIX_FMT_YUV444,
1355 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1357 if (!itv->osd_video_pbase)
1360 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1361 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1363 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1364 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1365 pixfmt = (data[0] >> 3) & 0xf;
1367 fb->fmt.pixelformat = pixel_format[pixfmt];
1368 fb->fmt.width = itv->osd_rect.width;
1369 fb->fmt.height = itv->osd_rect.height;
1370 fb->fmt.field = V4L2_FIELD_INTERLACED;
1371 fb->fmt.bytesperline = fb->fmt.width;
1372 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1373 fb->fmt.field = V4L2_FIELD_INTERLACED;
1375 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1376 fb->fmt.bytesperline *= 2;
1377 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1378 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1379 fb->fmt.bytesperline *= 2;
1380 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1381 fb->base = (void *)itv->osd_video_pbase;
1384 if (itv->osd_chroma_key_state)
1385 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1387 if (itv->osd_global_alpha_state)
1388 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1391 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1395 /* no local alpha for RGB565 or unknown formats */
1396 if (pixfmt == 1 || pixfmt > 4)
1399 /* 16-bit formats have inverted local alpha */
1400 if (pixfmt == 2 || pixfmt == 3)
1401 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1403 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1405 if (itv->osd_local_alpha_state) {
1406 /* 16-bit formats have inverted local alpha */
1407 if (pixfmt == 2 || pixfmt == 3)
1408 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1410 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1416 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1418 struct ivtv_open_id *id = fh2id(fh);
1419 struct ivtv *itv = id->itv;
1420 struct yuv_playback_info *yi = &itv->yuv_info;
1422 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1424 if (!itv->osd_video_pbase)
1427 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1428 itv->osd_local_alpha_state =
1429 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1430 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1431 ivtv_set_osd_alpha(itv);
1432 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1433 return ivtv_g_fbuf(file, fh, fb);
1436 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1438 struct ivtv_open_id *id = fh2id(fh);
1439 struct ivtv *itv = id->itv;
1441 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1444 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1449 static int ivtv_subscribe_event(struct v4l2_fh *fh, struct v4l2_event_subscription *sub)
1451 switch (sub->type) {
1452 case V4L2_EVENT_VSYNC:
1453 case V4L2_EVENT_EOS:
1458 return v4l2_event_subscribe(fh, sub);
1461 static int ivtv_log_status(struct file *file, void *fh)
1463 struct ivtv *itv = fh2id(fh)->itv;
1464 u32 data[CX2341X_MBOX_MAX_DATA];
1466 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1467 struct v4l2_input vidin;
1468 struct v4l2_audio audin;
1471 IVTV_INFO("================= START STATUS CARD #%d =================\n",
1473 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1474 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1477 ivtv_read_eeprom(itv, &tv);
1479 ivtv_call_all(itv, core, log_status);
1480 ivtv_get_input(itv, itv->active_input, &vidin);
1481 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1482 IVTV_INFO("Video Input: %s\n", vidin.name);
1483 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1484 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1486 struct v4l2_output vidout;
1487 struct v4l2_audioout audout;
1488 int mode = itv->output_mode;
1489 static const char * const output_modes[5] = {
1496 static const char * const audio_modes[5] = {
1503 static const char * const alpha_mode[4] = {
1509 static const char * const pixel_format[16] = {
1528 ivtv_get_output(itv, itv->active_output, &vidout);
1529 ivtv_get_audio_output(itv, 0, &audout);
1530 IVTV_INFO("Video Output: %s\n", vidout.name);
1531 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1532 audio_modes[itv->audio_stereo_mode],
1533 audio_modes[itv->audio_bilingual_mode]);
1534 if (mode < 0 || mode > OUT_PASSTHROUGH)
1536 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1537 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1538 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1539 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1540 data[0] & 1 ? "On" : "Off",
1541 alpha_mode[(data[0] >> 1) & 0x3],
1542 pixel_format[(data[0] >> 3) & 0xf]);
1544 IVTV_INFO("Tuner: %s\n",
1545 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1546 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1547 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1548 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1549 struct ivtv_stream *s = &itv->streams[i];
1551 if (s->vdev == NULL || s->buffers == 0)
1553 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1554 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1555 (s->buffers * s->buf_size) / 1024, s->buffers);
1558 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1559 (long long)itv->mpg_data_received,
1560 (long long)itv->vbi_data_inserted);
1561 IVTV_INFO("================== END STATUS CARD #%d ==================\n",
1567 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1569 struct ivtv_open_id *id = fh2id(filp->private_data);
1570 struct ivtv *itv = id->itv;
1571 int nonblocking = filp->f_flags & O_NONBLOCK;
1572 struct ivtv_stream *s = &itv->streams[id->type];
1573 unsigned long iarg = (unsigned long)arg;
1576 case IVTV_IOC_DMA_FRAME: {
1577 struct ivtv_dma_frame *args = arg;
1579 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1580 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1582 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1584 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1586 if (ivtv_start_decoding(id, id->type)) {
1589 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1590 ivtv_release_stream(s);
1593 /* Mark that this file handle started the UDMA_YUV mode */
1595 if (args->y_source == NULL)
1597 return ivtv_yuv_prep_frame(itv, args);
1600 case VIDEO_GET_PTS: {
1601 u32 data[CX2341X_MBOX_MAX_DATA];
1604 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1605 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1609 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1612 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1613 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1614 (u64)itv->last_dec_timing[1];
1618 if (atomic_read(&itv->decoding)) {
1619 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1620 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1623 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1624 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1625 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1626 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1631 case VIDEO_GET_FRAME_COUNT: {
1632 u32 data[CX2341X_MBOX_MAX_DATA];
1635 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1636 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1640 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1643 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1644 *frame = itv->last_dec_timing[0];
1648 if (atomic_read(&itv->decoding)) {
1649 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1650 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1653 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1654 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1661 struct video_command vc;
1663 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1664 memset(&vc, 0, sizeof(vc));
1665 vc.cmd = VIDEO_CMD_PLAY;
1666 return ivtv_video_command(itv, id, &vc, 0);
1670 struct video_command vc;
1672 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1673 memset(&vc, 0, sizeof(vc));
1674 vc.cmd = VIDEO_CMD_STOP;
1675 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1676 return ivtv_video_command(itv, id, &vc, 0);
1679 case VIDEO_FREEZE: {
1680 struct video_command vc;
1682 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1683 memset(&vc, 0, sizeof(vc));
1684 vc.cmd = VIDEO_CMD_FREEZE;
1685 return ivtv_video_command(itv, id, &vc, 0);
1688 case VIDEO_CONTINUE: {
1689 struct video_command vc;
1691 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1692 memset(&vc, 0, sizeof(vc));
1693 vc.cmd = VIDEO_CMD_CONTINUE;
1694 return ivtv_video_command(itv, id, &vc, 0);
1698 case VIDEO_TRY_COMMAND: {
1699 struct video_command *vc = arg;
1700 int try = (cmd == VIDEO_TRY_COMMAND);
1703 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1705 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1706 return ivtv_video_command(itv, id, vc, try);
1709 case VIDEO_GET_EVENT: {
1710 struct video_event *ev = arg;
1713 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1714 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1716 memset(ev, 0, sizeof(*ev));
1717 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1720 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1721 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1722 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1723 ev->type = VIDEO_EVENT_VSYNC;
1724 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1725 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1726 if (itv->output_mode == OUT_UDMA_YUV &&
1727 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1728 IVTV_YUV_MODE_PROGRESSIVE) {
1729 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1736 /* Wait for event. Note that serialize_lock is locked,
1737 so to allow other processes to access the driver while
1738 we are waiting unlock first and later lock again. */
1739 mutex_unlock(&itv->serialize_lock);
1740 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1741 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1742 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1744 finish_wait(&itv->event_waitq, &wait);
1745 mutex_lock(&itv->serialize_lock);
1746 if (signal_pending(current)) {
1747 /* return if a signal was received */
1748 IVTV_DEBUG_INFO("User stopped wait for event\n");
1755 case VIDEO_SELECT_SOURCE:
1756 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1757 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1759 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1761 case AUDIO_SET_MUTE:
1762 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1763 itv->speed_mute_audio = iarg;
1766 case AUDIO_CHANNEL_SELECT:
1767 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1768 if (iarg > AUDIO_STEREO_SWAPPED)
1770 itv->audio_stereo_mode = iarg;
1771 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1774 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1775 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1776 if (iarg > AUDIO_STEREO_SWAPPED)
1778 itv->audio_bilingual_mode = iarg;
1779 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1788 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1791 struct ivtv *itv = fh2id(fh)->itv;
1798 case VIDEO_CONTINUE:
1800 case VIDEO_SELECT_SOURCE:
1801 case AUDIO_SET_MUTE:
1802 case AUDIO_CHANNEL_SELECT:
1803 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1809 case VIDIOC_INT_RESET: {
1810 u32 val = *(u32 *)arg;
1812 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1813 ivtv_reset_ir_gpio(itv);
1815 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1819 case IVTV_IOC_DMA_FRAME:
1821 case VIDEO_GET_FRAME_COUNT:
1822 case VIDEO_GET_EVENT:
1826 case VIDEO_CONTINUE:
1828 case VIDEO_TRY_COMMAND:
1829 case VIDEO_SELECT_SOURCE:
1830 case AUDIO_SET_MUTE:
1831 case AUDIO_CHANNEL_SELECT:
1832 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1833 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1841 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1842 unsigned int cmd, unsigned long arg)
1844 struct video_device *vfd = video_devdata(filp);
1847 if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1848 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1849 ret = video_ioctl2(filp, cmd, arg);
1854 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1856 struct ivtv_open_id *id = fh2id(filp->private_data);
1857 struct ivtv *itv = id->itv;
1860 /* DQEVENT can block, so this should not run with the serialize lock */
1861 if (cmd == VIDIOC_DQEVENT)
1862 return ivtv_serialized_ioctl(itv, filp, cmd, arg);
1863 mutex_lock(&itv->serialize_lock);
1864 res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1865 mutex_unlock(&itv->serialize_lock);
1869 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1870 .vidioc_querycap = ivtv_querycap,
1871 .vidioc_s_audio = ivtv_s_audio,
1872 .vidioc_g_audio = ivtv_g_audio,
1873 .vidioc_enumaudio = ivtv_enumaudio,
1874 .vidioc_s_audout = ivtv_s_audout,
1875 .vidioc_g_audout = ivtv_g_audout,
1876 .vidioc_enum_input = ivtv_enum_input,
1877 .vidioc_enum_output = ivtv_enum_output,
1878 .vidioc_enumaudout = ivtv_enumaudout,
1879 .vidioc_cropcap = ivtv_cropcap,
1880 .vidioc_s_crop = ivtv_s_crop,
1881 .vidioc_g_crop = ivtv_g_crop,
1882 .vidioc_g_input = ivtv_g_input,
1883 .vidioc_s_input = ivtv_s_input,
1884 .vidioc_g_output = ivtv_g_output,
1885 .vidioc_s_output = ivtv_s_output,
1886 .vidioc_g_frequency = ivtv_g_frequency,
1887 .vidioc_s_frequency = ivtv_s_frequency,
1888 .vidioc_s_tuner = ivtv_s_tuner,
1889 .vidioc_g_tuner = ivtv_g_tuner,
1890 .vidioc_g_enc_index = ivtv_g_enc_index,
1891 .vidioc_g_fbuf = ivtv_g_fbuf,
1892 .vidioc_s_fbuf = ivtv_s_fbuf,
1893 .vidioc_g_std = ivtv_g_std,
1894 .vidioc_s_std = ivtv_s_std,
1895 .vidioc_overlay = ivtv_overlay,
1896 .vidioc_log_status = ivtv_log_status,
1897 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1898 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1899 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1900 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1901 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1902 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1903 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1904 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1905 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1906 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1907 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1908 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1909 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1910 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1911 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1912 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1913 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1914 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1915 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1916 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1917 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1918 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1919 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1920 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1921 #ifdef CONFIG_VIDEO_ADV_DEBUG
1922 .vidioc_g_register = ivtv_g_register,
1923 .vidioc_s_register = ivtv_s_register,
1925 .vidioc_default = ivtv_default,
1926 .vidioc_subscribe_event = ivtv_subscribe_event,
1927 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1930 void ivtv_set_funcs(struct video_device *vdev)
1932 vdev->ioctl_ops = &ivtv_ioctl_ops;