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