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