xref: /linux/drivers/media/pci/ivtv/ivtv-ioctl.c (revision 5c8166419acf468b5bc3e48f928a040485d3e0c2)
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->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->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 	snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
736 	vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
737 	return 0;
738 }
739 
740 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
741 {
742 	struct ivtv *itv = fh2id(fh)->itv;
743 
744 	return ivtv_get_audio_input(itv, vin->index, vin);
745 }
746 
747 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
748 {
749 	struct ivtv *itv = fh2id(fh)->itv;
750 
751 	vin->index = itv->audio_input;
752 	return ivtv_get_audio_input(itv, vin->index, vin);
753 }
754 
755 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
756 {
757 	struct ivtv *itv = fh2id(fh)->itv;
758 
759 	if (vout->index >= itv->nof_audio_inputs)
760 		return -EINVAL;
761 
762 	itv->audio_input = vout->index;
763 	ivtv_audio_set_io(itv);
764 
765 	return 0;
766 }
767 
768 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
769 {
770 	struct ivtv *itv = fh2id(fh)->itv;
771 
772 	/* set it to defaults from our table */
773 	return ivtv_get_audio_output(itv, vin->index, vin);
774 }
775 
776 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
777 {
778 	struct ivtv *itv = fh2id(fh)->itv;
779 
780 	vin->index = 0;
781 	return ivtv_get_audio_output(itv, vin->index, vin);
782 }
783 
784 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
785 {
786 	struct ivtv *itv = fh2id(fh)->itv;
787 
788 	if (itv->card->video_outputs == NULL || vout->index != 0)
789 		return -EINVAL;
790 	return 0;
791 }
792 
793 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
794 {
795 	struct ivtv *itv = fh2id(fh)->itv;
796 
797 	/* set it to defaults from our table */
798 	return ivtv_get_input(itv, vin->index, vin);
799 }
800 
801 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
802 {
803 	struct ivtv *itv = fh2id(fh)->itv;
804 
805 	return ivtv_get_output(itv, vout->index, vout);
806 }
807 
808 static int ivtv_g_pixelaspect(struct file *file, void *fh,
809 			      int type, struct v4l2_fract *f)
810 {
811 	struct ivtv_open_id *id = fh2id(fh);
812 	struct ivtv *itv = id->itv;
813 
814 	if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
815 		f->numerator = itv->is_50hz ? 54 : 11;
816 		f->denominator = itv->is_50hz ? 59 : 10;
817 	} else if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
818 		f->numerator = itv->is_out_50hz ? 54 : 11;
819 		f->denominator = itv->is_out_50hz ? 59 : 10;
820 	} else {
821 		return -EINVAL;
822 	}
823 	return 0;
824 }
825 
826 static int ivtv_s_selection(struct file *file, void *fh,
827 			    struct v4l2_selection *sel)
828 {
829 	struct ivtv_open_id *id = fh2id(fh);
830 	struct ivtv *itv = id->itv;
831 	struct yuv_playback_info *yi = &itv->yuv_info;
832 	struct v4l2_rect r = { 0, 0, 720, 0 };
833 	int streamtype = id->type;
834 
835 	if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
836 	    !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
837 		return -EINVAL;
838 
839 	if (sel->target != V4L2_SEL_TGT_COMPOSE)
840 		return -EINVAL;
841 
842 
843 	if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
844 	    !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
845 		return -EINVAL;
846 
847 	r.height = itv->is_out_50hz ? 576 : 480;
848 	if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
849 		r.width = yi->osd_full_w;
850 		r.height = yi->osd_full_h;
851 	}
852 	sel->r.width = clamp(sel->r.width, 16U, r.width);
853 	sel->r.height = clamp(sel->r.height, 16U, r.height);
854 	sel->r.left = clamp_t(unsigned, sel->r.left, 0, r.width - sel->r.width);
855 	sel->r.top = clamp_t(unsigned, sel->r.top, 0, r.height - sel->r.height);
856 
857 	if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
858 		yi->main_rect = sel->r;
859 		return 0;
860 	}
861 	if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
862 			sel->r.width, sel->r.height, sel->r.left, sel->r.top)) {
863 		itv->main_rect = sel->r;
864 		return 0;
865 	}
866 	return -EINVAL;
867 }
868 
869 static int ivtv_g_selection(struct file *file, void *fh,
870 			    struct v4l2_selection *sel)
871 {
872 	struct ivtv_open_id *id = fh2id(fh);
873 	struct ivtv *itv = id->itv;
874 	struct yuv_playback_info *yi = &itv->yuv_info;
875 	struct v4l2_rect r = { 0, 0, 720, 0 };
876 	int streamtype = id->type;
877 
878 	if (sel->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
879 		switch (sel->target) {
880 		case V4L2_SEL_TGT_CROP_DEFAULT:
881 		case V4L2_SEL_TGT_CROP_BOUNDS:
882 			sel->r.top = sel->r.left = 0;
883 			sel->r.width = 720;
884 			sel->r.height = itv->is_50hz ? 576 : 480;
885 			return 0;
886 		default:
887 			return -EINVAL;
888 		}
889 	}
890 
891 	if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
892 	    !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
893 		return -EINVAL;
894 
895 	switch (sel->target) {
896 	case V4L2_SEL_TGT_COMPOSE:
897 		if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
898 			sel->r = yi->main_rect;
899 		else
900 			sel->r = itv->main_rect;
901 		return 0;
902 	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
903 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
904 		r.height = itv->is_out_50hz ? 576 : 480;
905 		if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
906 			r.width = yi->osd_full_w;
907 			r.height = yi->osd_full_h;
908 		}
909 		sel->r = r;
910 		return 0;
911 	}
912 	return -EINVAL;
913 }
914 
915 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
916 {
917 	static const struct v4l2_fmtdesc hm12 = {
918 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
919 		.description = "HM12 (YUV 4:2:0)",
920 		.pixelformat = V4L2_PIX_FMT_NV12_16L16,
921 	};
922 	static const struct v4l2_fmtdesc mpeg = {
923 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
924 		.flags = V4L2_FMT_FLAG_COMPRESSED,
925 		.description = "MPEG",
926 		.pixelformat = V4L2_PIX_FMT_MPEG,
927 	};
928 	struct ivtv *itv = fh2id(fh)->itv;
929 	struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
930 
931 	if (fmt->index)
932 		return -EINVAL;
933 	if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
934 		*fmt = mpeg;
935 	else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
936 		*fmt = hm12;
937 	else
938 		return -EINVAL;
939 	return 0;
940 }
941 
942 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
943 {
944 	static const struct v4l2_fmtdesc hm12 = {
945 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
946 		.description = "HM12 (YUV 4:2:0)",
947 		.pixelformat = V4L2_PIX_FMT_NV12_16L16,
948 	};
949 	static const struct v4l2_fmtdesc mpeg = {
950 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
951 		.flags = V4L2_FMT_FLAG_COMPRESSED,
952 		.description = "MPEG",
953 		.pixelformat = V4L2_PIX_FMT_MPEG,
954 	};
955 	struct ivtv *itv = fh2id(fh)->itv;
956 	struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
957 
958 	if (fmt->index)
959 		return -EINVAL;
960 	if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
961 		*fmt = mpeg;
962 	else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
963 		*fmt = hm12;
964 	else
965 		return -EINVAL;
966 	return 0;
967 }
968 
969 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
970 {
971 	struct ivtv *itv = fh2id(fh)->itv;
972 
973 	*i = itv->active_input;
974 
975 	return 0;
976 }
977 
978 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
979 {
980 	struct ivtv *itv = fh2id(fh)->itv;
981 	v4l2_std_id std;
982 	int i;
983 
984 	if (inp >= itv->nof_inputs)
985 		return -EINVAL;
986 
987 	if (inp == itv->active_input) {
988 		IVTV_DEBUG_INFO("Input unchanged\n");
989 		return 0;
990 	}
991 
992 	if (atomic_read(&itv->capturing) > 0) {
993 		return -EBUSY;
994 	}
995 
996 	IVTV_DEBUG_INFO("Changing input from %d to %d\n",
997 			itv->active_input, inp);
998 
999 	itv->active_input = inp;
1000 	/* Set the audio input to whatever is appropriate for the
1001 	   input type. */
1002 	itv->audio_input = itv->card->video_inputs[inp].audio_index;
1003 
1004 	if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
1005 		std = itv->tuner_std;
1006 	else
1007 		std = V4L2_STD_ALL;
1008 	for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
1009 		itv->streams[i].vdev.tvnorms = std;
1010 
1011 	/* prevent others from messing with the streams until
1012 	   we're finished changing inputs. */
1013 	ivtv_mute(itv);
1014 	ivtv_video_set_io(itv);
1015 	ivtv_audio_set_io(itv);
1016 	ivtv_unmute(itv);
1017 
1018 	return 0;
1019 }
1020 
1021 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1022 {
1023 	struct ivtv *itv = fh2id(fh)->itv;
1024 
1025 	if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1026 		return -EINVAL;
1027 
1028 	*i = itv->active_output;
1029 
1030 	return 0;
1031 }
1032 
1033 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1034 {
1035 	struct ivtv *itv = fh2id(fh)->itv;
1036 
1037 	if (outp >= itv->card->nof_outputs)
1038 		return -EINVAL;
1039 
1040 	if (outp == itv->active_output) {
1041 		IVTV_DEBUG_INFO("Output unchanged\n");
1042 		return 0;
1043 	}
1044 	IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1045 		   itv->active_output, outp);
1046 
1047 	itv->active_output = outp;
1048 	ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1049 			SAA7127_INPUT_TYPE_NORMAL,
1050 			itv->card->video_outputs[outp].video_output, 0);
1051 
1052 	return 0;
1053 }
1054 
1055 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1056 {
1057 	struct ivtv *itv = fh2id(fh)->itv;
1058 	struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1059 
1060 	if (s->vdev.vfl_dir)
1061 		return -ENOTTY;
1062 	if (vf->tuner != 0)
1063 		return -EINVAL;
1064 
1065 	ivtv_call_all(itv, tuner, g_frequency, vf);
1066 	return 0;
1067 }
1068 
1069 int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1070 {
1071 	struct ivtv *itv = fh2id(fh)->itv;
1072 	struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1073 
1074 	if (s->vdev.vfl_dir)
1075 		return -ENOTTY;
1076 	if (vf->tuner != 0)
1077 		return -EINVAL;
1078 
1079 	ivtv_mute(itv);
1080 	IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1081 	ivtv_call_all(itv, tuner, s_frequency, vf);
1082 	ivtv_unmute(itv);
1083 	return 0;
1084 }
1085 
1086 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1087 {
1088 	struct ivtv *itv = fh2id(fh)->itv;
1089 
1090 	*std = itv->std;
1091 	return 0;
1092 }
1093 
1094 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1095 {
1096 	itv->std = std;
1097 	itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1098 	itv->is_50hz = !itv->is_60hz;
1099 	cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1100 	itv->cxhdl.width = 720;
1101 	itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1102 	itv->vbi.count = itv->is_50hz ? 18 : 12;
1103 	itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1104 	itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1105 
1106 	if (itv->hw_flags & IVTV_HW_CX25840)
1107 		itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1108 
1109 	/* Tuner */
1110 	ivtv_call_all(itv, video, s_std, itv->std);
1111 }
1112 
1113 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1114 {
1115 	struct yuv_playback_info *yi = &itv->yuv_info;
1116 	DEFINE_WAIT(wait);
1117 	int f;
1118 
1119 	/* set display standard */
1120 	itv->std_out = std;
1121 	itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1122 	itv->is_out_50hz = !itv->is_out_60hz;
1123 	ivtv_call_all(itv, video, s_std_output, itv->std_out);
1124 
1125 	/*
1126 	 * The next firmware call is time sensitive. Time it to
1127 	 * avoid risk of a hard lock, by trying to ensure the call
1128 	 * happens within the first 100 lines of the top field.
1129 	 * Make 4 attempts to sync to the decoder before giving up.
1130 	 */
1131 	mutex_unlock(&itv->serialize_lock);
1132 	for (f = 0; f < 4; f++) {
1133 		prepare_to_wait(&itv->vsync_waitq, &wait,
1134 				TASK_UNINTERRUPTIBLE);
1135 		if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1136 			break;
1137 		schedule_timeout(msecs_to_jiffies(25));
1138 	}
1139 	finish_wait(&itv->vsync_waitq, &wait);
1140 	mutex_lock(&itv->serialize_lock);
1141 
1142 	if (f == 4)
1143 		IVTV_WARN("Mode change failed to sync to decoder\n");
1144 
1145 	ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1146 	itv->main_rect.left = 0;
1147 	itv->main_rect.top = 0;
1148 	itv->main_rect.width = 720;
1149 	itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1150 	ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1151 		720, itv->main_rect.height, 0, 0);
1152 	yi->main_rect = itv->main_rect;
1153 	if (!itv->osd_info) {
1154 		yi->osd_full_w = 720;
1155 		yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1156 	}
1157 }
1158 
1159 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1160 {
1161 	struct ivtv *itv = fh2id(fh)->itv;
1162 
1163 	if ((std & V4L2_STD_ALL) == 0)
1164 		return -EINVAL;
1165 
1166 	if (std == itv->std)
1167 		return 0;
1168 
1169 	if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1170 	    atomic_read(&itv->capturing) > 0 ||
1171 	    atomic_read(&itv->decoding) > 0) {
1172 		/* Switching standard would mess with already running
1173 		   streams, prevent that by returning EBUSY. */
1174 		return -EBUSY;
1175 	}
1176 
1177 	IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1178 		(unsigned long long)itv->std);
1179 
1180 	ivtv_s_std_enc(itv, std);
1181 	if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1182 		ivtv_s_std_dec(itv, std);
1183 
1184 	return 0;
1185 }
1186 
1187 static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1188 {
1189 	struct ivtv_open_id *id = fh2id(fh);
1190 	struct ivtv *itv = id->itv;
1191 
1192 	if (vt->index != 0)
1193 		return -EINVAL;
1194 
1195 	ivtv_call_all(itv, tuner, s_tuner, vt);
1196 
1197 	return 0;
1198 }
1199 
1200 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1201 {
1202 	struct ivtv *itv = fh2id(fh)->itv;
1203 
1204 	if (vt->index != 0)
1205 		return -EINVAL;
1206 
1207 	ivtv_call_all(itv, tuner, g_tuner, vt);
1208 
1209 	if (vt->type == V4L2_TUNER_RADIO)
1210 		strscpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1211 	else
1212 		strscpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1213 	return 0;
1214 }
1215 
1216 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1217 {
1218 	struct ivtv *itv = fh2id(fh)->itv;
1219 	int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1220 	int f, l;
1221 
1222 	if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1223 		for (f = 0; f < 2; f++) {
1224 			for (l = 0; l < 24; l++) {
1225 				if (valid_service_line(f, l, itv->is_50hz))
1226 					cap->service_lines[f][l] = set;
1227 			}
1228 		}
1229 	} else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1230 		if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1231 			return -EINVAL;
1232 		if (itv->is_60hz) {
1233 			cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1234 			cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1235 		} else {
1236 			cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1237 			cap->service_lines[0][16] = V4L2_SLICED_VPS;
1238 		}
1239 	} else {
1240 		return -EINVAL;
1241 	}
1242 
1243 	set = 0;
1244 	for (f = 0; f < 2; f++)
1245 		for (l = 0; l < 24; l++)
1246 			set |= cap->service_lines[f][l];
1247 	cap->service_set = set;
1248 	return 0;
1249 }
1250 
1251 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1252 {
1253 	struct ivtv *itv = fh2id(fh)->itv;
1254 	struct v4l2_enc_idx_entry *e = idx->entry;
1255 	int entries;
1256 	int i;
1257 
1258 	entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1259 				IVTV_MAX_PGM_INDEX;
1260 	if (entries > V4L2_ENC_IDX_ENTRIES)
1261 		entries = V4L2_ENC_IDX_ENTRIES;
1262 	idx->entries = 0;
1263 	idx->entries_cap = IVTV_MAX_PGM_INDEX;
1264 	if (!atomic_read(&itv->capturing))
1265 		return 0;
1266 	for (i = 0; i < entries; i++) {
1267 		*e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1268 		if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1269 			idx->entries++;
1270 			e++;
1271 		}
1272 	}
1273 	itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1274 	return 0;
1275 }
1276 
1277 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1278 {
1279 	struct ivtv_open_id *id = fh2id(fh);
1280 	struct ivtv *itv = id->itv;
1281 
1282 
1283 	switch (enc->cmd) {
1284 	case V4L2_ENC_CMD_START:
1285 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1286 		enc->flags = 0;
1287 		return ivtv_start_capture(id);
1288 
1289 	case V4L2_ENC_CMD_STOP:
1290 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1291 		enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1292 		ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1293 		return 0;
1294 
1295 	case V4L2_ENC_CMD_PAUSE:
1296 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1297 		enc->flags = 0;
1298 
1299 		if (!atomic_read(&itv->capturing))
1300 			return -EPERM;
1301 		if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1302 			return 0;
1303 
1304 		ivtv_mute(itv);
1305 		ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1306 		break;
1307 
1308 	case V4L2_ENC_CMD_RESUME:
1309 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1310 		enc->flags = 0;
1311 
1312 		if (!atomic_read(&itv->capturing))
1313 			return -EPERM;
1314 
1315 		if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1316 			return 0;
1317 
1318 		ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1319 		ivtv_unmute(itv);
1320 		break;
1321 	default:
1322 		IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1323 		return -EINVAL;
1324 	}
1325 
1326 	return 0;
1327 }
1328 
1329 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1330 {
1331 	struct ivtv *itv = fh2id(fh)->itv;
1332 
1333 	switch (enc->cmd) {
1334 	case V4L2_ENC_CMD_START:
1335 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1336 		enc->flags = 0;
1337 		return 0;
1338 
1339 	case V4L2_ENC_CMD_STOP:
1340 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1341 		enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1342 		return 0;
1343 
1344 	case V4L2_ENC_CMD_PAUSE:
1345 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1346 		enc->flags = 0;
1347 		return 0;
1348 
1349 	case V4L2_ENC_CMD_RESUME:
1350 		IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1351 		enc->flags = 0;
1352 		return 0;
1353 	default:
1354 		IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1355 		return -EINVAL;
1356 	}
1357 }
1358 
1359 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1360 {
1361 	struct ivtv *itv = fh2id(fh)->itv;
1362 	struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1363 	u32 data[CX2341X_MBOX_MAX_DATA];
1364 	struct yuv_playback_info *yi = &itv->yuv_info;
1365 
1366 	int pixfmt;
1367 	static u32 pixel_format[16] = {
1368 		V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1369 		V4L2_PIX_FMT_RGB565,
1370 		V4L2_PIX_FMT_RGB555,
1371 		V4L2_PIX_FMT_RGB444,
1372 		V4L2_PIX_FMT_RGB32,
1373 		0,
1374 		0,
1375 		0,
1376 		V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1377 		V4L2_PIX_FMT_YUV565,
1378 		V4L2_PIX_FMT_YUV555,
1379 		V4L2_PIX_FMT_YUV444,
1380 		V4L2_PIX_FMT_YUV32,
1381 		0,
1382 		0,
1383 		0,
1384 	};
1385 
1386 	if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1387 		return -ENOTTY;
1388 	if (!itv->osd_video_pbase)
1389 		return -ENOTTY;
1390 
1391 	fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1392 		V4L2_FBUF_CAP_GLOBAL_ALPHA;
1393 
1394 	ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1395 	data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1396 	pixfmt = (data[0] >> 3) & 0xf;
1397 
1398 	fb->fmt.pixelformat = pixel_format[pixfmt];
1399 	fb->fmt.width = itv->osd_rect.width;
1400 	fb->fmt.height = itv->osd_rect.height;
1401 	fb->fmt.field = V4L2_FIELD_INTERLACED;
1402 	fb->fmt.bytesperline = fb->fmt.width;
1403 	fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1404 	fb->fmt.field = V4L2_FIELD_INTERLACED;
1405 	if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1406 		fb->fmt.bytesperline *= 2;
1407 	if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1408 	    fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1409 		fb->fmt.bytesperline *= 2;
1410 	fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1411 	fb->base = (void *)itv->osd_video_pbase;
1412 	fb->flags = 0;
1413 
1414 	if (itv->osd_chroma_key_state)
1415 		fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1416 
1417 	if (itv->osd_global_alpha_state)
1418 		fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1419 
1420 	if (yi->track_osd)
1421 		fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1422 
1423 	pixfmt &= 7;
1424 
1425 	/* no local alpha for RGB565 or unknown formats */
1426 	if (pixfmt == 1 || pixfmt > 4)
1427 		return 0;
1428 
1429 	/* 16-bit formats have inverted local alpha */
1430 	if (pixfmt == 2 || pixfmt == 3)
1431 		fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1432 	else
1433 		fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1434 
1435 	if (itv->osd_local_alpha_state) {
1436 		/* 16-bit formats have inverted local alpha */
1437 		if (pixfmt == 2 || pixfmt == 3)
1438 			fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1439 		else
1440 			fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1441 	}
1442 
1443 	return 0;
1444 }
1445 
1446 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1447 {
1448 	struct ivtv_open_id *id = fh2id(fh);
1449 	struct ivtv *itv = id->itv;
1450 	struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1451 	struct yuv_playback_info *yi = &itv->yuv_info;
1452 
1453 	if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1454 		return -ENOTTY;
1455 	if (!itv->osd_video_pbase)
1456 		return -ENOTTY;
1457 
1458 	itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1459 	itv->osd_local_alpha_state =
1460 		(fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1461 	itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1462 	ivtv_set_osd_alpha(itv);
1463 	yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1464 	return 0;
1465 }
1466 
1467 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1468 {
1469 	struct ivtv_open_id *id = fh2id(fh);
1470 	struct ivtv *itv = id->itv;
1471 	struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1472 
1473 	if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1474 		return -ENOTTY;
1475 	if (!itv->osd_video_pbase)
1476 		return -ENOTTY;
1477 
1478 	ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1479 
1480 	return 0;
1481 }
1482 
1483 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1484 {
1485 	switch (sub->type) {
1486 	case V4L2_EVENT_VSYNC:
1487 	case V4L2_EVENT_EOS:
1488 		return v4l2_event_subscribe(fh, sub, 0, NULL);
1489 	default:
1490 		return v4l2_ctrl_subscribe_event(fh, sub);
1491 	}
1492 }
1493 
1494 static int ivtv_log_status(struct file *file, void *fh)
1495 {
1496 	struct ivtv *itv = fh2id(fh)->itv;
1497 	u32 data[CX2341X_MBOX_MAX_DATA];
1498 
1499 	int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1500 	struct v4l2_input vidin;
1501 	struct v4l2_audio audin;
1502 	int i;
1503 
1504 	IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1505 	if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1506 		struct tveeprom tv;
1507 
1508 		ivtv_read_eeprom(itv, &tv);
1509 	}
1510 	ivtv_call_all(itv, core, log_status);
1511 	ivtv_get_input(itv, itv->active_input, &vidin);
1512 	ivtv_get_audio_input(itv, itv->audio_input, &audin);
1513 	IVTV_INFO("Video Input:  %s\n", vidin.name);
1514 	IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1515 		itv->dualwatch_stereo_mode == V4L2_MPEG_AUDIO_MODE_DUAL ?
1516 			" (Bilingual)" : "");
1517 	if (has_output) {
1518 		struct v4l2_output vidout;
1519 		struct v4l2_audioout audout;
1520 		int mode = itv->output_mode;
1521 		static const char * const output_modes[5] = {
1522 			"None",
1523 			"MPEG Streaming",
1524 			"YUV Streaming",
1525 			"YUV Frames",
1526 			"Passthrough",
1527 		};
1528 		static const char * const alpha_mode[4] = {
1529 			"None",
1530 			"Global",
1531 			"Local",
1532 			"Global and Local"
1533 		};
1534 		static const char * const pixel_format[16] = {
1535 			"ARGB Indexed",
1536 			"RGB 5:6:5",
1537 			"ARGB 1:5:5:5",
1538 			"ARGB 1:4:4:4",
1539 			"ARGB 8:8:8:8",
1540 			"5",
1541 			"6",
1542 			"7",
1543 			"AYUV Indexed",
1544 			"YUV 5:6:5",
1545 			"AYUV 1:5:5:5",
1546 			"AYUV 1:4:4:4",
1547 			"AYUV 8:8:8:8",
1548 			"13",
1549 			"14",
1550 			"15",
1551 		};
1552 
1553 		ivtv_get_output(itv, itv->active_output, &vidout);
1554 		ivtv_get_audio_output(itv, 0, &audout);
1555 		IVTV_INFO("Video Output: %s\n", vidout.name);
1556 		if (mode < 0 || mode > OUT_PASSTHROUGH)
1557 			mode = OUT_NONE;
1558 		IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1559 		ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1560 		data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1561 		IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1562 			data[0] & 1 ? "On" : "Off",
1563 			alpha_mode[(data[0] >> 1) & 0x3],
1564 			pixel_format[(data[0] >> 3) & 0xf]);
1565 	}
1566 	IVTV_INFO("Tuner:  %s\n",
1567 		test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1568 	v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1569 	IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1570 	for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1571 		struct ivtv_stream *s = &itv->streams[i];
1572 
1573 		if (s->vdev.v4l2_dev == NULL || s->buffers == 0)
1574 			continue;
1575 		IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1576 				(s->buffers - s->q_free.buffers) * 100 / s->buffers,
1577 				(s->buffers * s->buf_size) / 1024, s->buffers);
1578 	}
1579 
1580 	IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1581 			(long long)itv->mpg_data_received,
1582 			(long long)itv->vbi_data_inserted);
1583 	return 0;
1584 }
1585 
1586 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1587 {
1588 	struct ivtv_open_id *id = fh2id(file->private_data);
1589 	struct ivtv *itv = id->itv;
1590 
1591 	IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1592 	return ivtv_video_command(itv, id, dec, false);
1593 }
1594 
1595 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1596 {
1597 	struct ivtv_open_id *id = fh2id(file->private_data);
1598 	struct ivtv *itv = id->itv;
1599 
1600 	IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1601 	return ivtv_video_command(itv, id, dec, true);
1602 }
1603 
1604 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1605 {
1606 	struct ivtv_open_id *id = fh2id(filp->private_data);
1607 	struct ivtv *itv = id->itv;
1608 	struct ivtv_stream *s = &itv->streams[id->type];
1609 
1610 	switch (cmd) {
1611 	case IVTV_IOC_DMA_FRAME: {
1612 		struct ivtv_dma_frame *args = arg;
1613 
1614 		IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1615 		if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1616 			return -EINVAL;
1617 		if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1618 			return -EINVAL;
1619 		if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1620 			return 0;
1621 		if (ivtv_start_decoding(id, id->type)) {
1622 			return -EBUSY;
1623 		}
1624 		if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1625 			ivtv_release_stream(s);
1626 			return -EBUSY;
1627 		}
1628 		/* Mark that this file handle started the UDMA_YUV mode */
1629 		id->yuv_frames = 1;
1630 		if (args->y_source == NULL)
1631 			return 0;
1632 		return ivtv_yuv_prep_frame(itv, args);
1633 	}
1634 
1635 	case IVTV_IOC_PASSTHROUGH_MODE:
1636 		IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1637 		if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1638 			return -EINVAL;
1639 		return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1640 	default:
1641 		return -EINVAL;
1642 	}
1643 	return 0;
1644 }
1645 
1646 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1647 			 unsigned int cmd, void *arg)
1648 {
1649 	struct ivtv *itv = fh2id(fh)->itv;
1650 
1651 	if (!valid_prio) {
1652 		switch (cmd) {
1653 		case IVTV_IOC_PASSTHROUGH_MODE:
1654 			return -EBUSY;
1655 		}
1656 	}
1657 
1658 	switch (cmd) {
1659 	case VIDIOC_INT_RESET: {
1660 		u32 val = *(u32 *)arg;
1661 
1662 		if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1663 			ivtv_reset_ir_gpio(itv);
1664 		if (val & 0x02)
1665 			v4l2_subdev_call(itv->sd_video, core, reset, 0);
1666 		break;
1667 	}
1668 
1669 	case IVTV_IOC_DMA_FRAME:
1670 	case IVTV_IOC_PASSTHROUGH_MODE:
1671 		return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1672 
1673 	default:
1674 		return -ENOTTY;
1675 	}
1676 	return 0;
1677 }
1678 
1679 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1680 	.vidioc_querycap		    = ivtv_querycap,
1681 	.vidioc_s_audio			    = ivtv_s_audio,
1682 	.vidioc_g_audio			    = ivtv_g_audio,
1683 	.vidioc_enumaudio		    = ivtv_enumaudio,
1684 	.vidioc_s_audout		    = ivtv_s_audout,
1685 	.vidioc_g_audout		    = ivtv_g_audout,
1686 	.vidioc_enum_input		    = ivtv_enum_input,
1687 	.vidioc_enum_output		    = ivtv_enum_output,
1688 	.vidioc_enumaudout		    = ivtv_enumaudout,
1689 	.vidioc_g_pixelaspect		    = ivtv_g_pixelaspect,
1690 	.vidioc_s_selection		    = ivtv_s_selection,
1691 	.vidioc_g_selection		    = ivtv_g_selection,
1692 	.vidioc_g_input			    = ivtv_g_input,
1693 	.vidioc_s_input			    = ivtv_s_input,
1694 	.vidioc_g_output		    = ivtv_g_output,
1695 	.vidioc_s_output		    = ivtv_s_output,
1696 	.vidioc_g_frequency		    = ivtv_g_frequency,
1697 	.vidioc_s_frequency		    = ivtv_s_frequency,
1698 	.vidioc_s_tuner			    = ivtv_s_tuner,
1699 	.vidioc_g_tuner			    = ivtv_g_tuner,
1700 	.vidioc_g_enc_index		    = ivtv_g_enc_index,
1701 	.vidioc_g_fbuf			    = ivtv_g_fbuf,
1702 	.vidioc_s_fbuf			    = ivtv_s_fbuf,
1703 	.vidioc_g_std			    = ivtv_g_std,
1704 	.vidioc_s_std			    = ivtv_s_std,
1705 	.vidioc_overlay			    = ivtv_overlay,
1706 	.vidioc_log_status		    = ivtv_log_status,
1707 	.vidioc_enum_fmt_vid_cap	    = ivtv_enum_fmt_vid_cap,
1708 	.vidioc_encoder_cmd		    = ivtv_encoder_cmd,
1709 	.vidioc_try_encoder_cmd		    = ivtv_try_encoder_cmd,
1710 	.vidioc_decoder_cmd		    = ivtv_decoder_cmd,
1711 	.vidioc_try_decoder_cmd		    = ivtv_try_decoder_cmd,
1712 	.vidioc_enum_fmt_vid_out	    = ivtv_enum_fmt_vid_out,
1713 	.vidioc_g_fmt_vid_cap		    = ivtv_g_fmt_vid_cap,
1714 	.vidioc_g_fmt_vbi_cap		    = ivtv_g_fmt_vbi_cap,
1715 	.vidioc_g_fmt_sliced_vbi_cap        = ivtv_g_fmt_sliced_vbi_cap,
1716 	.vidioc_g_fmt_vid_out               = ivtv_g_fmt_vid_out,
1717 	.vidioc_g_fmt_vid_out_overlay       = ivtv_g_fmt_vid_out_overlay,
1718 	.vidioc_g_fmt_sliced_vbi_out        = ivtv_g_fmt_sliced_vbi_out,
1719 	.vidioc_s_fmt_vid_cap		    = ivtv_s_fmt_vid_cap,
1720 	.vidioc_s_fmt_vbi_cap		    = ivtv_s_fmt_vbi_cap,
1721 	.vidioc_s_fmt_sliced_vbi_cap        = ivtv_s_fmt_sliced_vbi_cap,
1722 	.vidioc_s_fmt_vid_out               = ivtv_s_fmt_vid_out,
1723 	.vidioc_s_fmt_vid_out_overlay       = ivtv_s_fmt_vid_out_overlay,
1724 	.vidioc_s_fmt_sliced_vbi_out        = ivtv_s_fmt_sliced_vbi_out,
1725 	.vidioc_try_fmt_vid_cap		    = ivtv_try_fmt_vid_cap,
1726 	.vidioc_try_fmt_vbi_cap		    = ivtv_try_fmt_vbi_cap,
1727 	.vidioc_try_fmt_sliced_vbi_cap      = ivtv_try_fmt_sliced_vbi_cap,
1728 	.vidioc_try_fmt_vid_out		    = ivtv_try_fmt_vid_out,
1729 	.vidioc_try_fmt_vid_out_overlay     = ivtv_try_fmt_vid_out_overlay,
1730 	.vidioc_try_fmt_sliced_vbi_out	    = ivtv_try_fmt_sliced_vbi_out,
1731 	.vidioc_g_sliced_vbi_cap	    = ivtv_g_sliced_vbi_cap,
1732 #ifdef CONFIG_VIDEO_ADV_DEBUG
1733 	.vidioc_g_register		    = ivtv_g_register,
1734 	.vidioc_s_register		    = ivtv_s_register,
1735 #endif
1736 	.vidioc_default			    = ivtv_default,
1737 	.vidioc_subscribe_event		    = ivtv_subscribe_event,
1738 	.vidioc_unsubscribe_event	    = v4l2_event_unsubscribe,
1739 };
1740 
1741 void ivtv_set_funcs(struct video_device *vdev)
1742 {
1743 	vdev->ioctl_ops = &ivtv_ioctl_ops;
1744 }
1745