Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * cx2341x - generic code for cx23415/6/8 based devices
0004  *
0005  * Copyright (C) 2006 Hans Verkuil <hverkuil@xs4all.nl>
0006  */
0007 
0008 
0009 #include <linux/module.h>
0010 #include <linux/errno.h>
0011 #include <linux/kernel.h>
0012 #include <linux/init.h>
0013 #include <linux/types.h>
0014 #include <linux/videodev2.h>
0015 
0016 #include <media/tuner.h>
0017 #include <media/drv-intf/cx2341x.h>
0018 #include <media/v4l2-common.h>
0019 
0020 MODULE_DESCRIPTION("cx23415/6/8 driver");
0021 MODULE_AUTHOR("Hans Verkuil");
0022 MODULE_LICENSE("GPL");
0023 
0024 static int debug;
0025 module_param(debug, int, 0644);
0026 MODULE_PARM_DESC(debug, "Debug level (0-1)");
0027 
0028 /********************** COMMON CODE *********************/
0029 
0030 /* definitions for audio properties bits 29-28 */
0031 #define CX2341X_AUDIO_ENCODING_METHOD_MPEG  0
0032 #define CX2341X_AUDIO_ENCODING_METHOD_AC3   1
0033 #define CX2341X_AUDIO_ENCODING_METHOD_LPCM  2
0034 
0035 static const char *cx2341x_get_name(u32 id)
0036 {
0037     switch (id) {
0038     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0039         return "Spatial Filter Mode";
0040     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
0041         return "Spatial Filter";
0042     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0043         return "Spatial Luma Filter Type";
0044     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0045         return "Spatial Chroma Filter Type";
0046     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0047         return "Temporal Filter Mode";
0048     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
0049         return "Temporal Filter";
0050     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0051         return "Median Filter Type";
0052     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
0053         return "Median Luma Filter Maximum";
0054     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
0055         return "Median Luma Filter Minimum";
0056     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
0057         return "Median Chroma Filter Maximum";
0058     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
0059         return "Median Chroma Filter Minimum";
0060     case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
0061         return "Insert Navigation Packets";
0062     }
0063     return NULL;
0064 }
0065 
0066 static const char **cx2341x_get_menu(u32 id)
0067 {
0068     static const char *cx2341x_video_spatial_filter_mode_menu[] = {
0069         "Manual",
0070         "Auto",
0071         NULL
0072     };
0073 
0074     static const char *cx2341x_video_luma_spatial_filter_type_menu[] = {
0075         "Off",
0076         "1D Horizontal",
0077         "1D Vertical",
0078         "2D H/V Separable",
0079         "2D Symmetric non-separable",
0080         NULL
0081     };
0082 
0083     static const char *cx2341x_video_chroma_spatial_filter_type_menu[] = {
0084         "Off",
0085         "1D Horizontal",
0086         NULL
0087     };
0088 
0089     static const char *cx2341x_video_temporal_filter_mode_menu[] = {
0090         "Manual",
0091         "Auto",
0092         NULL
0093     };
0094 
0095     static const char *cx2341x_video_median_filter_type_menu[] = {
0096         "Off",
0097         "Horizontal",
0098         "Vertical",
0099         "Horizontal/Vertical",
0100         "Diagonal",
0101         NULL
0102     };
0103 
0104     switch (id) {
0105     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0106         return cx2341x_video_spatial_filter_mode_menu;
0107     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0108         return cx2341x_video_luma_spatial_filter_type_menu;
0109     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0110         return cx2341x_video_chroma_spatial_filter_type_menu;
0111     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0112         return cx2341x_video_temporal_filter_mode_menu;
0113     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0114         return cx2341x_video_median_filter_type_menu;
0115     }
0116     return NULL;
0117 }
0118 
0119 static void cx2341x_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
0120             s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags)
0121 {
0122     *name = cx2341x_get_name(id);
0123     *flags = 0;
0124 
0125     switch (id) {
0126     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0127     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0128     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0129     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0130     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0131         *type = V4L2_CTRL_TYPE_MENU;
0132         *min = 0;
0133         *step = 0;
0134         break;
0135     case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
0136         *type = V4L2_CTRL_TYPE_BOOLEAN;
0137         *min = 0;
0138         *max = *step = 1;
0139         break;
0140     default:
0141         *type = V4L2_CTRL_TYPE_INTEGER;
0142         break;
0143     }
0144     switch (id) {
0145     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0146     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0147     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0148         *flags |= V4L2_CTRL_FLAG_UPDATE;
0149         break;
0150     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
0151     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
0152     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
0153     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
0154     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
0155     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
0156         *flags |= V4L2_CTRL_FLAG_SLIDER;
0157         break;
0158     case V4L2_CID_MPEG_VIDEO_ENCODING:
0159         *flags |= V4L2_CTRL_FLAG_READ_ONLY;
0160         break;
0161     }
0162 }
0163 
0164 
0165 /********************** OLD CODE *********************/
0166 
0167 /* Must be sorted from low to high control ID! */
0168 const u32 cx2341x_mpeg_ctrls[] = {
0169     V4L2_CID_CODEC_CLASS,
0170     V4L2_CID_MPEG_STREAM_TYPE,
0171     V4L2_CID_MPEG_STREAM_VBI_FMT,
0172     V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
0173     V4L2_CID_MPEG_AUDIO_ENCODING,
0174     V4L2_CID_MPEG_AUDIO_L2_BITRATE,
0175     V4L2_CID_MPEG_AUDIO_MODE,
0176     V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
0177     V4L2_CID_MPEG_AUDIO_EMPHASIS,
0178     V4L2_CID_MPEG_AUDIO_CRC,
0179     V4L2_CID_MPEG_AUDIO_MUTE,
0180     V4L2_CID_MPEG_AUDIO_AC3_BITRATE,
0181     V4L2_CID_MPEG_VIDEO_ENCODING,
0182     V4L2_CID_MPEG_VIDEO_ASPECT,
0183     V4L2_CID_MPEG_VIDEO_B_FRAMES,
0184     V4L2_CID_MPEG_VIDEO_GOP_SIZE,
0185     V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
0186     V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
0187     V4L2_CID_MPEG_VIDEO_BITRATE,
0188     V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
0189     V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
0190     V4L2_CID_MPEG_VIDEO_MUTE,
0191     V4L2_CID_MPEG_VIDEO_MUTE_YUV,
0192     V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
0193     V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
0194     V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
0195     V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
0196     V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
0197     V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
0198     V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
0199     V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
0200     V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
0201     V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
0202     V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
0203     V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS,
0204     0
0205 };
0206 EXPORT_SYMBOL(cx2341x_mpeg_ctrls);
0207 
0208 static const struct cx2341x_mpeg_params default_params = {
0209     /* misc */
0210     .capabilities = 0,
0211     .port = CX2341X_PORT_MEMORY,
0212     .width = 720,
0213     .height = 480,
0214     .is_50hz = 0,
0215 
0216     /* stream */
0217     .stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
0218     .stream_vbi_fmt = V4L2_MPEG_STREAM_VBI_FMT_NONE,
0219     .stream_insert_nav_packets = 0,
0220 
0221     /* audio */
0222     .audio_sampling_freq = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
0223     .audio_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
0224     .audio_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_224K,
0225     .audio_ac3_bitrate = V4L2_MPEG_AUDIO_AC3_BITRATE_224K,
0226     .audio_mode = V4L2_MPEG_AUDIO_MODE_STEREO,
0227     .audio_mode_extension = V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
0228     .audio_emphasis = V4L2_MPEG_AUDIO_EMPHASIS_NONE,
0229     .audio_crc = V4L2_MPEG_AUDIO_CRC_NONE,
0230     .audio_mute = 0,
0231 
0232     /* video */
0233     .video_encoding = V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
0234     .video_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
0235     .video_b_frames = 2,
0236     .video_gop_size = 12,
0237     .video_gop_closure = 1,
0238     .video_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
0239     .video_bitrate = 6000000,
0240     .video_bitrate_peak = 8000000,
0241     .video_temporal_decimation = 0,
0242     .video_mute = 0,
0243     .video_mute_yuv = 0x008080,  /* YCbCr value for black */
0244 
0245     /* encoding filters */
0246     .video_spatial_filter_mode =
0247         V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
0248     .video_spatial_filter = 0,
0249     .video_luma_spatial_filter_type =
0250         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR,
0251     .video_chroma_spatial_filter_type =
0252         V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
0253     .video_temporal_filter_mode =
0254         V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
0255     .video_temporal_filter = 8,
0256     .video_median_filter_type =
0257         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
0258     .video_luma_median_filter_top = 255,
0259     .video_luma_median_filter_bottom = 0,
0260     .video_chroma_median_filter_top = 255,
0261     .video_chroma_median_filter_bottom = 0,
0262 };
0263 /* Map the control ID to the correct field in the cx2341x_mpeg_params
0264    struct. Return -EINVAL if the ID is unknown, else return 0. */
0265 static int cx2341x_get_ctrl(const struct cx2341x_mpeg_params *params,
0266         struct v4l2_ext_control *ctrl)
0267 {
0268     switch (ctrl->id) {
0269     case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
0270         ctrl->value = params->audio_sampling_freq;
0271         break;
0272     case V4L2_CID_MPEG_AUDIO_ENCODING:
0273         ctrl->value = params->audio_encoding;
0274         break;
0275     case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
0276         ctrl->value = params->audio_l2_bitrate;
0277         break;
0278     case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
0279         ctrl->value = params->audio_ac3_bitrate;
0280         break;
0281     case V4L2_CID_MPEG_AUDIO_MODE:
0282         ctrl->value = params->audio_mode;
0283         break;
0284     case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
0285         ctrl->value = params->audio_mode_extension;
0286         break;
0287     case V4L2_CID_MPEG_AUDIO_EMPHASIS:
0288         ctrl->value = params->audio_emphasis;
0289         break;
0290     case V4L2_CID_MPEG_AUDIO_CRC:
0291         ctrl->value = params->audio_crc;
0292         break;
0293     case V4L2_CID_MPEG_AUDIO_MUTE:
0294         ctrl->value = params->audio_mute;
0295         break;
0296     case V4L2_CID_MPEG_VIDEO_ENCODING:
0297         ctrl->value = params->video_encoding;
0298         break;
0299     case V4L2_CID_MPEG_VIDEO_ASPECT:
0300         ctrl->value = params->video_aspect;
0301         break;
0302     case V4L2_CID_MPEG_VIDEO_B_FRAMES:
0303         ctrl->value = params->video_b_frames;
0304         break;
0305     case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
0306         ctrl->value = params->video_gop_size;
0307         break;
0308     case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
0309         ctrl->value = params->video_gop_closure;
0310         break;
0311     case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
0312         ctrl->value = params->video_bitrate_mode;
0313         break;
0314     case V4L2_CID_MPEG_VIDEO_BITRATE:
0315         ctrl->value = params->video_bitrate;
0316         break;
0317     case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
0318         ctrl->value = params->video_bitrate_peak;
0319         break;
0320     case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
0321         ctrl->value = params->video_temporal_decimation;
0322         break;
0323     case V4L2_CID_MPEG_VIDEO_MUTE:
0324         ctrl->value = params->video_mute;
0325         break;
0326     case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
0327         ctrl->value = params->video_mute_yuv;
0328         break;
0329     case V4L2_CID_MPEG_STREAM_TYPE:
0330         ctrl->value = params->stream_type;
0331         break;
0332     case V4L2_CID_MPEG_STREAM_VBI_FMT:
0333         ctrl->value = params->stream_vbi_fmt;
0334         break;
0335     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0336         ctrl->value = params->video_spatial_filter_mode;
0337         break;
0338     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
0339         ctrl->value = params->video_spatial_filter;
0340         break;
0341     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0342         ctrl->value = params->video_luma_spatial_filter_type;
0343         break;
0344     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0345         ctrl->value = params->video_chroma_spatial_filter_type;
0346         break;
0347     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0348         ctrl->value = params->video_temporal_filter_mode;
0349         break;
0350     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
0351         ctrl->value = params->video_temporal_filter;
0352         break;
0353     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0354         ctrl->value = params->video_median_filter_type;
0355         break;
0356     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
0357         ctrl->value = params->video_luma_median_filter_top;
0358         break;
0359     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
0360         ctrl->value = params->video_luma_median_filter_bottom;
0361         break;
0362     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
0363         ctrl->value = params->video_chroma_median_filter_top;
0364         break;
0365     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
0366         ctrl->value = params->video_chroma_median_filter_bottom;
0367         break;
0368     case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
0369         ctrl->value = params->stream_insert_nav_packets;
0370         break;
0371     default:
0372         return -EINVAL;
0373     }
0374     return 0;
0375 }
0376 
0377 /* Map the control ID to the correct field in the cx2341x_mpeg_params
0378    struct. Return -EINVAL if the ID is unknown, else return 0. */
0379 static int cx2341x_set_ctrl(struct cx2341x_mpeg_params *params, int busy,
0380         struct v4l2_ext_control *ctrl)
0381 {
0382     switch (ctrl->id) {
0383     case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
0384         if (busy)
0385             return -EBUSY;
0386         params->audio_sampling_freq = ctrl->value;
0387         break;
0388     case V4L2_CID_MPEG_AUDIO_ENCODING:
0389         if (busy)
0390             return -EBUSY;
0391         if (params->capabilities & CX2341X_CAP_HAS_AC3)
0392             if (ctrl->value != V4L2_MPEG_AUDIO_ENCODING_LAYER_2 &&
0393                 ctrl->value != V4L2_MPEG_AUDIO_ENCODING_AC3)
0394                 return -ERANGE;
0395         params->audio_encoding = ctrl->value;
0396         break;
0397     case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
0398         if (busy)
0399             return -EBUSY;
0400         params->audio_l2_bitrate = ctrl->value;
0401         break;
0402     case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
0403         if (busy)
0404             return -EBUSY;
0405         if (!(params->capabilities & CX2341X_CAP_HAS_AC3))
0406             return -EINVAL;
0407         params->audio_ac3_bitrate = ctrl->value;
0408         break;
0409     case V4L2_CID_MPEG_AUDIO_MODE:
0410         params->audio_mode = ctrl->value;
0411         break;
0412     case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
0413         params->audio_mode_extension = ctrl->value;
0414         break;
0415     case V4L2_CID_MPEG_AUDIO_EMPHASIS:
0416         params->audio_emphasis = ctrl->value;
0417         break;
0418     case V4L2_CID_MPEG_AUDIO_CRC:
0419         params->audio_crc = ctrl->value;
0420         break;
0421     case V4L2_CID_MPEG_AUDIO_MUTE:
0422         params->audio_mute = ctrl->value;
0423         break;
0424     case V4L2_CID_MPEG_VIDEO_ASPECT:
0425         params->video_aspect = ctrl->value;
0426         break;
0427     case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
0428         int b = ctrl->value + 1;
0429         int gop = params->video_gop_size;
0430         params->video_b_frames = ctrl->value;
0431         params->video_gop_size = b * ((gop + b - 1) / b);
0432         /* Max GOP size = 34 */
0433         while (params->video_gop_size > 34)
0434             params->video_gop_size -= b;
0435         break;
0436     }
0437     case V4L2_CID_MPEG_VIDEO_GOP_SIZE: {
0438         int b = params->video_b_frames + 1;
0439         int gop = ctrl->value;
0440         params->video_gop_size = b * ((gop + b - 1) / b);
0441         /* Max GOP size = 34 */
0442         while (params->video_gop_size > 34)
0443             params->video_gop_size -= b;
0444         ctrl->value = params->video_gop_size;
0445         break;
0446     }
0447     case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
0448         params->video_gop_closure = ctrl->value;
0449         break;
0450     case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
0451         if (busy)
0452             return -EBUSY;
0453         /* MPEG-1 only allows CBR */
0454         if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1 &&
0455             ctrl->value != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
0456             return -EINVAL;
0457         params->video_bitrate_mode = ctrl->value;
0458         break;
0459     case V4L2_CID_MPEG_VIDEO_BITRATE:
0460         if (busy)
0461             return -EBUSY;
0462         params->video_bitrate = ctrl->value;
0463         break;
0464     case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
0465         if (busy)
0466             return -EBUSY;
0467         params->video_bitrate_peak = ctrl->value;
0468         break;
0469     case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
0470         params->video_temporal_decimation = ctrl->value;
0471         break;
0472     case V4L2_CID_MPEG_VIDEO_MUTE:
0473         params->video_mute = (ctrl->value != 0);
0474         break;
0475     case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
0476         params->video_mute_yuv = ctrl->value;
0477         break;
0478     case V4L2_CID_MPEG_STREAM_TYPE:
0479         if (busy)
0480             return -EBUSY;
0481         params->stream_type = ctrl->value;
0482         params->video_encoding =
0483             (params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
0484              params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
0485             V4L2_MPEG_VIDEO_ENCODING_MPEG_1 :
0486             V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
0487         if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
0488             /* MPEG-1 implies CBR */
0489             params->video_bitrate_mode =
0490                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
0491         break;
0492     case V4L2_CID_MPEG_STREAM_VBI_FMT:
0493         params->stream_vbi_fmt = ctrl->value;
0494         break;
0495     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0496         params->video_spatial_filter_mode = ctrl->value;
0497         break;
0498     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
0499         params->video_spatial_filter = ctrl->value;
0500         break;
0501     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0502         params->video_luma_spatial_filter_type = ctrl->value;
0503         break;
0504     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0505         params->video_chroma_spatial_filter_type = ctrl->value;
0506         break;
0507     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0508         params->video_temporal_filter_mode = ctrl->value;
0509         break;
0510     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
0511         params->video_temporal_filter = ctrl->value;
0512         break;
0513     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0514         params->video_median_filter_type = ctrl->value;
0515         break;
0516     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
0517         params->video_luma_median_filter_top = ctrl->value;
0518         break;
0519     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
0520         params->video_luma_median_filter_bottom = ctrl->value;
0521         break;
0522     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
0523         params->video_chroma_median_filter_top = ctrl->value;
0524         break;
0525     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
0526         params->video_chroma_median_filter_bottom = ctrl->value;
0527         break;
0528     case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
0529         params->stream_insert_nav_packets = ctrl->value;
0530         break;
0531     default:
0532         return -EINVAL;
0533     }
0534     return 0;
0535 }
0536 
0537 static int cx2341x_ctrl_query_fill(struct v4l2_queryctrl *qctrl,
0538                    s32 min, s32 max, s32 step, s32 def)
0539 {
0540     const char *name;
0541 
0542     switch (qctrl->id) {
0543     /* MPEG controls */
0544     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0545     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
0546     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0547     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0548     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0549     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
0550     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0551     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
0552     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
0553     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
0554     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
0555     case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
0556         cx2341x_ctrl_fill(qctrl->id, &name, &qctrl->type,
0557                 &min, &max, &step, &def, &qctrl->flags);
0558         qctrl->minimum = min;
0559         qctrl->maximum = max;
0560         qctrl->step = step;
0561         qctrl->default_value = def;
0562         qctrl->reserved[0] = qctrl->reserved[1] = 0;
0563         strscpy(qctrl->name, name, sizeof(qctrl->name));
0564         return 0;
0565 
0566     default:
0567         return v4l2_ctrl_query_fill(qctrl, min, max, step, def);
0568     }
0569 }
0570 
0571 int cx2341x_ctrl_query(const struct cx2341x_mpeg_params *params,
0572                struct v4l2_queryctrl *qctrl)
0573 {
0574     int err;
0575 
0576     switch (qctrl->id) {
0577     case V4L2_CID_CODEC_CLASS:
0578         return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
0579     case V4L2_CID_MPEG_STREAM_TYPE:
0580         return v4l2_ctrl_query_fill(qctrl,
0581                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
0582                 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
0583                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
0584 
0585     case V4L2_CID_MPEG_STREAM_VBI_FMT:
0586         if (params->capabilities & CX2341X_CAP_HAS_SLICED_VBI)
0587             return v4l2_ctrl_query_fill(qctrl,
0588                     V4L2_MPEG_STREAM_VBI_FMT_NONE,
0589                     V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
0590                     V4L2_MPEG_STREAM_VBI_FMT_NONE);
0591         return cx2341x_ctrl_query_fill(qctrl,
0592                 V4L2_MPEG_STREAM_VBI_FMT_NONE,
0593                 V4L2_MPEG_STREAM_VBI_FMT_NONE, 1,
0594                 default_params.stream_vbi_fmt);
0595 
0596     case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
0597         return v4l2_ctrl_query_fill(qctrl,
0598                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
0599                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
0600                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
0601 
0602     case V4L2_CID_MPEG_AUDIO_ENCODING:
0603         if (params->capabilities & CX2341X_CAP_HAS_AC3) {
0604             /*
0605              * The state of L2 & AC3 bitrate controls can change
0606              * when this control changes, but v4l2_ctrl_query_fill()
0607              * already sets V4L2_CTRL_FLAG_UPDATE for
0608              * V4L2_CID_MPEG_AUDIO_ENCODING, so we don't here.
0609              */
0610             return v4l2_ctrl_query_fill(qctrl,
0611                     V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
0612                     V4L2_MPEG_AUDIO_ENCODING_AC3, 1,
0613                     default_params.audio_encoding);
0614         }
0615 
0616         return v4l2_ctrl_query_fill(qctrl,
0617                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
0618                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2, 1,
0619                 default_params.audio_encoding);
0620 
0621     case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
0622         err = v4l2_ctrl_query_fill(qctrl,
0623                 V4L2_MPEG_AUDIO_L2_BITRATE_192K,
0624                 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
0625                 default_params.audio_l2_bitrate);
0626         if (err)
0627             return err;
0628         if (params->capabilities & CX2341X_CAP_HAS_AC3 &&
0629             params->audio_encoding != V4L2_MPEG_AUDIO_ENCODING_LAYER_2)
0630             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0631         return 0;
0632 
0633     case V4L2_CID_MPEG_AUDIO_MODE:
0634         return v4l2_ctrl_query_fill(qctrl,
0635                 V4L2_MPEG_AUDIO_MODE_STEREO,
0636                 V4L2_MPEG_AUDIO_MODE_MONO, 1,
0637                 V4L2_MPEG_AUDIO_MODE_STEREO);
0638 
0639     case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
0640         err = v4l2_ctrl_query_fill(qctrl,
0641                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
0642                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
0643                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
0644         if (err == 0 &&
0645             params->audio_mode != V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
0646             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0647         return err;
0648 
0649     case V4L2_CID_MPEG_AUDIO_EMPHASIS:
0650         return v4l2_ctrl_query_fill(qctrl,
0651                 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
0652                 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
0653                 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
0654 
0655     case V4L2_CID_MPEG_AUDIO_CRC:
0656         return v4l2_ctrl_query_fill(qctrl,
0657                 V4L2_MPEG_AUDIO_CRC_NONE,
0658                 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
0659                 V4L2_MPEG_AUDIO_CRC_NONE);
0660 
0661     case V4L2_CID_MPEG_AUDIO_MUTE:
0662         return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
0663 
0664     case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
0665         err = v4l2_ctrl_query_fill(qctrl,
0666                 V4L2_MPEG_AUDIO_AC3_BITRATE_48K,
0667                 V4L2_MPEG_AUDIO_AC3_BITRATE_448K, 1,
0668                 default_params.audio_ac3_bitrate);
0669         if (err)
0670             return err;
0671         if (params->capabilities & CX2341X_CAP_HAS_AC3) {
0672             if (params->audio_encoding !=
0673                            V4L2_MPEG_AUDIO_ENCODING_AC3)
0674                 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0675         } else
0676             qctrl->flags |= V4L2_CTRL_FLAG_DISABLED;
0677         return 0;
0678 
0679     case V4L2_CID_MPEG_VIDEO_ENCODING:
0680         /* this setting is read-only for the cx2341x since the
0681            V4L2_CID_MPEG_STREAM_TYPE really determines the
0682            MPEG-1/2 setting */
0683         err = v4l2_ctrl_query_fill(qctrl,
0684                        V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
0685                        V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
0686                        V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
0687         if (err == 0)
0688             qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
0689         return err;
0690 
0691     case V4L2_CID_MPEG_VIDEO_ASPECT:
0692         return v4l2_ctrl_query_fill(qctrl,
0693                 V4L2_MPEG_VIDEO_ASPECT_1x1,
0694                 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
0695                 V4L2_MPEG_VIDEO_ASPECT_4x3);
0696 
0697     case V4L2_CID_MPEG_VIDEO_B_FRAMES:
0698         return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
0699 
0700     case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
0701         return v4l2_ctrl_query_fill(qctrl, 1, 34, 1,
0702                 params->is_50hz ? 12 : 15);
0703 
0704     case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
0705         return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
0706 
0707     case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
0708         err = v4l2_ctrl_query_fill(qctrl,
0709                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
0710                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
0711                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
0712         if (err == 0 &&
0713             params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
0714             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0715         return err;
0716 
0717     case V4L2_CID_MPEG_VIDEO_BITRATE:
0718         return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
0719 
0720     case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
0721         err = v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
0722         if (err == 0 &&
0723             params->video_bitrate_mode ==
0724                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
0725             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0726         return err;
0727 
0728     case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
0729         return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
0730 
0731     case V4L2_CID_MPEG_VIDEO_MUTE:
0732         return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
0733 
0734     case V4L2_CID_MPEG_VIDEO_MUTE_YUV:  /* Init YUV (really YCbCr) to black */
0735         return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
0736 
0737     /* CX23415/6 specific */
0738     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0739         return cx2341x_ctrl_query_fill(qctrl,
0740             V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
0741             V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 1,
0742             default_params.video_spatial_filter_mode);
0743 
0744     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
0745         cx2341x_ctrl_query_fill(qctrl, 0, 15, 1,
0746                 default_params.video_spatial_filter);
0747         qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
0748         if (params->video_spatial_filter_mode ==
0749                 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
0750             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0751         return 0;
0752 
0753     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0754         cx2341x_ctrl_query_fill(qctrl,
0755             V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
0756             V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE,
0757             1,
0758             default_params.video_luma_spatial_filter_type);
0759         if (params->video_spatial_filter_mode ==
0760                 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
0761             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0762         return 0;
0763 
0764     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0765         cx2341x_ctrl_query_fill(qctrl,
0766             V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
0767             V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
0768             1,
0769             default_params.video_chroma_spatial_filter_type);
0770         if (params->video_spatial_filter_mode ==
0771             V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
0772             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0773         return 0;
0774 
0775     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0776         return cx2341x_ctrl_query_fill(qctrl,
0777             V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
0778             V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO, 1,
0779             default_params.video_temporal_filter_mode);
0780 
0781     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
0782         cx2341x_ctrl_query_fill(qctrl, 0, 31, 1,
0783                 default_params.video_temporal_filter);
0784         qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
0785         if (params->video_temporal_filter_mode ==
0786             V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO)
0787             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0788         return 0;
0789 
0790     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0791         return cx2341x_ctrl_query_fill(qctrl,
0792             V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
0793             V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG, 1,
0794             default_params.video_median_filter_type);
0795 
0796     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
0797         cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
0798                 default_params.video_luma_median_filter_top);
0799         qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
0800         if (params->video_median_filter_type ==
0801                 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
0802             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0803         return 0;
0804 
0805     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
0806         cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
0807                 default_params.video_luma_median_filter_bottom);
0808         qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
0809         if (params->video_median_filter_type ==
0810                 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
0811             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0812         return 0;
0813 
0814     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
0815         cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
0816                 default_params.video_chroma_median_filter_top);
0817         qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
0818         if (params->video_median_filter_type ==
0819                 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
0820             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0821         return 0;
0822 
0823     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
0824         cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
0825             default_params.video_chroma_median_filter_bottom);
0826         qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
0827         if (params->video_median_filter_type ==
0828                 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
0829             qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
0830         return 0;
0831 
0832     case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
0833         return cx2341x_ctrl_query_fill(qctrl, 0, 1, 1,
0834                 default_params.stream_insert_nav_packets);
0835 
0836     default:
0837         return -EINVAL;
0838 
0839     }
0840 }
0841 EXPORT_SYMBOL(cx2341x_ctrl_query);
0842 
0843 const char * const *cx2341x_ctrl_get_menu(const struct cx2341x_mpeg_params *p, u32 id)
0844 {
0845     static const char * const mpeg_stream_type_without_ts[] = {
0846         "MPEG-2 Program Stream",
0847         "",
0848         "MPEG-1 System Stream",
0849         "MPEG-2 DVD-compatible Stream",
0850         "MPEG-1 VCD-compatible Stream",
0851         "MPEG-2 SVCD-compatible Stream",
0852         NULL
0853     };
0854 
0855     static const char *mpeg_stream_type_with_ts[] = {
0856         "MPEG-2 Program Stream",
0857         "MPEG-2 Transport Stream",
0858         "MPEG-1 System Stream",
0859         "MPEG-2 DVD-compatible Stream",
0860         "MPEG-1 VCD-compatible Stream",
0861         "MPEG-2 SVCD-compatible Stream",
0862         NULL
0863     };
0864 
0865     static const char *mpeg_audio_encoding_l2_ac3[] = {
0866         "",
0867         "MPEG-1/2 Layer II",
0868         "",
0869         "",
0870         "AC-3",
0871         NULL
0872     };
0873 
0874     switch (id) {
0875     case V4L2_CID_MPEG_STREAM_TYPE:
0876         return (p->capabilities & CX2341X_CAP_HAS_TS) ?
0877             mpeg_stream_type_with_ts : mpeg_stream_type_without_ts;
0878     case V4L2_CID_MPEG_AUDIO_ENCODING:
0879         return (p->capabilities & CX2341X_CAP_HAS_AC3) ?
0880             mpeg_audio_encoding_l2_ac3 : v4l2_ctrl_get_menu(id);
0881     case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
0882     case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
0883         return NULL;
0884     case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
0885     case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
0886     case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
0887     case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
0888     case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
0889         return cx2341x_get_menu(id);
0890     default:
0891         return v4l2_ctrl_get_menu(id);
0892     }
0893 }
0894 EXPORT_SYMBOL(cx2341x_ctrl_get_menu);
0895 
0896 static void cx2341x_calc_audio_properties(struct cx2341x_mpeg_params *params)
0897 {
0898     params->audio_properties =
0899         (params->audio_sampling_freq << 0) |
0900         (params->audio_mode << 8) |
0901         (params->audio_mode_extension << 10) |
0902         (((params->audio_emphasis == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17)
0903           ? 3 : params->audio_emphasis) << 12) |
0904         (params->audio_crc << 14);
0905 
0906     if ((params->capabilities & CX2341X_CAP_HAS_AC3) &&
0907         params->audio_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3) {
0908         params->audio_properties |=
0909             /* Not sure if this MPEG Layer II setting is required */
0910             ((3 - V4L2_MPEG_AUDIO_ENCODING_LAYER_2) << 2) |
0911             (params->audio_ac3_bitrate << 4) |
0912             (CX2341X_AUDIO_ENCODING_METHOD_AC3 << 28);
0913     } else {
0914         /* Assuming MPEG Layer II */
0915         params->audio_properties |=
0916             ((3 - params->audio_encoding) << 2) |
0917             ((1 + params->audio_l2_bitrate) << 4);
0918     }
0919 }
0920 
0921 /* Check for correctness of the ctrl's value based on the data from
0922    struct v4l2_queryctrl and the available menu items. Note that
0923    menu_items may be NULL, in that case it is ignored. */
0924 static int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
0925         const char * const *menu_items)
0926 {
0927     if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
0928         return -EINVAL;
0929     if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
0930         return -EBUSY;
0931     if (qctrl->type == V4L2_CTRL_TYPE_STRING)
0932         return 0;
0933     if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
0934         qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
0935         qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
0936         return 0;
0937     if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
0938         return -ERANGE;
0939     if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
0940         if (menu_items[ctrl->value] == NULL ||
0941             menu_items[ctrl->value][0] == '\0')
0942             return -EINVAL;
0943     }
0944     if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
0945             (ctrl->value & ~qctrl->maximum))
0946         return -ERANGE;
0947     return 0;
0948 }
0949 
0950 int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
0951           struct v4l2_ext_controls *ctrls, unsigned int cmd)
0952 {
0953     int err = 0;
0954     int i;
0955 
0956     if (cmd == VIDIOC_G_EXT_CTRLS) {
0957         for (i = 0; i < ctrls->count; i++) {
0958             struct v4l2_ext_control *ctrl = ctrls->controls + i;
0959 
0960             err = cx2341x_get_ctrl(params, ctrl);
0961             if (err) {
0962                 ctrls->error_idx = i;
0963                 break;
0964             }
0965         }
0966         return err;
0967     }
0968     for (i = 0; i < ctrls->count; i++) {
0969         struct v4l2_ext_control *ctrl = ctrls->controls + i;
0970         struct v4l2_queryctrl qctrl;
0971         const char * const *menu_items = NULL;
0972 
0973         qctrl.id = ctrl->id;
0974         err = cx2341x_ctrl_query(params, &qctrl);
0975         if (err)
0976             break;
0977         if (qctrl.type == V4L2_CTRL_TYPE_MENU)
0978             menu_items = cx2341x_ctrl_get_menu(params, qctrl.id);
0979         err = v4l2_ctrl_check(ctrl, &qctrl, menu_items);
0980         if (err)
0981             break;
0982         err = cx2341x_set_ctrl(params, busy, ctrl);
0983         if (err)
0984             break;
0985     }
0986     if (err == 0 &&
0987         params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
0988         params->video_bitrate_peak < params->video_bitrate) {
0989         err = -ERANGE;
0990         ctrls->error_idx = ctrls->count;
0991     }
0992     if (err)
0993         ctrls->error_idx = i;
0994     else
0995         cx2341x_calc_audio_properties(params);
0996     return err;
0997 }
0998 EXPORT_SYMBOL(cx2341x_ext_ctrls);
0999 
1000 void cx2341x_fill_defaults(struct cx2341x_mpeg_params *p)
1001 {
1002     *p = default_params;
1003     cx2341x_calc_audio_properties(p);
1004 }
1005 EXPORT_SYMBOL(cx2341x_fill_defaults);
1006 
1007 static 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 
1024 int 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 }
1185 EXPORT_SYMBOL(cx2341x_update);
1186 
1187 static 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 
1202 invalid:
1203     return "<invalid>";
1204 }
1205 
1206 void 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 }
1289 EXPORT_SYMBOL(cx2341x_log_status);
1290 
1291 
1292 
1293 /********************** NEW CODE *********************/
1294 
1295 static inline struct cx2341x_handler *to_cxhdl(struct v4l2_ctrl *ctrl)
1296 {
1297     return container_of(ctrl->handler, struct cx2341x_handler, hdl);
1298 }
1299 
1300 static 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 */
1316 static inline int cx2341x_neq(struct v4l2_ctrl *ctrl)
1317 {
1318     return ctrl && ctrl->val != ctrl->cur.val;
1319 }
1320 
1321 static 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 
1361 static 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 
1534 static const struct v4l2_ctrl_ops cx2341x_ops = {
1535     .try_ctrl = cx2341x_try_ctrl,
1536     .s_ctrl = cx2341x_s_ctrl,
1537 };
1538 
1539 static 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 
1562 static 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 
1568 static 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 
1574 int 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 }
1733 EXPORT_SYMBOL(cx2341x_handler_init);
1734 
1735 void 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 }
1740 EXPORT_SYMBOL(cx2341x_handler_set_50hz);
1741 
1742 int 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 }
1764 EXPORT_SYMBOL(cx2341x_handler_setup);
1765 
1766 void 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 }
1778 EXPORT_SYMBOL(cx2341x_handler_set_busy);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!