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