3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "ivtv-driver.h"
22 #include "ivtv-version.h"
23 #include "ivtv-mailbox.h"
25 #include "ivtv-queue.h"
26 #include "ivtv-fileops.h"
28 #include "ivtv-routing.h"
29 #include "ivtv-streams.h"
31 #include "ivtv-ioctl.h"
32 #include "ivtv-gpio.h"
33 #include "ivtv-controls.h"
34 #include "ivtv-cards.h"
35 #include <media/saa7127.h>
36 #include <media/tveeprom.h>
37 #include <media/v4l2-chip-ident.h>
38 #include <linux/dvb/audio.h>
39 #include <linux/i2c-id.h>
41 u16
ivtv_service2vbi(int type
)
44 case V4L2_SLICED_TELETEXT_B
:
45 return IVTV_SLICED_TYPE_TELETEXT_B
;
46 case V4L2_SLICED_CAPTION_525
:
47 return IVTV_SLICED_TYPE_CAPTION_525
;
48 case V4L2_SLICED_WSS_625
:
49 return IVTV_SLICED_TYPE_WSS_625
;
51 return IVTV_SLICED_TYPE_VPS
;
57 static int valid_service_line(int field
, int line
, int is_pal
)
59 return (is_pal
&& line
>= 6 && (line
!= 23 || field
== 0)) ||
60 (!is_pal
&& line
>= 10 && line
< 22);
63 static u16
select_service_from_set(int field
, int line
, u16 set
, int is_pal
)
65 u16 valid_set
= (is_pal
? V4L2_SLICED_VBI_625
: V4L2_SLICED_VBI_525
);
68 set
= set
& valid_set
;
69 if (set
== 0 || !valid_service_line(field
, line
, is_pal
)) {
73 if (line
== 21 && (set
& V4L2_SLICED_CAPTION_525
))
74 return V4L2_SLICED_CAPTION_525
;
77 if (line
== 16 && field
== 0 && (set
& V4L2_SLICED_VPS
))
78 return V4L2_SLICED_VPS
;
79 if (line
== 23 && field
== 0 && (set
& V4L2_SLICED_WSS_625
))
80 return V4L2_SLICED_WSS_625
;
84 for (i
= 0; i
< 32; i
++) {
91 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format
*fmt
, int is_pal
)
93 u16 set
= fmt
->service_set
;
97 for (f
= 0; f
< 2; f
++) {
98 for (l
= 0; l
< 24; l
++) {
99 fmt
->service_lines
[f
][l
] = select_service_from_set(f
, l
, set
, is_pal
);
104 static int check_service_set(struct v4l2_sliced_vbi_format
*fmt
, int is_pal
)
109 for (f
= 0; f
< 2; f
++) {
110 for (l
= 0; l
< 24; l
++) {
111 fmt
->service_lines
[f
][l
] = select_service_from_set(f
, l
, fmt
->service_lines
[f
][l
], is_pal
);
112 set
|= fmt
->service_lines
[f
][l
];
118 u16
ivtv_get_service_set(struct v4l2_sliced_vbi_format
*fmt
)
123 for (f
= 0; f
< 2; f
++) {
124 for (l
= 0; l
< 24; l
++) {
125 set
|= fmt
->service_lines
[f
][l
];
131 void ivtv_set_osd_alpha(struct ivtv
*itv
)
133 ivtv_vapi(itv
, CX2341X_OSD_SET_GLOBAL_ALPHA
, 3,
134 itv
->osd_global_alpha_state
, itv
->osd_global_alpha
, !itv
->osd_local_alpha_state
);
135 ivtv_vapi(itv
, CX2341X_OSD_SET_CHROMA_KEY
, 2, itv
->osd_chroma_key_state
, itv
->osd_chroma_key
);
138 int ivtv_set_speed(struct ivtv
*itv
, int speed
)
140 u32 data
[CX2341X_MBOX_MAX_DATA
];
141 struct ivtv_stream
*s
;
142 int single_step
= (speed
== 1 || speed
== -1);
145 if (speed
== 0) speed
= 1000;
148 if (speed
== itv
->speed
&& !single_step
)
151 s
= &itv
->streams
[IVTV_DEC_STREAM_TYPE_MPG
];
153 if (single_step
&& (speed
< 0) == (itv
->speed
< 0)) {
154 /* Single step video and no need to change direction */
155 ivtv_vapi(itv
, CX2341X_DEC_STEP_VIDEO
, 1, 0);
160 /* Need to change direction */
161 speed
= speed
< 0 ? -1000 : 1000;
163 data
[0] = (speed
> 1000 || speed
< -1000) ? 0x80000000 : 0;
164 data
[0] |= (speed
> 1000 || speed
< -1500) ? 0x40000000 : 0;
165 data
[1] = (speed
< 0);
166 data
[2] = speed
< 0 ? 3 : 7;
167 data
[3] = itv
->params
.video_b_frames
;
168 data
[4] = (speed
== 1500 || speed
== 500) ? itv
->speed_mute_audio
: 0;
172 if (speed
== 1500 || speed
== -1500) data
[0] |= 1;
173 else if (speed
== 2000 || speed
== -2000) data
[0] |= 2;
174 else if (speed
> -1000 && speed
< 0) data
[0] |= (-1000 / speed
);
175 else if (speed
< 1000 && speed
> 0) data
[0] |= (1000 / speed
);
177 /* If not decoding, just change speed setting */
178 if (atomic_read(&itv
->decoding
) > 0) {
181 /* Stop all DMA and decoding activity */
182 ivtv_vapi(itv
, CX2341X_DEC_PAUSE_PLAYBACK
, 1, 0);
184 /* Wait for any DMA to finish */
185 prepare_to_wait(&itv
->dma_waitq
, &wait
, TASK_INTERRUPTIBLE
);
186 while (itv
->i_flags
& IVTV_F_I_DMA
) {
187 got_sig
= signal_pending(current
);
193 finish_wait(&itv
->dma_waitq
, &wait
);
197 /* Change Speed safely */
198 ivtv_api(itv
, CX2341X_DEC_SET_PLAYBACK_SPEED
, 7, data
);
199 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
200 data
[0], data
[1], data
[2], data
[3], data
[4], data
[5], data
[6]);
203 speed
= (speed
< 0) ? -1 : 1;
204 ivtv_vapi(itv
, CX2341X_DEC_STEP_VIDEO
, 1, 0);
210 static int ivtv_validate_speed(int cur_speed
, int new_speed
)
212 int fact
= new_speed
< 0 ? -1 : 1;
218 new_speed
= -new_speed
;
220 cur_speed
= -cur_speed
;
222 if (cur_speed
<= new_speed
) {
223 if (new_speed
> 1500)
225 if (new_speed
> 1000)
229 if (new_speed
>= 2000)
231 if (new_speed
>= 1500)
233 if (new_speed
>= 1000)
238 if (new_speed
== 1 || new_speed
== 1000)
239 return fact
* new_speed
;
242 new_speed
= 1000 / new_speed
;
243 if (1000 / cur_speed
== new_speed
)
244 new_speed
+= (cur_speed
< s
) ? -1 : 1;
245 if (new_speed
> 60) return 1000 / (fact
* 60);
246 return 1000 / (fact
* new_speed
);
249 static int ivtv_video_command(struct ivtv
*itv
, struct ivtv_open_id
*id
,
250 struct video_command
*vc
, int try)
252 struct ivtv_stream
*s
= &itv
->streams
[IVTV_DEC_STREAM_TYPE_MPG
];
254 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
258 case VIDEO_CMD_PLAY
: {
260 vc
->play
.speed
= ivtv_validate_speed(itv
->speed
, vc
->play
.speed
);
261 if (vc
->play
.speed
< 0)
262 vc
->play
.format
= VIDEO_PLAY_FMT_GOP
;
265 if (ivtv_set_output_mode(itv
, OUT_MPG
) != OUT_MPG
)
267 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED
, &itv
->i_flags
)) {
268 /* forces ivtv_set_speed to be called */
271 return ivtv_start_decoding(id
, vc
->play
.speed
);
275 vc
->flags
&= VIDEO_CMD_STOP_IMMEDIATELY
|VIDEO_CMD_STOP_TO_BLACK
;
276 if (vc
->flags
& VIDEO_CMD_STOP_IMMEDIATELY
)
279 if (atomic_read(&itv
->decoding
) == 0)
281 if (itv
->output_mode
!= OUT_MPG
)
284 itv
->output_mode
= OUT_NONE
;
285 return ivtv_stop_v4l2_decode_stream(s
, vc
->flags
, vc
->stop
.pts
);
287 case VIDEO_CMD_FREEZE
:
288 vc
->flags
&= VIDEO_CMD_FREEZE_TO_BLACK
;
290 if (itv
->output_mode
!= OUT_MPG
)
292 if (atomic_read(&itv
->decoding
) > 0) {
293 ivtv_vapi(itv
, CX2341X_DEC_PAUSE_PLAYBACK
, 1,
294 (vc
->flags
& VIDEO_CMD_FREEZE_TO_BLACK
) ? 1 : 0);
295 set_bit(IVTV_F_I_DEC_PAUSED
, &itv
->i_flags
);
299 case VIDEO_CMD_CONTINUE
:
302 if (itv
->output_mode
!= OUT_MPG
)
304 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED
, &itv
->i_flags
)) {
305 int speed
= itv
->speed
;
307 return ivtv_start_decoding(id
, speed
);
317 static int ivtv_g_fmt_sliced_vbi_out(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
319 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
320 struct v4l2_sliced_vbi_format
*vbifmt
= &fmt
->fmt
.sliced
;
322 vbifmt
->reserved
[0] = 0;
323 vbifmt
->reserved
[1] = 0;
324 if (!(itv
->v4l2_cap
& V4L2_CAP_SLICED_VBI_OUTPUT
))
326 vbifmt
->io_size
= sizeof(struct v4l2_sliced_vbi_data
) * 36;
328 vbifmt
->service_lines
[0][21] = V4L2_SLICED_CAPTION_525
;
329 vbifmt
->service_lines
[1][21] = V4L2_SLICED_CAPTION_525
;
331 vbifmt
->service_lines
[0][23] = V4L2_SLICED_WSS_625
;
332 vbifmt
->service_lines
[0][16] = V4L2_SLICED_VPS
;
334 vbifmt
->service_set
= ivtv_get_service_set(vbifmt
);
338 static int ivtv_g_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
340 struct ivtv_open_id
*id
= fh
;
341 struct ivtv
*itv
= id
->itv
;
342 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
344 pixfmt
->width
= itv
->params
.width
;
345 pixfmt
->height
= itv
->params
.height
;
346 pixfmt
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
347 pixfmt
->field
= V4L2_FIELD_INTERLACED
;
349 if (id
->type
== IVTV_ENC_STREAM_TYPE_YUV
) {
350 pixfmt
->pixelformat
= V4L2_PIX_FMT_HM12
;
351 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
353 pixfmt
->height
* pixfmt
->width
+
354 pixfmt
->height
* (pixfmt
->width
/ 2);
355 pixfmt
->bytesperline
= 720;
357 pixfmt
->pixelformat
= V4L2_PIX_FMT_MPEG
;
358 pixfmt
->sizeimage
= 128 * 1024;
359 pixfmt
->bytesperline
= 0;
364 static int ivtv_g_fmt_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
366 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
367 struct v4l2_vbi_format
*vbifmt
= &fmt
->fmt
.vbi
;
369 vbifmt
->sampling_rate
= 27000000;
370 vbifmt
->offset
= 248;
371 vbifmt
->samples_per_line
= itv
->vbi
.raw_decoder_line_size
- 4;
372 vbifmt
->sample_format
= V4L2_PIX_FMT_GREY
;
373 vbifmt
->start
[0] = itv
->vbi
.start
[0];
374 vbifmt
->start
[1] = itv
->vbi
.start
[1];
375 vbifmt
->count
[0] = vbifmt
->count
[1] = itv
->vbi
.count
;
377 vbifmt
->reserved
[0] = 0;
378 vbifmt
->reserved
[1] = 0;
382 static int ivtv_g_fmt_sliced_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
384 struct v4l2_sliced_vbi_format
*vbifmt
= &fmt
->fmt
.sliced
;
385 struct ivtv_open_id
*id
= fh
;
386 struct ivtv
*itv
= id
->itv
;
388 vbifmt
->reserved
[0] = 0;
389 vbifmt
->reserved
[1] = 0;
390 vbifmt
->io_size
= sizeof(struct v4l2_sliced_vbi_data
) * 36;
392 if (id
->type
== IVTV_DEC_STREAM_TYPE_VBI
) {
393 vbifmt
->service_set
= itv
->is_50hz
? V4L2_SLICED_VBI_625
:
395 ivtv_expand_service_set(vbifmt
, itv
->is_50hz
);
399 itv
->video_dec_func(itv
, VIDIOC_G_FMT
, fmt
);
400 vbifmt
->service_set
= ivtv_get_service_set(vbifmt
);
404 static int ivtv_g_fmt_vid_out(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
406 struct ivtv_open_id
*id
= fh
;
407 struct ivtv
*itv
= id
->itv
;
408 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
410 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
412 pixfmt
->width
= itv
->main_rect
.width
;
413 pixfmt
->height
= itv
->main_rect
.height
;
414 pixfmt
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
415 pixfmt
->field
= V4L2_FIELD_INTERLACED
;
417 if (id
->type
== IVTV_DEC_STREAM_TYPE_YUV
) {
418 switch (itv
->yuv_info
.lace_mode
& IVTV_YUV_MODE_MASK
) {
419 case IVTV_YUV_MODE_INTERLACED
:
420 pixfmt
->field
= (itv
->yuv_info
.lace_mode
& IVTV_YUV_SYNC_MASK
) ?
421 V4L2_FIELD_INTERLACED_BT
: V4L2_FIELD_INTERLACED_TB
;
423 case IVTV_YUV_MODE_PROGRESSIVE
:
424 pixfmt
->field
= V4L2_FIELD_NONE
;
427 pixfmt
->field
= V4L2_FIELD_ANY
;
430 pixfmt
->pixelformat
= V4L2_PIX_FMT_HM12
;
431 pixfmt
->bytesperline
= 720;
432 pixfmt
->width
= itv
->yuv_info
.v4l2_src_w
;
433 pixfmt
->height
= itv
->yuv_info
.v4l2_src_h
;
434 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
436 1080 * ((pixfmt
->height
+ 31) & ~31);
438 pixfmt
->pixelformat
= V4L2_PIX_FMT_MPEG
;
439 pixfmt
->sizeimage
= 128 * 1024;
440 pixfmt
->bytesperline
= 0;
445 static int ivtv_g_fmt_vid_out_overlay(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
447 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
448 struct v4l2_window
*winfmt
= &fmt
->fmt
.win
;
450 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
452 winfmt
->chromakey
= itv
->osd_chroma_key
;
453 winfmt
->global_alpha
= itv
->osd_global_alpha
;
454 winfmt
->field
= V4L2_FIELD_INTERLACED
;
455 winfmt
->clips
= NULL
;
456 winfmt
->clipcount
= 0;
457 winfmt
->bitmap
= NULL
;
458 winfmt
->w
.top
= winfmt
->w
.left
= 0;
459 winfmt
->w
.width
= itv
->osd_rect
.width
;
460 winfmt
->w
.height
= itv
->osd_rect
.height
;
464 static int ivtv_try_fmt_sliced_vbi_out(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
466 return ivtv_g_fmt_sliced_vbi_out(file
, fh
, fmt
);
469 static int ivtv_try_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
471 struct ivtv_open_id
*id
= fh
;
472 struct ivtv
*itv
= id
->itv
;
473 int w
= fmt
->fmt
.pix
.width
;
474 int h
= fmt
->fmt
.pix
.height
;
478 h
= min(h
, itv
->is_50hz
? 576 : 480);
480 ivtv_g_fmt_vid_cap(file
, fh
, fmt
);
481 fmt
->fmt
.pix
.width
= w
;
482 fmt
->fmt
.pix
.height
= h
;
486 static int ivtv_try_fmt_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
488 return ivtv_g_fmt_vbi_cap(file
, fh
, fmt
);
491 static int ivtv_try_fmt_sliced_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
493 struct v4l2_sliced_vbi_format
*vbifmt
= &fmt
->fmt
.sliced
;
494 struct ivtv_open_id
*id
= fh
;
495 struct ivtv
*itv
= id
->itv
;
497 if (id
->type
== IVTV_DEC_STREAM_TYPE_VBI
)
498 return ivtv_g_fmt_sliced_vbi_cap(file
, fh
, fmt
);
500 /* set sliced VBI capture format */
501 vbifmt
->io_size
= sizeof(struct v4l2_sliced_vbi_data
) * 36;
502 vbifmt
->reserved
[0] = 0;
503 vbifmt
->reserved
[1] = 0;
505 if (vbifmt
->service_set
)
506 ivtv_expand_service_set(vbifmt
, itv
->is_50hz
);
507 check_service_set(vbifmt
, itv
->is_50hz
);
508 vbifmt
->service_set
= ivtv_get_service_set(vbifmt
);
512 static int ivtv_try_fmt_vid_out(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
514 struct ivtv_open_id
*id
= fh
;
519 w
= fmt
->fmt
.pix
.width
;
520 h
= fmt
->fmt
.pix
.height
;
521 field
= fmt
->fmt
.pix
.field
;
522 ret
= ivtv_g_fmt_vid_out(file
, fh
, fmt
);
523 fmt
->fmt
.pix
.width
= w
;
524 fmt
->fmt
.pix
.height
= h
;
525 if (!ret
&& id
->type
== IVTV_DEC_STREAM_TYPE_YUV
) {
526 fmt
->fmt
.pix
.field
= field
;
527 if (fmt
->fmt
.pix
.width
< 2)
528 fmt
->fmt
.pix
.width
= 2;
529 if (fmt
->fmt
.pix
.width
> 720)
530 fmt
->fmt
.pix
.width
= 720;
531 if (fmt
->fmt
.pix
.height
< 2)
532 fmt
->fmt
.pix
.height
= 2;
533 if (fmt
->fmt
.pix
.height
> 576)
534 fmt
->fmt
.pix
.height
= 576;
539 static int ivtv_try_fmt_vid_out_overlay(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
541 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
542 u32 chromakey
= fmt
->fmt
.win
.chromakey
;
543 u8 global_alpha
= fmt
->fmt
.win
.global_alpha
;
545 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
547 ivtv_g_fmt_vid_out_overlay(file
, fh
, fmt
);
548 fmt
->fmt
.win
.chromakey
= chromakey
;
549 fmt
->fmt
.win
.global_alpha
= global_alpha
;
553 static int ivtv_s_fmt_sliced_vbi_out(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
555 return ivtv_g_fmt_sliced_vbi_out(file
, fh
, fmt
);
558 static int ivtv_s_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
560 struct ivtv_open_id
*id
= fh
;
561 struct ivtv
*itv
= id
->itv
;
562 struct cx2341x_mpeg_params
*p
= &itv
->params
;
563 int w
= fmt
->fmt
.pix
.width
;
564 int h
= fmt
->fmt
.pix
.height
;
565 int ret
= ivtv_try_fmt_vid_cap(file
, fh
, fmt
);
570 if (p
->width
== w
&& p
->height
== h
)
573 if (atomic_read(&itv
->capturing
) > 0)
578 if (p
->video_encoding
== V4L2_MPEG_VIDEO_ENCODING_MPEG_1
)
579 fmt
->fmt
.pix
.width
/= 2;
580 itv
->video_dec_func(itv
, VIDIOC_S_FMT
, fmt
);
581 return ivtv_g_fmt_vid_cap(file
, fh
, fmt
);
584 static int ivtv_s_fmt_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
586 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
588 itv
->vbi
.sliced_in
->service_set
= 0;
589 itv
->video_dec_func(itv
, VIDIOC_S_FMT
, &itv
->vbi
.in
);
590 return ivtv_g_fmt_vbi_cap(file
, fh
, fmt
);
593 static int ivtv_s_fmt_sliced_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
595 struct v4l2_sliced_vbi_format
*vbifmt
= &fmt
->fmt
.sliced
;
596 struct ivtv_open_id
*id
= fh
;
597 struct ivtv
*itv
= id
->itv
;
598 int ret
= ivtv_try_fmt_sliced_vbi_cap(file
, fh
, fmt
);
600 if (ret
|| id
->type
== IVTV_DEC_STREAM_TYPE_VBI
)
603 if (check_service_set(vbifmt
, itv
->is_50hz
) == 0)
605 if (atomic_read(&itv
->capturing
) > 0)
607 itv
->video_dec_func(itv
, VIDIOC_S_FMT
, fmt
);
608 memcpy(itv
->vbi
.sliced_in
, vbifmt
, sizeof(*itv
->vbi
.sliced_in
));
612 static int ivtv_s_fmt_vid_out(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
614 struct ivtv_open_id
*id
= fh
;
615 struct ivtv
*itv
= id
->itv
;
616 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
617 int ret
= ivtv_try_fmt_vid_out(file
, fh
, fmt
);
622 if (id
->type
!= IVTV_DEC_STREAM_TYPE_YUV
)
625 /* Return now if we already have some frame data */
629 yi
->v4l2_src_w
= fmt
->fmt
.pix
.width
;
630 yi
->v4l2_src_h
= fmt
->fmt
.pix
.height
;
632 switch (fmt
->fmt
.pix
.field
) {
633 case V4L2_FIELD_NONE
:
634 yi
->lace_mode
= IVTV_YUV_MODE_PROGRESSIVE
;
637 yi
->lace_mode
= IVTV_YUV_MODE_AUTO
;
639 case V4L2_FIELD_INTERLACED_BT
:
641 IVTV_YUV_MODE_INTERLACED
|IVTV_YUV_SYNC_ODD
;
643 case V4L2_FIELD_INTERLACED_TB
:
645 yi
->lace_mode
= IVTV_YUV_MODE_INTERLACED
;
648 yi
->lace_sync_field
= (yi
->lace_mode
& IVTV_YUV_SYNC_MASK
) == IVTV_YUV_SYNC_EVEN
? 0 : 1;
650 if (test_bit(IVTV_F_I_DEC_YUV
, &itv
->i_flags
))
651 itv
->dma_data_req_size
=
652 1080 * ((yi
->v4l2_src_h
+ 31) & ~31);
654 /* Force update of yuv registers */
655 yi
->yuv_forced_update
= 1;
659 static int ivtv_s_fmt_vid_out_overlay(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
661 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
662 int ret
= ivtv_try_fmt_vid_out_overlay(file
, fh
, fmt
);
665 itv
->osd_chroma_key
= fmt
->fmt
.win
.chromakey
;
666 itv
->osd_global_alpha
= fmt
->fmt
.win
.global_alpha
;
667 ivtv_set_osd_alpha(itv
);
672 static int ivtv_g_chip_ident(struct file
*file
, void *fh
, struct v4l2_chip_ident
*chip
)
674 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
676 chip
->ident
= V4L2_IDENT_NONE
;
678 if (chip
->match_type
== V4L2_CHIP_MATCH_HOST
) {
679 if (v4l2_chip_match_host(chip
->match_type
, chip
->match_chip
))
680 chip
->ident
= itv
->has_cx23415
? V4L2_IDENT_CX23415
: V4L2_IDENT_CX23416
;
683 if (chip
->match_type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
684 return ivtv_i2c_id(itv
, chip
->match_chip
, VIDIOC_G_CHIP_IDENT
, chip
);
685 if (chip
->match_type
== V4L2_CHIP_MATCH_I2C_ADDR
)
686 return ivtv_call_i2c_client(itv
, chip
->match_chip
, VIDIOC_G_CHIP_IDENT
, chip
);
690 #ifdef CONFIG_VIDEO_ADV_DEBUG
691 static int ivtv_itvc(struct ivtv
*itv
, unsigned int cmd
, void *arg
)
693 struct v4l2_register
*regs
= arg
;
695 volatile u8 __iomem
*reg_start
;
697 if (!capable(CAP_SYS_ADMIN
))
699 if (regs
->reg
>= IVTV_REG_OFFSET
&& regs
->reg
< IVTV_REG_OFFSET
+ IVTV_REG_SIZE
)
700 reg_start
= itv
->reg_mem
- IVTV_REG_OFFSET
;
701 else if (itv
->has_cx23415
&& regs
->reg
>= IVTV_DECODER_OFFSET
&&
702 regs
->reg
< IVTV_DECODER_OFFSET
+ IVTV_DECODER_SIZE
)
703 reg_start
= itv
->dec_mem
- IVTV_DECODER_OFFSET
;
704 else if (regs
->reg
>= 0 && regs
->reg
< IVTV_ENCODER_SIZE
)
705 reg_start
= itv
->enc_mem
;
709 spin_lock_irqsave(&ivtv_cards_lock
, flags
);
710 if (cmd
== VIDIOC_DBG_G_REGISTER
)
711 regs
->val
= readl(regs
->reg
+ reg_start
);
713 writel(regs
->val
, regs
->reg
+ reg_start
);
714 spin_unlock_irqrestore(&ivtv_cards_lock
, flags
);
718 static int ivtv_g_register(struct file
*file
, void *fh
, struct v4l2_register
*reg
)
720 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
722 if (v4l2_chip_match_host(reg
->match_type
, reg
->match_chip
))
723 return ivtv_itvc(itv
, VIDIOC_DBG_G_REGISTER
, reg
);
724 if (reg
->match_type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
725 return ivtv_i2c_id(itv
, reg
->match_chip
, VIDIOC_DBG_G_REGISTER
, reg
);
726 return ivtv_call_i2c_client(itv
, reg
->match_chip
, VIDIOC_DBG_G_REGISTER
, reg
);
729 static int ivtv_s_register(struct file
*file
, void *fh
, struct v4l2_register
*reg
)
731 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
733 if (v4l2_chip_match_host(reg
->match_type
, reg
->match_chip
))
734 return ivtv_itvc(itv
, VIDIOC_DBG_S_REGISTER
, reg
);
735 if (reg
->match_type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
736 return ivtv_i2c_id(itv
, reg
->match_chip
, VIDIOC_DBG_S_REGISTER
, reg
);
737 return ivtv_call_i2c_client(itv
, reg
->match_chip
, VIDIOC_DBG_S_REGISTER
, reg
);
741 static int ivtv_g_priority(struct file
*file
, void *fh
, enum v4l2_priority
*p
)
743 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
745 *p
= v4l2_prio_max(&itv
->prio
);
750 static int ivtv_s_priority(struct file
*file
, void *fh
, enum v4l2_priority prio
)
752 struct ivtv_open_id
*id
= fh
;
753 struct ivtv
*itv
= id
->itv
;
755 return v4l2_prio_change(&itv
->prio
, &id
->prio
, prio
);
758 static int ivtv_querycap(struct file
*file
, void *fh
, struct v4l2_capability
*vcap
)
760 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
762 strlcpy(vcap
->driver
, IVTV_DRIVER_NAME
, sizeof(vcap
->driver
));
763 strlcpy(vcap
->card
, itv
->card_name
, sizeof(vcap
->card
));
764 strlcpy(vcap
->bus_info
, pci_name(itv
->dev
), sizeof(vcap
->bus_info
));
765 vcap
->version
= IVTV_DRIVER_VERSION
; /* version */
766 vcap
->capabilities
= itv
->v4l2_cap
; /* capabilities */
770 static int ivtv_enumaudio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
772 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
774 return ivtv_get_audio_input(itv
, vin
->index
, vin
);
777 static int ivtv_g_audio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
779 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
781 vin
->index
= itv
->audio_input
;
782 return ivtv_get_audio_input(itv
, vin
->index
, vin
);
785 static int ivtv_s_audio(struct file
*file
, void *fh
, struct v4l2_audio
*vout
)
787 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
789 if (vout
->index
>= itv
->nof_audio_inputs
)
792 itv
->audio_input
= vout
->index
;
793 ivtv_audio_set_io(itv
);
798 static int ivtv_enumaudout(struct file
*file
, void *fh
, struct v4l2_audioout
*vin
)
800 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
802 /* set it to defaults from our table */
803 return ivtv_get_audio_output(itv
, vin
->index
, vin
);
806 static int ivtv_g_audout(struct file
*file
, void *fh
, struct v4l2_audioout
*vin
)
808 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
811 return ivtv_get_audio_output(itv
, vin
->index
, vin
);
814 static int ivtv_s_audout(struct file
*file
, void *fh
, struct v4l2_audioout
*vout
)
816 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
818 return ivtv_get_audio_output(itv
, vout
->index
, vout
);
821 static int ivtv_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*vin
)
823 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
825 /* set it to defaults from our table */
826 return ivtv_get_input(itv
, vin
->index
, vin
);
829 static int ivtv_enum_output(struct file
*file
, void *fh
, struct v4l2_output
*vout
)
831 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
833 return ivtv_get_output(itv
, vout
->index
, vout
);
836 static int ivtv_cropcap(struct file
*file
, void *fh
, struct v4l2_cropcap
*cropcap
)
838 struct ivtv_open_id
*id
= fh
;
839 struct ivtv
*itv
= id
->itv
;
840 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
843 streamtype
= id
->type
;
845 if (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
847 cropcap
->bounds
.top
= cropcap
->bounds
.left
= 0;
848 cropcap
->bounds
.width
= 720;
849 if (cropcap
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
850 cropcap
->bounds
.height
= itv
->is_50hz
? 576 : 480;
851 cropcap
->pixelaspect
.numerator
= itv
->is_50hz
? 59 : 10;
852 cropcap
->pixelaspect
.denominator
= itv
->is_50hz
? 54 : 11;
853 } else if (streamtype
== IVTV_DEC_STREAM_TYPE_YUV
) {
855 cropcap
->bounds
.width
= yi
->osd_full_w
;
856 cropcap
->bounds
.height
= yi
->osd_full_h
;
858 cropcap
->bounds
.width
= 720;
859 cropcap
->bounds
.height
=
860 itv
->is_out_50hz
? 576 : 480;
862 cropcap
->pixelaspect
.numerator
= itv
->is_out_50hz
? 59 : 10;
863 cropcap
->pixelaspect
.denominator
= itv
->is_out_50hz
? 54 : 11;
865 cropcap
->bounds
.height
= itv
->is_out_50hz
? 576 : 480;
866 cropcap
->pixelaspect
.numerator
= itv
->is_out_50hz
? 59 : 10;
867 cropcap
->pixelaspect
.denominator
= itv
->is_out_50hz
? 54 : 11;
869 cropcap
->defrect
= cropcap
->bounds
;
873 static int ivtv_s_crop(struct file
*file
, void *fh
, struct v4l2_crop
*crop
)
875 struct ivtv_open_id
*id
= fh
;
876 struct ivtv
*itv
= id
->itv
;
877 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
880 streamtype
= id
->type
;
882 if (ivtv_debug
& IVTV_DBGFLG_IOCTL
) {
883 printk(KERN_INFO
"ivtv%d ioctl: ", itv
->num
);
884 /* Should be replaced */
885 /* v4l_printk_ioctl(VIDIOC_S_CROP); */
888 if (crop
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
889 (itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
)) {
890 if (streamtype
== IVTV_DEC_STREAM_TYPE_YUV
) {
891 yi
->main_rect
= crop
->c
;
894 if (!ivtv_vapi(itv
, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW
, 4,
895 crop
->c
.width
, crop
->c
.height
, crop
->c
.left
, crop
->c
.top
)) {
896 itv
->main_rect
= crop
->c
;
905 static int ivtv_g_crop(struct file
*file
, void *fh
, struct v4l2_crop
*crop
)
907 struct ivtv_open_id
*id
= fh
;
908 struct ivtv
*itv
= id
->itv
;
909 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
912 streamtype
= id
->type
;
914 if (crop
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
915 (itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
)) {
916 if (streamtype
== IVTV_DEC_STREAM_TYPE_YUV
)
917 crop
->c
= yi
->main_rect
;
919 crop
->c
= itv
->main_rect
;
925 static int ivtv_enum_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_fmtdesc
*fmt
)
927 static struct v4l2_fmtdesc formats
[] = {
929 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12
,
932 { 1, 0, V4L2_FMT_FLAG_COMPRESSED
,
933 "MPEG", V4L2_PIX_FMT_MPEG
,
937 enum v4l2_buf_type type
= fmt
->type
;
942 *fmt
= formats
[fmt
->index
];
947 static int ivtv_enum_fmt_vid_out(struct file
*file
, void *fh
, struct v4l2_fmtdesc
*fmt
)
949 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
951 static struct v4l2_fmtdesc formats
[] = {
953 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12
,
956 { 1, 0, V4L2_FMT_FLAG_COMPRESSED
,
957 "MPEG", V4L2_PIX_FMT_MPEG
,
961 enum v4l2_buf_type type
= fmt
->type
;
963 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
969 *fmt
= formats
[fmt
->index
];
975 static int ivtv_g_input(struct file
*file
, void *fh
, unsigned int *i
)
977 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
979 *i
= itv
->active_input
;
984 int ivtv_s_input(struct file
*file
, void *fh
, unsigned int inp
)
986 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
988 if (inp
< 0 || inp
>= itv
->nof_inputs
)
991 if (inp
== itv
->active_input
) {
992 IVTV_DEBUG_INFO("Input unchanged\n");
996 if (atomic_read(&itv
->capturing
) > 0) {
1000 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1001 itv
->active_input
, inp
);
1003 itv
->active_input
= inp
;
1004 /* Set the audio input to whatever is appropriate for the
1006 itv
->audio_input
= itv
->card
->video_inputs
[inp
].audio_index
;
1008 /* prevent others from messing with the streams until
1009 we're finished changing inputs. */
1011 ivtv_video_set_io(itv
);
1012 ivtv_audio_set_io(itv
);
1018 static int ivtv_g_output(struct file
*file
, void *fh
, unsigned int *i
)
1020 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1022 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
1025 *i
= itv
->active_output
;
1030 static int ivtv_s_output(struct file
*file
, void *fh
, unsigned int outp
)
1032 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1033 struct v4l2_routing route
;
1035 if (outp
>= itv
->card
->nof_outputs
)
1038 if (outp
== itv
->active_output
) {
1039 IVTV_DEBUG_INFO("Output unchanged\n");
1042 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1043 itv
->active_output
, outp
);
1045 itv
->active_output
= outp
;
1046 route
.input
= SAA7127_INPUT_TYPE_NORMAL
;
1047 route
.output
= itv
->card
->video_outputs
[outp
].video_output
;
1048 ivtv_saa7127(itv
, VIDIOC_INT_S_VIDEO_ROUTING
, &route
);
1053 static int ivtv_g_frequency(struct file
*file
, void *fh
, struct v4l2_frequency
*vf
)
1055 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1060 ivtv_call_i2c_clients(itv
, VIDIOC_G_FREQUENCY
, vf
);
1064 int ivtv_s_frequency(struct file
*file
, void *fh
, struct v4l2_frequency
*vf
)
1066 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1072 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf
->frequency
);
1073 ivtv_call_i2c_clients(itv
, VIDIOC_S_FREQUENCY
, vf
);
1078 static int ivtv_g_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
1080 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1086 int ivtv_s_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
1088 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1089 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
1091 if ((*std
& V4L2_STD_ALL
) == 0)
1094 if (*std
== itv
->std
)
1097 if (test_bit(IVTV_F_I_RADIO_USER
, &itv
->i_flags
) ||
1098 atomic_read(&itv
->capturing
) > 0 ||
1099 atomic_read(&itv
->decoding
) > 0) {
1100 /* Switching standard would turn off the radio or mess
1101 with already running streams, prevent that by
1107 itv
->is_60hz
= (*std
& V4L2_STD_525_60
) ? 1 : 0;
1108 itv
->params
.is_50hz
= itv
->is_50hz
= !itv
->is_60hz
;
1109 itv
->params
.width
= 720;
1110 itv
->params
.height
= itv
->is_50hz
? 576 : 480;
1111 itv
->vbi
.count
= itv
->is_50hz
? 18 : 12;
1112 itv
->vbi
.start
[0] = itv
->is_50hz
? 6 : 10;
1113 itv
->vbi
.start
[1] = itv
->is_50hz
? 318 : 273;
1115 if (itv
->hw_flags
& IVTV_HW_CX25840
)
1116 itv
->vbi
.sliced_decoder_line_size
= itv
->is_60hz
? 272 : 284;
1118 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv
->std
);
1121 ivtv_call_i2c_clients(itv
, VIDIOC_S_STD
, &itv
->std
);
1123 if (itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
) {
1124 /* set display standard */
1125 itv
->std_out
= *std
;
1126 itv
->is_out_60hz
= itv
->is_60hz
;
1127 itv
->is_out_50hz
= itv
->is_50hz
;
1128 ivtv_call_i2c_clients(itv
, VIDIOC_INT_S_STD_OUTPUT
, &itv
->std_out
);
1129 ivtv_vapi(itv
, CX2341X_DEC_SET_STANDARD
, 1, itv
->is_out_50hz
);
1130 itv
->main_rect
.left
= itv
->main_rect
.top
= 0;
1131 itv
->main_rect
.width
= 720;
1132 itv
->main_rect
.height
= itv
->params
.height
;
1133 ivtv_vapi(itv
, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW
, 4,
1134 720, itv
->main_rect
.height
, 0, 0);
1135 yi
->main_rect
= itv
->main_rect
;
1136 if (!itv
->osd_info
) {
1137 yi
->osd_full_w
= 720;
1138 yi
->osd_full_h
= itv
->is_out_50hz
? 576 : 480;
1144 static int ivtv_s_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*vt
)
1146 struct ivtv_open_id
*id
= fh
;
1147 struct ivtv
*itv
= id
->itv
;
1152 ivtv_call_i2c_clients(itv
, VIDIOC_S_TUNER
, vt
);
1157 static int ivtv_g_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*vt
)
1159 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1164 ivtv_call_i2c_clients(itv
, VIDIOC_G_TUNER
, vt
);
1166 if (test_bit(IVTV_F_I_RADIO_USER
, &itv
->i_flags
)) {
1167 strlcpy(vt
->name
, "ivtv Radio Tuner", sizeof(vt
->name
));
1168 vt
->type
= V4L2_TUNER_RADIO
;
1170 strlcpy(vt
->name
, "ivtv TV Tuner", sizeof(vt
->name
));
1171 vt
->type
= V4L2_TUNER_ANALOG_TV
;
1177 static int ivtv_g_sliced_vbi_cap(struct file
*file
, void *fh
, struct v4l2_sliced_vbi_cap
*cap
)
1179 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1180 int set
= itv
->is_50hz
? V4L2_SLICED_VBI_625
: V4L2_SLICED_VBI_525
;
1183 if (cap
->type
== V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
) {
1184 for (f
= 0; f
< 2; f
++) {
1185 for (l
= 0; l
< 24; l
++) {
1186 if (valid_service_line(f
, l
, itv
->is_50hz
))
1187 cap
->service_lines
[f
][l
] = set
;
1192 if (cap
->type
== V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
) {
1193 if (!(itv
->v4l2_cap
& V4L2_CAP_SLICED_VBI_OUTPUT
))
1196 cap
->service_lines
[0][21] = V4L2_SLICED_CAPTION_525
;
1197 cap
->service_lines
[1][21] = V4L2_SLICED_CAPTION_525
;
1199 cap
->service_lines
[0][23] = V4L2_SLICED_WSS_625
;
1200 cap
->service_lines
[0][16] = V4L2_SLICED_VPS
;
1207 static int ivtv_g_enc_index(struct file
*file
, void *fh
, struct v4l2_enc_idx
*idx
)
1209 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1210 struct v4l2_enc_idx_entry
*e
= idx
->entry
;
1214 entries
= (itv
->pgm_info_write_idx
+ IVTV_MAX_PGM_INDEX
- itv
->pgm_info_read_idx
) %
1216 if (entries
> V4L2_ENC_IDX_ENTRIES
)
1217 entries
= V4L2_ENC_IDX_ENTRIES
;
1219 for (i
= 0; i
< entries
; i
++) {
1220 *e
= itv
->pgm_info
[(itv
->pgm_info_read_idx
+ i
) % IVTV_MAX_PGM_INDEX
];
1221 if ((e
->flags
& V4L2_ENC_IDX_FRAME_MASK
) <= V4L2_ENC_IDX_FRAME_B
) {
1226 itv
->pgm_info_read_idx
= (itv
->pgm_info_read_idx
+ idx
->entries
) % IVTV_MAX_PGM_INDEX
;
1230 static int ivtv_encoder_cmd(struct file
*file
, void *fh
, struct v4l2_encoder_cmd
*enc
)
1232 struct ivtv_open_id
*id
= fh
;
1233 struct ivtv
*itv
= id
->itv
;
1237 case V4L2_ENC_CMD_START
:
1238 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1240 return ivtv_start_capture(id
);
1242 case V4L2_ENC_CMD_STOP
:
1243 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1244 enc
->flags
&= V4L2_ENC_CMD_STOP_AT_GOP_END
;
1245 ivtv_stop_capture(id
, enc
->flags
& V4L2_ENC_CMD_STOP_AT_GOP_END
);
1248 case V4L2_ENC_CMD_PAUSE
:
1249 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1252 if (!atomic_read(&itv
->capturing
))
1254 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED
, &itv
->i_flags
))
1258 ivtv_vapi(itv
, CX2341X_ENC_PAUSE_ENCODER
, 1, 0);
1261 case V4L2_ENC_CMD_RESUME
:
1262 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1265 if (!atomic_read(&itv
->capturing
))
1268 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED
, &itv
->i_flags
))
1271 ivtv_vapi(itv
, CX2341X_ENC_PAUSE_ENCODER
, 1, 1);
1275 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc
->cmd
);
1282 static int ivtv_try_encoder_cmd(struct file
*file
, void *fh
, struct v4l2_encoder_cmd
*enc
)
1284 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1287 case V4L2_ENC_CMD_START
:
1288 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1292 case V4L2_ENC_CMD_STOP
:
1293 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1294 enc
->flags
&= V4L2_ENC_CMD_STOP_AT_GOP_END
;
1297 case V4L2_ENC_CMD_PAUSE
:
1298 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1302 case V4L2_ENC_CMD_RESUME
:
1303 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1307 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc
->cmd
);
1312 static int ivtv_g_fbuf(struct file
*file
, void *fh
, struct v4l2_framebuffer
*fb
)
1314 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1315 u32 data
[CX2341X_MBOX_MAX_DATA
];
1316 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
1319 static u32 pixel_format
[16] = {
1320 V4L2_PIX_FMT_PAL8
, /* Uses a 256-entry RGB colormap */
1321 V4L2_PIX_FMT_RGB565
,
1322 V4L2_PIX_FMT_RGB555
,
1323 V4L2_PIX_FMT_RGB444
,
1328 V4L2_PIX_FMT_PAL8
, /* Uses a 256-entry YUV colormap */
1329 V4L2_PIX_FMT_YUV565
,
1330 V4L2_PIX_FMT_YUV555
,
1331 V4L2_PIX_FMT_YUV444
,
1338 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT_OVERLAY
))
1340 if (!itv
->osd_video_pbase
)
1343 fb
->capability
= V4L2_FBUF_CAP_EXTERNOVERLAY
| V4L2_FBUF_CAP_CHROMAKEY
|
1344 V4L2_FBUF_CAP_GLOBAL_ALPHA
;
1346 ivtv_vapi_result(itv
, data
, CX2341X_OSD_GET_STATE
, 0);
1347 data
[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1348 pixfmt
= (data
[0] >> 3) & 0xf;
1350 fb
->fmt
.pixelformat
= pixel_format
[pixfmt
];
1351 fb
->fmt
.width
= itv
->osd_rect
.width
;
1352 fb
->fmt
.height
= itv
->osd_rect
.height
;
1353 fb
->fmt
.field
= V4L2_FIELD_INTERLACED
;
1354 fb
->fmt
.bytesperline
= fb
->fmt
.width
;
1355 fb
->fmt
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1356 fb
->fmt
.field
= V4L2_FIELD_INTERLACED
;
1358 if (fb
->fmt
.pixelformat
!= V4L2_PIX_FMT_PAL8
)
1359 fb
->fmt
.bytesperline
*= 2;
1360 if (fb
->fmt
.pixelformat
== V4L2_PIX_FMT_RGB32
||
1361 fb
->fmt
.pixelformat
== V4L2_PIX_FMT_YUV32
)
1362 fb
->fmt
.bytesperline
*= 2;
1363 fb
->fmt
.sizeimage
= fb
->fmt
.bytesperline
* fb
->fmt
.height
;
1364 fb
->base
= (void *)itv
->osd_video_pbase
;
1367 if (itv
->osd_chroma_key_state
)
1368 fb
->flags
|= V4L2_FBUF_FLAG_CHROMAKEY
;
1370 if (itv
->osd_global_alpha_state
)
1371 fb
->flags
|= V4L2_FBUF_FLAG_GLOBAL_ALPHA
;
1375 /* no local alpha for RGB565 or unknown formats */
1376 if (pixfmt
== 1 || pixfmt
> 4)
1379 /* 16-bit formats have inverted local alpha */
1380 if (pixfmt
== 2 || pixfmt
== 3)
1381 fb
->capability
|= V4L2_FBUF_CAP_LOCAL_INV_ALPHA
;
1383 fb
->capability
|= V4L2_FBUF_CAP_LOCAL_ALPHA
;
1385 if (itv
->osd_local_alpha_state
) {
1386 /* 16-bit formats have inverted local alpha */
1387 if (pixfmt
== 2 || pixfmt
== 3)
1388 fb
->flags
|= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA
;
1390 fb
->flags
|= V4L2_FBUF_FLAG_LOCAL_ALPHA
;
1393 fb
->flags
|= V4L2_FBUF_FLAG_OVERLAY
;
1398 static int ivtv_s_fbuf(struct file
*file
, void *fh
, struct v4l2_framebuffer
*fb
)
1400 struct ivtv_open_id
*id
= fh
;
1401 struct ivtv
*itv
= id
->itv
;
1402 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
1404 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT_OVERLAY
))
1406 if (!itv
->osd_video_pbase
)
1409 itv
->osd_global_alpha_state
= (fb
->flags
& V4L2_FBUF_FLAG_GLOBAL_ALPHA
) != 0;
1410 itv
->osd_local_alpha_state
=
1411 (fb
->flags
& (V4L2_FBUF_FLAG_LOCAL_ALPHA
|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA
)) != 0;
1412 itv
->osd_chroma_key_state
= (fb
->flags
& V4L2_FBUF_FLAG_CHROMAKEY
) != 0;
1413 ivtv_set_osd_alpha(itv
);
1414 yi
->track_osd
= (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) != 0;
1415 return ivtv_g_fbuf(file
, fh
, fb
);
1418 static int ivtv_overlay(struct file
*file
, void *fh
, unsigned int on
)
1420 struct ivtv_open_id
*id
= fh
;
1421 struct ivtv
*itv
= id
->itv
;
1423 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT_OVERLAY
))
1426 ivtv_vapi(itv
, CX2341X_OSD_SET_STATE
, 1, on
!= 0);
1431 static int ivtv_log_status(struct file
*file
, void *fh
)
1433 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1434 u32 data
[CX2341X_MBOX_MAX_DATA
];
1436 int has_output
= itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
;
1437 struct v4l2_input vidin
;
1438 struct v4l2_audio audin
;
1441 IVTV_INFO("================= START STATUS CARD #%d =================\n", itv
->num
);
1442 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION
, itv
->card_name
);
1443 if (itv
->hw_flags
& IVTV_HW_TVEEPROM
) {
1446 ivtv_read_eeprom(itv
, &tv
);
1448 ivtv_call_i2c_clients(itv
, VIDIOC_LOG_STATUS
, NULL
);
1449 ivtv_get_input(itv
, itv
->active_input
, &vidin
);
1450 ivtv_get_audio_input(itv
, itv
->audio_input
, &audin
);
1451 IVTV_INFO("Video Input: %s\n", vidin
.name
);
1452 IVTV_INFO("Audio Input: %s%s\n", audin
.name
,
1453 (itv
->dualwatch_stereo_mode
& ~0x300) == 0x200 ? " (Bilingual)" : "");
1455 struct v4l2_output vidout
;
1456 struct v4l2_audioout audout
;
1457 int mode
= itv
->output_mode
;
1458 static const char * const output_modes
[5] = {
1465 static const char * const audio_modes
[5] = {
1472 static const char * const alpha_mode
[4] = {
1478 static const char * const pixel_format
[16] = {
1497 ivtv_get_output(itv
, itv
->active_output
, &vidout
);
1498 ivtv_get_audio_output(itv
, 0, &audout
);
1499 IVTV_INFO("Video Output: %s\n", vidout
.name
);
1500 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout
.name
,
1501 audio_modes
[itv
->audio_stereo_mode
],
1502 audio_modes
[itv
->audio_bilingual_mode
]);
1503 if (mode
< 0 || mode
> OUT_PASSTHROUGH
)
1505 IVTV_INFO("Output Mode: %s\n", output_modes
[mode
]);
1506 ivtv_vapi_result(itv
, data
, CX2341X_OSD_GET_STATE
, 0);
1507 data
[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1508 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1509 data
[0] & 1 ? "On" : "Off",
1510 alpha_mode
[(data
[0] >> 1) & 0x3],
1511 pixel_format
[(data
[0] >> 3) & 0xf]);
1513 IVTV_INFO("Tuner: %s\n",
1514 test_bit(IVTV_F_I_RADIO_USER
, &itv
->i_flags
) ? "Radio" : "TV");
1515 cx2341x_log_status(&itv
->params
, itv
->name
);
1516 IVTV_INFO("Status flags: 0x%08lx\n", itv
->i_flags
);
1517 for (i
= 0; i
< IVTV_MAX_STREAMS
; i
++) {
1518 struct ivtv_stream
*s
= &itv
->streams
[i
];
1520 if (s
->v4l2dev
== NULL
|| s
->buffers
== 0)
1522 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s
->name
, s
->s_flags
,
1523 (s
->buffers
- s
->q_free
.buffers
) * 100 / s
->buffers
,
1524 (s
->buffers
* s
->buf_size
) / 1024, s
->buffers
);
1527 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv
->mpg_data_received
, (long long)itv
->vbi_data_inserted
);
1528 IVTV_INFO("================== END STATUS CARD #%d ==================\n", itv
->num
);
1533 static int ivtv_decoder_ioctls(struct file
*filp
, unsigned int cmd
, void *arg
)
1535 struct ivtv_open_id
*id
= (struct ivtv_open_id
*)filp
->private_data
;
1536 struct ivtv
*itv
= id
->itv
;
1537 int nonblocking
= filp
->f_flags
& O_NONBLOCK
;
1538 struct ivtv_stream
*s
= &itv
->streams
[id
->type
];
1541 case IVTV_IOC_DMA_FRAME
: {
1542 struct ivtv_dma_frame
*args
= arg
;
1544 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1545 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
1547 if (args
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
1549 if (itv
->output_mode
== OUT_UDMA_YUV
&& args
->y_source
== NULL
)
1551 if (ivtv_start_decoding(id
, id
->type
)) {
1554 if (ivtv_set_output_mode(itv
, OUT_UDMA_YUV
) != OUT_UDMA_YUV
) {
1555 ivtv_release_stream(s
);
1558 /* Mark that this file handle started the UDMA_YUV mode */
1560 if (args
->y_source
== NULL
)
1562 return ivtv_yuv_prep_frame(itv
, args
);
1565 case VIDEO_GET_PTS
: {
1566 u32 data
[CX2341X_MBOX_MAX_DATA
];
1569 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1570 if (s
->type
< IVTV_DEC_STREAM_TYPE_MPG
) {
1574 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
1577 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS
, &itv
->i_flags
)) {
1578 *pts
= (u64
) ((u64
)itv
->last_dec_timing
[2] << 32) |
1579 (u64
)itv
->last_dec_timing
[1];
1583 if (atomic_read(&itv
->decoding
)) {
1584 if (ivtv_api(itv
, CX2341X_DEC_GET_TIMING_INFO
, 5, data
)) {
1585 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1588 memcpy(itv
->last_dec_timing
, data
, sizeof(itv
->last_dec_timing
));
1589 set_bit(IVTV_F_I_VALID_DEC_TIMINGS
, &itv
->i_flags
);
1590 *pts
= (u64
) ((u64
) data
[2] << 32) | (u64
) data
[1];
1591 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1596 case VIDEO_GET_FRAME_COUNT
: {
1597 u32 data
[CX2341X_MBOX_MAX_DATA
];
1600 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1601 if (s
->type
< IVTV_DEC_STREAM_TYPE_MPG
) {
1605 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
1608 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS
, &itv
->i_flags
)) {
1609 *frame
= itv
->last_dec_timing
[0];
1613 if (atomic_read(&itv
->decoding
)) {
1614 if (ivtv_api(itv
, CX2341X_DEC_GET_TIMING_INFO
, 5, data
)) {
1615 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1618 memcpy(itv
->last_dec_timing
, data
, sizeof(itv
->last_dec_timing
));
1619 set_bit(IVTV_F_I_VALID_DEC_TIMINGS
, &itv
->i_flags
);
1626 struct video_command vc
;
1628 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1629 memset(&vc
, 0, sizeof(vc
));
1630 vc
.cmd
= VIDEO_CMD_PLAY
;
1631 return ivtv_video_command(itv
, id
, &vc
, 0);
1635 struct video_command vc
;
1637 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1638 memset(&vc
, 0, sizeof(vc
));
1639 vc
.cmd
= VIDEO_CMD_STOP
;
1640 vc
.flags
= VIDEO_CMD_STOP_TO_BLACK
| VIDEO_CMD_STOP_IMMEDIATELY
;
1641 return ivtv_video_command(itv
, id
, &vc
, 0);
1644 case VIDEO_FREEZE
: {
1645 struct video_command vc
;
1647 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1648 memset(&vc
, 0, sizeof(vc
));
1649 vc
.cmd
= VIDEO_CMD_FREEZE
;
1650 return ivtv_video_command(itv
, id
, &vc
, 0);
1653 case VIDEO_CONTINUE
: {
1654 struct video_command vc
;
1656 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1657 memset(&vc
, 0, sizeof(vc
));
1658 vc
.cmd
= VIDEO_CMD_CONTINUE
;
1659 return ivtv_video_command(itv
, id
, &vc
, 0);
1663 case VIDEO_TRY_COMMAND
: {
1664 struct video_command
*vc
= arg
;
1665 int try = (cmd
== VIDEO_TRY_COMMAND
);
1668 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc
->cmd
);
1670 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc
->cmd
);
1671 return ivtv_video_command(itv
, id
, vc
, try);
1674 case VIDEO_GET_EVENT
: {
1675 struct video_event
*ev
= arg
;
1678 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1679 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
1681 memset(ev
, 0, sizeof(*ev
));
1682 set_bit(IVTV_F_I_EV_VSYNC_ENABLED
, &itv
->i_flags
);
1685 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED
, &itv
->i_flags
))
1686 ev
->type
= VIDEO_EVENT_DECODER_STOPPED
;
1687 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC
, &itv
->i_flags
)) {
1688 ev
->type
= VIDEO_EVENT_VSYNC
;
1689 ev
->u
.vsync_field
= test_bit(IVTV_F_I_EV_VSYNC_FIELD
, &itv
->i_flags
) ?
1690 VIDEO_VSYNC_FIELD_ODD
: VIDEO_VSYNC_FIELD_EVEN
;
1691 if (itv
->output_mode
== OUT_UDMA_YUV
&&
1692 (itv
->yuv_info
.lace_mode
& IVTV_YUV_MODE_MASK
) ==
1693 IVTV_YUV_MODE_PROGRESSIVE
) {
1694 ev
->u
.vsync_field
= VIDEO_VSYNC_FIELD_PROGRESSIVE
;
1701 /* Wait for event. Note that serialize_lock is locked,
1702 so to allow other processes to access the driver while
1703 we are waiting unlock first and later lock again. */
1704 mutex_unlock(&itv
->serialize_lock
);
1705 prepare_to_wait(&itv
->event_waitq
, &wait
, TASK_INTERRUPTIBLE
);
1706 if ((itv
->i_flags
& (IVTV_F_I_EV_DEC_STOPPED
|IVTV_F_I_EV_VSYNC
)) == 0)
1708 finish_wait(&itv
->event_waitq
, &wait
);
1709 mutex_lock(&itv
->serialize_lock
);
1710 if (signal_pending(current
)) {
1711 /* return if a signal was received */
1712 IVTV_DEBUG_INFO("User stopped wait for event\n");
1725 static int ivtv_default(struct file
*file
, void *fh
, int cmd
, void *arg
)
1727 struct ivtv
*itv
= ((struct ivtv_open_id
*)fh
)->itv
;
1730 case VIDIOC_INT_S_AUDIO_ROUTING
: {
1731 struct v4l2_routing
*route
= arg
;
1733 ivtv_i2c_hw(itv
, itv
->card
->hw_audio
, VIDIOC_INT_S_AUDIO_ROUTING
, route
);
1737 case VIDIOC_INT_RESET
: {
1738 u32 val
= *(u32
*)arg
;
1740 if ((val
== 0 && itv
->options
.newi2c
) || (val
& 0x01))
1741 ivtv_reset_ir_gpio(itv
);
1743 itv
->video_dec_func(itv
, cmd
, NULL
);
1753 static int ivtv_serialized_ioctl(struct ivtv
*itv
, struct inode
*inode
, struct file
*filp
,
1754 unsigned int cmd
, unsigned long arg
)
1756 struct video_device
*vfd
= video_devdata(filp
);
1757 struct ivtv_open_id
*id
= (struct ivtv_open_id
*)filp
->private_data
;
1760 /* Filter dvb ioctls that cannot be handled by the v4l ioctl framework */
1762 case VIDEO_SELECT_SOURCE
:
1763 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1764 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
1766 return ivtv_passthrough_mode(itv
, arg
== VIDEO_SOURCE_DEMUX
);
1768 case AUDIO_SET_MUTE
:
1769 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1770 itv
->speed_mute_audio
= arg
;
1773 case AUDIO_CHANNEL_SELECT
:
1774 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1775 if (arg
> AUDIO_STEREO_SWAPPED
)
1777 itv
->audio_stereo_mode
= arg
;
1778 ivtv_vapi(itv
, CX2341X_DEC_SET_AUDIO_MODE
, 2, itv
->audio_bilingual_mode
, itv
->audio_stereo_mode
);
1781 case AUDIO_BILINGUAL_CHANNEL_SELECT
:
1782 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1783 if (arg
> AUDIO_STEREO_SWAPPED
)
1785 itv
->audio_bilingual_mode
= arg
;
1786 ivtv_vapi(itv
, CX2341X_DEC_SET_AUDIO_MODE
, 2, itv
->audio_bilingual_mode
, itv
->audio_stereo_mode
);
1789 case IVTV_IOC_DMA_FRAME
:
1791 case VIDEO_GET_FRAME_COUNT
:
1792 case VIDEO_GET_EVENT
:
1796 case VIDEO_CONTINUE
:
1798 case VIDEO_TRY_COMMAND
:
1799 return ivtv_decoder_ioctls(filp
, cmd
, (void *)arg
);
1805 /* check priority */
1809 case VIDIOC_S_INPUT
:
1810 case VIDIOC_S_OUTPUT
:
1811 case VIDIOC_S_TUNER
:
1812 case VIDIOC_S_FREQUENCY
:
1815 case VIDIOC_S_AUDIO
:
1816 case VIDIOC_S_AUDOUT
:
1817 case VIDIOC_S_EXT_CTRLS
:
1819 case VIDIOC_OVERLAY
:
1820 ret
= v4l2_prio_check(&itv
->prio
, &id
->prio
);
1825 if (ivtv_debug
& IVTV_DBGFLG_IOCTL
)
1826 vfd
->debug
= V4L2_DEBUG_IOCTL
| V4L2_DEBUG_IOCTL_ARG
;
1827 ret
= video_ioctl2(inode
, filp
, cmd
, arg
);
1832 int ivtv_v4l2_ioctl(struct inode
*inode
, struct file
*filp
, unsigned int cmd
,
1835 struct ivtv_open_id
*id
= (struct ivtv_open_id
*)filp
->private_data
;
1836 struct ivtv
*itv
= id
->itv
;
1839 mutex_lock(&itv
->serialize_lock
);
1840 res
= ivtv_serialized_ioctl(itv
, inode
, filp
, cmd
, arg
);
1841 mutex_unlock(&itv
->serialize_lock
);
1845 static const struct v4l2_ioctl_ops ivtv_ioctl_ops
= {
1846 .vidioc_querycap
= ivtv_querycap
,
1847 .vidioc_g_priority
= ivtv_g_priority
,
1848 .vidioc_s_priority
= ivtv_s_priority
,
1849 .vidioc_s_audio
= ivtv_s_audio
,
1850 .vidioc_g_audio
= ivtv_g_audio
,
1851 .vidioc_enumaudio
= ivtv_enumaudio
,
1852 .vidioc_s_audout
= ivtv_s_audout
,
1853 .vidioc_g_audout
= ivtv_g_audout
,
1854 .vidioc_enum_input
= ivtv_enum_input
,
1855 .vidioc_enum_output
= ivtv_enum_output
,
1856 .vidioc_enumaudout
= ivtv_enumaudout
,
1857 .vidioc_cropcap
= ivtv_cropcap
,
1858 .vidioc_s_crop
= ivtv_s_crop
,
1859 .vidioc_g_crop
= ivtv_g_crop
,
1860 .vidioc_g_input
= ivtv_g_input
,
1861 .vidioc_s_input
= ivtv_s_input
,
1862 .vidioc_g_output
= ivtv_g_output
,
1863 .vidioc_s_output
= ivtv_s_output
,
1864 .vidioc_g_frequency
= ivtv_g_frequency
,
1865 .vidioc_s_frequency
= ivtv_s_frequency
,
1866 .vidioc_s_tuner
= ivtv_s_tuner
,
1867 .vidioc_g_tuner
= ivtv_g_tuner
,
1868 .vidioc_g_enc_index
= ivtv_g_enc_index
,
1869 .vidioc_g_fbuf
= ivtv_g_fbuf
,
1870 .vidioc_s_fbuf
= ivtv_s_fbuf
,
1871 .vidioc_g_std
= ivtv_g_std
,
1872 .vidioc_s_std
= ivtv_s_std
,
1873 .vidioc_overlay
= ivtv_overlay
,
1874 .vidioc_log_status
= ivtv_log_status
,
1875 .vidioc_enum_fmt_vid_cap
= ivtv_enum_fmt_vid_cap
,
1876 .vidioc_encoder_cmd
= ivtv_encoder_cmd
,
1877 .vidioc_try_encoder_cmd
= ivtv_try_encoder_cmd
,
1878 .vidioc_enum_fmt_vid_out
= ivtv_enum_fmt_vid_out
,
1879 .vidioc_g_fmt_vid_cap
= ivtv_g_fmt_vid_cap
,
1880 .vidioc_g_fmt_vbi_cap
= ivtv_g_fmt_vbi_cap
,
1881 .vidioc_g_fmt_sliced_vbi_cap
= ivtv_g_fmt_sliced_vbi_cap
,
1882 .vidioc_g_fmt_vid_out
= ivtv_g_fmt_vid_out
,
1883 .vidioc_g_fmt_vid_out_overlay
= ivtv_g_fmt_vid_out_overlay
,
1884 .vidioc_g_fmt_sliced_vbi_out
= ivtv_g_fmt_sliced_vbi_out
,
1885 .vidioc_s_fmt_vid_cap
= ivtv_s_fmt_vid_cap
,
1886 .vidioc_s_fmt_vbi_cap
= ivtv_s_fmt_vbi_cap
,
1887 .vidioc_s_fmt_sliced_vbi_cap
= ivtv_s_fmt_sliced_vbi_cap
,
1888 .vidioc_s_fmt_vid_out
= ivtv_s_fmt_vid_out
,
1889 .vidioc_s_fmt_vid_out_overlay
= ivtv_s_fmt_vid_out_overlay
,
1890 .vidioc_s_fmt_sliced_vbi_out
= ivtv_s_fmt_sliced_vbi_out
,
1891 .vidioc_try_fmt_vid_cap
= ivtv_try_fmt_vid_cap
,
1892 .vidioc_try_fmt_vbi_cap
= ivtv_try_fmt_vbi_cap
,
1893 .vidioc_try_fmt_sliced_vbi_cap
= ivtv_try_fmt_sliced_vbi_cap
,
1894 .vidioc_try_fmt_vid_out
= ivtv_try_fmt_vid_out
,
1895 .vidioc_try_fmt_vid_out_overlay
= ivtv_try_fmt_vid_out_overlay
,
1896 .vidioc_try_fmt_sliced_vbi_out
= ivtv_try_fmt_sliced_vbi_out
,
1897 .vidioc_g_sliced_vbi_cap
= ivtv_g_sliced_vbi_cap
,
1898 .vidioc_g_chip_ident
= ivtv_g_chip_ident
,
1899 #ifdef CONFIG_VIDEO_ADV_DEBUG
1900 .vidioc_g_register
= ivtv_g_register
,
1901 .vidioc_s_register
= ivtv_s_register
,
1903 .vidioc_default
= ivtv_default
,
1904 .vidioc_queryctrl
= ivtv_queryctrl
,
1905 .vidioc_querymenu
= ivtv_querymenu
,
1906 .vidioc_g_ext_ctrls
= ivtv_g_ext_ctrls
,
1907 .vidioc_s_ext_ctrls
= ivtv_s_ext_ctrls
,
1908 .vidioc_try_ext_ctrls
= ivtv_try_ext_ctrls
,
1911 void ivtv_set_funcs(struct video_device
*vdev
)
1913 vdev
->ioctl_ops
= &ivtv_ioctl_ops
;