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