xref: /openbmc/linux/drivers/media/common/cx2341x.c (revision 12eb4683)
1 /*
2  * cx2341x - generic code for cx23415/6/8 based devices
3  *
4  * Copyright (C) 2006 Hans Verkuil <hverkuil@xs4all.nl>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20 
21 
22 #include <linux/module.h>
23 #include <linux/errno.h>
24 #include <linux/kernel.h>
25 #include <linux/init.h>
26 #include <linux/types.h>
27 #include <linux/videodev2.h>
28 
29 #include <media/tuner.h>
30 #include <media/cx2341x.h>
31 #include <media/v4l2-common.h>
32 
33 MODULE_DESCRIPTION("cx23415/6/8 driver");
34 MODULE_AUTHOR("Hans Verkuil");
35 MODULE_LICENSE("GPL");
36 
37 static int debug;
38 module_param(debug, int, 0644);
39 MODULE_PARM_DESC(debug, "Debug level (0-1)");
40 
41 /********************** COMMON CODE *********************/
42 
43 /* definitions for audio properties bits 29-28 */
44 #define CX2341X_AUDIO_ENCODING_METHOD_MPEG	0
45 #define CX2341X_AUDIO_ENCODING_METHOD_AC3	1
46 #define CX2341X_AUDIO_ENCODING_METHOD_LPCM	2
47 
48 static const char *cx2341x_get_name(u32 id)
49 {
50 	switch (id) {
51 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
52 		return "Spatial Filter Mode";
53 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
54 		return "Spatial Filter";
55 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
56 		return "Spatial Luma Filter Type";
57 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
58 		return "Spatial Chroma Filter Type";
59 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
60 		return "Temporal Filter Mode";
61 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
62 		return "Temporal Filter";
63 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
64 		return "Median Filter Type";
65 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
66 		return "Median Luma Filter Maximum";
67 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
68 		return "Median Luma Filter Minimum";
69 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
70 		return "Median Chroma Filter Maximum";
71 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
72 		return "Median Chroma Filter Minimum";
73 	case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
74 		return "Insert Navigation Packets";
75 	}
76 	return NULL;
77 }
78 
79 static const char **cx2341x_get_menu(u32 id)
80 {
81 	static const char *cx2341x_video_spatial_filter_mode_menu[] = {
82 		"Manual",
83 		"Auto",
84 		NULL
85 	};
86 
87 	static const char *cx2341x_video_luma_spatial_filter_type_menu[] = {
88 		"Off",
89 		"1D Horizontal",
90 		"1D Vertical",
91 		"2D H/V Separable",
92 		"2D Symmetric non-separable",
93 		NULL
94 	};
95 
96 	static const char *cx2341x_video_chroma_spatial_filter_type_menu[] = {
97 		"Off",
98 		"1D Horizontal",
99 		NULL
100 	};
101 
102 	static const char *cx2341x_video_temporal_filter_mode_menu[] = {
103 		"Manual",
104 		"Auto",
105 		NULL
106 	};
107 
108 	static const char *cx2341x_video_median_filter_type_menu[] = {
109 		"Off",
110 		"Horizontal",
111 		"Vertical",
112 		"Horizontal/Vertical",
113 		"Diagonal",
114 		NULL
115 	};
116 
117 	switch (id) {
118 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
119 		return cx2341x_video_spatial_filter_mode_menu;
120 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
121 		return cx2341x_video_luma_spatial_filter_type_menu;
122 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
123 		return cx2341x_video_chroma_spatial_filter_type_menu;
124 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
125 		return cx2341x_video_temporal_filter_mode_menu;
126 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
127 		return cx2341x_video_median_filter_type_menu;
128 	}
129 	return NULL;
130 }
131 
132 static void cx2341x_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
133 		    s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags)
134 {
135 	*name = cx2341x_get_name(id);
136 	*flags = 0;
137 
138 	switch (id) {
139 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
140 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
141 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
142 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
143 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
144 		*type = V4L2_CTRL_TYPE_MENU;
145 		*min = 0;
146 		*step = 0;
147 		break;
148 	case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
149 		*type = V4L2_CTRL_TYPE_BOOLEAN;
150 		*min = 0;
151 		*max = *step = 1;
152 		break;
153 	default:
154 		*type = V4L2_CTRL_TYPE_INTEGER;
155 		break;
156 	}
157 	switch (id) {
158 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
159 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
160 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
161 		*flags |= V4L2_CTRL_FLAG_UPDATE;
162 		break;
163 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
164 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
165 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
166 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
167 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
168 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
169 		*flags |= V4L2_CTRL_FLAG_SLIDER;
170 		break;
171 	case V4L2_CID_MPEG_VIDEO_ENCODING:
172 		*flags |= V4L2_CTRL_FLAG_READ_ONLY;
173 		break;
174 	}
175 }
176 
177 
178 /********************** OLD CODE *********************/
179 
180 /* Must be sorted from low to high control ID! */
181 const u32 cx2341x_mpeg_ctrls[] = {
182 	V4L2_CID_MPEG_CLASS,
183 	V4L2_CID_MPEG_STREAM_TYPE,
184 	V4L2_CID_MPEG_STREAM_VBI_FMT,
185 	V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
186 	V4L2_CID_MPEG_AUDIO_ENCODING,
187 	V4L2_CID_MPEG_AUDIO_L2_BITRATE,
188 	V4L2_CID_MPEG_AUDIO_MODE,
189 	V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
190 	V4L2_CID_MPEG_AUDIO_EMPHASIS,
191 	V4L2_CID_MPEG_AUDIO_CRC,
192 	V4L2_CID_MPEG_AUDIO_MUTE,
193 	V4L2_CID_MPEG_AUDIO_AC3_BITRATE,
194 	V4L2_CID_MPEG_VIDEO_ENCODING,
195 	V4L2_CID_MPEG_VIDEO_ASPECT,
196 	V4L2_CID_MPEG_VIDEO_B_FRAMES,
197 	V4L2_CID_MPEG_VIDEO_GOP_SIZE,
198 	V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
199 	V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
200 	V4L2_CID_MPEG_VIDEO_BITRATE,
201 	V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
202 	V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
203 	V4L2_CID_MPEG_VIDEO_MUTE,
204 	V4L2_CID_MPEG_VIDEO_MUTE_YUV,
205 	V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
206 	V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
207 	V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
208 	V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
209 	V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
210 	V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
211 	V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
212 	V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
213 	V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
214 	V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
215 	V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
216 	V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS,
217 	0
218 };
219 EXPORT_SYMBOL(cx2341x_mpeg_ctrls);
220 
221 static const struct cx2341x_mpeg_params default_params = {
222 	/* misc */
223 	.capabilities = 0,
224 	.port = CX2341X_PORT_MEMORY,
225 	.width = 720,
226 	.height = 480,
227 	.is_50hz = 0,
228 
229 	/* stream */
230 	.stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
231 	.stream_vbi_fmt = V4L2_MPEG_STREAM_VBI_FMT_NONE,
232 	.stream_insert_nav_packets = 0,
233 
234 	/* audio */
235 	.audio_sampling_freq = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
236 	.audio_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
237 	.audio_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_224K,
238 	.audio_ac3_bitrate = V4L2_MPEG_AUDIO_AC3_BITRATE_224K,
239 	.audio_mode = V4L2_MPEG_AUDIO_MODE_STEREO,
240 	.audio_mode_extension = V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
241 	.audio_emphasis = V4L2_MPEG_AUDIO_EMPHASIS_NONE,
242 	.audio_crc = V4L2_MPEG_AUDIO_CRC_NONE,
243 	.audio_mute = 0,
244 
245 	/* video */
246 	.video_encoding = V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
247 	.video_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
248 	.video_b_frames = 2,
249 	.video_gop_size = 12,
250 	.video_gop_closure = 1,
251 	.video_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
252 	.video_bitrate = 6000000,
253 	.video_bitrate_peak = 8000000,
254 	.video_temporal_decimation = 0,
255 	.video_mute = 0,
256 	.video_mute_yuv = 0x008080,  /* YCbCr value for black */
257 
258 	/* encoding filters */
259 	.video_spatial_filter_mode =
260 		V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
261 	.video_spatial_filter = 0,
262 	.video_luma_spatial_filter_type =
263 		V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR,
264 	.video_chroma_spatial_filter_type =
265 		V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
266 	.video_temporal_filter_mode =
267 		V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
268 	.video_temporal_filter = 8,
269 	.video_median_filter_type =
270 		V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
271 	.video_luma_median_filter_top = 255,
272 	.video_luma_median_filter_bottom = 0,
273 	.video_chroma_median_filter_top = 255,
274 	.video_chroma_median_filter_bottom = 0,
275 };
276 /* Map the control ID to the correct field in the cx2341x_mpeg_params
277    struct. Return -EINVAL if the ID is unknown, else return 0. */
278 static int cx2341x_get_ctrl(const struct cx2341x_mpeg_params *params,
279 		struct v4l2_ext_control *ctrl)
280 {
281 	switch (ctrl->id) {
282 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
283 		ctrl->value = params->audio_sampling_freq;
284 		break;
285 	case V4L2_CID_MPEG_AUDIO_ENCODING:
286 		ctrl->value = params->audio_encoding;
287 		break;
288 	case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
289 		ctrl->value = params->audio_l2_bitrate;
290 		break;
291 	case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
292 		ctrl->value = params->audio_ac3_bitrate;
293 		break;
294 	case V4L2_CID_MPEG_AUDIO_MODE:
295 		ctrl->value = params->audio_mode;
296 		break;
297 	case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
298 		ctrl->value = params->audio_mode_extension;
299 		break;
300 	case V4L2_CID_MPEG_AUDIO_EMPHASIS:
301 		ctrl->value = params->audio_emphasis;
302 		break;
303 	case V4L2_CID_MPEG_AUDIO_CRC:
304 		ctrl->value = params->audio_crc;
305 		break;
306 	case V4L2_CID_MPEG_AUDIO_MUTE:
307 		ctrl->value = params->audio_mute;
308 		break;
309 	case V4L2_CID_MPEG_VIDEO_ENCODING:
310 		ctrl->value = params->video_encoding;
311 		break;
312 	case V4L2_CID_MPEG_VIDEO_ASPECT:
313 		ctrl->value = params->video_aspect;
314 		break;
315 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
316 		ctrl->value = params->video_b_frames;
317 		break;
318 	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
319 		ctrl->value = params->video_gop_size;
320 		break;
321 	case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
322 		ctrl->value = params->video_gop_closure;
323 		break;
324 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
325 		ctrl->value = params->video_bitrate_mode;
326 		break;
327 	case V4L2_CID_MPEG_VIDEO_BITRATE:
328 		ctrl->value = params->video_bitrate;
329 		break;
330 	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
331 		ctrl->value = params->video_bitrate_peak;
332 		break;
333 	case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
334 		ctrl->value = params->video_temporal_decimation;
335 		break;
336 	case V4L2_CID_MPEG_VIDEO_MUTE:
337 		ctrl->value = params->video_mute;
338 		break;
339 	case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
340 		ctrl->value = params->video_mute_yuv;
341 		break;
342 	case V4L2_CID_MPEG_STREAM_TYPE:
343 		ctrl->value = params->stream_type;
344 		break;
345 	case V4L2_CID_MPEG_STREAM_VBI_FMT:
346 		ctrl->value = params->stream_vbi_fmt;
347 		break;
348 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
349 		ctrl->value = params->video_spatial_filter_mode;
350 		break;
351 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
352 		ctrl->value = params->video_spatial_filter;
353 		break;
354 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
355 		ctrl->value = params->video_luma_spatial_filter_type;
356 		break;
357 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
358 		ctrl->value = params->video_chroma_spatial_filter_type;
359 		break;
360 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
361 		ctrl->value = params->video_temporal_filter_mode;
362 		break;
363 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
364 		ctrl->value = params->video_temporal_filter;
365 		break;
366 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
367 		ctrl->value = params->video_median_filter_type;
368 		break;
369 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
370 		ctrl->value = params->video_luma_median_filter_top;
371 		break;
372 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
373 		ctrl->value = params->video_luma_median_filter_bottom;
374 		break;
375 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
376 		ctrl->value = params->video_chroma_median_filter_top;
377 		break;
378 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
379 		ctrl->value = params->video_chroma_median_filter_bottom;
380 		break;
381 	case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
382 		ctrl->value = params->stream_insert_nav_packets;
383 		break;
384 	default:
385 		return -EINVAL;
386 	}
387 	return 0;
388 }
389 
390 /* Map the control ID to the correct field in the cx2341x_mpeg_params
391    struct. Return -EINVAL if the ID is unknown, else return 0. */
392 static int cx2341x_set_ctrl(struct cx2341x_mpeg_params *params, int busy,
393 		struct v4l2_ext_control *ctrl)
394 {
395 	switch (ctrl->id) {
396 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
397 		if (busy)
398 			return -EBUSY;
399 		params->audio_sampling_freq = ctrl->value;
400 		break;
401 	case V4L2_CID_MPEG_AUDIO_ENCODING:
402 		if (busy)
403 			return -EBUSY;
404 		if (params->capabilities & CX2341X_CAP_HAS_AC3)
405 			if (ctrl->value != V4L2_MPEG_AUDIO_ENCODING_LAYER_2 &&
406 			    ctrl->value != V4L2_MPEG_AUDIO_ENCODING_AC3)
407 				return -ERANGE;
408 		params->audio_encoding = ctrl->value;
409 		break;
410 	case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
411 		if (busy)
412 			return -EBUSY;
413 		params->audio_l2_bitrate = ctrl->value;
414 		break;
415 	case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
416 		if (busy)
417 			return -EBUSY;
418 		if (!(params->capabilities & CX2341X_CAP_HAS_AC3))
419 			return -EINVAL;
420 		params->audio_ac3_bitrate = ctrl->value;
421 		break;
422 	case V4L2_CID_MPEG_AUDIO_MODE:
423 		params->audio_mode = ctrl->value;
424 		break;
425 	case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
426 		params->audio_mode_extension = ctrl->value;
427 		break;
428 	case V4L2_CID_MPEG_AUDIO_EMPHASIS:
429 		params->audio_emphasis = ctrl->value;
430 		break;
431 	case V4L2_CID_MPEG_AUDIO_CRC:
432 		params->audio_crc = ctrl->value;
433 		break;
434 	case V4L2_CID_MPEG_AUDIO_MUTE:
435 		params->audio_mute = ctrl->value;
436 		break;
437 	case V4L2_CID_MPEG_VIDEO_ASPECT:
438 		params->video_aspect = ctrl->value;
439 		break;
440 	case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
441 		int b = ctrl->value + 1;
442 		int gop = params->video_gop_size;
443 		params->video_b_frames = ctrl->value;
444 		params->video_gop_size = b * ((gop + b - 1) / b);
445 		/* Max GOP size = 34 */
446 		while (params->video_gop_size > 34)
447 			params->video_gop_size -= b;
448 		break;
449 	}
450 	case V4L2_CID_MPEG_VIDEO_GOP_SIZE: {
451 		int b = params->video_b_frames + 1;
452 		int gop = ctrl->value;
453 		params->video_gop_size = b * ((gop + b - 1) / b);
454 		/* Max GOP size = 34 */
455 		while (params->video_gop_size > 34)
456 			params->video_gop_size -= b;
457 		ctrl->value = params->video_gop_size;
458 		break;
459 	}
460 	case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
461 		params->video_gop_closure = ctrl->value;
462 		break;
463 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
464 		if (busy)
465 			return -EBUSY;
466 		/* MPEG-1 only allows CBR */
467 		if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1 &&
468 		    ctrl->value != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
469 			return -EINVAL;
470 		params->video_bitrate_mode = ctrl->value;
471 		break;
472 	case V4L2_CID_MPEG_VIDEO_BITRATE:
473 		if (busy)
474 			return -EBUSY;
475 		params->video_bitrate = ctrl->value;
476 		break;
477 	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
478 		if (busy)
479 			return -EBUSY;
480 		params->video_bitrate_peak = ctrl->value;
481 		break;
482 	case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
483 		params->video_temporal_decimation = ctrl->value;
484 		break;
485 	case V4L2_CID_MPEG_VIDEO_MUTE:
486 		params->video_mute = (ctrl->value != 0);
487 		break;
488 	case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
489 		params->video_mute_yuv = ctrl->value;
490 		break;
491 	case V4L2_CID_MPEG_STREAM_TYPE:
492 		if (busy)
493 			return -EBUSY;
494 		params->stream_type = ctrl->value;
495 		params->video_encoding =
496 		    (params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
497 		     params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
498 			V4L2_MPEG_VIDEO_ENCODING_MPEG_1 :
499 			V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
500 		if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
501 			/* MPEG-1 implies CBR */
502 			params->video_bitrate_mode =
503 				V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
504 		break;
505 	case V4L2_CID_MPEG_STREAM_VBI_FMT:
506 		params->stream_vbi_fmt = ctrl->value;
507 		break;
508 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
509 		params->video_spatial_filter_mode = ctrl->value;
510 		break;
511 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
512 		params->video_spatial_filter = ctrl->value;
513 		break;
514 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
515 		params->video_luma_spatial_filter_type = ctrl->value;
516 		break;
517 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
518 		params->video_chroma_spatial_filter_type = ctrl->value;
519 		break;
520 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
521 		params->video_temporal_filter_mode = ctrl->value;
522 		break;
523 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
524 		params->video_temporal_filter = ctrl->value;
525 		break;
526 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
527 		params->video_median_filter_type = ctrl->value;
528 		break;
529 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
530 		params->video_luma_median_filter_top = ctrl->value;
531 		break;
532 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
533 		params->video_luma_median_filter_bottom = ctrl->value;
534 		break;
535 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
536 		params->video_chroma_median_filter_top = ctrl->value;
537 		break;
538 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
539 		params->video_chroma_median_filter_bottom = ctrl->value;
540 		break;
541 	case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
542 		params->stream_insert_nav_packets = ctrl->value;
543 		break;
544 	default:
545 		return -EINVAL;
546 	}
547 	return 0;
548 }
549 
550 static int cx2341x_ctrl_query_fill(struct v4l2_queryctrl *qctrl,
551 				   s32 min, s32 max, s32 step, s32 def)
552 {
553 	const char *name;
554 
555 	switch (qctrl->id) {
556 	/* MPEG controls */
557 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
558 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
559 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
560 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
561 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
562 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
563 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
564 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
565 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
566 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
567 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
568 	case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
569 		cx2341x_ctrl_fill(qctrl->id, &name, &qctrl->type,
570 				&min, &max, &step, &def, &qctrl->flags);
571 		qctrl->minimum = min;
572 		qctrl->maximum = max;
573 		qctrl->step = step;
574 		qctrl->default_value = def;
575 		qctrl->reserved[0] = qctrl->reserved[1] = 0;
576 		strlcpy(qctrl->name, name, sizeof(qctrl->name));
577 		return 0;
578 
579 	default:
580 		return v4l2_ctrl_query_fill(qctrl, min, max, step, def);
581 	}
582 }
583 
584 int cx2341x_ctrl_query(const struct cx2341x_mpeg_params *params,
585 		       struct v4l2_queryctrl *qctrl)
586 {
587 	int err;
588 
589 	switch (qctrl->id) {
590 	case V4L2_CID_MPEG_CLASS:
591 		return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
592 	case V4L2_CID_MPEG_STREAM_TYPE:
593 		return v4l2_ctrl_query_fill(qctrl,
594 				V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
595 				V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
596 				V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
597 
598 	case V4L2_CID_MPEG_STREAM_VBI_FMT:
599 		if (params->capabilities & CX2341X_CAP_HAS_SLICED_VBI)
600 			return v4l2_ctrl_query_fill(qctrl,
601 					V4L2_MPEG_STREAM_VBI_FMT_NONE,
602 					V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
603 					V4L2_MPEG_STREAM_VBI_FMT_NONE);
604 		return cx2341x_ctrl_query_fill(qctrl,
605 				V4L2_MPEG_STREAM_VBI_FMT_NONE,
606 				V4L2_MPEG_STREAM_VBI_FMT_NONE, 1,
607 				default_params.stream_vbi_fmt);
608 
609 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
610 		return v4l2_ctrl_query_fill(qctrl,
611 				V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
612 				V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
613 				V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
614 
615 	case V4L2_CID_MPEG_AUDIO_ENCODING:
616 		if (params->capabilities & CX2341X_CAP_HAS_AC3) {
617 			/*
618 			 * The state of L2 & AC3 bitrate controls can change
619 			 * when this control changes, but v4l2_ctrl_query_fill()
620 			 * already sets V4L2_CTRL_FLAG_UPDATE for
621 			 * V4L2_CID_MPEG_AUDIO_ENCODING, so we don't here.
622 			 */
623 			return v4l2_ctrl_query_fill(qctrl,
624 					V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
625 					V4L2_MPEG_AUDIO_ENCODING_AC3, 1,
626 					default_params.audio_encoding);
627 		}
628 
629 		return v4l2_ctrl_query_fill(qctrl,
630 				V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
631 				V4L2_MPEG_AUDIO_ENCODING_LAYER_2, 1,
632 				default_params.audio_encoding);
633 
634 	case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
635 		err = v4l2_ctrl_query_fill(qctrl,
636 				V4L2_MPEG_AUDIO_L2_BITRATE_192K,
637 				V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
638 				default_params.audio_l2_bitrate);
639 		if (err)
640 			return err;
641 		if (params->capabilities & CX2341X_CAP_HAS_AC3 &&
642 		    params->audio_encoding != V4L2_MPEG_AUDIO_ENCODING_LAYER_2)
643 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
644 		return 0;
645 
646 	case V4L2_CID_MPEG_AUDIO_MODE:
647 		return v4l2_ctrl_query_fill(qctrl,
648 				V4L2_MPEG_AUDIO_MODE_STEREO,
649 				V4L2_MPEG_AUDIO_MODE_MONO, 1,
650 				V4L2_MPEG_AUDIO_MODE_STEREO);
651 
652 	case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
653 		err = v4l2_ctrl_query_fill(qctrl,
654 				V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
655 				V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
656 				V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
657 		if (err == 0 &&
658 		    params->audio_mode != V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
659 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
660 		return err;
661 
662 	case V4L2_CID_MPEG_AUDIO_EMPHASIS:
663 		return v4l2_ctrl_query_fill(qctrl,
664 				V4L2_MPEG_AUDIO_EMPHASIS_NONE,
665 				V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
666 				V4L2_MPEG_AUDIO_EMPHASIS_NONE);
667 
668 	case V4L2_CID_MPEG_AUDIO_CRC:
669 		return v4l2_ctrl_query_fill(qctrl,
670 				V4L2_MPEG_AUDIO_CRC_NONE,
671 				V4L2_MPEG_AUDIO_CRC_CRC16, 1,
672 				V4L2_MPEG_AUDIO_CRC_NONE);
673 
674 	case V4L2_CID_MPEG_AUDIO_MUTE:
675 		return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
676 
677 	case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
678 		err = v4l2_ctrl_query_fill(qctrl,
679 				V4L2_MPEG_AUDIO_AC3_BITRATE_48K,
680 				V4L2_MPEG_AUDIO_AC3_BITRATE_448K, 1,
681 				default_params.audio_ac3_bitrate);
682 		if (err)
683 			return err;
684 		if (params->capabilities & CX2341X_CAP_HAS_AC3) {
685 			if (params->audio_encoding !=
686 						   V4L2_MPEG_AUDIO_ENCODING_AC3)
687 				qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
688 		} else
689 			qctrl->flags |= V4L2_CTRL_FLAG_DISABLED;
690 		return 0;
691 
692 	case V4L2_CID_MPEG_VIDEO_ENCODING:
693 		/* this setting is read-only for the cx2341x since the
694 		   V4L2_CID_MPEG_STREAM_TYPE really determines the
695 		   MPEG-1/2 setting */
696 		err = v4l2_ctrl_query_fill(qctrl,
697 					   V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
698 					   V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
699 					   V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
700 		if (err == 0)
701 			qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
702 		return err;
703 
704 	case V4L2_CID_MPEG_VIDEO_ASPECT:
705 		return v4l2_ctrl_query_fill(qctrl,
706 				V4L2_MPEG_VIDEO_ASPECT_1x1,
707 				V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
708 				V4L2_MPEG_VIDEO_ASPECT_4x3);
709 
710 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
711 		return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
712 
713 	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
714 		return v4l2_ctrl_query_fill(qctrl, 1, 34, 1,
715 				params->is_50hz ? 12 : 15);
716 
717 	case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
718 		return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
719 
720 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
721 		err = v4l2_ctrl_query_fill(qctrl,
722 				V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
723 				V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
724 				V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
725 		if (err == 0 &&
726 		    params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
727 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
728 		return err;
729 
730 	case V4L2_CID_MPEG_VIDEO_BITRATE:
731 		return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
732 
733 	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
734 		err = v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
735 		if (err == 0 &&
736 		    params->video_bitrate_mode ==
737 				V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
738 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
739 		return err;
740 
741 	case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
742 		return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
743 
744 	case V4L2_CID_MPEG_VIDEO_MUTE:
745 		return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
746 
747 	case V4L2_CID_MPEG_VIDEO_MUTE_YUV:  /* Init YUV (really YCbCr) to black */
748 		return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
749 
750 	/* CX23415/6 specific */
751 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
752 		return cx2341x_ctrl_query_fill(qctrl,
753 			V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
754 			V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 1,
755 			default_params.video_spatial_filter_mode);
756 
757 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
758 		cx2341x_ctrl_query_fill(qctrl, 0, 15, 1,
759 				default_params.video_spatial_filter);
760 		qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
761 		if (params->video_spatial_filter_mode ==
762 			    V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
763 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
764 		return 0;
765 
766 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
767 		cx2341x_ctrl_query_fill(qctrl,
768 			V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
769 			V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE,
770 			1,
771 			default_params.video_luma_spatial_filter_type);
772 		if (params->video_spatial_filter_mode ==
773 			    V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
774 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
775 		return 0;
776 
777 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
778 		cx2341x_ctrl_query_fill(qctrl,
779 		    V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
780 		    V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
781 		    1,
782 		    default_params.video_chroma_spatial_filter_type);
783 		if (params->video_spatial_filter_mode ==
784 			V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
785 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
786 		return 0;
787 
788 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
789 		return cx2341x_ctrl_query_fill(qctrl,
790 			V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
791 			V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO, 1,
792 			default_params.video_temporal_filter_mode);
793 
794 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
795 		cx2341x_ctrl_query_fill(qctrl, 0, 31, 1,
796 				default_params.video_temporal_filter);
797 		qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
798 		if (params->video_temporal_filter_mode ==
799 			V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO)
800 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
801 		return 0;
802 
803 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
804 		return cx2341x_ctrl_query_fill(qctrl,
805 			V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
806 			V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG, 1,
807 			default_params.video_median_filter_type);
808 
809 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
810 		cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
811 				default_params.video_luma_median_filter_top);
812 		qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
813 		if (params->video_median_filter_type ==
814 				V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
815 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
816 		return 0;
817 
818 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
819 		cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
820 				default_params.video_luma_median_filter_bottom);
821 		qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
822 		if (params->video_median_filter_type ==
823 				V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
824 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
825 		return 0;
826 
827 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
828 		cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
829 				default_params.video_chroma_median_filter_top);
830 		qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
831 		if (params->video_median_filter_type ==
832 				V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
833 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
834 		return 0;
835 
836 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
837 		cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
838 			default_params.video_chroma_median_filter_bottom);
839 		qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
840 		if (params->video_median_filter_type ==
841 				V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
842 			qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
843 		return 0;
844 
845 	case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
846 		return cx2341x_ctrl_query_fill(qctrl, 0, 1, 1,
847 				default_params.stream_insert_nav_packets);
848 
849 	default:
850 		return -EINVAL;
851 
852 	}
853 }
854 EXPORT_SYMBOL(cx2341x_ctrl_query);
855 
856 const char * const *cx2341x_ctrl_get_menu(const struct cx2341x_mpeg_params *p, u32 id)
857 {
858 	static const char * const mpeg_stream_type_without_ts[] = {
859 		"MPEG-2 Program Stream",
860 		"",
861 		"MPEG-1 System Stream",
862 		"MPEG-2 DVD-compatible Stream",
863 		"MPEG-1 VCD-compatible Stream",
864 		"MPEG-2 SVCD-compatible Stream",
865 		NULL
866 	};
867 
868 	static const char *mpeg_stream_type_with_ts[] = {
869 		"MPEG-2 Program Stream",
870 		"MPEG-2 Transport Stream",
871 		"MPEG-1 System Stream",
872 		"MPEG-2 DVD-compatible Stream",
873 		"MPEG-1 VCD-compatible Stream",
874 		"MPEG-2 SVCD-compatible Stream",
875 		NULL
876 	};
877 
878 	static const char *mpeg_audio_encoding_l2_ac3[] = {
879 		"",
880 		"MPEG-1/2 Layer II",
881 		"",
882 		"",
883 		"AC-3",
884 		NULL
885 	};
886 
887 	switch (id) {
888 	case V4L2_CID_MPEG_STREAM_TYPE:
889 		return (p->capabilities & CX2341X_CAP_HAS_TS) ?
890 			mpeg_stream_type_with_ts : mpeg_stream_type_without_ts;
891 	case V4L2_CID_MPEG_AUDIO_ENCODING:
892 		return (p->capabilities & CX2341X_CAP_HAS_AC3) ?
893 			mpeg_audio_encoding_l2_ac3 : v4l2_ctrl_get_menu(id);
894 	case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
895 	case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
896 		return NULL;
897 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
898 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
899 	case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
900 	case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
901 	case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
902 		return cx2341x_get_menu(id);
903 	default:
904 		return v4l2_ctrl_get_menu(id);
905 	}
906 }
907 EXPORT_SYMBOL(cx2341x_ctrl_get_menu);
908 
909 static void cx2341x_calc_audio_properties(struct cx2341x_mpeg_params *params)
910 {
911 	params->audio_properties =
912 		(params->audio_sampling_freq << 0) |
913 		(params->audio_mode << 8) |
914 		(params->audio_mode_extension << 10) |
915 		(((params->audio_emphasis == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17)
916 		  ? 3 : params->audio_emphasis) << 12) |
917 		(params->audio_crc << 14);
918 
919 	if ((params->capabilities & CX2341X_CAP_HAS_AC3) &&
920 	    params->audio_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3) {
921 		params->audio_properties |=
922 			/* Not sure if this MPEG Layer II setting is required */
923 			((3 - V4L2_MPEG_AUDIO_ENCODING_LAYER_2) << 2) |
924 			(params->audio_ac3_bitrate << 4) |
925 			(CX2341X_AUDIO_ENCODING_METHOD_AC3 << 28);
926 	} else {
927 		/* Assuming MPEG Layer II */
928 		params->audio_properties |=
929 			((3 - params->audio_encoding) << 2) |
930 			((1 + params->audio_l2_bitrate) << 4);
931 	}
932 }
933 
934 int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
935 		  struct v4l2_ext_controls *ctrls, unsigned int cmd)
936 {
937 	int err = 0;
938 	int i;
939 
940 	if (cmd == VIDIOC_G_EXT_CTRLS) {
941 		for (i = 0; i < ctrls->count; i++) {
942 			struct v4l2_ext_control *ctrl = ctrls->controls + i;
943 
944 			err = cx2341x_get_ctrl(params, ctrl);
945 			if (err) {
946 				ctrls->error_idx = i;
947 				break;
948 			}
949 		}
950 		return err;
951 	}
952 	for (i = 0; i < ctrls->count; i++) {
953 		struct v4l2_ext_control *ctrl = ctrls->controls + i;
954 		struct v4l2_queryctrl qctrl;
955 		const char * const *menu_items = NULL;
956 
957 		qctrl.id = ctrl->id;
958 		err = cx2341x_ctrl_query(params, &qctrl);
959 		if (err)
960 			break;
961 		if (qctrl.type == V4L2_CTRL_TYPE_MENU)
962 			menu_items = cx2341x_ctrl_get_menu(params, qctrl.id);
963 		err = v4l2_ctrl_check(ctrl, &qctrl, menu_items);
964 		if (err)
965 			break;
966 		err = cx2341x_set_ctrl(params, busy, ctrl);
967 		if (err)
968 			break;
969 	}
970 	if (err == 0 &&
971 	    params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
972 	    params->video_bitrate_peak < params->video_bitrate) {
973 		err = -ERANGE;
974 		ctrls->error_idx = ctrls->count;
975 	}
976 	if (err)
977 		ctrls->error_idx = i;
978 	else
979 		cx2341x_calc_audio_properties(params);
980 	return err;
981 }
982 EXPORT_SYMBOL(cx2341x_ext_ctrls);
983 
984 void cx2341x_fill_defaults(struct cx2341x_mpeg_params *p)
985 {
986 	*p = default_params;
987 	cx2341x_calc_audio_properties(p);
988 }
989 EXPORT_SYMBOL(cx2341x_fill_defaults);
990 
991 static int cx2341x_api(void *priv, cx2341x_mbox_func func,
992 		       u32 cmd, int args, ...)
993 {
994 	u32 data[CX2341X_MBOX_MAX_DATA];
995 	va_list vargs;
996 	int i;
997 
998 	va_start(vargs, args);
999 
1000 	for (i = 0; i < args; i++)
1001 		data[i] = va_arg(vargs, int);
1002 	va_end(vargs);
1003 	return func(priv, cmd, args, 0, data);
1004 }
1005 
1006 #define NEQ(field) (old->field != new->field)
1007 
1008 int cx2341x_update(void *priv, cx2341x_mbox_func func,
1009 		   const struct cx2341x_mpeg_params *old,
1010 		   const struct cx2341x_mpeg_params *new)
1011 {
1012 	static int mpeg_stream_type[] = {
1013 		0,	/* MPEG-2 PS */
1014 		1,	/* MPEG-2 TS */
1015 		2,	/* MPEG-1 SS */
1016 		14,	/* DVD */
1017 		11,	/* VCD */
1018 		12,	/* SVCD */
1019 	};
1020 
1021 	int err = 0;
1022 	int force = (old == NULL);
1023 	u16 temporal = new->video_temporal_filter;
1024 
1025 	cx2341x_api(priv, func, CX2341X_ENC_SET_OUTPUT_PORT, 2, new->port, 0);
1026 
1027 	if (force || NEQ(is_50hz)) {
1028 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_RATE, 1,
1029 				  new->is_50hz);
1030 		if (err) return err;
1031 	}
1032 
1033 	if (force || NEQ(width) || NEQ(height) || NEQ(video_encoding)) {
1034 		u16 w = new->width;
1035 		u16 h = new->height;
1036 
1037 		if (new->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
1038 			w /= 2;
1039 			h /= 2;
1040 		}
1041 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_SIZE, 2,
1042 				  h, w);
1043 		if (err) return err;
1044 	}
1045 	if (force || NEQ(stream_type)) {
1046 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_STREAM_TYPE, 1,
1047 				  mpeg_stream_type[new->stream_type]);
1048 		if (err) return err;
1049 	}
1050 	if (force || NEQ(video_aspect)) {
1051 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_ASPECT_RATIO, 1,
1052 				  1 + new->video_aspect);
1053 		if (err) return err;
1054 	}
1055 	if (force || NEQ(video_b_frames) || NEQ(video_gop_size)) {
1056 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_PROPERTIES, 2,
1057 				new->video_gop_size, new->video_b_frames + 1);
1058 		if (err) return err;
1059 	}
1060 	if (force || NEQ(video_gop_closure)) {
1061 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_CLOSURE, 1,
1062 				  new->video_gop_closure);
1063 		if (err) return err;
1064 	}
1065 	if (force || NEQ(audio_properties)) {
1066 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_AUDIO_PROPERTIES,
1067 				  1, new->audio_properties);
1068 		if (err) return err;
1069 	}
1070 	if (force || NEQ(audio_mute)) {
1071 		err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_AUDIO, 1,
1072 				  new->audio_mute);
1073 		if (err) return err;
1074 	}
1075 	if (force || NEQ(video_bitrate_mode) || NEQ(video_bitrate) ||
1076 						NEQ(video_bitrate_peak)) {
1077 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_BIT_RATE, 5,
1078 				new->video_bitrate_mode, new->video_bitrate,
1079 				new->video_bitrate_peak / 400, 0, 0);
1080 		if (err) return err;
1081 	}
1082 	if (force || NEQ(video_spatial_filter_mode) ||
1083 		     NEQ(video_temporal_filter_mode) ||
1084 		     NEQ(video_median_filter_type)) {
1085 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_MODE,
1086 				  2, new->video_spatial_filter_mode |
1087 					(new->video_temporal_filter_mode << 1),
1088 				new->video_median_filter_type);
1089 		if (err) return err;
1090 	}
1091 	if (force || NEQ(video_luma_median_filter_bottom) ||
1092 		     NEQ(video_luma_median_filter_top) ||
1093 		     NEQ(video_chroma_median_filter_bottom) ||
1094 		     NEQ(video_chroma_median_filter_top)) {
1095 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_CORING_LEVELS, 4,
1096 				new->video_luma_median_filter_bottom,
1097 				new->video_luma_median_filter_top,
1098 				new->video_chroma_median_filter_bottom,
1099 				new->video_chroma_median_filter_top);
1100 		if (err) return err;
1101 	}
1102 	if (force || NEQ(video_luma_spatial_filter_type) ||
1103 		     NEQ(video_chroma_spatial_filter_type)) {
1104 		err = cx2341x_api(priv, func,
1105 				  CX2341X_ENC_SET_SPATIAL_FILTER_TYPE,
1106 				  2, new->video_luma_spatial_filter_type,
1107 				  new->video_chroma_spatial_filter_type);
1108 		if (err) return err;
1109 	}
1110 	if (force || NEQ(video_spatial_filter) ||
1111 		     old->video_temporal_filter != temporal) {
1112 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_PROPS,
1113 				  2, new->video_spatial_filter, temporal);
1114 		if (err) return err;
1115 	}
1116 	if (force || NEQ(video_temporal_decimation)) {
1117 		err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_DROP_RATE,
1118 				  1, new->video_temporal_decimation);
1119 		if (err) return err;
1120 	}
1121 	if (force || NEQ(video_mute) ||
1122 		(new->video_mute && NEQ(video_mute_yuv))) {
1123 		err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_VIDEO, 1,
1124 				new->video_mute | (new->video_mute_yuv << 8));
1125 		if (err) return err;
1126 	}
1127 	if (force || NEQ(stream_insert_nav_packets)) {
1128 		err = cx2341x_api(priv, func, CX2341X_ENC_MISC, 2,
1129 				7, new->stream_insert_nav_packets);
1130 		if (err) return err;
1131 	}
1132 	return 0;
1133 }
1134 EXPORT_SYMBOL(cx2341x_update);
1135 
1136 static const char *cx2341x_menu_item(const struct cx2341x_mpeg_params *p, u32 id)
1137 {
1138 	const char * const *menu = cx2341x_ctrl_get_menu(p, id);
1139 	struct v4l2_ext_control ctrl;
1140 
1141 	if (menu == NULL)
1142 		goto invalid;
1143 	ctrl.id = id;
1144 	if (cx2341x_get_ctrl(p, &ctrl))
1145 		goto invalid;
1146 	while (ctrl.value-- && *menu) menu++;
1147 	if (*menu == NULL)
1148 		goto invalid;
1149 	return *menu;
1150 
1151 invalid:
1152 	return "<invalid>";
1153 }
1154 
1155 void cx2341x_log_status(const struct cx2341x_mpeg_params *p, const char *prefix)
1156 {
1157 	int is_mpeg1 = p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1;
1158 
1159 	/* Stream */
1160 	printk(KERN_INFO "%s: Stream: %s",
1161 		prefix,
1162 		cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_TYPE));
1163 	if (p->stream_insert_nav_packets)
1164 		printk(" (with navigation packets)");
1165 	printk("\n");
1166 	printk(KERN_INFO "%s: VBI Format: %s\n",
1167 		prefix,
1168 		cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_VBI_FMT));
1169 
1170 	/* Video */
1171 	printk(KERN_INFO "%s: Video:  %dx%d, %d fps%s\n",
1172 		prefix,
1173 		p->width / (is_mpeg1 ? 2 : 1), p->height / (is_mpeg1 ? 2 : 1),
1174 		p->is_50hz ? 25 : 30,
1175 		(p->video_mute) ? " (muted)" : "");
1176 	printk(KERN_INFO "%s: Video:  %s, %s, %s, %d",
1177 		prefix,
1178 		cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ENCODING),
1179 		cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ASPECT),
1180 		cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_BITRATE_MODE),
1181 		p->video_bitrate);
1182 	if (p->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR)
1183 		printk(", Peak %d", p->video_bitrate_peak);
1184 	printk("\n");
1185 	printk(KERN_INFO
1186 		"%s: Video:  GOP Size %d, %d B-Frames, %sGOP Closure\n",
1187 		prefix,
1188 		p->video_gop_size, p->video_b_frames,
1189 		p->video_gop_closure ? "" : "No ");
1190 	if (p->video_temporal_decimation)
1191 		printk(KERN_INFO "%s: Video: Temporal Decimation %d\n",
1192 			prefix, p->video_temporal_decimation);
1193 
1194 	/* Audio */
1195 	printk(KERN_INFO "%s: Audio:  %s, %s, %s, %s%s",
1196 		prefix,
1197 		cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ),
1198 		cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_ENCODING),
1199 		cx2341x_menu_item(p,
1200 			   p->audio_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3
1201 					      ? V4L2_CID_MPEG_AUDIO_AC3_BITRATE
1202 					      : V4L2_CID_MPEG_AUDIO_L2_BITRATE),
1203 		cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_MODE),
1204 		p->audio_mute ? " (muted)" : "");
1205 	if (p->audio_mode == V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
1206 		printk(", %s", cx2341x_menu_item(p,
1207 				V4L2_CID_MPEG_AUDIO_MODE_EXTENSION));
1208 	printk(", %s, %s\n",
1209 		cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_EMPHASIS),
1210 		cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_CRC));
1211 
1212 	/* Encoding filters */
1213 	printk(KERN_INFO "%s: Spatial Filter:  %s, Luma %s, Chroma %s, %d\n",
1214 		prefix,
1215 		cx2341x_menu_item(p,
1216 		    V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE),
1217 		cx2341x_menu_item(p,
1218 		    V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE),
1219 		cx2341x_menu_item(p,
1220 		    V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE),
1221 		p->video_spatial_filter);
1222 
1223 	printk(KERN_INFO "%s: Temporal Filter: %s, %d\n",
1224 		prefix,
1225 		cx2341x_menu_item(p,
1226 			V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE),
1227 		p->video_temporal_filter);
1228 	printk(KERN_INFO
1229 		"%s: Median Filter:   %s, Luma [%d, %d], Chroma [%d, %d]\n",
1230 		prefix,
1231 		cx2341x_menu_item(p,
1232 			V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE),
1233 		p->video_luma_median_filter_bottom,
1234 		p->video_luma_median_filter_top,
1235 		p->video_chroma_median_filter_bottom,
1236 		p->video_chroma_median_filter_top);
1237 }
1238 EXPORT_SYMBOL(cx2341x_log_status);
1239 
1240 
1241 
1242 /********************** NEW CODE *********************/
1243 
1244 static inline struct cx2341x_handler *to_cxhdl(struct v4l2_ctrl *ctrl)
1245 {
1246 	return container_of(ctrl->handler, struct cx2341x_handler, hdl);
1247 }
1248 
1249 static int cx2341x_hdl_api(struct cx2341x_handler *hdl,
1250 		       u32 cmd, int args, ...)
1251 {
1252 	u32 data[CX2341X_MBOX_MAX_DATA];
1253 	va_list vargs;
1254 	int i;
1255 
1256 	va_start(vargs, args);
1257 
1258 	for (i = 0; i < args; i++)
1259 		data[i] = va_arg(vargs, int);
1260 	va_end(vargs);
1261 	return hdl->func(hdl->priv, cmd, args, 0, data);
1262 }
1263 
1264 /* ctrl->handler->lock is held, so it is safe to access cur.val */
1265 static inline int cx2341x_neq(struct v4l2_ctrl *ctrl)
1266 {
1267 	return ctrl && ctrl->val != ctrl->cur.val;
1268 }
1269 
1270 static int cx2341x_try_ctrl(struct v4l2_ctrl *ctrl)
1271 {
1272 	struct cx2341x_handler *hdl = to_cxhdl(ctrl);
1273 	s32 val = ctrl->val;
1274 
1275 	switch (ctrl->id) {
1276 	case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
1277 		/* video gop cluster */
1278 		int b = val + 1;
1279 		int gop = hdl->video_gop_size->val;
1280 
1281 		gop = b * ((gop + b - 1) / b);
1282 
1283 		/* Max GOP size = 34 */
1284 		while (gop > 34)
1285 			gop -= b;
1286 		hdl->video_gop_size->val = gop;
1287 		break;
1288 	}
1289 
1290 	case V4L2_CID_MPEG_STREAM_TYPE:
1291 		/* stream type cluster */
1292 		hdl->video_encoding->val =
1293 		    (hdl->stream_type->val == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
1294 		     hdl->stream_type->val == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
1295 			V4L2_MPEG_VIDEO_ENCODING_MPEG_1 :
1296 			V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
1297 		if (hdl->video_encoding->val == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
1298 			/* MPEG-1 implies CBR */
1299 			hdl->video_bitrate_mode->val =
1300 				V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
1301 		/* peak bitrate shall be >= normal bitrate */
1302 		if (hdl->video_bitrate_mode->val == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
1303 		    hdl->video_bitrate_peak->val < hdl->video_bitrate->val)
1304 			hdl->video_bitrate_peak->val = hdl->video_bitrate->val;
1305 		break;
1306 	}
1307 	return 0;
1308 }
1309 
1310 static int cx2341x_s_ctrl(struct v4l2_ctrl *ctrl)
1311 {
1312 	static const int mpeg_stream_type[] = {
1313 		0,	/* MPEG-2 PS */
1314 		1,	/* MPEG-2 TS */
1315 		2,	/* MPEG-1 SS */
1316 		14,	/* DVD */
1317 		11,	/* VCD */
1318 		12,	/* SVCD */
1319 	};
1320 	struct cx2341x_handler *hdl = to_cxhdl(ctrl);
1321 	s32 val = ctrl->val;
1322 	u32 props;
1323 	int err;
1324 
1325 	switch (ctrl->id) {
1326 	case V4L2_CID_MPEG_STREAM_VBI_FMT:
1327 		if (hdl->ops && hdl->ops->s_stream_vbi_fmt)
1328 			return hdl->ops->s_stream_vbi_fmt(hdl, val);
1329 		return 0;
1330 
1331 	case V4L2_CID_MPEG_VIDEO_ASPECT:
1332 		return cx2341x_hdl_api(hdl,
1333 			CX2341X_ENC_SET_ASPECT_RATIO, 1, val + 1);
1334 
1335 	case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1336 		return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_GOP_CLOSURE, 1, val);
1337 
1338 	case V4L2_CID_MPEG_AUDIO_MUTE:
1339 		return cx2341x_hdl_api(hdl, CX2341X_ENC_MUTE_AUDIO, 1, val);
1340 
1341 	case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
1342 		return cx2341x_hdl_api(hdl,
1343 			CX2341X_ENC_SET_FRAME_DROP_RATE, 1, val);
1344 
1345 	case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
1346 		return cx2341x_hdl_api(hdl, CX2341X_ENC_MISC, 2, 7, val);
1347 
1348 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1349 		/* audio properties cluster */
1350 		props = (hdl->audio_sampling_freq->val << 0) |
1351 			(hdl->audio_mode->val << 8) |
1352 			(hdl->audio_mode_extension->val << 10) |
1353 			(hdl->audio_crc->val << 14);
1354 		if (hdl->audio_emphasis->val == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17)
1355 			props |= 3 << 12;
1356 		else
1357 			props |= hdl->audio_emphasis->val << 12;
1358 
1359 		if (hdl->audio_encoding->val == V4L2_MPEG_AUDIO_ENCODING_AC3) {
1360 			props |=
1361 #if 1
1362 				/* Not sure if this MPEG Layer II setting is required */
1363 				((3 - V4L2_MPEG_AUDIO_ENCODING_LAYER_2) << 2) |
1364 #endif
1365 				(hdl->audio_ac3_bitrate->val << 4) |
1366 				(CX2341X_AUDIO_ENCODING_METHOD_AC3 << 28);
1367 		} else {
1368 			/* Assuming MPEG Layer II */
1369 			props |=
1370 				((3 - hdl->audio_encoding->val) << 2) |
1371 				((1 + hdl->audio_l2_bitrate->val) << 4);
1372 		}
1373 		err = cx2341x_hdl_api(hdl,
1374 				CX2341X_ENC_SET_AUDIO_PROPERTIES, 1, props);
1375 		if (err)
1376 			return err;
1377 
1378 		hdl->audio_properties = props;
1379 		if (hdl->audio_ac3_bitrate) {
1380 			int is_ac3 = hdl->audio_encoding->val ==
1381 						V4L2_MPEG_AUDIO_ENCODING_AC3;
1382 
1383 			v4l2_ctrl_activate(hdl->audio_ac3_bitrate, is_ac3);
1384 			v4l2_ctrl_activate(hdl->audio_l2_bitrate, !is_ac3);
1385 		}
1386 		v4l2_ctrl_activate(hdl->audio_mode_extension,
1387 			hdl->audio_mode->val == V4L2_MPEG_AUDIO_MODE_JOINT_STEREO);
1388 		if (cx2341x_neq(hdl->audio_sampling_freq) &&
1389 		    hdl->ops && hdl->ops->s_audio_sampling_freq)
1390 			return hdl->ops->s_audio_sampling_freq(hdl, hdl->audio_sampling_freq->val);
1391 		if (cx2341x_neq(hdl->audio_mode) &&
1392 		    hdl->ops && hdl->ops->s_audio_mode)
1393 			return hdl->ops->s_audio_mode(hdl, hdl->audio_mode->val);
1394 		return 0;
1395 
1396 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1397 		/* video gop cluster */
1398 		return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_GOP_PROPERTIES, 2,
1399 				hdl->video_gop_size->val,
1400 				hdl->video_b_frames->val + 1);
1401 
1402 	case V4L2_CID_MPEG_STREAM_TYPE:
1403 		/* stream type cluster */
1404 		err = cx2341x_hdl_api(hdl,
1405 			CX2341X_ENC_SET_STREAM_TYPE, 1, mpeg_stream_type[val]);
1406 		if (err)
1407 			return err;
1408 
1409 		err = cx2341x_hdl_api(hdl, CX2341X_ENC_SET_BIT_RATE, 5,
1410 				hdl->video_bitrate_mode->val,
1411 				hdl->video_bitrate->val,
1412 				hdl->video_bitrate_peak->val / 400, 0, 0);
1413 		if (err)
1414 			return err;
1415 
1416 		v4l2_ctrl_activate(hdl->video_bitrate_mode,
1417 			hdl->video_encoding->val != V4L2_MPEG_VIDEO_ENCODING_MPEG_1);
1418 		v4l2_ctrl_activate(hdl->video_bitrate_peak,
1419 			hdl->video_bitrate_mode->val != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR);
1420 		if (cx2341x_neq(hdl->video_encoding) &&
1421 		    hdl->ops && hdl->ops->s_video_encoding)
1422 			return hdl->ops->s_video_encoding(hdl, hdl->video_encoding->val);
1423 		return 0;
1424 
1425 	case V4L2_CID_MPEG_VIDEO_MUTE:
1426 		/* video mute cluster */
1427 		return cx2341x_hdl_api(hdl, CX2341X_ENC_MUTE_VIDEO, 1,
1428 				hdl->video_mute->val |
1429 					(hdl->video_mute_yuv->val << 8));
1430 
1431 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE: {
1432 		int active_filter;
1433 
1434 		/* video filter mode */
1435 		err = cx2341x_hdl_api(hdl, CX2341X_ENC_SET_DNR_FILTER_MODE, 2,
1436 				hdl->video_spatial_filter_mode->val |
1437 					(hdl->video_temporal_filter_mode->val << 1),
1438 				hdl->video_median_filter_type->val);
1439 		if (err)
1440 			return err;
1441 
1442 		active_filter = hdl->video_spatial_filter_mode->val !=
1443 				V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO;
1444 		v4l2_ctrl_activate(hdl->video_spatial_filter, active_filter);
1445 		v4l2_ctrl_activate(hdl->video_luma_spatial_filter_type, active_filter);
1446 		v4l2_ctrl_activate(hdl->video_chroma_spatial_filter_type, active_filter);
1447 		active_filter = hdl->video_temporal_filter_mode->val !=
1448 				V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO;
1449 		v4l2_ctrl_activate(hdl->video_temporal_filter, active_filter);
1450 		active_filter = hdl->video_median_filter_type->val !=
1451 				V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF;
1452 		v4l2_ctrl_activate(hdl->video_luma_median_filter_bottom, active_filter);
1453 		v4l2_ctrl_activate(hdl->video_luma_median_filter_top, active_filter);
1454 		v4l2_ctrl_activate(hdl->video_chroma_median_filter_bottom, active_filter);
1455 		v4l2_ctrl_activate(hdl->video_chroma_median_filter_top, active_filter);
1456 		return 0;
1457 	}
1458 
1459 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
1460 		/* video filter type cluster */
1461 		return cx2341x_hdl_api(hdl,
1462 				CX2341X_ENC_SET_SPATIAL_FILTER_TYPE, 2,
1463 				hdl->video_luma_spatial_filter_type->val,
1464 				hdl->video_chroma_spatial_filter_type->val);
1465 
1466 	case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
1467 		/* video filter cluster */
1468 		return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_DNR_FILTER_PROPS, 2,
1469 				hdl->video_spatial_filter->val,
1470 				hdl->video_temporal_filter->val);
1471 
1472 	case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
1473 		/* video median cluster */
1474 		return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_CORING_LEVELS, 4,
1475 				hdl->video_luma_median_filter_bottom->val,
1476 				hdl->video_luma_median_filter_top->val,
1477 				hdl->video_chroma_median_filter_bottom->val,
1478 				hdl->video_chroma_median_filter_top->val);
1479 	}
1480 	return -EINVAL;
1481 }
1482 
1483 static const struct v4l2_ctrl_ops cx2341x_ops = {
1484 	.try_ctrl = cx2341x_try_ctrl,
1485 	.s_ctrl = cx2341x_s_ctrl,
1486 };
1487 
1488 static struct v4l2_ctrl *cx2341x_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1489 			u32 id, s32 min, s32 max, s32 step, s32 def)
1490 {
1491 	struct v4l2_ctrl_config cfg;
1492 
1493 	cx2341x_ctrl_fill(id, &cfg.name, &cfg.type, &min, &max, &step, &def, &cfg.flags);
1494 	cfg.ops = &cx2341x_ops;
1495 	cfg.id = id;
1496 	cfg.min = min;
1497 	cfg.max = max;
1498 	cfg.def = def;
1499 	if (cfg.type == V4L2_CTRL_TYPE_MENU) {
1500 		cfg.step = 0;
1501 		cfg.menu_skip_mask = step;
1502 		cfg.qmenu = cx2341x_get_menu(id);
1503 	} else {
1504 		cfg.step = step;
1505 		cfg.menu_skip_mask = 0;
1506 	}
1507 	return v4l2_ctrl_new_custom(hdl, &cfg, NULL);
1508 }
1509 
1510 static struct v4l2_ctrl *cx2341x_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1511 			u32 id, s32 min, s32 max, s32 step, s32 def)
1512 {
1513 	return v4l2_ctrl_new_std(hdl, &cx2341x_ops, id, min, max, step, def);
1514 }
1515 
1516 static struct v4l2_ctrl *cx2341x_ctrl_new_menu(struct v4l2_ctrl_handler *hdl,
1517 			u32 id, s32 max, s32 mask, s32 def)
1518 {
1519 	return v4l2_ctrl_new_std_menu(hdl, &cx2341x_ops, id, max, mask, def);
1520 }
1521 
1522 int cx2341x_handler_init(struct cx2341x_handler *cxhdl,
1523 			 unsigned nr_of_controls_hint)
1524 {
1525 	struct v4l2_ctrl_handler *hdl = &cxhdl->hdl;
1526 	u32 caps = cxhdl->capabilities;
1527 	int has_sliced_vbi = caps & CX2341X_CAP_HAS_SLICED_VBI;
1528 	int has_ac3 = caps & CX2341X_CAP_HAS_AC3;
1529 	int has_ts = caps & CX2341X_CAP_HAS_TS;
1530 
1531 	cxhdl->width = 720;
1532 	cxhdl->height = 480;
1533 
1534 	v4l2_ctrl_handler_init(hdl, nr_of_controls_hint);
1535 
1536 	/* Add controls in ascending control ID order for fastest
1537 	   insertion time. */
1538 	cxhdl->stream_type = cx2341x_ctrl_new_menu(hdl,
1539 			V4L2_CID_MPEG_STREAM_TYPE,
1540 			V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, has_ts ? 0 : 2,
1541 			V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1542 	cxhdl->stream_vbi_fmt = cx2341x_ctrl_new_menu(hdl,
1543 			V4L2_CID_MPEG_STREAM_VBI_FMT,
1544 			V4L2_MPEG_STREAM_VBI_FMT_IVTV, has_sliced_vbi ? 0 : 2,
1545 			V4L2_MPEG_STREAM_VBI_FMT_NONE);
1546 	cxhdl->audio_sampling_freq = cx2341x_ctrl_new_menu(hdl,
1547 			V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
1548 			V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 0,
1549 			V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
1550 	cxhdl->audio_encoding = cx2341x_ctrl_new_menu(hdl,
1551 			V4L2_CID_MPEG_AUDIO_ENCODING,
1552 			V4L2_MPEG_AUDIO_ENCODING_AC3, has_ac3 ? ~0x12 : ~0x2,
1553 			V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
1554 	cxhdl->audio_l2_bitrate = cx2341x_ctrl_new_menu(hdl,
1555 			V4L2_CID_MPEG_AUDIO_L2_BITRATE,
1556 			V4L2_MPEG_AUDIO_L2_BITRATE_384K, 0x1ff,
1557 			V4L2_MPEG_AUDIO_L2_BITRATE_224K);
1558 	cxhdl->audio_mode = cx2341x_ctrl_new_menu(hdl,
1559 			V4L2_CID_MPEG_AUDIO_MODE,
1560 			V4L2_MPEG_AUDIO_MODE_MONO, 0,
1561 			V4L2_MPEG_AUDIO_MODE_STEREO);
1562 	cxhdl->audio_mode_extension = cx2341x_ctrl_new_menu(hdl,
1563 			V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
1564 			V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 0,
1565 			V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
1566 	cxhdl->audio_emphasis = cx2341x_ctrl_new_menu(hdl,
1567 			V4L2_CID_MPEG_AUDIO_EMPHASIS,
1568 			V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 0,
1569 			V4L2_MPEG_AUDIO_EMPHASIS_NONE);
1570 	cxhdl->audio_crc = cx2341x_ctrl_new_menu(hdl,
1571 			V4L2_CID_MPEG_AUDIO_CRC,
1572 			V4L2_MPEG_AUDIO_CRC_CRC16, 0,
1573 			V4L2_MPEG_AUDIO_CRC_NONE);
1574 
1575 	cx2341x_ctrl_new_std(hdl, V4L2_CID_MPEG_AUDIO_MUTE, 0, 1, 1, 0);
1576 	if (has_ac3)
1577 		cxhdl->audio_ac3_bitrate = cx2341x_ctrl_new_menu(hdl,
1578 				V4L2_CID_MPEG_AUDIO_AC3_BITRATE,
1579 				V4L2_MPEG_AUDIO_AC3_BITRATE_448K, 0x03,
1580 				V4L2_MPEG_AUDIO_AC3_BITRATE_224K);
1581 	cxhdl->video_encoding = cx2341x_ctrl_new_menu(hdl,
1582 			V4L2_CID_MPEG_VIDEO_ENCODING,
1583 			V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 0,
1584 			V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
1585 	cx2341x_ctrl_new_menu(hdl,
1586 			V4L2_CID_MPEG_VIDEO_ASPECT,
1587 			V4L2_MPEG_VIDEO_ASPECT_221x100, 0,
1588 			V4L2_MPEG_VIDEO_ASPECT_4x3);
1589 	cxhdl->video_b_frames = cx2341x_ctrl_new_std(hdl,
1590 			V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 33, 1, 2);
1591 	cxhdl->video_gop_size = cx2341x_ctrl_new_std(hdl,
1592 			V4L2_CID_MPEG_VIDEO_GOP_SIZE,
1593 			1, 34, 1, cxhdl->is_50hz ? 12 : 15);
1594 	cx2341x_ctrl_new_std(hdl, V4L2_CID_MPEG_VIDEO_GOP_CLOSURE, 0, 1, 1, 1);
1595 	cxhdl->video_bitrate_mode = cx2341x_ctrl_new_menu(hdl,
1596 			V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
1597 			V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0,
1598 			V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1599 	cxhdl->video_bitrate = cx2341x_ctrl_new_std(hdl,
1600 			V4L2_CID_MPEG_VIDEO_BITRATE,
1601 			0, 27000000, 1, 6000000);
1602 	cxhdl->video_bitrate_peak = cx2341x_ctrl_new_std(hdl,
1603 			V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
1604 			0, 27000000, 1, 8000000);
1605 	cx2341x_ctrl_new_std(hdl,
1606 			V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION, 0, 255, 1, 0);
1607 	cxhdl->video_mute = cx2341x_ctrl_new_std(hdl,
1608 			V4L2_CID_MPEG_VIDEO_MUTE, 0, 1, 1, 0);
1609 	cxhdl->video_mute_yuv = cx2341x_ctrl_new_std(hdl,
1610 			V4L2_CID_MPEG_VIDEO_MUTE_YUV, 0, 0xffffff, 1, 0x008080);
1611 
1612 	/* CX23415/6 specific */
1613 	cxhdl->video_spatial_filter_mode = cx2341x_ctrl_new_custom(hdl,
1614 			V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
1615 			V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
1616 			V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 0,
1617 			V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL);
1618 	cxhdl->video_spatial_filter = cx2341x_ctrl_new_custom(hdl,
1619 			V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
1620 			0, 15, 1, 0);
1621 	cxhdl->video_luma_spatial_filter_type = cx2341x_ctrl_new_custom(hdl,
1622 			V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
1623 			V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
1624 			V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE,
1625 			0,
1626 			V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR);
1627 	cxhdl->video_chroma_spatial_filter_type = cx2341x_ctrl_new_custom(hdl,
1628 			V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
1629 			V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
1630 			V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
1631 			0,
1632 			V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR);
1633 	cxhdl->video_temporal_filter_mode = cx2341x_ctrl_new_custom(hdl,
1634 			V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
1635 			V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
1636 			V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO,
1637 			0,
1638 			V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL);
1639 	cxhdl->video_temporal_filter = cx2341x_ctrl_new_custom(hdl,
1640 			V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
1641 			0, 31, 1, 8);
1642 	cxhdl->video_median_filter_type = cx2341x_ctrl_new_custom(hdl,
1643 			V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
1644 			V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
1645 			V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG,
1646 			0,
1647 			V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF);
1648 	cxhdl->video_luma_median_filter_bottom = cx2341x_ctrl_new_custom(hdl,
1649 			V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
1650 			0, 255, 1, 0);
1651 	cxhdl->video_luma_median_filter_top = cx2341x_ctrl_new_custom(hdl,
1652 			V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
1653 			0, 255, 1, 255);
1654 	cxhdl->video_chroma_median_filter_bottom = cx2341x_ctrl_new_custom(hdl,
1655 			V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
1656 			0, 255, 1, 0);
1657 	cxhdl->video_chroma_median_filter_top = cx2341x_ctrl_new_custom(hdl,
1658 			V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
1659 			0, 255, 1, 255);
1660 	cx2341x_ctrl_new_custom(hdl, V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS,
1661 			0, 1, 1, 0);
1662 
1663 	if (hdl->error) {
1664 		int err = hdl->error;
1665 
1666 		v4l2_ctrl_handler_free(hdl);
1667 		return err;
1668 	}
1669 
1670 	v4l2_ctrl_cluster(8, &cxhdl->audio_sampling_freq);
1671 	v4l2_ctrl_cluster(2, &cxhdl->video_b_frames);
1672 	v4l2_ctrl_cluster(5, &cxhdl->stream_type);
1673 	v4l2_ctrl_cluster(2, &cxhdl->video_mute);
1674 	v4l2_ctrl_cluster(3, &cxhdl->video_spatial_filter_mode);
1675 	v4l2_ctrl_cluster(2, &cxhdl->video_luma_spatial_filter_type);
1676 	v4l2_ctrl_cluster(2, &cxhdl->video_spatial_filter);
1677 	v4l2_ctrl_cluster(4, &cxhdl->video_luma_median_filter_top);
1678 
1679 	return 0;
1680 }
1681 EXPORT_SYMBOL(cx2341x_handler_init);
1682 
1683 void cx2341x_handler_set_50hz(struct cx2341x_handler *cxhdl, int is_50hz)
1684 {
1685 	cxhdl->is_50hz = is_50hz;
1686 	cxhdl->video_gop_size->default_value = cxhdl->is_50hz ? 12 : 15;
1687 }
1688 EXPORT_SYMBOL(cx2341x_handler_set_50hz);
1689 
1690 int cx2341x_handler_setup(struct cx2341x_handler *cxhdl)
1691 {
1692 	int h = cxhdl->height;
1693 	int w = cxhdl->width;
1694 	int err;
1695 
1696 	err = cx2341x_hdl_api(cxhdl, CX2341X_ENC_SET_OUTPUT_PORT, 2, cxhdl->port, 0);
1697 	if (err)
1698 		return err;
1699 	err = cx2341x_hdl_api(cxhdl, CX2341X_ENC_SET_FRAME_RATE, 1, cxhdl->is_50hz);
1700 	if (err)
1701 		return err;
1702 
1703 	if (v4l2_ctrl_g_ctrl(cxhdl->video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
1704 		w /= 2;
1705 		h /= 2;
1706 	}
1707 	err = cx2341x_hdl_api(cxhdl, CX2341X_ENC_SET_FRAME_SIZE, 2, h, w);
1708 	if (err)
1709 		return err;
1710 	return v4l2_ctrl_handler_setup(&cxhdl->hdl);
1711 }
1712 EXPORT_SYMBOL(cx2341x_handler_setup);
1713 
1714 void cx2341x_handler_set_busy(struct cx2341x_handler *cxhdl, int busy)
1715 {
1716 	v4l2_ctrl_grab(cxhdl->audio_sampling_freq, busy);
1717 	v4l2_ctrl_grab(cxhdl->audio_encoding, busy);
1718 	v4l2_ctrl_grab(cxhdl->audio_l2_bitrate, busy);
1719 	v4l2_ctrl_grab(cxhdl->audio_ac3_bitrate, busy);
1720 	v4l2_ctrl_grab(cxhdl->stream_vbi_fmt, busy);
1721 	v4l2_ctrl_grab(cxhdl->stream_type, busy);
1722 	v4l2_ctrl_grab(cxhdl->video_bitrate_mode, busy);
1723 	v4l2_ctrl_grab(cxhdl->video_bitrate, busy);
1724 	v4l2_ctrl_grab(cxhdl->video_bitrate_peak, busy);
1725 }
1726 EXPORT_SYMBOL(cx2341x_handler_set_busy);
1727