kernel/drivers/media/common/cx2341x.c

   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 /* Check for correctness of the ctrl's value based on the data from
 935    struct v4l2_queryctrl and the available menu items. Note that
 936    menu_items may be NULL, in that case it is ignored. */
 937 static int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
 938                 const char * const *menu_items)
 939 {
 940         if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
 941                 return -EINVAL;
 942         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
 943                 return -EBUSY;
 944         if (qctrl->type == V4L2_CTRL_TYPE_STRING)
 945                 return 0;
 946         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
 947             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
 948             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
 949                 return 0;
 950         if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
 951                 return -ERANGE;
 952         if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
 953                 if (menu_items[ctrl->value] == NULL ||
 954                     menu_items[ctrl->value][0] == '\0')
 955                         return -EINVAL;
 956         }
 957         if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
 958                         (ctrl->value & ~qctrl->maximum))
 959                 return -ERANGE;
 960         return 0;
 961 }
 962
 963 int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
 964                   struct v4l2_ext_controls *ctrls, unsigned int cmd)
 965 {
 966         int err = 0;
 967         int i;
 968
 969         if (cmd == VIDIOC_G_EXT_CTRLS) {
 970                 for (i = 0; i < ctrls->count; i++) {
 971                         struct v4l2_ext_control *ctrl = ctrls->controls + i;
 972
 973                         err = cx2341x_get_ctrl(params, ctrl);
 974                         if (err) {
 975                                 ctrls->error_idx = i;
 976                                 break;
 977                         }
 978                 }
 979                 return err;
 980         }
 981         for (i = 0; i < ctrls->count; i++) {
 982                 struct v4l2_ext_control *ctrl = ctrls->controls + i;
 983                 struct v4l2_queryctrl qctrl;
 984                 const char * const *menu_items = NULL;
 985
 986                 qctrl.id = ctrl->id;
 987                 err = cx2341x_ctrl_query(params, &qctrl);
 988                 if (err)
 989                         break;
 990                 if (qctrl.type == V4L2_CTRL_TYPE_MENU)
 991                         menu_items = cx2341x_ctrl_get_menu(params, qctrl.id);
 992                 err = v4l2_ctrl_check(ctrl, &qctrl, menu_items);
 993                 if (err)
 994                         break;
 995                 err = cx2341x_set_ctrl(params, busy, ctrl);
 996                 if (err)
 997                         break;
 998         }
 999         if (err == 0 &&
1000             params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
1001             params->video_bitrate_peak < params->video_bitrate) {
1002                 err = -ERANGE;
1003                 ctrls->error_idx = ctrls->count;
1004         }
1005         if (err)
1006                 ctrls->error_idx = i;
1007         else
1008                 cx2341x_calc_audio_properties(params);
1009         return err;
1010 }
1011 EXPORT_SYMBOL(cx2341x_ext_ctrls);
1012
1013 void cx2341x_fill_defaults(struct cx2341x_mpeg_params *p)
1014 {
1015         *p = default_params;
1016         cx2341x_calc_audio_properties(p);
1017 }
1018 EXPORT_SYMBOL(cx2341x_fill_defaults);
1019
1020 static int cx2341x_api(void *priv, cx2341x_mbox_func func,
1021                        u32 cmd, int args, ...)
1022 {
1023         u32 data[CX2341X_MBOX_MAX_DATA];
1024         va_list vargs;
1025         int i;
1026
1027         va_start(vargs, args);
1028
1029         for (i = 0; i < args; i++)
1030                 data[i] = va_arg(vargs, int);
1031         va_end(vargs);
1032         return func(priv, cmd, args, 0, data);
1033 }
1034
1035 #define NEQ(field) (old->field != new->field)
1036
1037 int cx2341x_update(void *priv, cx2341x_mbox_func func,
1038                    const struct cx2341x_mpeg_params *old,
1039                    const struct cx2341x_mpeg_params *new)
1040 {
1041         static int mpeg_stream_type[] = {
1042                 0,      /* MPEG-2 PS */
1043                 1,      /* MPEG-2 TS */
1044                 2,      /* MPEG-1 SS */
1045                 14,     /* DVD */
1046                 11,     /* VCD */
1047                 12,     /* SVCD */
1048         };
1049
1050         int err = 0;
1051         int force = (old == NULL);
1052         u16 temporal = new->video_temporal_filter;
1053
1054         cx2341x_api(priv, func, CX2341X_ENC_SET_OUTPUT_PORT, 2, new->port, 0);
1055
1056         if (force || NEQ(is_50hz)) {
1057                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_RATE, 1,
1058                                   new->is_50hz);
1059                 if (err) return err;
1060         }
1061
1062         if (force || NEQ(width) || NEQ(height) || NEQ(video_encoding)) {
1063                 u16 w = new->width;
1064                 u16 h = new->height;
1065
1066                 if (new->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
1067                         w /= 2;
1068                         h /= 2;
1069                 }
1070                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_SIZE, 2,
1071                                   h, w);
1072                 if (err) return err;
1073         }
1074         if (force || NEQ(stream_type)) {
1075                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_STREAM_TYPE, 1,
1076                                   mpeg_stream_type[new->stream_type]);
1077                 if (err) return err;
1078         }
1079         if (force || NEQ(video_aspect)) {
1080                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_ASPECT_RATIO, 1,
1081                                   1 + new->video_aspect);
1082                 if (err) return err;
1083         }
1084         if (force || NEQ(video_b_frames) || NEQ(video_gop_size)) {
1085                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_PROPERTIES, 2,
1086                                 new->video_gop_size, new->video_b_frames + 1);
1087                 if (err) return err;
1088         }
1089         if (force || NEQ(video_gop_closure)) {
1090                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_CLOSURE, 1,
1091                                   new->video_gop_closure);
1092                 if (err) return err;
1093         }
1094         if (force || NEQ(audio_properties)) {
1095                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_AUDIO_PROPERTIES,
1096                                   1, new->audio_properties);
1097                 if (err) return err;
1098         }
1099         if (force || NEQ(audio_mute)) {
1100                 err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_AUDIO, 1,
1101                                   new->audio_mute);
1102                 if (err) return err;
1103         }
1104         if (force || NEQ(video_bitrate_mode) || NEQ(video_bitrate) ||
1105                                                 NEQ(video_bitrate_peak)) {
1106                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_BIT_RATE, 5,
1107                                 new->video_bitrate_mode, new->video_bitrate,
1108                                 new->video_bitrate_peak / 400, 0, 0);
1109                 if (err) return err;
1110         }
1111         if (force || NEQ(video_spatial_filter_mode) ||
1112                      NEQ(video_temporal_filter_mode) ||
1113                      NEQ(video_median_filter_type)) {
1114                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_MODE,
1115                                   2, new->video_spatial_filter_mode |
1116                                         (new->video_temporal_filter_mode << 1),
1117                                 new->video_median_filter_type);
1118                 if (err) return err;
1119         }
1120         if (force || NEQ(video_luma_median_filter_bottom) ||
1121                      NEQ(video_luma_median_filter_top) ||
1122                      NEQ(video_chroma_median_filter_bottom) ||
1123                      NEQ(video_chroma_median_filter_top)) {
1124                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_CORING_LEVELS, 4,
1125                                 new->video_luma_median_filter_bottom,
1126                                 new->video_luma_median_filter_top,
1127                                 new->video_chroma_median_filter_bottom,
1128                                 new->video_chroma_median_filter_top);
1129                 if (err) return err;
1130         }
1131         if (force || NEQ(video_luma_spatial_filter_type) ||
1132                      NEQ(video_chroma_spatial_filter_type)) {
1133                 err = cx2341x_api(priv, func,
1134                                   CX2341X_ENC_SET_SPATIAL_FILTER_TYPE,
1135                                   2, new->video_luma_spatial_filter_type,
1136                                   new->video_chroma_spatial_filter_type);
1137                 if (err) return err;
1138         }
1139         if (force || NEQ(video_spatial_filter) ||
1140                      old->video_temporal_filter != temporal) {
1141                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_PROPS,
1142                                   2, new->video_spatial_filter, temporal);
1143                 if (err) return err;
1144         }
1145         if (force || NEQ(video_temporal_decimation)) {
1146                 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_DROP_RATE,
1147                                   1, new->video_temporal_decimation);
1148                 if (err) return err;
1149         }
1150         if (force || NEQ(video_mute) ||
1151                 (new->video_mute && NEQ(video_mute_yuv))) {
1152                 err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_VIDEO, 1,
1153                                 new->video_mute | (new->video_mute_yuv << 8));
1154                 if (err) return err;
1155         }
1156         if (force || NEQ(stream_insert_nav_packets)) {
1157                 err = cx2341x_api(priv, func, CX2341X_ENC_MISC, 2,
1158                                 7, new->stream_insert_nav_packets);
1159                 if (err) return err;
1160         }
1161         return 0;
1162 }
1163 EXPORT_SYMBOL(cx2341x_update);
1164
1165 static const char *cx2341x_menu_item(const struct cx2341x_mpeg_params *p, u32 id)
1166 {
1167         const char * const *menu = cx2341x_ctrl_get_menu(p, id);
1168         struct v4l2_ext_control ctrl;
1169
1170         if (menu == NULL)
1171                 goto invalid;
1172         ctrl.id = id;
1173         if (cx2341x_get_ctrl(p, &ctrl))
1174                 goto invalid;
1175         while (ctrl.value-- && *menu) menu++;
1176         if (*menu == NULL)
1177                 goto invalid;
1178         return *menu;
1179
1180 invalid:
1181         return "<invalid>";
1182 }
1183
1184 void cx2341x_log_status(const struct cx2341x_mpeg_params *p, const char *prefix)
1185 {
1186         int is_mpeg1 = p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1;
1187
1188         /* Stream */
1189         printk(KERN_INFO "%s: Stream: %s",
1190                 prefix,
1191                 cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_TYPE));
1192         if (p->stream_insert_nav_packets)
1193                 printk(" (with navigation packets)");
1194         printk("\n");
1195         printk(KERN_INFO "%s: VBI Format: %s\n",
1196                 prefix,
1197                 cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_VBI_FMT));
1198
1199         /* Video */
1200         printk(KERN_INFO "%s: Video:  %dx%d, %d fps%s\n",
1201                 prefix,
1202                 p->width / (is_mpeg1 ? 2 : 1), p->height / (is_mpeg1 ? 2 : 1),
1203                 p->is_50hz ? 25 : 30,
1204                 (p->video_mute) ? " (muted)" : "");
1205         printk(KERN_INFO "%s: Video:  %s, %s, %s, %d",
1206                 prefix,
1207                 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ENCODING),
1208                 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ASPECT),
1209                 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_BITRATE_MODE),
1210                 p->video_bitrate);
1211         if (p->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR)
1212                 printk(", Peak %d", p->video_bitrate_peak);
1213         printk("\n");
1214         printk(KERN_INFO
1215                 "%s: Video:  GOP Size %d, %d B-Frames, %sGOP Closure\n",
1216                 prefix,
1217                 p->video_gop_size, p->video_b_frames,
1218                 p->video_gop_closure ? "" : "No ");
1219         if (p->video_temporal_decimation)
1220                 printk(KERN_INFO "%s: Video: Temporal Decimation %d\n",
1221                         prefix, p->video_temporal_decimation);
1222
1223         /* Audio */
1224         printk(KERN_INFO "%s: Audio:  %s, %s, %s, %s%s",
1225                 prefix,
1226                 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ),
1227                 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_ENCODING),
1228                 cx2341x_menu_item(p,
1229                            p->audio_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3
1230                                               ? V4L2_CID_MPEG_AUDIO_AC3_BITRATE
1231                                               : V4L2_CID_MPEG_AUDIO_L2_BITRATE),
1232                 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_MODE),
1233                 p->audio_mute ? " (muted)" : "");
1234         if (p->audio_mode == V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
1235                 printk(", %s", cx2341x_menu_item(p,
1236                                 V4L2_CID_MPEG_AUDIO_MODE_EXTENSION));
1237         printk(", %s, %s\n",
1238                 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_EMPHASIS),
1239                 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_CRC));
1240
1241         /* Encoding filters */
1242         printk(KERN_INFO "%s: Spatial Filter:  %s, Luma %s, Chroma %s, %d\n",
1243                 prefix,
1244                 cx2341x_menu_item(p,
1245                     V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE),
1246                 cx2341x_menu_item(p,
1247                     V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE),
1248                 cx2341x_menu_item(p,
1249                     V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE),
1250                 p->video_spatial_filter);
1251
1252         printk(KERN_INFO "%s: Temporal Filter: %s, %d\n",
1253                 prefix,
1254                 cx2341x_menu_item(p,
1255                         V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE),
1256                 p->video_temporal_filter);
1257         printk(KERN_INFO
1258                 "%s: Median Filter:   %s, Luma [%d, %d], Chroma [%d, %d]\n",
1259                 prefix,
1260                 cx2341x_menu_item(p,
1261                         V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE),
1262                 p->video_luma_median_filter_bottom,
1263                 p->video_luma_median_filter_top,
1264                 p->video_chroma_median_filter_bottom,
1265                 p->video_chroma_median_filter_top);
1266 }
1267 EXPORT_SYMBOL(cx2341x_log_status);
1268
1269
1270
1271 /********************** NEW CODE *********************/
1272
1273 static inline struct cx2341x_handler *to_cxhdl(struct v4l2_ctrl *ctrl)
1274 {
1275         return container_of(ctrl->handler, struct cx2341x_handler, hdl);
1276 }
1277
1278 static int cx2341x_hdl_api(struct cx2341x_handler *hdl,
1279                        u32 cmd, int args, ...)
1280 {
1281         u32 data[CX2341X_MBOX_MAX_DATA];
1282         va_list vargs;
1283         int i;
1284
1285         va_start(vargs, args);
1286
1287         for (i = 0; i < args; i++)
1288                 data[i] = va_arg(vargs, int);
1289         va_end(vargs);
1290         return hdl->func(hdl->priv, cmd, args, 0, data);
1291 }
1292
1293 /* ctrl->handler->lock is held, so it is safe to access cur.val */
1294 static inline int cx2341x_neq(struct v4l2_ctrl *ctrl)
1295 {
1296         return ctrl && ctrl->val != ctrl->cur.val;
1297 }
1298
1299 static int cx2341x_try_ctrl(struct v4l2_ctrl *ctrl)
1300 {
1301         struct cx2341x_handler *hdl = to_cxhdl(ctrl);
1302         s32 val = ctrl->val;
1303
1304         switch (ctrl->id) {
1305         case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
1306                 /* video gop cluster */
1307                 int b = val + 1;
1308                 int gop = hdl->video_gop_size->val;
1309
1310                 gop = b * ((gop + b - 1) / b);
1311
1312                 /* Max GOP size = 34 */
1313                 while (gop > 34)
1314                         gop -= b;
1315                 hdl->video_gop_size->val = gop;
1316                 break;
1317         }
1318
1319         case V4L2_CID_MPEG_STREAM_TYPE:
1320                 /* stream type cluster */
1321                 hdl->video_encoding->val =
1322                     (hdl->stream_type->val == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
1323                      hdl->stream_type->val == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
1324                         V4L2_MPEG_VIDEO_ENCODING_MPEG_1 :
1325                         V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
1326                 if (hdl->video_encoding->val == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
1327                         /* MPEG-1 implies CBR */
1328                         hdl->video_bitrate_mode->val =
1329                                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
1330                 /* peak bitrate shall be >= normal bitrate */
1331                 if (hdl->video_bitrate_mode->val == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
1332                     hdl->video_bitrate_peak->val < hdl->video_bitrate->val)
1333                         hdl->video_bitrate_peak->val = hdl->video_bitrate->val;
1334                 break;
1335         }
1336         return 0;
1337 }
1338
1339 static int cx2341x_s_ctrl(struct v4l2_ctrl *ctrl)
1340 {
1341         static const int mpeg_stream_type[] = {
1342                 0,      /* MPEG-2 PS */
1343                 1,      /* MPEG-2 TS */
1344                 2,      /* MPEG-1 SS */
1345                 14,     /* DVD */
1346                 11,     /* VCD */
1347                 12,     /* SVCD */
1348         };
1349         struct cx2341x_handler *hdl = to_cxhdl(ctrl);
1350         s32 val = ctrl->val;
1351         u32 props;
1352         int err;
1353
1354         switch (ctrl->id) {
1355         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1356                 if (hdl->ops && hdl->ops->s_stream_vbi_fmt)
1357                         return hdl->ops->s_stream_vbi_fmt(hdl, val);
1358                 return 0;
1359
1360         case V4L2_CID_MPEG_VIDEO_ASPECT:
1361                 return cx2341x_hdl_api(hdl,
1362                         CX2341X_ENC_SET_ASPECT_RATIO, 1, val + 1);
1363
1364         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1365                 return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_GOP_CLOSURE, 1, val);
1366
1367         case V4L2_CID_MPEG_AUDIO_MUTE:
1368                 return cx2341x_hdl_api(hdl, CX2341X_ENC_MUTE_AUDIO, 1, val);
1369
1370         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
1371                 return cx2341x_hdl_api(hdl,
1372                         CX2341X_ENC_SET_FRAME_DROP_RATE, 1, val);
1373
1374         case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
1375                 return cx2341x_hdl_api(hdl, CX2341X_ENC_MISC, 2, 7, val);
1376
1377         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1378                 /* audio properties cluster */
1379                 props = (hdl->audio_sampling_freq->val << 0) |
1380                         (hdl->audio_mode->val << 8) |
1381                         (hdl->audio_mode_extension->val << 10) |
1382                         (hdl->audio_crc->val << 14);
1383                 if (hdl->audio_emphasis->val == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17)
1384                         props |= 3 << 12;
1385                 else
1386                         props |= hdl->audio_emphasis->val << 12;
1387
1388                 if (hdl->audio_encoding->val == V4L2_MPEG_AUDIO_ENCODING_AC3) {
1389                         props |=
1390 #if 1
1391                                 /* Not sure if this MPEG Layer II setting is required */
1392                                 ((3 - V4L2_MPEG_AUDIO_ENCODING_LAYER_2) << 2) |
1393 #endif
1394                                 (hdl->audio_ac3_bitrate->val << 4) |
1395                                 (CX2341X_AUDIO_ENCODING_METHOD_AC3 << 28);
1396                 } else {
1397                         /* Assuming MPEG Layer II */
1398                         props |=
1399                                 ((3 - hdl->audio_encoding->val) << 2) |
1400                                 ((1 + hdl->audio_l2_bitrate->val) << 4);
1401                 }
1402                 err = cx2341x_hdl_api(hdl,
1403                                 CX2341X_ENC_SET_AUDIO_PROPERTIES, 1, props);
1404                 if (err)
1405                         return err;
1406
1407                 hdl->audio_properties = props;
1408                 if (hdl->audio_ac3_bitrate) {
1409                         int is_ac3 = hdl->audio_encoding->val ==
1410                                                 V4L2_MPEG_AUDIO_ENCODING_AC3;
1411
1412                         v4l2_ctrl_activate(hdl->audio_ac3_bitrate, is_ac3);
1413                         v4l2_ctrl_activate(hdl->audio_l2_bitrate, !is_ac3);
1414                 }
1415                 v4l2_ctrl_activate(hdl->audio_mode_extension,
1416                         hdl->audio_mode->val == V4L2_MPEG_AUDIO_MODE_JOINT_STEREO);
1417                 if (cx2341x_neq(hdl->audio_sampling_freq) &&
1418                     hdl->ops && hdl->ops->s_audio_sampling_freq)
1419                         return hdl->ops->s_audio_sampling_freq(hdl, hdl->audio_sampling_freq->val);
1420                 if (cx2341x_neq(hdl->audio_mode) &&
1421                     hdl->ops && hdl->ops->s_audio_mode)
1422                         return hdl->ops->s_audio_mode(hdl, hdl->audio_mode->val);
1423                 return 0;
1424
1425         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1426                 /* video gop cluster */
1427                 return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_GOP_PROPERTIES, 2,
1428                                 hdl->video_gop_size->val,
1429                                 hdl->video_b_frames->val + 1);
1430
1431         case V4L2_CID_MPEG_STREAM_TYPE:
1432                 /* stream type cluster */
1433                 err = cx2341x_hdl_api(hdl,
1434                         CX2341X_ENC_SET_STREAM_TYPE, 1, mpeg_stream_type[val]);
1435                 if (err)
1436                         return err;
1437
1438                 err = cx2341x_hdl_api(hdl, CX2341X_ENC_SET_BIT_RATE, 5,
1439                                 hdl->video_bitrate_mode->val,
1440                                 hdl->video_bitrate->val,
1441                                 hdl->video_bitrate_peak->val / 400, 0, 0);
1442                 if (err)
1443                         return err;
1444
1445                 v4l2_ctrl_activate(hdl->video_bitrate_mode,
1446                         hdl->video_encoding->val != V4L2_MPEG_VIDEO_ENCODING_MPEG_1);
1447                 v4l2_ctrl_activate(hdl->video_bitrate_peak,
1448                         hdl->video_bitrate_mode->val != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR);
1449                 if (cx2341x_neq(hdl->video_encoding) &&
1450                     hdl->ops && hdl->ops->s_video_encoding)
1451                         return hdl->ops->s_video_encoding(hdl, hdl->video_encoding->val);
1452                 return 0;
1453
1454         case V4L2_CID_MPEG_VIDEO_MUTE:
1455                 /* video mute cluster */
1456                 return cx2341x_hdl_api(hdl, CX2341X_ENC_MUTE_VIDEO, 1,
1457                                 hdl->video_mute->val |
1458                                         (hdl->video_mute_yuv->val << 8));
1459
1460         case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE: {
1461                 int active_filter;
1462
1463                 /* video filter mode */
1464                 err = cx2341x_hdl_api(hdl, CX2341X_ENC_SET_DNR_FILTER_MODE, 2,
1465                                 hdl->video_spatial_filter_mode->val |
1466                                         (hdl->video_temporal_filter_mode->val << 1),
1467                                 hdl->video_median_filter_type->val);
1468                 if (err)
1469                         return err;
1470
1471                 active_filter = hdl->video_spatial_filter_mode->val !=
1472                                 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO;
1473                 v4l2_ctrl_activate(hdl->video_spatial_filter, active_filter);
1474                 v4l2_ctrl_activate(hdl->video_luma_spatial_filter_type, active_filter);
1475                 v4l2_ctrl_activate(hdl->video_chroma_spatial_filter_type, active_filter);
1476                 active_filter = hdl->video_temporal_filter_mode->val !=
1477                                 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO;
1478                 v4l2_ctrl_activate(hdl->video_temporal_filter, active_filter);
1479                 active_filter = hdl->video_median_filter_type->val !=
1480                                 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF;
1481                 v4l2_ctrl_activate(hdl->video_luma_median_filter_bottom, active_filter);
1482                 v4l2_ctrl_activate(hdl->video_luma_median_filter_top, active_filter);
1483                 v4l2_ctrl_activate(hdl->video_chroma_median_filter_bottom, active_filter);
1484                 v4l2_ctrl_activate(hdl->video_chroma_median_filter_top, active_filter);
1485                 return 0;
1486         }
1487
1488         case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
1489                 /* video filter type cluster */
1490                 return cx2341x_hdl_api(hdl,
1491                                 CX2341X_ENC_SET_SPATIAL_FILTER_TYPE, 2,
1492                                 hdl->video_luma_spatial_filter_type->val,
1493                                 hdl->video_chroma_spatial_filter_type->val);
1494
1495         case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
1496                 /* video filter cluster */
1497                 return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_DNR_FILTER_PROPS, 2,
1498                                 hdl->video_spatial_filter->val,
1499                                 hdl->video_temporal_filter->val);
1500
1501         case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
1502                 /* video median cluster */
1503                 return cx2341x_hdl_api(hdl, CX2341X_ENC_SET_CORING_LEVELS, 4,
1504                                 hdl->video_luma_median_filter_bottom->val,
1505                                 hdl->video_luma_median_filter_top->val,
1506                                 hdl->video_chroma_median_filter_bottom->val,
1507                                 hdl->video_chroma_median_filter_top->val);
1508         }
1509         return -EINVAL;
1510 }
1511
1512 static const struct v4l2_ctrl_ops cx2341x_ops = {
1513         .try_ctrl = cx2341x_try_ctrl,
1514         .s_ctrl = cx2341x_s_ctrl,
1515 };
1516
1517 static struct v4l2_ctrl *cx2341x_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1518                         u32 id, s32 min, s32 max, s32 step, s32 def)
1519 {
1520         struct v4l2_ctrl_config cfg;
1521
1522         memset(&cfg, 0, sizeof(cfg));
1523         cx2341x_ctrl_fill(id, &cfg.name, &cfg.type, &min, &max, &step, &def, &cfg.flags);
1524         cfg.ops = &cx2341x_ops;
1525         cfg.id = id;
1526         cfg.min = min;
1527         cfg.max = max;
1528         cfg.def = def;
1529         if (cfg.type == V4L2_CTRL_TYPE_MENU) {
1530                 cfg.step = 0;
1531                 cfg.menu_skip_mask = step;
1532                 cfg.qmenu = cx2341x_get_menu(id);
1533         } else {
1534                 cfg.step = step;
1535                 cfg.menu_skip_mask = 0;
1536         }
1537         return v4l2_ctrl_new_custom(hdl, &cfg, NULL);
1538 }
1539
1540 static struct v4l2_ctrl *cx2341x_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1541                         u32 id, s32 min, s32 max, s32 step, s32 def)
1542 {
1543         return v4l2_ctrl_new_std(hdl, &cx2341x_ops, id, min, max, step, def);
1544 }
1545
1546 static struct v4l2_ctrl *cx2341x_ctrl_new_menu(struct v4l2_ctrl_handler *hdl,
1547                         u32 id, s32 max, s32 mask, s32 def)
1548 {
1549         return v4l2_ctrl_new_std_menu(hdl, &cx2341x_ops, id, max, mask, def);
1550 }
1551
1552 int cx2341x_handler_init(struct cx2341x_handler *cxhdl,
1553                          unsigned nr_of_controls_hint)
1554 {
1555         struct v4l2_ctrl_handler *hdl = &cxhdl->hdl;
1556         u32 caps = cxhdl->capabilities;
1557         int has_sliced_vbi = caps & CX2341X_CAP_HAS_SLICED_VBI;
1558         int has_ac3 = caps & CX2341X_CAP_HAS_AC3;
1559         int has_ts = caps & CX2341X_CAP_HAS_TS;
1560
1561         cxhdl->width = 720;
1562         cxhdl->height = 480;
1563
1564         v4l2_ctrl_handler_init(hdl, nr_of_controls_hint);
1565
1566         /* Add controls in ascending control ID order for fastest
1567            insertion time. */
1568         cxhdl->stream_type = cx2341x_ctrl_new_menu(hdl,
1569                         V4L2_CID_MPEG_STREAM_TYPE,
1570                         V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, has_ts ? 0 : 2,
1571                         V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1572         cxhdl->stream_vbi_fmt = cx2341x_ctrl_new_menu(hdl,
1573                         V4L2_CID_MPEG_STREAM_VBI_FMT,
1574                         V4L2_MPEG_STREAM_VBI_FMT_IVTV, has_sliced_vbi ? 0 : 2,
1575                         V4L2_MPEG_STREAM_VBI_FMT_NONE);
1576         cxhdl->audio_sampling_freq = cx2341x_ctrl_new_menu(hdl,
1577                         V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
1578                         V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 0,
1579                         V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
1580         cxhdl->audio_encoding = cx2341x_ctrl_new_menu(hdl,
1581                         V4L2_CID_MPEG_AUDIO_ENCODING,
1582                         V4L2_MPEG_AUDIO_ENCODING_AC3, has_ac3 ? ~0x12 : ~0x2,
1583                         V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
1584         cxhdl->audio_l2_bitrate = cx2341x_ctrl_new_menu(hdl,
1585                         V4L2_CID_MPEG_AUDIO_L2_BITRATE,
1586                         V4L2_MPEG_AUDIO_L2_BITRATE_384K, 0x1ff,
1587                         V4L2_MPEG_AUDIO_L2_BITRATE_224K);
1588         cxhdl->audio_mode = cx2341x_ctrl_new_menu(hdl,
1589                         V4L2_CID_MPEG_AUDIO_MODE,
1590                         V4L2_MPEG_AUDIO_MODE_MONO, 0,
1591                         V4L2_MPEG_AUDIO_MODE_STEREO);
1592         cxhdl->audio_mode_extension = cx2341x_ctrl_new_menu(hdl,
1593                         V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
1594                         V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 0,
1595                         V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
1596         cxhdl->audio_emphasis = cx2341x_ctrl_new_menu(hdl,
1597                         V4L2_CID_MPEG_AUDIO_EMPHASIS,
1598                         V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 0,
1599                         V4L2_MPEG_AUDIO_EMPHASIS_NONE);
1600         cxhdl->audio_crc = cx2341x_ctrl_new_menu(hdl,
1601                         V4L2_CID_MPEG_AUDIO_CRC,
1602                         V4L2_MPEG_AUDIO_CRC_CRC16, 0,
1603                         V4L2_MPEG_AUDIO_CRC_NONE);
1604
1605         cx2341x_ctrl_new_std(hdl, V4L2_CID_MPEG_AUDIO_MUTE, 0, 1, 1, 0);
1606         if (has_ac3)
1607                 cxhdl->audio_ac3_bitrate = cx2341x_ctrl_new_menu(hdl,
1608                                 V4L2_CID_MPEG_AUDIO_AC3_BITRATE,
1609                                 V4L2_MPEG_AUDIO_AC3_BITRATE_448K, 0x03,
1610                                 V4L2_MPEG_AUDIO_AC3_BITRATE_224K);
1611         cxhdl->video_encoding = cx2341x_ctrl_new_menu(hdl,
1612                         V4L2_CID_MPEG_VIDEO_ENCODING,
1613                         V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 0,
1614                         V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
1615         cx2341x_ctrl_new_menu(hdl,
1616                         V4L2_CID_MPEG_VIDEO_ASPECT,
1617                         V4L2_MPEG_VIDEO_ASPECT_221x100, 0,
1618                         V4L2_MPEG_VIDEO_ASPECT_4x3);
1619         cxhdl->video_b_frames = cx2341x_ctrl_new_std(hdl,
1620                         V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 33, 1, 2);
1621         cxhdl->video_gop_size = cx2341x_ctrl_new_std(hdl,
1622                         V4L2_CID_MPEG_VIDEO_GOP_SIZE,
1623                         1, 34, 1, cxhdl->is_50hz ? 12 : 15);
1624         cx2341x_ctrl_new_std(hdl, V4L2_CID_MPEG_VIDEO_GOP_CLOSURE, 0, 1, 1, 1);
1625         cxhdl->video_bitrate_mode = cx2341x_ctrl_new_menu(hdl,
1626                         V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
1627                         V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0,
1628                         V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1629         cxhdl->video_bitrate = cx2341x_ctrl_new_std(hdl,
1630                         V4L2_CID_MPEG_VIDEO_BITRATE,
1631                         0, 27000000, 1, 6000000);
1632         cxhdl->video_bitrate_peak = cx2341x_ctrl_new_std(hdl,
1633                         V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
1634                         0, 27000000, 1, 8000000);
1635         cx2341x_ctrl_new_std(hdl,
1636                         V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION, 0, 255, 1, 0);
1637         cxhdl->video_mute = cx2341x_ctrl_new_std(hdl,
1638                         V4L2_CID_MPEG_VIDEO_MUTE, 0, 1, 1, 0);
1639         cxhdl->video_mute_yuv = cx2341x_ctrl_new_std(hdl,
1640                         V4L2_CID_MPEG_VIDEO_MUTE_YUV, 0, 0xffffff, 1, 0x008080);
1641
1642         /* CX23415/6 specific */
1643         cxhdl->video_spatial_filter_mode = cx2341x_ctrl_new_custom(hdl,
1644                         V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
1645                         V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
1646                         V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 0,
1647                         V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL);
1648         cxhdl->video_spatial_filter = cx2341x_ctrl_new_custom(hdl,
1649                         V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
1650                         0, 15, 1, 0);
1651         cxhdl->video_luma_spatial_filter_type = cx2341x_ctrl_new_custom(hdl,
1652                         V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
1653                         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
1654                         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE,
1655                         0,
1656                         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR);
1657         cxhdl->video_chroma_spatial_filter_type = cx2341x_ctrl_new_custom(hdl,
1658                         V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
1659                         V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
1660                         V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
1661                         0,
1662                         V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR);
1663         cxhdl->video_temporal_filter_mode = cx2341x_ctrl_new_custom(hdl,
1664                         V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
1665                         V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
1666                         V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO,
1667                         0,
1668                         V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL);
1669         cxhdl->video_temporal_filter = cx2341x_ctrl_new_custom(hdl,
1670                         V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
1671                         0, 31, 1, 8);
1672         cxhdl->video_median_filter_type = cx2341x_ctrl_new_custom(hdl,
1673                         V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
1674                         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
1675                         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG,
1676                         0,
1677                         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF);
1678         cxhdl->video_luma_median_filter_bottom = cx2341x_ctrl_new_custom(hdl,
1679                         V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
1680                         0, 255, 1, 0);
1681         cxhdl->video_luma_median_filter_top = cx2341x_ctrl_new_custom(hdl,
1682                         V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
1683                         0, 255, 1, 255);
1684         cxhdl->video_chroma_median_filter_bottom = cx2341x_ctrl_new_custom(hdl,
1685                         V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
1686                         0, 255, 1, 0);
1687         cxhdl->video_chroma_median_filter_top = cx2341x_ctrl_new_custom(hdl,
1688                         V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
1689                         0, 255, 1, 255);
1690         cx2341x_ctrl_new_custom(hdl, V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS,
1691                         0, 1, 1, 0);
1692
1693         if (hdl->error) {
1694                 int err = hdl->error;
1695
1696                 v4l2_ctrl_handler_free(hdl);
1697                 return err;
1698         }
1699
1700         v4l2_ctrl_cluster(8, &cxhdl->audio_sampling_freq);
1701         v4l2_ctrl_cluster(2, &cxhdl->video_b_frames);
1702         v4l2_ctrl_cluster(5, &cxhdl->stream_type);
1703         v4l2_ctrl_cluster(2, &cxhdl->video_mute);
1704         v4l2_ctrl_cluster(3, &cxhdl->video_spatial_filter_mode);
1705         v4l2_ctrl_cluster(2, &cxhdl->video_luma_spatial_filter_type);
1706         v4l2_ctrl_cluster(2, &cxhdl->video_spatial_filter);
1707         v4l2_ctrl_cluster(4, &cxhdl->video_luma_median_filter_top);
1708
1709         return 0;
1710 }
1711 EXPORT_SYMBOL(cx2341x_handler_init);
1712
1713 void cx2341x_handler_set_50hz(struct cx2341x_handler *cxhdl, int is_50hz)
1714 {
1715         cxhdl->is_50hz = is_50hz;
1716         cxhdl->video_gop_size->default_value = cxhdl->is_50hz ? 12 : 15;
1717 }
1718 EXPORT_SYMBOL(cx2341x_handler_set_50hz);
1719
1720 int cx2341x_handler_setup(struct cx2341x_handler *cxhdl)
1721 {
1722         int h = cxhdl->height;
1723         int w = cxhdl->width;
1724         int err;
1725
1726         err = cx2341x_hdl_api(cxhdl, CX2341X_ENC_SET_OUTPUT_PORT, 2, cxhdl->port, 0);
1727         if (err)
1728                 return err;
1729         err = cx2341x_hdl_api(cxhdl, CX2341X_ENC_SET_FRAME_RATE, 1, cxhdl->is_50hz);
1730         if (err)
1731                 return err;
1732
1733         if (v4l2_ctrl_g_ctrl(cxhdl->video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
1734                 w /= 2;
1735                 h /= 2;
1736         }
1737         err = cx2341x_hdl_api(cxhdl, CX2341X_ENC_SET_FRAME_SIZE, 2, h, w);
1738         if (err)
1739                 return err;
1740         return v4l2_ctrl_handler_setup(&cxhdl->hdl);
1741 }
1742 EXPORT_SYMBOL(cx2341x_handler_setup);
1743
1744 void cx2341x_handler_set_busy(struct cx2341x_handler *cxhdl, int busy)
1745 {
1746         v4l2_ctrl_grab(cxhdl->audio_sampling_freq, busy);
1747         v4l2_ctrl_grab(cxhdl->audio_encoding, busy);
1748         v4l2_ctrl_grab(cxhdl->audio_l2_bitrate, busy);
1749         v4l2_ctrl_grab(cxhdl->audio_ac3_bitrate, busy);
1750         v4l2_ctrl_grab(cxhdl->stream_vbi_fmt, busy);
1751         v4l2_ctrl_grab(cxhdl->stream_type, busy);
1752         v4l2_ctrl_grab(cxhdl->video_bitrate_mode, busy);
1753         v4l2_ctrl_grab(cxhdl->video_bitrate, busy);
1754         v4l2_ctrl_grab(cxhdl->video_bitrate_peak, busy);
1755 }
1756 EXPORT_SYMBOL(cx2341x_handler_set_busy);