?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / media / common / cx2341x.c
blob1392bd6b0026fa3459e23dea0011bd1b942331e7
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * cx2341x - generic code for cx23415/6/8 based devices
4 *
5 * Copyright (C) 2006 Hans Verkuil <hverkuil@xs4all.nl>
6 */
7
8
9 #include <linux/module.h>
10 #include <linux/errno.h>
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/types.h>
14 #include <linux/videodev2.h>
15
16 #include <media/tuner.h>
17 #include <media/drv-intf/cx2341x.h>
18 #include <media/v4l2-common.h>
19
20 MODULE_DESCRIPTION("cx23415/6/8 driver");
21 MODULE_AUTHOR("Hans Verkuil");
22 MODULE_LICENSE("GPL");
23
24 static int debug;
25 module_param(debug, int, 0644);
26 MODULE_PARM_DESC(debug, "Debug level (0-1)");
27
28 /********************** COMMON CODE *********************/
29
30 /* definitions for audio properties bits 29-28 */
31 #define CX2341X_AUDIO_ENCODING_METHOD_MPEG 0
32 #define CX2341X_AUDIO_ENCODING_METHOD_AC3 1
33 #define CX2341X_AUDIO_ENCODING_METHOD_LPCM 2
34
35 static const char *cx2341x_get_name(u32 id)
36 {
37 switch (id) {
38 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
39 return "Spatial Filter Mode";
40 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
41 return "Spatial Filter";
42 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
43 return "Spatial Luma Filter Type";
44 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
45 return "Spatial Chroma Filter Type";
46 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
47 return "Temporal Filter Mode";
48 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
49 return "Temporal Filter";
50 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
51 return "Median Filter Type";
52 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
53 return "Median Luma Filter Maximum";
54 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
55 return "Median Luma Filter Minimum";
56 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
57 return "Median Chroma Filter Maximum";
58 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
59 return "Median Chroma Filter Minimum";
60 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
61 return "Insert Navigation Packets";
62 }
63 return NULL;
64 }
65
66 static const char **cx2341x_get_menu(u32 id)
67 {
68 static const char *cx2341x_video_spatial_filter_mode_menu[] = {
69 "Manual",
70 "Auto",
71 NULL
72 };
73
74 static const char *cx2341x_video_luma_spatial_filter_type_menu[] = {
75 "Off",
76 "1D Horizontal",
77 "1D Vertical",
78 "2D H/V Separable",
79 "2D Symmetric non-separable",
80 NULL
81 };
82
83 static const char *cx2341x_video_chroma_spatial_filter_type_menu[] = {
84 "Off",
85 "1D Horizontal",
86 NULL
87 };
88
89 static const char *cx2341x_video_temporal_filter_mode_menu[] = {
90 "Manual",
91 "Auto",
92 NULL
93 };
94
95 static const char *cx2341x_video_median_filter_type_menu[] = {
96 "Off",
97 "Horizontal",
98 "Vertical",
99 "Horizontal/Vertical",
100 "Diagonal",
101 NULL
102 };
103
104 switch (id) {
105 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
106 return cx2341x_video_spatial_filter_mode_menu;
107 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
108 return cx2341x_video_luma_spatial_filter_type_menu;
109 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
110 return cx2341x_video_chroma_spatial_filter_type_menu;
111 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
112 return cx2341x_video_temporal_filter_mode_menu;
113 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
114 return cx2341x_video_median_filter_type_menu;
115 }
116 return NULL;
117 }
118
119 static void cx2341x_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
120 s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags)
121 {
122 *name = cx2341x_get_name(id);
123 *flags = 0;
124
125 switch (id) {
126 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
127 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
128 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
129 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
130 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
131 *type = V4L2_CTRL_TYPE_MENU;
132 *min = 0;
133 *step = 0;
134 break;
135 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
136 *type = V4L2_CTRL_TYPE_BOOLEAN;
137 *min = 0;
138 *max = *step = 1;
139 break;
140 default:
141 *type = V4L2_CTRL_TYPE_INTEGER;
142 break;
143 }
144 switch (id) {
145 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
146 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
147 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
148 *flags |= V4L2_CTRL_FLAG_UPDATE;
149 break;
150 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
151 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
152 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
153 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
154 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
155 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
156 *flags |= V4L2_CTRL_FLAG_SLIDER;
157 break;
158 case V4L2_CID_MPEG_VIDEO_ENCODING:
159 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
160 break;
161 }
162 }
163
164
165 /********************** OLD CODE *********************/
166
167 /* Must be sorted from low to high control ID! */
168 const u32 cx2341x_mpeg_ctrls[] = {
169 V4L2_CID_CODEC_CLASS,
170 V4L2_CID_MPEG_STREAM_TYPE,
171 V4L2_CID_MPEG_STREAM_VBI_FMT,
172 V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
173 V4L2_CID_MPEG_AUDIO_ENCODING,
174 V4L2_CID_MPEG_AUDIO_L2_BITRATE,
175 V4L2_CID_MPEG_AUDIO_MODE,
176 V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
177 V4L2_CID_MPEG_AUDIO_EMPHASIS,
178 V4L2_CID_MPEG_AUDIO_CRC,
179 V4L2_CID_MPEG_AUDIO_MUTE,
180 V4L2_CID_MPEG_AUDIO_AC3_BITRATE,
181 V4L2_CID_MPEG_VIDEO_ENCODING,
182 V4L2_CID_MPEG_VIDEO_ASPECT,
183 V4L2_CID_MPEG_VIDEO_B_FRAMES,
184 V4L2_CID_MPEG_VIDEO_GOP_SIZE,
185 V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
186 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
187 V4L2_CID_MPEG_VIDEO_BITRATE,
188 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
189 V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
190 V4L2_CID_MPEG_VIDEO_MUTE,
191 V4L2_CID_MPEG_VIDEO_MUTE_YUV,
192 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
193 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
194 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
195 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
196 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
197 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
198 V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
199 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
200 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
201 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
202 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
203 V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS,
204 0
205 };
206 EXPORT_SYMBOL(cx2341x_mpeg_ctrls);
207
208 static const struct cx2341x_mpeg_params default_params = {
209 /* misc */
210 .capabilities = 0,
211 .port = CX2341X_PORT_MEMORY,
212 .width = 720,
213 .height = 480,
214 .is_50hz = 0,
215
216 /* stream */
217 .stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
218 .stream_vbi_fmt = V4L2_MPEG_STREAM_VBI_FMT_NONE,
219 .stream_insert_nav_packets = 0,
220
221 /* audio */
222 .audio_sampling_freq = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
223 .audio_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
224 .audio_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_224K,
225 .audio_ac3_bitrate = V4L2_MPEG_AUDIO_AC3_BITRATE_224K,
226 .audio_mode = V4L2_MPEG_AUDIO_MODE_STEREO,
227 .audio_mode_extension = V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
228 .audio_emphasis = V4L2_MPEG_AUDIO_EMPHASIS_NONE,
229 .audio_crc = V4L2_MPEG_AUDIO_CRC_NONE,
230 .audio_mute = 0,
231
232 /* video */
233 .video_encoding = V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
234 .video_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
235 .video_b_frames = 2,
236 .video_gop_size = 12,
237 .video_gop_closure = 1,
238 .video_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
239 .video_bitrate = 6000000,
240 .video_bitrate_peak = 8000000,
241 .video_temporal_decimation = 0,
242 .video_mute = 0,
243 .video_mute_yuv = 0x008080, /* YCbCr value for black */
244
245 /* encoding filters */
246 .video_spatial_filter_mode =
247 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
248 .video_spatial_filter = 0,
249 .video_luma_spatial_filter_type =
250 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR,
251 .video_chroma_spatial_filter_type =
252 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
253 .video_temporal_filter_mode =
254 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
255 .video_temporal_filter = 8,
256 .video_median_filter_type =
257 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
258 .video_luma_median_filter_top = 255,
259 .video_luma_median_filter_bottom = 0,
260 .video_chroma_median_filter_top = 255,
261 .video_chroma_median_filter_bottom = 0,
262 };
263 /* Map the control ID to the correct field in the cx2341x_mpeg_params
264 struct. Return -EINVAL if the ID is unknown, else return 0. */
265 static int cx2341x_get_ctrl(const struct cx2341x_mpeg_params *params,
266 struct v4l2_ext_control *ctrl)
267 {
268 switch (ctrl->id) {
269 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
270 ctrl->value = params->audio_sampling_freq;
271 break;
272 case V4L2_CID_MPEG_AUDIO_ENCODING:
273 ctrl->value = params->audio_encoding;
274 break;
275 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
276 ctrl->value = params->audio_l2_bitrate;
277 break;
278 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
279 ctrl->value = params->audio_ac3_bitrate;
280 break;
281 case V4L2_CID_MPEG_AUDIO_MODE:
282 ctrl->value = params->audio_mode;
283 break;
284 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
285 ctrl->value = params->audio_mode_extension;
286 break;
287 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
288 ctrl->value = params->audio_emphasis;
289 break;
290 case V4L2_CID_MPEG_AUDIO_CRC:
291 ctrl->value = params->audio_crc;
292 break;
293 case V4L2_CID_MPEG_AUDIO_MUTE:
294 ctrl->value = params->audio_mute;
295 break;
296 case V4L2_CID_MPEG_VIDEO_ENCODING:
297 ctrl->value = params->video_encoding;
298 break;
299 case V4L2_CID_MPEG_VIDEO_ASPECT:
300 ctrl->value = params->video_aspect;
301 break;
302 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
303 ctrl->value = params->video_b_frames;
304 break;
305 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
306 ctrl->value = params->video_gop_size;
307 break;
308 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
309 ctrl->value = params->video_gop_closure;
310 break;
311 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
312 ctrl->value = params->video_bitrate_mode;
313 break;
314 case V4L2_CID_MPEG_VIDEO_BITRATE:
315 ctrl->value = params->video_bitrate;
316 break;
317 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
318 ctrl->value = params->video_bitrate_peak;
319 break;
320 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
321 ctrl->value = params->video_temporal_decimation;
322 break;
323 case V4L2_CID_MPEG_VIDEO_MUTE:
324 ctrl->value = params->video_mute;
325 break;
326 case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
327 ctrl->value = params->video_mute_yuv;
328 break;
329 case V4L2_CID_MPEG_STREAM_TYPE:
330 ctrl->value = params->stream_type;
331 break;
332 case V4L2_CID_MPEG_STREAM_VBI_FMT:
333 ctrl->value = params->stream_vbi_fmt;
334 break;
335 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
336 ctrl->value = params->video_spatial_filter_mode;
337 break;
338 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
339 ctrl->value = params->video_spatial_filter;
340 break;
341 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
342 ctrl->value = params->video_luma_spatial_filter_type;
343 break;
344 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
345 ctrl->value = params->video_chroma_spatial_filter_type;
346 break;
347 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
348 ctrl->value = params->video_temporal_filter_mode;
349 break;
350 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
351 ctrl->value = params->video_temporal_filter;
352 break;
353 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
354 ctrl->value = params->video_median_filter_type;
355 break;
356 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
357 ctrl->value = params->video_luma_median_filter_top;
358 break;
359 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
360 ctrl->value = params->video_luma_median_filter_bottom;
361 break;
362 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
363 ctrl->value = params->video_chroma_median_filter_top;
364 break;
365 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
366 ctrl->value = params->video_chroma_median_filter_bottom;
367 break;
368 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
369 ctrl->value = params->stream_insert_nav_packets;
370 break;
371 default:
372 return -EINVAL;
373 }
374 return 0;
375 }
376
377 /* Map the control ID to the correct field in the cx2341x_mpeg_params
378 struct. Return -EINVAL if the ID is unknown, else return 0. */
379 static int cx2341x_set_ctrl(struct cx2341x_mpeg_params *params, int busy,
380 struct v4l2_ext_control *ctrl)
381 {
382 switch (ctrl->id) {
383 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
384 if (busy)
385 return -EBUSY;
386 params->audio_sampling_freq = ctrl->value;
387 break;
388 case V4L2_CID_MPEG_AUDIO_ENCODING:
389 if (busy)
390 return -EBUSY;
391 if (params->capabilities & CX2341X_CAP_HAS_AC3)
392 if (ctrl->value != V4L2_MPEG_AUDIO_ENCODING_LAYER_2 &&
393 ctrl->value != V4L2_MPEG_AUDIO_ENCODING_AC3)
394 return -ERANGE;
395 params->audio_encoding = ctrl->value;
396 break;
397 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
398 if (busy)
399 return -EBUSY;
400 params->audio_l2_bitrate = ctrl->value;
401 break;
402 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
403 if (busy)
404 return -EBUSY;
405 if (!(params->capabilities & CX2341X_CAP_HAS_AC3))
406 return -EINVAL;
407 params->audio_ac3_bitrate = ctrl->value;
408 break;
409 case V4L2_CID_MPEG_AUDIO_MODE:
410 params->audio_mode = ctrl->value;
411 break;
412 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
413 params->audio_mode_extension = ctrl->value;
414 break;
415 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
416 params->audio_emphasis = ctrl->value;
417 break;
418 case V4L2_CID_MPEG_AUDIO_CRC:
419 params->audio_crc = ctrl->value;
420 break;
421 case V4L2_CID_MPEG_AUDIO_MUTE:
422 params->audio_mute = ctrl->value;
423 break;
424 case V4L2_CID_MPEG_VIDEO_ASPECT:
425 params->video_aspect = ctrl->value;
426 break;
427 case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
428 int b = ctrl->value + 1;
429 int gop = params->video_gop_size;
430 params->video_b_frames = ctrl->value;
431 params->video_gop_size = b * ((gop + b - 1) / b);
432 /* Max GOP size = 34 */
433 while (params->video_gop_size > 34)
434 params->video_gop_size -= b;
435 break;
436 }
437 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: {
438 int b = params->video_b_frames + 1;
439 int gop = ctrl->value;
440 params->video_gop_size = b * ((gop + b - 1) / b);
441 /* Max GOP size = 34 */
442 while (params->video_gop_size > 34)
443 params->video_gop_size -= b;
444 ctrl->value = params->video_gop_size;
445 break;
446 }
447 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
448 params->video_gop_closure = ctrl->value;
449 break;
450 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
451 if (busy)
452 return -EBUSY;
453 /* MPEG-1 only allows CBR */
454 if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1 &&
455 ctrl->value != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
456 return -EINVAL;
457 params->video_bitrate_mode = ctrl->value;
458 break;
459 case V4L2_CID_MPEG_VIDEO_BITRATE:
460 if (busy)
461 return -EBUSY;
462 params->video_bitrate = ctrl->value;
463 break;
464 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
465 if (busy)
466 return -EBUSY;
467 params->video_bitrate_peak = ctrl->value;
468 break;
469 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
470 params->video_temporal_decimation = ctrl->value;
471 break;
472 case V4L2_CID_MPEG_VIDEO_MUTE:
473 params->video_mute = (ctrl->value != 0);
474 break;
475 case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
476 params->video_mute_yuv = ctrl->value;
477 break;
478 case V4L2_CID_MPEG_STREAM_TYPE:
479 if (busy)
480 return -EBUSY;
481 params->stream_type = ctrl->value;
482 params->video_encoding =
483 (params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
484 params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
485 V4L2_MPEG_VIDEO_ENCODING_MPEG_1 :
486 V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
487 if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
488 /* MPEG-1 implies CBR */
489 params->video_bitrate_mode =
490 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
491 break;
492 case V4L2_CID_MPEG_STREAM_VBI_FMT:
493 params->stream_vbi_fmt = ctrl->value;
494 break;
495 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
496 params->video_spatial_filter_mode = ctrl->value;
497 break;
498 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
499 params->video_spatial_filter = ctrl->value;
500 break;
501 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
502 params->video_luma_spatial_filter_type = ctrl->value;
503 break;
504 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
505 params->video_chroma_spatial_filter_type = ctrl->value;
506 break;
507 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
508 params->video_temporal_filter_mode = ctrl->value;
509 break;
510 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
511 params->video_temporal_filter = ctrl->value;
512 break;
513 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
514 params->video_median_filter_type = ctrl->value;
515 break;
516 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
517 params->video_luma_median_filter_top = ctrl->value;
518 break;
519 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
520 params->video_luma_median_filter_bottom = ctrl->value;
521 break;
522 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
523 params->video_chroma_median_filter_top = ctrl->value;
524 break;
525 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
526 params->video_chroma_median_filter_bottom = ctrl->value;
527 break;
528 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
529 params->stream_insert_nav_packets = ctrl->value;
530 break;
531 default:
532 return -EINVAL;
533 }
534 return 0;
535 }
536
537 static int cx2341x_ctrl_query_fill(struct v4l2_queryctrl *qctrl,
538 s32 min, s32 max, s32 step, s32 def)
539 {
540 const char *name;
541
542 switch (qctrl->id) {
543 /* MPEG controls */
544 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
545 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
546 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
547 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
548 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
549 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
550 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
551 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
552 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
553 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
554 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
555 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
556 cx2341x_ctrl_fill(qctrl->id, &name, &qctrl->type,
557 &min, &max, &step, &def, &qctrl->flags);
558 qctrl->minimum = min;
559 qctrl->maximum = max;
560 qctrl->step = step;
561 qctrl->default_value = def;
562 qctrl->reserved[0] = qctrl->reserved[1] = 0;
563 strscpy(qctrl->name, name, sizeof(qctrl->name));
564 return 0;
565
566 default:
567 return v4l2_ctrl_query_fill(qctrl, min, max, step, def);
568 }
569 }
570
571 int cx2341x_ctrl_query(const struct cx2341x_mpeg_params *params,
572 struct v4l2_queryctrl *qctrl)
573 {
574 int err;
575
576 switch (qctrl->id) {
577 case V4L2_CID_CODEC_CLASS:
578 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
579 case V4L2_CID_MPEG_STREAM_TYPE:
580 return v4l2_ctrl_query_fill(qctrl,
581 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
582 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
583 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
584
585 case V4L2_CID_MPEG_STREAM_VBI_FMT:
586 if (params->capabilities & CX2341X_CAP_HAS_SLICED_VBI)
587 return v4l2_ctrl_query_fill(qctrl,
588 V4L2_MPEG_STREAM_VBI_FMT_NONE,
589 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
590 V4L2_MPEG_STREAM_VBI_FMT_NONE);
591 return cx2341x_ctrl_query_fill(qctrl,
592 V4L2_MPEG_STREAM_VBI_FMT_NONE,
593 V4L2_MPEG_STREAM_VBI_FMT_NONE, 1,
594 default_params.stream_vbi_fmt);
595
596 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
597 return v4l2_ctrl_query_fill(qctrl,
598 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
599 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
600 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
601
602 case V4L2_CID_MPEG_AUDIO_ENCODING:
603 if (params->capabilities & CX2341X_CAP_HAS_AC3) {
604 /*
605 * The state of L2 & AC3 bitrate controls can change
606 * when this control changes, but v4l2_ctrl_query_fill()
607 * already sets V4L2_CTRL_FLAG_UPDATE for
608 * V4L2_CID_MPEG_AUDIO_ENCODING, so we don't here.
609 */
610 return v4l2_ctrl_query_fill(qctrl,
611 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
612 V4L2_MPEG_AUDIO_ENCODING_AC3, 1,
613 default_params.audio_encoding);
614 }
615
616 return v4l2_ctrl_query_fill(qctrl,
617 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
618 V4L2_MPEG_AUDIO_ENCODING_LAYER_2, 1,
619 default_params.audio_encoding);
620
621 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
622 err = v4l2_ctrl_query_fill(qctrl,
623 V4L2_MPEG_AUDIO_L2_BITRATE_192K,
624 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
625 default_params.audio_l2_bitrate);
626 if (err)
627 return err;
628 if (params->capabilities & CX2341X_CAP_HAS_AC3 &&
629 params->audio_encoding != V4L2_MPEG_AUDIO_ENCODING_LAYER_2)
630 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
631 return 0;
632
633 case V4L2_CID_MPEG_AUDIO_MODE:
634 return v4l2_ctrl_query_fill(qctrl,
635 V4L2_MPEG_AUDIO_MODE_STEREO,
636 V4L2_MPEG_AUDIO_MODE_MONO, 1,
637 V4L2_MPEG_AUDIO_MODE_STEREO);
638
639 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
640 err = v4l2_ctrl_query_fill(qctrl,
641 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
642 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
643 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
644 if (err == 0 &&
645 params->audio_mode != V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
646 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
647 return err;
648
649 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
650 return v4l2_ctrl_query_fill(qctrl,
651 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
652 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
653 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
654
655 case V4L2_CID_MPEG_AUDIO_CRC:
656 return v4l2_ctrl_query_fill(qctrl,
657 V4L2_MPEG_AUDIO_CRC_NONE,
658 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
659 V4L2_MPEG_AUDIO_CRC_NONE);
660
661 case V4L2_CID_MPEG_AUDIO_MUTE:
662 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
663
664 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
665 err = v4l2_ctrl_query_fill(qctrl,
666 V4L2_MPEG_AUDIO_AC3_BITRATE_48K,
667 V4L2_MPEG_AUDIO_AC3_BITRATE_448K, 1,
668 default_params.audio_ac3_bitrate);
669 if (err)
670 return err;
671 if (params->capabilities & CX2341X_CAP_HAS_AC3) {
672 if (params->audio_encoding !=
673 V4L2_MPEG_AUDIO_ENCODING_AC3)
674 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
675 } else
676 qctrl->flags |= V4L2_CTRL_FLAG_DISABLED;
677 return 0;
678
679 case V4L2_CID_MPEG_VIDEO_ENCODING:
680 /* this setting is read-only for the cx2341x since the
681 V4L2_CID_MPEG_STREAM_TYPE really determines the
682 MPEG-1/2 setting */
683 err = v4l2_ctrl_query_fill(qctrl,
684 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
685 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
686 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
687 if (err == 0)
688 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
689 return err;
690
691 case V4L2_CID_MPEG_VIDEO_ASPECT:
692 return v4l2_ctrl_query_fill(qctrl,
693 V4L2_MPEG_VIDEO_ASPECT_1x1,
694 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
695 V4L2_MPEG_VIDEO_ASPECT_4x3);
696
697 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
698 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
699
700 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
701 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1,
702 params->is_50hz ? 12 : 15);
703
704 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
705 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
706
707 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
708 err = v4l2_ctrl_query_fill(qctrl,
709 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
710 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
711 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
712 if (err == 0 &&
713 params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
714 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
715 return err;
716
717 case V4L2_CID_MPEG_VIDEO_BITRATE:
718 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
719
720 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
721 err = v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
722 if (err == 0 &&
723 params->video_bitrate_mode ==
724 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
725 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
726 return err;
727
728 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
729 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
730
731 case V4L2_CID_MPEG_VIDEO_MUTE:
732 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
733
734 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: /* Init YUV (really YCbCr) to black */
735 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
736
737 /* CX23415/6 specific */
738 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
739 return cx2341x_ctrl_query_fill(qctrl,
740 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
741 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 1,
742 default_params.video_spatial_filter_mode);
743
744 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
745 cx2341x_ctrl_query_fill(qctrl, 0, 15, 1,
746 default_params.video_spatial_filter);
747 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
748 if (params->video_spatial_filter_mode ==
749 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
750 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
751 return 0;
752
753 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
754 cx2341x_ctrl_query_fill(qctrl,
755 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
756 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE,
757 1,
758 default_params.video_luma_spatial_filter_type);
759 if (params->video_spatial_filter_mode ==
760 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
761 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
762 return 0;
763
764 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
765 cx2341x_ctrl_query_fill(qctrl,
766 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
767 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
768 1,
769 default_params.video_chroma_spatial_filter_type);
770 if (params->video_spatial_filter_mode ==
771 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
772 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
773 return 0;
774
775 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
776 return cx2341x_ctrl_query_fill(qctrl,
777 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
778 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO, 1,
779 default_params.video_temporal_filter_mode);
780
781 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
782 cx2341x_ctrl_query_fill(qctrl, 0, 31, 1,
783 default_params.video_temporal_filter);
784 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
785 if (params->video_temporal_filter_mode ==
786 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO)
787 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
788 return 0;
789
790 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
791 return cx2341x_ctrl_query_fill(qctrl,
792 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
793 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG, 1,
794 default_params.video_median_filter_type);
795
796 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
797 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
798 default_params.video_luma_median_filter_top);
799 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
800 if (params->video_median_filter_type ==
801 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
802 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
803 return 0;
804
805 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
806 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
807 default_params.video_luma_median_filter_bottom);
808 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
809 if (params->video_median_filter_type ==
810 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
811 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
812 return 0;
813
814 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
815 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
816 default_params.video_chroma_median_filter_top);
817 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
818 if (params->video_median_filter_type ==
819 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
820 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
821 return 0;
822
823 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
824 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
825 default_params.video_chroma_median_filter_bottom);
826 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
827 if (params->video_median_filter_type ==
828 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
829 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
830 return 0;
831
832 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
833 return cx2341x_ctrl_query_fill(qctrl, 0, 1, 1,
834 default_params.stream_insert_nav_packets);
835
836 default:
837 return -EINVAL;
838
839 }
840 }
841 EXPORT_SYMBOL(cx2341x_ctrl_query);
842
843 const char * const *cx2341x_ctrl_get_menu(const struct cx2341x_mpeg_params *p, u32 id)
844 {
845 static const char * const mpeg_stream_type_without_ts[] = {
846 "MPEG-2 Program Stream",
847 "",
848 "MPEG-1 System Stream",
849 "MPEG-2 DVD-compatible Stream",
850 "MPEG-1 VCD-compatible Stream",
851 "MPEG-2 SVCD-compatible Stream",
852 NULL
853 };
854
855 static const char *mpeg_stream_type_with_ts[] = {
856 "MPEG-2 Program Stream",
857 "MPEG-2 Transport Stream",
858 "MPEG-1 System Stream",
859 "MPEG-2 DVD-compatible Stream",
860 "MPEG-1 VCD-compatible Stream",
861 "MPEG-2 SVCD-compatible Stream",
862 NULL
863 };
864
865 static const char *mpeg_audio_encoding_l2_ac3[] = {
866 "",
867 "MPEG-1/2 Layer II",
868 "",
869 "",
870 "AC-3",
871 NULL
872 };
873
874 switch (id) {
875 case V4L2_CID_MPEG_STREAM_TYPE:
876 return (p->capabilities & CX2341X_CAP_HAS_TS) ?
877 mpeg_stream_type_with_ts : mpeg_stream_type_without_ts;
878 case V4L2_CID_MPEG_AUDIO_ENCODING:
879 return (p->capabilities & CX2341X_CAP_HAS_AC3) ?
880 mpeg_audio_encoding_l2_ac3 : v4l2_ctrl_get_menu(id);
881 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
882 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
883 return NULL;
884 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
885 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
886 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
887 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
888 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
889 return cx2341x_get_menu(id);
890 default:
891 return v4l2_ctrl_get_menu(id);
892 }
893 }
894 EXPORT_SYMBOL(cx2341x_ctrl_get_menu);
895
896 static void cx2341x_calc_audio_properties(struct cx2341x_mpeg_params *params)
897 {
898 params->audio_properties =
899 (params->audio_sampling_freq << 0) |
900 (params->audio_mode << 8) |
901 (params->audio_mode_extension << 10) |
902 (((params->audio_emphasis == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17)
903 ? 3 : params->audio_emphasis) << 12) |
904 (params->audio_crc << 14);
905
906 if ((params->capabilities & CX2341X_CAP_HAS_AC3) &&
907 params->audio_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3) {
908 params->audio_properties |=
909 /* Not sure if this MPEG Layer II setting is required */
910 ((3 - V4L2_MPEG_AUDIO_ENCODING_LAYER_2) << 2) |
911 (params->audio_ac3_bitrate << 4) |
912 (CX2341X_AUDIO_ENCODING_METHOD_AC3 << 28);
913 } else {
914 /* Assuming MPEG Layer II */
915 params->audio_properties |=
916 ((3 - params->audio_encoding) << 2) |
917 ((1 + params->audio_l2_bitrate) << 4);
918 }
919 }
920
921 /* Check for correctness of the ctrl's value based on the data from
922 struct v4l2_queryctrl and the available menu items. Note that
923 menu_items may be NULL, in that case it is ignored. */
924 static int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
925 const char * const *menu_items)
926 {
927 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
928 return -EINVAL;
929 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
930 return -EBUSY;
931 if (qctrl->type == V4L2_CTRL_TYPE_STRING)
932 return 0;
933 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
934 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
935 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
936 return 0;
937 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
938 return -ERANGE;
939 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
940 if (menu_items[ctrl->value] == NULL ||
941 menu_items[ctrl->value][0] == '\0')
942 return -EINVAL;
943 }
944 if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
945 (ctrl->value & ~qctrl->maximum))
946 return -ERANGE;
947 return 0;
948 }
949
950 int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
951 struct v4l2_ext_controls *ctrls, unsigned int cmd)
952 {
953 int err = 0;
954 int i;
955
956 if (cmd == VIDIOC_G_EXT_CTRLS) {
957 for (i = 0; i < ctrls->count; i++) {
958 struct v4l2_ext_control *ctrl = ctrls->controls + i;
959
960 err = cx2341x_get_ctrl(params, ctrl);
961 if (err) {
962 ctrls->error_idx = i;
963 break;
964 }
965 }
966 return err;
967 }
968 for (i = 0; i < ctrls->count; i++) {
969 struct v4l2_ext_control *ctrl = ctrls->controls + i;
970 struct v4l2_queryctrl qctrl;
971 const char * const *menu_items = NULL;
972
973 qctrl.id = ctrl->id;
974 err = cx2341x_ctrl_query(params, &qctrl);
975 if (err)
976 break;
977 if (qctrl.type == V4L2_CTRL_TYPE_MENU)
978 menu_items = cx2341x_ctrl_get_menu(params, qctrl.id);
979 err = v4l2_ctrl_check(ctrl, &qctrl, menu_items);
980 if (err)
981 break;
982 err = cx2341x_set_ctrl(params, busy, ctrl);
983 if (err)
984 break;
985 }
986 if (err == 0 &&
987 params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
988 params->video_bitrate_peak < params->video_bitrate) {
989 err = -ERANGE;
990 ctrls->error_idx = ctrls->count;
991 }
992 if (err)
993 ctrls->error_idx = i;
994 else
995 cx2341x_calc_audio_properties(params);
996 return err;
997 }
998 EXPORT_SYMBOL(cx2341x_ext_ctrls);
999
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);
Kernel DRM miscellaneous fixes and cross-tree changes