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  
ivtv_service2vbi(int type)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  
valid_service_line(int field,int line,int is_pal)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  
select_service_from_set(int field,int line,u16 set,int is_pal)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  
ivtv_expand_service_set(struct v4l2_sliced_vbi_format * fmt,int is_pal)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  
check_service_set(struct v4l2_sliced_vbi_format * fmt,int is_pal)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  
ivtv_get_service_set(struct v4l2_sliced_vbi_format * fmt)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  
ivtv_set_osd_alpha(struct ivtv * itv)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  
ivtv_set_speed(struct ivtv * itv,int speed)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  
ivtv_validate_speed(int cur_speed,int new_speed)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  
ivtv_video_command(struct ivtv * itv,struct ivtv_open_id * id,struct v4l2_decoder_cmd * dc,int try)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  
ivtv_g_fmt_sliced_vbi_out(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_g_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_g_fmt_vbi_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_g_fmt_sliced_vbi_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_g_fmt_vid_out(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_g_fmt_vid_out_overlay(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_try_fmt_sliced_vbi_out(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_try_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_try_fmt_vbi_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_try_fmt_sliced_vbi_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_try_fmt_vid_out(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_try_fmt_vid_out_overlay(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_s_fmt_sliced_vbi_out(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_s_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_s_fmt_vbi_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_s_fmt_sliced_vbi_cap(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_s_fmt_vid_out(struct file * file,void * fh,struct v4l2_format * fmt)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  
ivtv_s_fmt_vid_out_overlay(struct file * file,void * fh,struct v4l2_format * fmt)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
ivtv_itvc(struct ivtv * itv,bool get,u64 reg,u64 * val)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  
ivtv_g_register(struct file * file,void * fh,struct v4l2_dbg_register * reg)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  
ivtv_s_register(struct file * file,void * fh,const struct v4l2_dbg_register * reg)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  
ivtv_querycap(struct file * file,void * fh,struct v4l2_capability * vcap)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  
ivtv_enumaudio(struct file * file,void * fh,struct v4l2_audio * vin)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  
ivtv_g_audio(struct file * file,void * fh,struct v4l2_audio * vin)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  
ivtv_s_audio(struct file * file,void * fh,const struct v4l2_audio * vout)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  
ivtv_enumaudout(struct file * file,void * fh,struct v4l2_audioout * vin)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  
ivtv_g_audout(struct file * file,void * fh,struct v4l2_audioout * vin)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  
ivtv_s_audout(struct file * file,void * fh,const struct v4l2_audioout * vout)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  
ivtv_enum_input(struct file * file,void * fh,struct v4l2_input * vin)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  
ivtv_enum_output(struct file * file,void * fh,struct v4l2_output * vout)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  
ivtv_g_pixelaspect(struct file * file,void * fh,int type,struct v4l2_fract * f)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  
ivtv_s_selection(struct file * file,void * fh,struct v4l2_selection * sel)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  
ivtv_g_selection(struct file * file,void * fh,struct v4l2_selection * sel)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  
ivtv_enum_fmt_vid_cap(struct file * file,void * fh,struct v4l2_fmtdesc * fmt)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  
ivtv_enum_fmt_vid_out(struct file * file,void * fh,struct v4l2_fmtdesc * fmt)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  
ivtv_g_input(struct file * file,void * fh,unsigned int * i)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  
ivtv_s_input(struct file * file,void * fh,unsigned int inp)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  
ivtv_g_output(struct file * file,void * fh,unsigned int * i)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  
ivtv_s_output(struct file * file,void * fh,unsigned int outp)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  
ivtv_g_frequency(struct file * file,void * fh,struct v4l2_frequency * vf)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  
ivtv_s_frequency(struct file * file,void * fh,const struct v4l2_frequency * vf)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  
ivtv_g_std(struct file * file,void * fh,v4l2_std_id * std)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  
ivtv_s_std_enc(struct ivtv * itv,v4l2_std_id std)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  
ivtv_s_std_dec(struct ivtv * itv,v4l2_std_id std)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  
ivtv_s_std(struct file * file,void * fh,v4l2_std_id std)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  
ivtv_s_tuner(struct file * file,void * fh,const struct v4l2_tuner * vt)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  
ivtv_g_tuner(struct file * file,void * fh,struct v4l2_tuner * vt)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  
ivtv_g_sliced_vbi_cap(struct file * file,void * fh,struct v4l2_sliced_vbi_cap * cap)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  
ivtv_g_enc_index(struct file * file,void * fh,struct v4l2_enc_idx * idx)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  
ivtv_encoder_cmd(struct file * file,void * fh,struct v4l2_encoder_cmd * enc)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  
ivtv_try_encoder_cmd(struct file * file,void * fh,struct v4l2_encoder_cmd * enc)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  
ivtv_g_fbuf(struct file * file,void * fh,struct v4l2_framebuffer * fb)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  
ivtv_s_fbuf(struct file * file,void * fh,const struct v4l2_framebuffer * fb)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  
ivtv_overlay(struct file * file,void * fh,unsigned int on)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  
ivtv_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)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  
ivtv_log_status(struct file * file,void * fh)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  
ivtv_decoder_cmd(struct file * file,void * fh,struct v4l2_decoder_cmd * dec)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  
ivtv_try_decoder_cmd(struct file * file,void * fh,struct v4l2_decoder_cmd * dec)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  
ivtv_decoder_ioctls(struct file * filp,unsigned int cmd,void * arg)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  
ivtv_default(struct file * file,void * fh,bool valid_prio,unsigned int cmd,void * arg)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  
ivtv_set_funcs(struct video_device * vdev)1740  void ivtv_set_funcs(struct video_device *vdev)
1741  {
1742  	vdev->ioctl_ops = &ivtv_ioctl_ops;
1743  }
1744