cx2341x.c

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