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