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