1
2
3
4
5
6
7
8
9#include "ivtv-driver.h"
10#include "ivtv-version.h"
11#include "ivtv-mailbox.h"
12#include "ivtv-i2c.h"
13#include "ivtv-queue.h"
14#include "ivtv-fileops.h"
15#include "ivtv-vbi.h"
16#include "ivtv-routing.h"
17#include "ivtv-streams.h"
18#include "ivtv-yuv.h"
19#include "ivtv-ioctl.h"
20#include "ivtv-gpio.h"
21#include "ivtv-controls.h"
22#include "ivtv-cards.h"
23#include <media/i2c/saa7127.h>
24#include <media/tveeprom.h>
25#include <media/v4l2-event.h>
26
27u16 ivtv_service2vbi(int type)
28{
29 switch (type) {
30 case V4L2_SLICED_TELETEXT_B:
31 return IVTV_SLICED_TYPE_TELETEXT_B;
32 case V4L2_SLICED_CAPTION_525:
33 return IVTV_SLICED_TYPE_CAPTION_525;
34 case V4L2_SLICED_WSS_625:
35 return IVTV_SLICED_TYPE_WSS_625;
36 case V4L2_SLICED_VPS:
37 return IVTV_SLICED_TYPE_VPS;
38 default:
39 return 0;
40 }
41}
42
43static int valid_service_line(int field, int line, int is_pal)
44{
45 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
46 (!is_pal && line >= 10 && line < 22);
47}
48
49static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
50{
51 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
52 int i;
53
54 set = set & valid_set;
55 if (set == 0 || !valid_service_line(field, line, is_pal)) {
56 return 0;
57 }
58 if (!is_pal) {
59 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
60 return V4L2_SLICED_CAPTION_525;
61 }
62 else {
63 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
64 return V4L2_SLICED_VPS;
65 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
66 return V4L2_SLICED_WSS_625;
67 if (line == 23)
68 return 0;
69 }
70 for (i = 0; i < 32; i++) {
71 if (BIT(i) & set)
72 return BIT(i);
73 }
74 return 0;
75}
76
77void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
78{
79 u16 set = fmt->service_set;
80 int f, l;
81
82 fmt->service_set = 0;
83 for (f = 0; f < 2; f++) {
84 for (l = 0; l < 24; l++) {
85 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
86 }
87 }
88}
89
90static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
91{
92 int f, l;
93
94 for (f = 0; f < 2; f++) {
95 for (l = 0; l < 24; l++) {
96 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
97 }
98 }
99}
100
101u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
102{
103 int f, l;
104 u16 set = 0;
105
106 for (f = 0; f < 2; f++) {
107 for (l = 0; l < 24; l++) {
108 set |= fmt->service_lines[f][l];
109 }
110 }
111 return set;
112}
113
114void ivtv_set_osd_alpha(struct ivtv *itv)
115{
116 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
117 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
118 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
119}
120
121int ivtv_set_speed(struct ivtv *itv, int speed)
122{
123 u32 data[CX2341X_MBOX_MAX_DATA];
124 int single_step = (speed == 1 || speed == -1);
125 DEFINE_WAIT(wait);
126
127 if (speed == 0) speed = 1000;
128
129
130 if (speed == itv->speed && !single_step)
131 return 0;
132
133 if (single_step && (speed < 0) == (itv->speed < 0)) {
134
135 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
136 itv->speed = speed;
137 return 0;
138 }
139 if (single_step)
140
141 speed = speed < 0 ? -1000 : 1000;
142
143 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
144 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
145 data[1] = (speed < 0);
146 data[2] = speed < 0 ? 3 : 7;
147 data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
148 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
149 data[5] = 0;
150 data[6] = 0;
151
152 if (speed == 1500 || speed == -1500) data[0] |= 1;
153 else if (speed == 2000 || speed == -2000) data[0] |= 2;
154 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
155 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
156
157
158 if (atomic_read(&itv->decoding) > 0) {
159 int got_sig = 0;
160
161
162 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
163
164
165 mutex_unlock(&itv->serialize_lock);
166 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
167 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
168 got_sig = signal_pending(current);
169 if (got_sig)
170 break;
171 got_sig = 0;
172 schedule();
173 }
174 finish_wait(&itv->dma_waitq, &wait);
175 mutex_lock(&itv->serialize_lock);
176 if (got_sig)
177 return -EINTR;
178
179
180 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
181 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
182 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
183 }
184 if (single_step) {
185 speed = (speed < 0) ? -1 : 1;
186 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
187 }
188 itv->speed = speed;
189 return 0;
190}
191
192static int ivtv_validate_speed(int cur_speed, int new_speed)
193{
194 int fact = new_speed < 0 ? -1 : 1;
195 int s;
196
197 if (cur_speed == 0)
198 cur_speed = 1000;
199 if (new_speed < 0)
200 new_speed = -new_speed;
201 if (cur_speed < 0)
202 cur_speed = -cur_speed;
203
204 if (cur_speed <= new_speed) {
205 if (new_speed > 1500)
206 return fact * 2000;
207 if (new_speed > 1000)
208 return fact * 1500;
209 }
210 else {
211 if (new_speed >= 2000)
212 return fact * 2000;
213 if (new_speed >= 1500)
214 return fact * 1500;
215 if (new_speed >= 1000)
216 return fact * 1000;
217 }
218 if (new_speed == 0)
219 return 1000;
220 if (new_speed == 1 || new_speed == 1000)
221 return fact * new_speed;
222
223 s = new_speed;
224 new_speed = 1000 / new_speed;
225 if (1000 / cur_speed == new_speed)
226 new_speed += (cur_speed < s) ? -1 : 1;
227 if (new_speed > 60) return 1000 / (fact * 60);
228 return 1000 / (fact * new_speed);
229}
230
231static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
232 struct v4l2_decoder_cmd *dc, int try)
233{
234 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
235
236 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
237 return -EINVAL;
238
239 switch (dc->cmd) {
240 case V4L2_DEC_CMD_START: {
241 dc->flags &= V4L2_DEC_CMD_START_MUTE_AUDIO;
242 dc->start.speed = ivtv_validate_speed(itv->speed, dc->start.speed);
243 if (dc->start.speed < 0)
244 dc->start.format = V4L2_DEC_START_FMT_GOP;
245 else
246 dc->start.format = V4L2_DEC_START_FMT_NONE;
247 if (dc->start.speed != 500 && dc->start.speed != 1500)
248 dc->flags = dc->start.speed == 1000 ? 0 :
249 V4L2_DEC_CMD_START_MUTE_AUDIO;
250 if (try) break;
251
252 itv->speed_mute_audio = dc->flags & V4L2_DEC_CMD_START_MUTE_AUDIO;
253 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
254 return -EBUSY;
255 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
256
257 itv->speed = 0;
258 }
259 return ivtv_start_decoding(id, dc->start.speed);
260 }
261
262 case V4L2_DEC_CMD_STOP:
263 dc->flags &= V4L2_DEC_CMD_STOP_IMMEDIATELY | V4L2_DEC_CMD_STOP_TO_BLACK;
264 if (dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY)
265 dc->stop.pts = 0;
266 if (try) break;
267 if (atomic_read(&itv->decoding) == 0)
268 return 0;
269 if (itv->output_mode != OUT_MPG)
270 return -EBUSY;
271
272 itv->output_mode = OUT_NONE;
273 return ivtv_stop_v4l2_decode_stream(s, dc->flags, dc->stop.pts);
274
275 case V4L2_DEC_CMD_PAUSE:
276 dc->flags &= V4L2_DEC_CMD_PAUSE_TO_BLACK;
277 if (try) break;
278 if (!atomic_read(&itv->decoding))
279 return -EPERM;
280 if (itv->output_mode != OUT_MPG)
281 return -EBUSY;
282 if (atomic_read(&itv->decoding) > 0) {
283 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
284 (dc->flags & V4L2_DEC_CMD_PAUSE_TO_BLACK) ? 1 : 0);
285 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
286 }
287 break;
288
289 case V4L2_DEC_CMD_RESUME:
290 dc->flags = 0;
291 if (try) break;
292 if (!atomic_read(&itv->decoding))
293 return -EPERM;
294 if (itv->output_mode != OUT_MPG)
295 return -EBUSY;
296 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
297 int speed = itv->speed;
298 itv->speed = 0;
299 return ivtv_start_decoding(id, speed);
300 }
301 break;
302
303 default:
304 return -EINVAL;
305 }
306 return 0;
307}
308
309static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
310{
311 struct ivtv *itv = fh2id(fh)->itv;
312 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
313
314 vbifmt->reserved[0] = 0;
315 vbifmt->reserved[1] = 0;
316 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
317 return -EINVAL;
318 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
319 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
320 if (itv->is_60hz) {
321 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
322 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
323 } else {
324 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
325 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
326 }
327 vbifmt->service_set = ivtv_get_service_set(vbifmt);
328 return 0;
329}
330
331static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
332{
333 struct ivtv_open_id *id = fh2id(fh);
334 struct ivtv *itv = id->itv;
335 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
336
337 pixfmt->width = itv->cxhdl.width;
338 pixfmt->height = itv->cxhdl.height;
339 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
340 pixfmt->field = V4L2_FIELD_INTERLACED;
341 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
342 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
343
344 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
345 pixfmt->bytesperline = 720;
346 } else {
347 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
348 pixfmt->sizeimage = 128 * 1024;
349 pixfmt->bytesperline = 0;
350 }
351 return 0;
352}
353
354static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
355{
356 struct ivtv *itv = fh2id(fh)->itv;
357 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
358
359 vbifmt->sampling_rate = 27000000;
360 vbifmt->offset = 248;
361 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
362 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
363 vbifmt->start[0] = itv->vbi.start[0];
364 vbifmt->start[1] = itv->vbi.start[1];
365 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
366 vbifmt->flags = 0;
367 vbifmt->reserved[0] = 0;
368 vbifmt->reserved[1] = 0;
369 return 0;
370}
371
372static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
373{
374 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
375 struct ivtv_open_id *id = fh2id(fh);
376 struct ivtv *itv = id->itv;
377
378 vbifmt->reserved[0] = 0;
379 vbifmt->reserved[1] = 0;
380 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
381
382 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
383 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
384 V4L2_SLICED_VBI_525;
385 ivtv_expand_service_set(vbifmt, itv->is_50hz);
386 vbifmt->service_set = ivtv_get_service_set(vbifmt);
387 return 0;
388 }
389
390 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
391 vbifmt->service_set = ivtv_get_service_set(vbifmt);
392 return 0;
393}
394
395static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
396{
397 struct ivtv_open_id *id = fh2id(fh);
398 struct ivtv *itv = id->itv;
399 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
400
401 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
402 return -EINVAL;
403 pixfmt->width = itv->main_rect.width;
404 pixfmt->height = itv->main_rect.height;
405 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
406 pixfmt->field = V4L2_FIELD_INTERLACED;
407 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
408 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
409 case IVTV_YUV_MODE_INTERLACED:
410 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
411 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
412 break;
413 case IVTV_YUV_MODE_PROGRESSIVE:
414 pixfmt->field = V4L2_FIELD_NONE;
415 break;
416 default:
417 pixfmt->field = V4L2_FIELD_ANY;
418 break;
419 }
420 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
421 pixfmt->bytesperline = 720;
422 pixfmt->width = itv->yuv_info.v4l2_src_w;
423 pixfmt->height = itv->yuv_info.v4l2_src_h;
424
425 pixfmt->sizeimage =
426 1080 * ((pixfmt->height + 31) & ~31);
427 } else {
428 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
429 pixfmt->sizeimage = 128 * 1024;
430 pixfmt->bytesperline = 0;
431 }
432 return 0;
433}
434
435static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
436{
437 struct ivtv *itv = fh2id(fh)->itv;
438 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
439 struct v4l2_window *winfmt = &fmt->fmt.win;
440
441 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
442 return -EINVAL;
443 if (!itv->osd_video_pbase)
444 return -EINVAL;
445 winfmt->chromakey = itv->osd_chroma_key;
446 winfmt->global_alpha = itv->osd_global_alpha;
447 winfmt->field = V4L2_FIELD_INTERLACED;
448 winfmt->clips = NULL;
449 winfmt->clipcount = 0;
450 winfmt->bitmap = NULL;
451 winfmt->w.top = winfmt->w.left = 0;
452 winfmt->w.width = itv->osd_rect.width;
453 winfmt->w.height = itv->osd_rect.height;
454 return 0;
455}
456
457static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
458{
459 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
460}
461
462static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
463{
464 struct ivtv_open_id *id = fh2id(fh);
465 struct ivtv *itv = id->itv;
466 int w = fmt->fmt.pix.width;
467 int h = fmt->fmt.pix.height;
468 int min_h = 2;
469
470 w = min(w, 720);
471 w = max(w, 2);
472 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
473
474 h &= ~0x1f;
475 min_h = 32;
476 }
477 h = min(h, itv->is_50hz ? 576 : 480);
478 h = max(h, min_h);
479 ivtv_g_fmt_vid_cap(file, fh, fmt);
480 fmt->fmt.pix.width = w;
481 fmt->fmt.pix.height = h;
482 return 0;
483}
484
485static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
486{
487 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
488}
489
490static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
491{
492 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
493 struct ivtv_open_id *id = fh2id(fh);
494 struct ivtv *itv = id->itv;
495
496 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
497 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
498
499
500 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
501 vbifmt->reserved[0] = 0;
502 vbifmt->reserved[1] = 0;
503
504 if (vbifmt->service_set)
505 ivtv_expand_service_set(vbifmt, itv->is_50hz);
506 check_service_set(vbifmt, itv->is_50hz);
507 vbifmt->service_set = ivtv_get_service_set(vbifmt);
508 return 0;
509}
510
511static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
512{
513 struct ivtv_open_id *id = fh2id(fh);
514 s32 w = fmt->fmt.pix.width;
515 s32 h = fmt->fmt.pix.height;
516 int field = fmt->fmt.pix.field;
517 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
518
519 w = min(w, 720);
520 w = max(w, 2);
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536 h = min(h, 576);
537 h = max(h, 2);
538 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
539 fmt->fmt.pix.field = field;
540 fmt->fmt.pix.width = w;
541 fmt->fmt.pix.height = h;
542 return ret;
543}
544
545static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
546{
547 struct ivtv *itv = fh2id(fh)->itv;
548 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
549 u32 chromakey = fmt->fmt.win.chromakey;
550 u8 global_alpha = fmt->fmt.win.global_alpha;
551
552 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
553 return -EINVAL;
554 if (!itv->osd_video_pbase)
555 return -EINVAL;
556 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
557 fmt->fmt.win.chromakey = chromakey;
558 fmt->fmt.win.global_alpha = global_alpha;
559 return 0;
560}
561
562static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
563{
564 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
565}
566
567static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
568{
569 struct ivtv_open_id *id = fh2id(fh);
570 struct ivtv *itv = id->itv;
571 struct v4l2_subdev_format format = {
572 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
573 };
574 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
575 int w = fmt->fmt.pix.width;
576 int h = fmt->fmt.pix.height;
577
578 if (ret)
579 return ret;
580
581 if (itv->cxhdl.width == w && itv->cxhdl.height == h)
582 return 0;
583
584 if (atomic_read(&itv->capturing) > 0)
585 return -EBUSY;
586
587 itv->cxhdl.width = w;
588 itv->cxhdl.height = h;
589 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
590 fmt->fmt.pix.width /= 2;
591 format.format.width = fmt->fmt.pix.width;
592 format.format.height = h;
593 format.format.code = MEDIA_BUS_FMT_FIXED;
594 v4l2_subdev_call(itv->sd_video, pad, set_fmt, NULL, &format);
595 return ivtv_g_fmt_vid_cap(file, fh, fmt);
596}
597
598static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
599{
600 struct ivtv *itv = fh2id(fh)->itv;
601
602 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
603 return -EBUSY;
604 itv->vbi.sliced_in->service_set = 0;
605 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
606 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
607 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
608}
609
610static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
611{
612 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
613 struct ivtv_open_id *id = fh2id(fh);
614 struct ivtv *itv = id->itv;
615 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
616
617 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
618 return ret;
619
620 check_service_set(vbifmt, itv->is_50hz);
621 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
622 return -EBUSY;
623 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
624 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
625 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
626 return 0;
627}
628
629static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
630{
631 struct ivtv_open_id *id = fh2id(fh);
632 struct ivtv *itv = id->itv;
633 struct yuv_playback_info *yi = &itv->yuv_info;
634 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
635
636 if (ret)
637 return ret;
638
639 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
640 return 0;
641
642
643 if (yi->stream_size)
644 return -EBUSY;
645
646 yi->v4l2_src_w = fmt->fmt.pix.width;
647 yi->v4l2_src_h = fmt->fmt.pix.height;
648
649 switch (fmt->fmt.pix.field) {
650 case V4L2_FIELD_NONE:
651 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
652 break;
653 case V4L2_FIELD_ANY:
654 yi->lace_mode = IVTV_YUV_MODE_AUTO;
655 break;
656 case V4L2_FIELD_INTERLACED_BT:
657 yi->lace_mode =
658 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
659 break;
660 case V4L2_FIELD_INTERLACED_TB:
661 default:
662 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
663 break;
664 }
665 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
666
667 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
668 itv->dma_data_req_size =
669 1080 * ((yi->v4l2_src_h + 31) & ~31);
670
671 return 0;
672}
673
674static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
675{
676 struct ivtv *itv = fh2id(fh)->itv;
677 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
678
679 if (ret == 0) {
680 itv->osd_chroma_key = fmt->fmt.win.chromakey;
681 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
682 ivtv_set_osd_alpha(itv);
683 }
684 return ret;
685}
686
687#ifdef CONFIG_VIDEO_ADV_DEBUG
688static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val)
689{
690 volatile u8 __iomem *reg_start;
691
692 if (reg & 0x3)
693 return -EINVAL;
694 if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
695 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
696 else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET &&
697 reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
698 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
699 else if (reg < IVTV_ENCODER_SIZE)
700 reg_start = itv->enc_mem;
701 else
702 return -EINVAL;
703
704 if (get)
705 *val = readl(reg + reg_start);
706 else
707 writel(*val, reg + reg_start);
708 return 0;
709}
710
711static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
712{
713 struct ivtv *itv = fh2id(fh)->itv;
714
715 reg->size = 4;
716 return ivtv_itvc(itv, true, reg->reg, ®->val);
717}
718
719static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg)
720{
721 struct ivtv *itv = fh2id(fh)->itv;
722 u64 val = reg->val;
723
724 return ivtv_itvc(itv, false, reg->reg, &val);
725}
726#endif
727
728static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
729{
730 struct ivtv_open_id *id = fh2id(file->private_data);
731 struct ivtv *itv = id->itv;
732
733 strscpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
734 strscpy(vcap->card, itv->card_name, sizeof(vcap->card));
735 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
736 vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
737 return 0;
738}
739
740static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
741{
742 struct ivtv *itv = fh2id(fh)->itv;
743
744 return ivtv_get_audio_input(itv, vin->index, vin);
745}
746
747static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
748{
749 struct ivtv *itv = fh2id(fh)->itv;
750
751 vin->index = itv->audio_input;
752 return ivtv_get_audio_input(itv, vin->index, vin);
753}
754
755static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
756{
757 struct ivtv *itv = fh2id(fh)->itv;
758
759 if (vout->index >= itv->nof_audio_inputs)
760 return -EINVAL;
761
762 itv->audio_input = vout->index;
763 ivtv_audio_set_io(itv);
764
765 return 0;
766}
767
768static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
769{
770 struct ivtv *itv = fh2id(fh)->itv;
771
772
773 return ivtv_get_audio_output(itv, vin->index, vin);
774}
775
776static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
777{
778 struct ivtv *itv = fh2id(fh)->itv;
779
780 vin->index = 0;
781 return ivtv_get_audio_output(itv, vin->index, vin);
782}
783
784static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
785{
786 struct ivtv *itv = fh2id(fh)->itv;
787
788 if (itv->card->video_outputs == NULL || vout->index != 0)
789 return -EINVAL;
790 return 0;
791}
792
793static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
794{
795 struct ivtv *itv = fh2id(fh)->itv;
796
797
798 return ivtv_get_input(itv, vin->index, vin);
799}
800
801static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
802{
803 struct ivtv *itv = fh2id(fh)->itv;
804
805 return ivtv_get_output(itv, vout->index, vout);
806}
807
808static int ivtv_g_pixelaspect(struct file *file, void *fh,
809 int type, struct v4l2_fract *f)
810{
811 struct ivtv_open_id *id = fh2id(fh);
812 struct ivtv *itv = id->itv;
813
814 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
815 f->numerator = itv->is_50hz ? 54 : 11;
816 f->denominator = itv->is_50hz ? 59 : 10;
817 } else if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
818 f->numerator = itv->is_out_50hz ? 54 : 11;
819 f->denominator = itv->is_out_50hz ? 59 : 10;
820 } else {
821 return -EINVAL;
822 }
823 return 0;
824}
825
826static int ivtv_s_selection(struct file *file, void *fh,
827 struct v4l2_selection *sel)
828{
829 struct ivtv_open_id *id = fh2id(fh);
830 struct ivtv *itv = id->itv;
831 struct yuv_playback_info *yi = &itv->yuv_info;
832 struct v4l2_rect r = { 0, 0, 720, 0 };
833 int streamtype = id->type;
834
835 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
836 !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
837 return -EINVAL;
838
839 if (sel->target != V4L2_SEL_TGT_COMPOSE)
840 return -EINVAL;
841
842
843 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
844 !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
845 return -EINVAL;
846
847 r.height = itv->is_out_50hz ? 576 : 480;
848 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
849 r.width = yi->osd_full_w;
850 r.height = yi->osd_full_h;
851 }
852 sel->r.width = clamp(sel->r.width, 16U, r.width);
853 sel->r.height = clamp(sel->r.height, 16U, r.height);
854 sel->r.left = clamp_t(unsigned, sel->r.left, 0, r.width - sel->r.width);
855 sel->r.top = clamp_t(unsigned, sel->r.top, 0, r.height - sel->r.height);
856
857 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
858 yi->main_rect = sel->r;
859 return 0;
860 }
861 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
862 sel->r.width, sel->r.height, sel->r.left, sel->r.top)) {
863 itv->main_rect = sel->r;
864 return 0;
865 }
866 return -EINVAL;
867}
868
869static int ivtv_g_selection(struct file *file, void *fh,
870 struct v4l2_selection *sel)
871{
872 struct ivtv_open_id *id = fh2id(fh);
873 struct ivtv *itv = id->itv;
874 struct yuv_playback_info *yi = &itv->yuv_info;
875 struct v4l2_rect r = { 0, 0, 720, 0 };
876 int streamtype = id->type;
877
878 if (sel->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
879 switch (sel->target) {
880 case V4L2_SEL_TGT_CROP_DEFAULT:
881 case V4L2_SEL_TGT_CROP_BOUNDS:
882 sel->r.top = sel->r.left = 0;
883 sel->r.width = 720;
884 sel->r.height = itv->is_50hz ? 576 : 480;
885 return 0;
886 default:
887 return -EINVAL;
888 }
889 }
890
891 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
892 !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
893 return -EINVAL;
894
895 switch (sel->target) {
896 case V4L2_SEL_TGT_COMPOSE:
897 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
898 sel->r = yi->main_rect;
899 else
900 sel->r = itv->main_rect;
901 return 0;
902 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
903 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
904 r.height = itv->is_out_50hz ? 576 : 480;
905 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
906 r.width = yi->osd_full_w;
907 r.height = yi->osd_full_h;
908 }
909 sel->r = r;
910 return 0;
911 }
912 return -EINVAL;
913}
914
915static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
916{
917 static const struct v4l2_fmtdesc hm12 = {
918 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
919 .description = "HM12 (YUV 4:2:0)",
920 .pixelformat = V4L2_PIX_FMT_HM12,
921 };
922 static const struct v4l2_fmtdesc mpeg = {
923 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
924 .flags = V4L2_FMT_FLAG_COMPRESSED,
925 .description = "MPEG",
926 .pixelformat = V4L2_PIX_FMT_MPEG,
927 };
928 struct ivtv *itv = fh2id(fh)->itv;
929 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
930
931 if (fmt->index)
932 return -EINVAL;
933 if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
934 *fmt = mpeg;
935 else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
936 *fmt = hm12;
937 else
938 return -EINVAL;
939 return 0;
940}
941
942static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
943{
944 static const struct v4l2_fmtdesc hm12 = {
945 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
946 .description = "HM12 (YUV 4:2:0)",
947 .pixelformat = V4L2_PIX_FMT_HM12,
948 };
949 static const struct v4l2_fmtdesc mpeg = {
950 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
951 .flags = V4L2_FMT_FLAG_COMPRESSED,
952 .description = "MPEG",
953 .pixelformat = V4L2_PIX_FMT_MPEG,
954 };
955 struct ivtv *itv = fh2id(fh)->itv;
956 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
957
958 if (fmt->index)
959 return -EINVAL;
960 if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
961 *fmt = mpeg;
962 else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
963 *fmt = hm12;
964 else
965 return -EINVAL;
966 return 0;
967}
968
969static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
970{
971 struct ivtv *itv = fh2id(fh)->itv;
972
973 *i = itv->active_input;
974
975 return 0;
976}
977
978int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
979{
980 struct ivtv *itv = fh2id(fh)->itv;
981 v4l2_std_id std;
982 int i;
983
984 if (inp >= itv->nof_inputs)
985 return -EINVAL;
986
987 if (inp == itv->active_input) {
988 IVTV_DEBUG_INFO("Input unchanged\n");
989 return 0;
990 }
991
992 if (atomic_read(&itv->capturing) > 0) {
993 return -EBUSY;
994 }
995
996 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
997 itv->active_input, inp);
998
999 itv->active_input = inp;
1000
1001
1002 itv->audio_input = itv->card->video_inputs[inp].audio_index;
1003
1004 if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
1005 std = itv->tuner_std;
1006 else
1007 std = V4L2_STD_ALL;
1008 for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
1009 itv->streams[i].vdev.tvnorms = std;
1010
1011
1012
1013 ivtv_mute(itv);
1014 ivtv_video_set_io(itv);
1015 ivtv_audio_set_io(itv);
1016 ivtv_unmute(itv);
1017
1018 return 0;
1019}
1020
1021static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1022{
1023 struct ivtv *itv = fh2id(fh)->itv;
1024
1025 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1026 return -EINVAL;
1027
1028 *i = itv->active_output;
1029
1030 return 0;
1031}
1032
1033static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1034{
1035 struct ivtv *itv = fh2id(fh)->itv;
1036
1037 if (outp >= itv->card->nof_outputs)
1038 return -EINVAL;
1039
1040 if (outp == itv->active_output) {
1041 IVTV_DEBUG_INFO("Output unchanged\n");
1042 return 0;
1043 }
1044 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1045 itv->active_output, outp);
1046
1047 itv->active_output = outp;
1048 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1049 SAA7127_INPUT_TYPE_NORMAL,
1050 itv->card->video_outputs[outp].video_output, 0);
1051
1052 return 0;
1053}
1054
1055static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1056{
1057 struct ivtv *itv = fh2id(fh)->itv;
1058 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1059
1060 if (s->vdev.vfl_dir)
1061 return -ENOTTY;
1062 if (vf->tuner != 0)
1063 return -EINVAL;
1064
1065 ivtv_call_all(itv, tuner, g_frequency, vf);
1066 return 0;
1067}
1068
1069int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1070{
1071 struct ivtv *itv = fh2id(fh)->itv;
1072 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1073
1074 if (s->vdev.vfl_dir)
1075 return -ENOTTY;
1076 if (vf->tuner != 0)
1077 return -EINVAL;
1078
1079 ivtv_mute(itv);
1080 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1081 ivtv_call_all(itv, tuner, s_frequency, vf);
1082 ivtv_unmute(itv);
1083 return 0;
1084}
1085
1086static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1087{
1088 struct ivtv *itv = fh2id(fh)->itv;
1089
1090 *std = itv->std;
1091 return 0;
1092}
1093
1094void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1095{
1096 itv->std = std;
1097 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1098 itv->is_50hz = !itv->is_60hz;
1099 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1100 itv->cxhdl.width = 720;
1101 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1102 itv->vbi.count = itv->is_50hz ? 18 : 12;
1103 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1104 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1105
1106 if (itv->hw_flags & IVTV_HW_CX25840)
1107 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1108
1109
1110 ivtv_call_all(itv, video, s_std, itv->std);
1111}
1112
1113void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1114{
1115 struct yuv_playback_info *yi = &itv->yuv_info;
1116 DEFINE_WAIT(wait);
1117 int f;
1118
1119
1120 itv->std_out = std;
1121 itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1122 itv->is_out_50hz = !itv->is_out_60hz;
1123 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1124
1125
1126
1127
1128
1129
1130
1131 mutex_unlock(&itv->serialize_lock);
1132 for (f = 0; f < 4; f++) {
1133 prepare_to_wait(&itv->vsync_waitq, &wait,
1134 TASK_UNINTERRUPTIBLE);
1135 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1136 break;
1137 schedule_timeout(msecs_to_jiffies(25));
1138 }
1139 finish_wait(&itv->vsync_waitq, &wait);
1140 mutex_lock(&itv->serialize_lock);
1141
1142 if (f == 4)
1143 IVTV_WARN("Mode change failed to sync to decoder\n");
1144
1145 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1146 itv->main_rect.left = 0;
1147 itv->main_rect.top = 0;
1148 itv->main_rect.width = 720;
1149 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1150 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1151 720, itv->main_rect.height, 0, 0);
1152 yi->main_rect = itv->main_rect;
1153 if (!itv->osd_info) {
1154 yi->osd_full_w = 720;
1155 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1156 }
1157}
1158
1159static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1160{
1161 struct ivtv *itv = fh2id(fh)->itv;
1162
1163 if ((std & V4L2_STD_ALL) == 0)
1164 return -EINVAL;
1165
1166 if (std == itv->std)
1167 return 0;
1168
1169 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1170 atomic_read(&itv->capturing) > 0 ||
1171 atomic_read(&itv->decoding) > 0) {
1172
1173
1174 return -EBUSY;
1175 }
1176
1177 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1178 (unsigned long long)itv->std);
1179
1180 ivtv_s_std_enc(itv, std);
1181 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1182 ivtv_s_std_dec(itv, std);
1183
1184 return 0;
1185}
1186
1187static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1188{
1189 struct ivtv_open_id *id = fh2id(fh);
1190 struct ivtv *itv = id->itv;
1191
1192 if (vt->index != 0)
1193 return -EINVAL;
1194
1195 ivtv_call_all(itv, tuner, s_tuner, vt);
1196
1197 return 0;
1198}
1199
1200static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1201{
1202 struct ivtv *itv = fh2id(fh)->itv;
1203
1204 if (vt->index != 0)
1205 return -EINVAL;
1206
1207 ivtv_call_all(itv, tuner, g_tuner, vt);
1208
1209 if (vt->type == V4L2_TUNER_RADIO)
1210 strscpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1211 else
1212 strscpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1213 return 0;
1214}
1215
1216static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1217{
1218 struct ivtv *itv = fh2id(fh)->itv;
1219 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1220 int f, l;
1221
1222 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1223 for (f = 0; f < 2; f++) {
1224 for (l = 0; l < 24; l++) {
1225 if (valid_service_line(f, l, itv->is_50hz))
1226 cap->service_lines[f][l] = set;
1227 }
1228 }
1229 } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1230 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1231 return -EINVAL;
1232 if (itv->is_60hz) {
1233 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1234 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1235 } else {
1236 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1237 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1238 }
1239 } else {
1240 return -EINVAL;
1241 }
1242
1243 set = 0;
1244 for (f = 0; f < 2; f++)
1245 for (l = 0; l < 24; l++)
1246 set |= cap->service_lines[f][l];
1247 cap->service_set = set;
1248 return 0;
1249}
1250
1251static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1252{
1253 struct ivtv *itv = fh2id(fh)->itv;
1254 struct v4l2_enc_idx_entry *e = idx->entry;
1255 int entries;
1256 int i;
1257
1258 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1259 IVTV_MAX_PGM_INDEX;
1260 if (entries > V4L2_ENC_IDX_ENTRIES)
1261 entries = V4L2_ENC_IDX_ENTRIES;
1262 idx->entries = 0;
1263 idx->entries_cap = IVTV_MAX_PGM_INDEX;
1264 if (!atomic_read(&itv->capturing))
1265 return 0;
1266 for (i = 0; i < entries; i++) {
1267 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1268 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1269 idx->entries++;
1270 e++;
1271 }
1272 }
1273 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1274 return 0;
1275}
1276
1277static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1278{
1279 struct ivtv_open_id *id = fh2id(fh);
1280 struct ivtv *itv = id->itv;
1281
1282
1283 switch (enc->cmd) {
1284 case V4L2_ENC_CMD_START:
1285 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1286 enc->flags = 0;
1287 return ivtv_start_capture(id);
1288
1289 case V4L2_ENC_CMD_STOP:
1290 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1291 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1292 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1293 return 0;
1294
1295 case V4L2_ENC_CMD_PAUSE:
1296 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1297 enc->flags = 0;
1298
1299 if (!atomic_read(&itv->capturing))
1300 return -EPERM;
1301 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1302 return 0;
1303
1304 ivtv_mute(itv);
1305 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1306 break;
1307
1308 case V4L2_ENC_CMD_RESUME:
1309 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1310 enc->flags = 0;
1311
1312 if (!atomic_read(&itv->capturing))
1313 return -EPERM;
1314
1315 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1316 return 0;
1317
1318 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1319 ivtv_unmute(itv);
1320 break;
1321 default:
1322 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1323 return -EINVAL;
1324 }
1325
1326 return 0;
1327}
1328
1329static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1330{
1331 struct ivtv *itv = fh2id(fh)->itv;
1332
1333 switch (enc->cmd) {
1334 case V4L2_ENC_CMD_START:
1335 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1336 enc->flags = 0;
1337 return 0;
1338
1339 case V4L2_ENC_CMD_STOP:
1340 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1341 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1342 return 0;
1343
1344 case V4L2_ENC_CMD_PAUSE:
1345 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1346 enc->flags = 0;
1347 return 0;
1348
1349 case V4L2_ENC_CMD_RESUME:
1350 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1351 enc->flags = 0;
1352 return 0;
1353 default:
1354 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1355 return -EINVAL;
1356 }
1357}
1358
1359static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1360{
1361 struct ivtv *itv = fh2id(fh)->itv;
1362 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1363 u32 data[CX2341X_MBOX_MAX_DATA];
1364 struct yuv_playback_info *yi = &itv->yuv_info;
1365
1366 int pixfmt;
1367 static u32 pixel_format[16] = {
1368 V4L2_PIX_FMT_PAL8,
1369 V4L2_PIX_FMT_RGB565,
1370 V4L2_PIX_FMT_RGB555,
1371 V4L2_PIX_FMT_RGB444,
1372 V4L2_PIX_FMT_RGB32,
1373 0,
1374 0,
1375 0,
1376 V4L2_PIX_FMT_PAL8,
1377 V4L2_PIX_FMT_YUV565,
1378 V4L2_PIX_FMT_YUV555,
1379 V4L2_PIX_FMT_YUV444,
1380 V4L2_PIX_FMT_YUV32,
1381 0,
1382 0,
1383 0,
1384 };
1385
1386 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1387 return -ENOTTY;
1388 if (!itv->osd_video_pbase)
1389 return -ENOTTY;
1390
1391 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1392 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1393
1394 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1395 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1396 pixfmt = (data[0] >> 3) & 0xf;
1397
1398 fb->fmt.pixelformat = pixel_format[pixfmt];
1399 fb->fmt.width = itv->osd_rect.width;
1400 fb->fmt.height = itv->osd_rect.height;
1401 fb->fmt.field = V4L2_FIELD_INTERLACED;
1402 fb->fmt.bytesperline = fb->fmt.width;
1403 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1404 fb->fmt.field = V4L2_FIELD_INTERLACED;
1405 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1406 fb->fmt.bytesperline *= 2;
1407 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1408 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1409 fb->fmt.bytesperline *= 2;
1410 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1411 fb->base = (void *)itv->osd_video_pbase;
1412 fb->flags = 0;
1413
1414 if (itv->osd_chroma_key_state)
1415 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1416
1417 if (itv->osd_global_alpha_state)
1418 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1419
1420 if (yi->track_osd)
1421 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1422
1423 pixfmt &= 7;
1424
1425
1426 if (pixfmt == 1 || pixfmt > 4)
1427 return 0;
1428
1429
1430 if (pixfmt == 2 || pixfmt == 3)
1431 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1432 else
1433 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1434
1435 if (itv->osd_local_alpha_state) {
1436
1437 if (pixfmt == 2 || pixfmt == 3)
1438 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1439 else
1440 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1441 }
1442
1443 return 0;
1444}
1445
1446static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1447{
1448 struct ivtv_open_id *id = fh2id(fh);
1449 struct ivtv *itv = id->itv;
1450 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1451 struct yuv_playback_info *yi = &itv->yuv_info;
1452
1453 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1454 return -ENOTTY;
1455 if (!itv->osd_video_pbase)
1456 return -ENOTTY;
1457
1458 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1459 itv->osd_local_alpha_state =
1460 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1461 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1462 ivtv_set_osd_alpha(itv);
1463 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1464 return 0;
1465}
1466
1467static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1468{
1469 struct ivtv_open_id *id = fh2id(fh);
1470 struct ivtv *itv = id->itv;
1471 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1472
1473 if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1474 return -ENOTTY;
1475 if (!itv->osd_video_pbase)
1476 return -ENOTTY;
1477
1478 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1479
1480 return 0;
1481}
1482
1483static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1484{
1485 switch (sub->type) {
1486 case V4L2_EVENT_VSYNC:
1487 case V4L2_EVENT_EOS:
1488 return v4l2_event_subscribe(fh, sub, 0, NULL);
1489 default:
1490 return v4l2_ctrl_subscribe_event(fh, sub);
1491 }
1492}
1493
1494static int ivtv_log_status(struct file *file, void *fh)
1495{
1496 struct ivtv *itv = fh2id(fh)->itv;
1497 u32 data[CX2341X_MBOX_MAX_DATA];
1498
1499 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1500 struct v4l2_input vidin;
1501 struct v4l2_audio audin;
1502 int i;
1503
1504 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1505 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1506 struct tveeprom tv;
1507
1508 ivtv_read_eeprom(itv, &tv);
1509 }
1510 ivtv_call_all(itv, core, log_status);
1511 ivtv_get_input(itv, itv->active_input, &vidin);
1512 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1513 IVTV_INFO("Video Input: %s\n", vidin.name);
1514 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1515 itv->dualwatch_stereo_mode == V4L2_MPEG_AUDIO_MODE_DUAL ?
1516 " (Bilingual)" : "");
1517 if (has_output) {
1518 struct v4l2_output vidout;
1519 struct v4l2_audioout audout;
1520 int mode = itv->output_mode;
1521 static const char * const output_modes[5] = {
1522 "None",
1523 "MPEG Streaming",
1524 "YUV Streaming",
1525 "YUV Frames",
1526 "Passthrough",
1527 };
1528 static const char * const alpha_mode[4] = {
1529 "None",
1530 "Global",
1531 "Local",
1532 "Global and Local"
1533 };
1534 static const char * const pixel_format[16] = {
1535 "ARGB Indexed",
1536 "RGB 5:6:5",
1537 "ARGB 1:5:5:5",
1538 "ARGB 1:4:4:4",
1539 "ARGB 8:8:8:8",
1540 "5",
1541 "6",
1542 "7",
1543 "AYUV Indexed",
1544 "YUV 5:6:5",
1545 "AYUV 1:5:5:5",
1546 "AYUV 1:4:4:4",
1547 "AYUV 8:8:8:8",
1548 "13",
1549 "14",
1550 "15",
1551 };
1552
1553 ivtv_get_output(itv, itv->active_output, &vidout);
1554 ivtv_get_audio_output(itv, 0, &audout);
1555 IVTV_INFO("Video Output: %s\n", vidout.name);
1556 if (mode < 0 || mode > OUT_PASSTHROUGH)
1557 mode = OUT_NONE;
1558 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1559 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1560 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1561 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1562 data[0] & 1 ? "On" : "Off",
1563 alpha_mode[(data[0] >> 1) & 0x3],
1564 pixel_format[(data[0] >> 3) & 0xf]);
1565 }
1566 IVTV_INFO("Tuner: %s\n",
1567 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1568 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1569 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1570 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1571 struct ivtv_stream *s = &itv->streams[i];
1572
1573 if (s->vdev.v4l2_dev == NULL || s->buffers == 0)
1574 continue;
1575 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1576 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1577 (s->buffers * s->buf_size) / 1024, s->buffers);
1578 }
1579
1580 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1581 (long long)itv->mpg_data_received,
1582 (long long)itv->vbi_data_inserted);
1583 return 0;
1584}
1585
1586static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1587{
1588 struct ivtv_open_id *id = fh2id(file->private_data);
1589 struct ivtv *itv = id->itv;
1590
1591 IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1592 return ivtv_video_command(itv, id, dec, false);
1593}
1594
1595static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1596{
1597 struct ivtv_open_id *id = fh2id(file->private_data);
1598 struct ivtv *itv = id->itv;
1599
1600 IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1601 return ivtv_video_command(itv, id, dec, true);
1602}
1603
1604static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1605{
1606 struct ivtv_open_id *id = fh2id(filp->private_data);
1607 struct ivtv *itv = id->itv;
1608 struct ivtv_stream *s = &itv->streams[id->type];
1609
1610 switch (cmd) {
1611 case IVTV_IOC_DMA_FRAME: {
1612 struct ivtv_dma_frame *args = arg;
1613
1614 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1615 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1616 return -EINVAL;
1617 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1618 return -EINVAL;
1619 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1620 return 0;
1621 if (ivtv_start_decoding(id, id->type)) {
1622 return -EBUSY;
1623 }
1624 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1625 ivtv_release_stream(s);
1626 return -EBUSY;
1627 }
1628
1629 id->yuv_frames = 1;
1630 if (args->y_source == NULL)
1631 return 0;
1632 return ivtv_yuv_prep_frame(itv, args);
1633 }
1634
1635 case IVTV_IOC_PASSTHROUGH_MODE:
1636 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1637 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1638 return -EINVAL;
1639 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1640 default:
1641 return -EINVAL;
1642 }
1643 return 0;
1644}
1645
1646static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1647 unsigned int cmd, void *arg)
1648{
1649 struct ivtv *itv = fh2id(fh)->itv;
1650
1651 if (!valid_prio) {
1652 switch (cmd) {
1653 case IVTV_IOC_PASSTHROUGH_MODE:
1654 return -EBUSY;
1655 }
1656 }
1657
1658 switch (cmd) {
1659 case VIDIOC_INT_RESET: {
1660 u32 val = *(u32 *)arg;
1661
1662 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1663 ivtv_reset_ir_gpio(itv);
1664 if (val & 0x02)
1665 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1666 break;
1667 }
1668
1669 case IVTV_IOC_DMA_FRAME:
1670 case IVTV_IOC_PASSTHROUGH_MODE:
1671 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1672
1673 default:
1674 return -ENOTTY;
1675 }
1676 return 0;
1677}
1678
1679static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1680 .vidioc_querycap = ivtv_querycap,
1681 .vidioc_s_audio = ivtv_s_audio,
1682 .vidioc_g_audio = ivtv_g_audio,
1683 .vidioc_enumaudio = ivtv_enumaudio,
1684 .vidioc_s_audout = ivtv_s_audout,
1685 .vidioc_g_audout = ivtv_g_audout,
1686 .vidioc_enum_input = ivtv_enum_input,
1687 .vidioc_enum_output = ivtv_enum_output,
1688 .vidioc_enumaudout = ivtv_enumaudout,
1689 .vidioc_g_pixelaspect = ivtv_g_pixelaspect,
1690 .vidioc_s_selection = ivtv_s_selection,
1691 .vidioc_g_selection = ivtv_g_selection,
1692 .vidioc_g_input = ivtv_g_input,
1693 .vidioc_s_input = ivtv_s_input,
1694 .vidioc_g_output = ivtv_g_output,
1695 .vidioc_s_output = ivtv_s_output,
1696 .vidioc_g_frequency = ivtv_g_frequency,
1697 .vidioc_s_frequency = ivtv_s_frequency,
1698 .vidioc_s_tuner = ivtv_s_tuner,
1699 .vidioc_g_tuner = ivtv_g_tuner,
1700 .vidioc_g_enc_index = ivtv_g_enc_index,
1701 .vidioc_g_fbuf = ivtv_g_fbuf,
1702 .vidioc_s_fbuf = ivtv_s_fbuf,
1703 .vidioc_g_std = ivtv_g_std,
1704 .vidioc_s_std = ivtv_s_std,
1705 .vidioc_overlay = ivtv_overlay,
1706 .vidioc_log_status = ivtv_log_status,
1707 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1708 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1709 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1710 .vidioc_decoder_cmd = ivtv_decoder_cmd,
1711 .vidioc_try_decoder_cmd = ivtv_try_decoder_cmd,
1712 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1713 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1714 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1715 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1716 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1717 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1718 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1719 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1720 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1721 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1722 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1723 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1724 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1725 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1726 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1727 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1728 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1729 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1730 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1731 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1732#ifdef CONFIG_VIDEO_ADV_DEBUG
1733 .vidioc_g_register = ivtv_g_register,
1734 .vidioc_s_register = ivtv_s_register,
1735#endif
1736 .vidioc_default = ivtv_default,
1737 .vidioc_subscribe_event = ivtv_subscribe_event,
1738 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1739};
1740
1741void ivtv_set_funcs(struct video_device *vdev)
1742{
1743 vdev->ioctl_ops = &ivtv_ioctl_ops;
1744}
1745
