?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PRCM: 34XX: Fix wrong shift value used in dpll4_m4x2_ck enable bit
[linux-ginger.git] / drivers / media / video / cx2341x.c
blobc592899a23175f8a75febad62b3e39b8e930f9cb
1 /*
2 * cx2341x - generic code for cx23415/6 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 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 const u32 cx2341x_mpeg_ctrls[] = {
42 V4L2_CID_MPEG_CLASS,
43 V4L2_CID_MPEG_STREAM_TYPE,
44 V4L2_CID_MPEG_STREAM_VBI_FMT,
45 V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
46 V4L2_CID_MPEG_AUDIO_ENCODING,
47 V4L2_CID_MPEG_AUDIO_L2_BITRATE,
48 V4L2_CID_MPEG_AUDIO_MODE,
49 V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
50 V4L2_CID_MPEG_AUDIO_EMPHASIS,
51 V4L2_CID_MPEG_AUDIO_CRC,
52 V4L2_CID_MPEG_AUDIO_MUTE,
53 V4L2_CID_MPEG_VIDEO_ENCODING,
54 V4L2_CID_MPEG_VIDEO_ASPECT,
55 V4L2_CID_MPEG_VIDEO_B_FRAMES,
56 V4L2_CID_MPEG_VIDEO_GOP_SIZE,
57 V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
58 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
59 V4L2_CID_MPEG_VIDEO_BITRATE,
60 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
61 V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
62 V4L2_CID_MPEG_VIDEO_MUTE,
63 V4L2_CID_MPEG_VIDEO_MUTE_YUV,
64 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
65 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
66 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
67 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
68 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
69 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
70 V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
71 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
72 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
73 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
74 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
75 V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS,
76 0
77 };
78 EXPORT_SYMBOL(cx2341x_mpeg_ctrls);
79
80
81 /* Map the control ID to the correct field in the cx2341x_mpeg_params
82 struct. Return -EINVAL if the ID is unknown, else return 0. */
83 static int cx2341x_get_ctrl(struct cx2341x_mpeg_params *params,
84 struct v4l2_ext_control *ctrl)
85 {
86 switch (ctrl->id) {
87 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
88 ctrl->value = params->audio_sampling_freq;
89 break;
90 case V4L2_CID_MPEG_AUDIO_ENCODING:
91 ctrl->value = params->audio_encoding;
92 break;
93 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
94 ctrl->value = params->audio_l2_bitrate;
95 break;
96 case V4L2_CID_MPEG_AUDIO_MODE:
97 ctrl->value = params->audio_mode;
98 break;
99 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
100 ctrl->value = params->audio_mode_extension;
101 break;
102 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
103 ctrl->value = params->audio_emphasis;
104 break;
105 case V4L2_CID_MPEG_AUDIO_CRC:
106 ctrl->value = params->audio_crc;
107 break;
108 case V4L2_CID_MPEG_AUDIO_MUTE:
109 ctrl->value = params->audio_mute;
110 break;
111 case V4L2_CID_MPEG_VIDEO_ENCODING:
112 ctrl->value = params->video_encoding;
113 break;
114 case V4L2_CID_MPEG_VIDEO_ASPECT:
115 ctrl->value = params->video_aspect;
116 break;
117 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
118 ctrl->value = params->video_b_frames;
119 break;
120 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
121 ctrl->value = params->video_gop_size;
122 break;
123 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
124 ctrl->value = params->video_gop_closure;
125 break;
126 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
127 ctrl->value = params->video_bitrate_mode;
128 break;
129 case V4L2_CID_MPEG_VIDEO_BITRATE:
130 ctrl->value = params->video_bitrate;
131 break;
132 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
133 ctrl->value = params->video_bitrate_peak;
134 break;
135 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
136 ctrl->value = params->video_temporal_decimation;
137 break;
138 case V4L2_CID_MPEG_VIDEO_MUTE:
139 ctrl->value = params->video_mute;
140 break;
141 case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
142 ctrl->value = params->video_mute_yuv;
143 break;
144 case V4L2_CID_MPEG_STREAM_TYPE:
145 ctrl->value = params->stream_type;
146 break;
147 case V4L2_CID_MPEG_STREAM_VBI_FMT:
148 ctrl->value = params->stream_vbi_fmt;
149 break;
150 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
151 ctrl->value = params->video_spatial_filter_mode;
152 break;
153 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
154 ctrl->value = params->video_spatial_filter;
155 break;
156 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
157 ctrl->value = params->video_luma_spatial_filter_type;
158 break;
159 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
160 ctrl->value = params->video_chroma_spatial_filter_type;
161 break;
162 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
163 ctrl->value = params->video_temporal_filter_mode;
164 break;
165 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
166 ctrl->value = params->video_temporal_filter;
167 break;
168 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
169 ctrl->value = params->video_median_filter_type;
170 break;
171 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
172 ctrl->value = params->video_luma_median_filter_top;
173 break;
174 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
175 ctrl->value = params->video_luma_median_filter_bottom;
176 break;
177 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
178 ctrl->value = params->video_chroma_median_filter_top;
179 break;
180 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
181 ctrl->value = params->video_chroma_median_filter_bottom;
182 break;
183 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
184 ctrl->value = params->stream_insert_nav_packets;
185 break;
186 default:
187 return -EINVAL;
188 }
189 return 0;
190 }
191
192 /* Map the control ID to the correct field in the cx2341x_mpeg_params
193 struct. Return -EINVAL if the ID is unknown, else return 0. */
194 static int cx2341x_set_ctrl(struct cx2341x_mpeg_params *params, int busy,
195 struct v4l2_ext_control *ctrl)
196 {
197 switch (ctrl->id) {
198 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
199 if (busy)
200 return -EBUSY;
201 params->audio_sampling_freq = ctrl->value;
202 break;
203 case V4L2_CID_MPEG_AUDIO_ENCODING:
204 params->audio_encoding = ctrl->value;
205 break;
206 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
207 if (busy)
208 return -EBUSY;
209 params->audio_l2_bitrate = ctrl->value;
210 break;
211 case V4L2_CID_MPEG_AUDIO_MODE:
212 params->audio_mode = ctrl->value;
213 break;
214 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
215 params->audio_mode_extension = ctrl->value;
216 break;
217 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
218 params->audio_emphasis = ctrl->value;
219 break;
220 case V4L2_CID_MPEG_AUDIO_CRC:
221 params->audio_crc = ctrl->value;
222 break;
223 case V4L2_CID_MPEG_AUDIO_MUTE:
224 params->audio_mute = ctrl->value;
225 break;
226 case V4L2_CID_MPEG_VIDEO_ASPECT:
227 params->video_aspect = ctrl->value;
228 break;
229 case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
230 int b = ctrl->value + 1;
231 int gop = params->video_gop_size;
232 params->video_b_frames = ctrl->value;
233 params->video_gop_size = b * ((gop + b - 1) / b);
234 /* Max GOP size = 34 */
235 while (params->video_gop_size > 34)
236 params->video_gop_size -= b;
237 break;
238 }
239 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: {
240 int b = params->video_b_frames + 1;
241 int gop = ctrl->value;
242 params->video_gop_size = b * ((gop + b - 1) / b);
243 /* Max GOP size = 34 */
244 while (params->video_gop_size > 34)
245 params->video_gop_size -= b;
246 ctrl->value = params->video_gop_size;
247 break;
248 }
249 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
250 params->video_gop_closure = ctrl->value;
251 break;
252 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
253 if (busy)
254 return -EBUSY;
255 /* MPEG-1 only allows CBR */
256 if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1 &&
257 ctrl->value != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
258 return -EINVAL;
259 params->video_bitrate_mode = ctrl->value;
260 break;
261 case V4L2_CID_MPEG_VIDEO_BITRATE:
262 if (busy)
263 return -EBUSY;
264 params->video_bitrate = ctrl->value;
265 break;
266 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
267 if (busy)
268 return -EBUSY;
269 params->video_bitrate_peak = ctrl->value;
270 break;
271 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
272 params->video_temporal_decimation = ctrl->value;
273 break;
274 case V4L2_CID_MPEG_VIDEO_MUTE:
275 params->video_mute = (ctrl->value != 0);
276 break;
277 case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
278 params->video_mute_yuv = ctrl->value;
279 break;
280 case V4L2_CID_MPEG_STREAM_TYPE:
281 if (busy)
282 return -EBUSY;
283 params->stream_type = ctrl->value;
284 params->video_encoding =
285 (params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
286 params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
287 V4L2_MPEG_VIDEO_ENCODING_MPEG_1 :
288 V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
289 if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
290 /* MPEG-1 implies CBR */
291 params->video_bitrate_mode =
292 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
293 break;
294 case V4L2_CID_MPEG_STREAM_VBI_FMT:
295 params->stream_vbi_fmt = ctrl->value;
296 break;
297 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
298 params->video_spatial_filter_mode = ctrl->value;
299 break;
300 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
301 params->video_spatial_filter = ctrl->value;
302 break;
303 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
304 params->video_luma_spatial_filter_type = ctrl->value;
305 break;
306 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
307 params->video_chroma_spatial_filter_type = ctrl->value;
308 break;
309 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
310 params->video_temporal_filter_mode = ctrl->value;
311 break;
312 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
313 params->video_temporal_filter = ctrl->value;
314 break;
315 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
316 params->video_median_filter_type = ctrl->value;
317 break;
318 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
319 params->video_luma_median_filter_top = ctrl->value;
320 break;
321 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
322 params->video_luma_median_filter_bottom = ctrl->value;
323 break;
324 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
325 params->video_chroma_median_filter_top = ctrl->value;
326 break;
327 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
328 params->video_chroma_median_filter_bottom = ctrl->value;
329 break;
330 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
331 params->stream_insert_nav_packets = ctrl->value;
332 break;
333 default:
334 return -EINVAL;
335 }
336 return 0;
337 }
338
339 static int cx2341x_ctrl_query_fill(struct v4l2_queryctrl *qctrl,
340 s32 min, s32 max, s32 step, s32 def)
341 {
342 const char *name;
343
344 qctrl->flags = 0;
345 switch (qctrl->id) {
346 /* MPEG controls */
347 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
348 name = "Spatial Filter Mode";
349 break;
350 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
351 name = "Spatial Filter";
352 break;
353 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
354 name = "Spatial Luma Filter Type";
355 break;
356 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
357 name = "Spatial Chroma Filter Type";
358 break;
359 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
360 name = "Temporal Filter Mode";
361 break;
362 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
363 name = "Temporal Filter";
364 break;
365 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
366 name = "Median Filter Type";
367 break;
368 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
369 name = "Median Luma Filter Maximum";
370 break;
371 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
372 name = "Median Luma Filter Minimum";
373 break;
374 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
375 name = "Median Chroma Filter Maximum";
376 break;
377 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
378 name = "Median Chroma Filter Minimum";
379 break;
380 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
381 name = "Insert Navigation Packets";
382 break;
383
384 default:
385 return v4l2_ctrl_query_fill(qctrl, min, max, step, def);
386 }
387 switch (qctrl->id) {
388 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
389 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
390 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
391 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
392 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
393 qctrl->type = V4L2_CTRL_TYPE_MENU;
394 min = 0;
395 step = 1;
396 break;
397 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
398 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
399 min = 0;
400 max = 1;
401 step = 1;
402 break;
403 default:
404 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
405 break;
406 }
407 switch (qctrl->id) {
408 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
409 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
410 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
411 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
412 break;
413 }
414 qctrl->minimum = min;
415 qctrl->maximum = max;
416 qctrl->step = step;
417 qctrl->default_value = def;
418 qctrl->reserved[0] = qctrl->reserved[1] = 0;
419 snprintf(qctrl->name, sizeof(qctrl->name), name);
420 return 0;
421 }
422
423 int cx2341x_ctrl_query(struct cx2341x_mpeg_params *params,
424 struct v4l2_queryctrl *qctrl)
425 {
426 int err;
427
428 switch (qctrl->id) {
429 case V4L2_CID_MPEG_AUDIO_ENCODING:
430 return v4l2_ctrl_query_fill(qctrl,
431 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
432 V4L2_MPEG_AUDIO_ENCODING_LAYER_2, 1,
433 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
434
435 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
436 return v4l2_ctrl_query_fill(qctrl,
437 V4L2_MPEG_AUDIO_L2_BITRATE_192K,
438 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
439 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
440
441 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
442 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
443 return -EINVAL;
444
445 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
446 err = v4l2_ctrl_query_fill_std(qctrl);
447 if (err == 0 &&
448 params->audio_mode != V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
449 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
450 return err;
451
452 case V4L2_CID_MPEG_VIDEO_ENCODING:
453 /* this setting is read-only for the cx2341x since the
454 V4L2_CID_MPEG_STREAM_TYPE really determines the
455 MPEG-1/2 setting */
456 err = v4l2_ctrl_query_fill_std(qctrl);
457 if (err == 0)
458 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
459 return err;
460
461 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
462 err = v4l2_ctrl_query_fill_std(qctrl);
463 if (err == 0 &&
464 params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
465 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
466 return err;
467
468 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
469 err = v4l2_ctrl_query_fill_std(qctrl);
470 if (err == 0 &&
471 params->video_bitrate_mode ==
472 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
473 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
474 return err;
475
476 case V4L2_CID_MPEG_STREAM_VBI_FMT:
477 if (params->capabilities & CX2341X_CAP_HAS_SLICED_VBI)
478 return v4l2_ctrl_query_fill_std(qctrl);
479 return cx2341x_ctrl_query_fill(qctrl,
480 V4L2_MPEG_STREAM_VBI_FMT_NONE,
481 V4L2_MPEG_STREAM_VBI_FMT_NONE, 1,
482 V4L2_MPEG_STREAM_VBI_FMT_NONE);
483
484 /* CX23415/6 specific */
485 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
486 return cx2341x_ctrl_query_fill(qctrl,
487 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
488 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 1,
489 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL);
490
491 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
492 cx2341x_ctrl_query_fill(qctrl, 0, 15, 1, 0);
493 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
494 if (params->video_spatial_filter_mode ==
495 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
496 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
497 return 0;
498
499 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
500 cx2341x_ctrl_query_fill(qctrl,
501 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
502 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE,
503 1,
504 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF);
505 if (params->video_spatial_filter_mode ==
506 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
507 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
508 return 0;
509
510 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
511 cx2341x_ctrl_query_fill(qctrl,
512 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
513 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
514 1,
515 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF);
516 if (params->video_spatial_filter_mode ==
517 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
518 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
519 return 0;
520
521 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
522 return cx2341x_ctrl_query_fill(qctrl,
523 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
524 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO, 1,
525 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL);
526
527 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
528 cx2341x_ctrl_query_fill(qctrl, 0, 31, 1, 0);
529 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
530 if (params->video_temporal_filter_mode ==
531 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO)
532 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
533 return 0;
534
535 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
536 return cx2341x_ctrl_query_fill(qctrl,
537 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
538 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG, 1,
539 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF);
540
541 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
542 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 255);
543 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
544 if (params->video_median_filter_type ==
545 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
546 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
547 return 0;
548
549 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
550 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 0);
551 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
552 if (params->video_median_filter_type ==
553 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
554 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
555 return 0;
556
557 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
558 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 255);
559 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
560 if (params->video_median_filter_type ==
561 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
562 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
563 return 0;
564
565 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
566 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 0);
567 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
568 if (params->video_median_filter_type ==
569 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
570 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
571 return 0;
572
573 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
574 return cx2341x_ctrl_query_fill(qctrl, 0, 1, 1, 0);
575
576 default:
577 return v4l2_ctrl_query_fill_std(qctrl);
578
579 }
580 }
581 EXPORT_SYMBOL(cx2341x_ctrl_query);
582
583 const char **cx2341x_ctrl_get_menu(u32 id)
584 {
585 static const char *mpeg_stream_type[] = {
586 "MPEG-2 Program Stream",
587 "",
588 "MPEG-1 System Stream",
589 "MPEG-2 DVD-compatible Stream",
590 "MPEG-1 VCD-compatible Stream",
591 "MPEG-2 SVCD-compatible Stream",
592 NULL
593 };
594
595 static const char *cx2341x_video_spatial_filter_mode_menu[] = {
596 "Manual",
597 "Auto",
598 NULL
599 };
600
601 static const char *cx2341x_video_luma_spatial_filter_type_menu[] = {
602 "Off",
603 "1D Horizontal",
604 "1D Vertical",
605 "2D H/V Separable",
606 "2D Symmetric non-separable",
607 NULL
608 };
609
610 static const char *cx2341x_video_chroma_spatial_filter_type_menu[] = {
611 "Off",
612 "1D Horizontal",
613 NULL
614 };
615
616 static const char *cx2341x_video_temporal_filter_mode_menu[] = {
617 "Manual",
618 "Auto",
619 NULL
620 };
621
622 static const char *cx2341x_video_median_filter_type_menu[] = {
623 "Off",
624 "Horizontal",
625 "Vertical",
626 "Horizontal/Vertical",
627 "Diagonal",
628 NULL
629 };
630
631 switch (id) {
632 case V4L2_CID_MPEG_STREAM_TYPE:
633 return mpeg_stream_type;
634 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
635 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
636 return NULL;
637 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
638 return cx2341x_video_spatial_filter_mode_menu;
639 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
640 return cx2341x_video_luma_spatial_filter_type_menu;
641 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
642 return cx2341x_video_chroma_spatial_filter_type_menu;
643 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
644 return cx2341x_video_temporal_filter_mode_menu;
645 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
646 return cx2341x_video_median_filter_type_menu;
647 default:
648 return v4l2_ctrl_get_menu(id);
649 }
650 }
651 EXPORT_SYMBOL(cx2341x_ctrl_get_menu);
652
653 static void cx2341x_calc_audio_properties(struct cx2341x_mpeg_params *params)
654 {
655 params->audio_properties = (params->audio_sampling_freq << 0) |
656 ((3 - params->audio_encoding) << 2) |
657 ((1 + params->audio_l2_bitrate) << 4) |
658 (params->audio_mode << 8) |
659 (params->audio_mode_extension << 10) |
660 (((params->audio_emphasis == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17)
661 ? 3 : params->audio_emphasis) << 12) |
662 (params->audio_crc << 14);
663 }
664
665 int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
666 struct v4l2_ext_controls *ctrls, unsigned int cmd)
667 {
668 int err = 0;
669 int i;
670
671 if (cmd == VIDIOC_G_EXT_CTRLS) {
672 for (i = 0; i < ctrls->count; i++) {
673 struct v4l2_ext_control *ctrl = ctrls->controls + i;
674
675 err = cx2341x_get_ctrl(params, ctrl);
676 if (err) {
677 ctrls->error_idx = i;
678 break;
679 }
680 }
681 return err;
682 }
683 for (i = 0; i < ctrls->count; i++) {
684 struct v4l2_ext_control *ctrl = ctrls->controls + i;
685 struct v4l2_queryctrl qctrl;
686 const char **menu_items = NULL;
687
688 qctrl.id = ctrl->id;
689 err = cx2341x_ctrl_query(params, &qctrl);
690 if (err)
691 break;
692 if (qctrl.type == V4L2_CTRL_TYPE_MENU)
693 menu_items = cx2341x_ctrl_get_menu(qctrl.id);
694 err = v4l2_ctrl_check(ctrl, &qctrl, menu_items);
695 if (err)
696 break;
697 err = cx2341x_set_ctrl(params, busy, ctrl);
698 if (err)
699 break;
700 }
701 if (err == 0 &&
702 params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
703 params->video_bitrate_peak < params->video_bitrate) {
704 err = -ERANGE;
705 ctrls->error_idx = ctrls->count;
706 }
707 if (err)
708 ctrls->error_idx = i;
709 else
710 cx2341x_calc_audio_properties(params);
711 return err;
712 }
713 EXPORT_SYMBOL(cx2341x_ext_ctrls);
714
715 void cx2341x_fill_defaults(struct cx2341x_mpeg_params *p)
716 {
717 static struct cx2341x_mpeg_params default_params = {
718 /* misc */
719 .capabilities = 0,
720 .port = CX2341X_PORT_MEMORY,
721 .width = 720,
722 .height = 480,
723 .is_50hz = 0,
724
725 /* stream */
726 .stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
727 .stream_vbi_fmt = V4L2_MPEG_STREAM_VBI_FMT_NONE,
728 .stream_insert_nav_packets = 0,
729
730 /* audio */
731 .audio_sampling_freq = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
732 .audio_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
733 .audio_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_224K,
734 .audio_mode = V4L2_MPEG_AUDIO_MODE_STEREO,
735 .audio_mode_extension = V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
736 .audio_emphasis = V4L2_MPEG_AUDIO_EMPHASIS_NONE,
737 .audio_crc = V4L2_MPEG_AUDIO_CRC_NONE,
738 .audio_mute = 0,
739
740 /* video */
741 .video_encoding = V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
742 .video_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
743 .video_b_frames = 2,
744 .video_gop_size = 12,
745 .video_gop_closure = 1,
746 .video_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
747 .video_bitrate = 6000000,
748 .video_bitrate_peak = 8000000,
749 .video_temporal_decimation = 0,
750 .video_mute = 0,
751 .video_mute_yuv = 0x008080, /* YCbCr value for black */
752
753 /* encoding filters */
754 .video_spatial_filter_mode =
755 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
756 .video_spatial_filter = 0,
757 .video_luma_spatial_filter_type =
758 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR,
759 .video_chroma_spatial_filter_type =
760 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
761 .video_temporal_filter_mode =
762 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
763 .video_temporal_filter = 8,
764 .video_median_filter_type =
765 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
766 .video_luma_median_filter_top = 255,
767 .video_luma_median_filter_bottom = 0,
768 .video_chroma_median_filter_top = 255,
769 .video_chroma_median_filter_bottom = 0,
770 };
771
772 *p = default_params;
773 cx2341x_calc_audio_properties(p);
774 }
775 EXPORT_SYMBOL(cx2341x_fill_defaults);
776
777 static int cx2341x_api(void *priv, cx2341x_mbox_func func,
778 u32 cmd, int args, ...)
779 {
780 u32 data[CX2341X_MBOX_MAX_DATA];
781 va_list vargs;
782 int i;
783
784 va_start(vargs, args);
785
786 for (i = 0; i < args; i++)
787 data[i] = va_arg(vargs, int);
788 va_end(vargs);
789 return func(priv, cmd, args, 0, data);
790 }
791
792 #define NEQ(field) (old->field != new->field)
793
794 int cx2341x_update(void *priv, cx2341x_mbox_func func,
795 const struct cx2341x_mpeg_params *old,
796 const struct cx2341x_mpeg_params *new)
797 {
798 static int mpeg_stream_type[] = {
799 0, /* MPEG-2 PS */
800 1, /* MPEG-2 TS */
801 2, /* MPEG-1 SS */
802 14, /* DVD */
803 11, /* VCD */
804 12, /* SVCD */
805 };
806
807 int err = 0;
808 int force = (old == NULL);
809 u16 temporal = new->video_temporal_filter;
810
811 cx2341x_api(priv, func, CX2341X_ENC_SET_OUTPUT_PORT, 2, new->port, 0);
812
813 if (force || NEQ(is_50hz)) {
814 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_RATE, 1,
815 new->is_50hz);
816 if (err) return err;
817 }
818
819 if (force || NEQ(width) || NEQ(height) || NEQ(video_encoding)) {
820 u16 w = new->width;
821 u16 h = new->height;
822
823 if (new->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
824 w /= 2;
825 h /= 2;
826 }
827 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_SIZE, 2,
828 h, w);
829 if (err) return err;
830 }
831
832 if (new->width != 720 || new->height != (new->is_50hz ? 576 : 480)) {
833 /* Adjust temporal filter if necessary. The problem with the
834 temporal filter is that it works well with full resolution
835 capturing, but not when the capture window is scaled (the
836 filter introduces a ghosting effect). So if the capture
837 window is scaled, then force the filter to 0.
838
839 For full resolution the filter really improves the video
840 quality, especially if the original video quality is
841 suboptimal. */
842 temporal = 0;
843 }
844
845 if (force || NEQ(stream_type)) {
846 err = cx2341x_api(priv, func, CX2341X_ENC_SET_STREAM_TYPE, 1,
847 mpeg_stream_type[new->stream_type]);
848 if (err) return err;
849 }
850 if (force || NEQ(video_aspect)) {
851 err = cx2341x_api(priv, func, CX2341X_ENC_SET_ASPECT_RATIO, 1,
852 1 + new->video_aspect);
853 if (err) return err;
854 }
855 if (force || NEQ(video_b_frames) || NEQ(video_gop_size)) {
856 err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_PROPERTIES, 2,
857 new->video_gop_size, new->video_b_frames + 1);
858 if (err) return err;
859 }
860 if (force || NEQ(video_gop_closure)) {
861 err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_CLOSURE, 1,
862 new->video_gop_closure);
863 if (err) return err;
864 }
865 if (force || NEQ(audio_properties)) {
866 err = cx2341x_api(priv, func, CX2341X_ENC_SET_AUDIO_PROPERTIES,
867 1, new->audio_properties);
868 if (err) return err;
869 }
870 if (force || NEQ(audio_mute)) {
871 err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_AUDIO, 1,
872 new->audio_mute);
873 if (err) return err;
874 }
875 if (force || NEQ(video_bitrate_mode) || NEQ(video_bitrate) ||
876 NEQ(video_bitrate_peak)) {
877 err = cx2341x_api(priv, func, CX2341X_ENC_SET_BIT_RATE, 5,
878 new->video_bitrate_mode, new->video_bitrate,
879 new->video_bitrate_peak / 400, 0, 0);
880 if (err) return err;
881 }
882 if (force || NEQ(video_spatial_filter_mode) ||
883 NEQ(video_temporal_filter_mode) ||
884 NEQ(video_median_filter_type)) {
885 err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_MODE,
886 2, new->video_spatial_filter_mode |
887 (new->video_temporal_filter_mode << 1),
888 new->video_median_filter_type);
889 if (err) return err;
890 }
891 if (force || NEQ(video_luma_median_filter_bottom) ||
892 NEQ(video_luma_median_filter_top) ||
893 NEQ(video_chroma_median_filter_bottom) ||
894 NEQ(video_chroma_median_filter_top)) {
895 err = cx2341x_api(priv, func, CX2341X_ENC_SET_CORING_LEVELS, 4,
896 new->video_luma_median_filter_bottom,
897 new->video_luma_median_filter_top,
898 new->video_chroma_median_filter_bottom,
899 new->video_chroma_median_filter_top);
900 if (err) return err;
901 }
902 if (force || NEQ(video_luma_spatial_filter_type) ||
903 NEQ(video_chroma_spatial_filter_type)) {
904 err = cx2341x_api(priv, func,
905 CX2341X_ENC_SET_SPATIAL_FILTER_TYPE,
906 2, new->video_luma_spatial_filter_type,
907 new->video_chroma_spatial_filter_type);
908 if (err) return err;
909 }
910 if (force || NEQ(video_spatial_filter) ||
911 old->video_temporal_filter != temporal) {
912 err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_PROPS,
913 2, new->video_spatial_filter, temporal);
914 if (err) return err;
915 }
916 if (force || NEQ(video_temporal_decimation)) {
917 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_DROP_RATE,
918 1, new->video_temporal_decimation);
919 if (err) return err;
920 }
921 if (force || NEQ(video_mute) ||
922 (new->video_mute && NEQ(video_mute_yuv))) {
923 err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_VIDEO, 1,
924 new->video_mute | (new->video_mute_yuv << 8));
925 if (err) return err;
926 }
927 if (force || NEQ(stream_insert_nav_packets)) {
928 err = cx2341x_api(priv, func, CX2341X_ENC_MISC, 2,
929 7, new->stream_insert_nav_packets);
930 if (err) return err;
931 }
932 return 0;
933 }
934 EXPORT_SYMBOL(cx2341x_update);
935
936 static const char *cx2341x_menu_item(struct cx2341x_mpeg_params *p, u32 id)
937 {
938 const char **menu = cx2341x_ctrl_get_menu(id);
939 struct v4l2_ext_control ctrl;
940
941 if (menu == NULL)
942 goto invalid;
943 ctrl.id = id;
944 if (cx2341x_get_ctrl(p, &ctrl))
945 goto invalid;
946 while (ctrl.value-- && *menu) menu++;
947 if (*menu == NULL)
948 goto invalid;
949 return *menu;
950
951 invalid:
952 return "<invalid>";
953 }
954
955 void cx2341x_log_status(struct cx2341x_mpeg_params *p, const char *prefix)
956 {
957 int is_mpeg1 = p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1;
958 int temporal = p->video_temporal_filter;
959
960 /* Stream */
961 printk(KERN_INFO "%s: Stream: %s",
962 prefix,
963 cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_TYPE));
964 if (p->stream_insert_nav_packets)
965 printk(" (with navigation packets)");
966 printk("\n");
967 printk(KERN_INFO "%s: VBI Format: %s\n",
968 prefix,
969 cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_VBI_FMT));
970
971 /* Video */
972 printk(KERN_INFO "%s: Video: %dx%d, %d fps%s\n",
973 prefix,
974 p->width / (is_mpeg1 ? 2 : 1), p->height / (is_mpeg1 ? 2 : 1),
975 p->is_50hz ? 25 : 30,
976 (p->video_mute) ? " (muted)" : "");
977 printk(KERN_INFO "%s: Video: %s, %s, %s, %d",
978 prefix,
979 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ENCODING),
980 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ASPECT),
981 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_BITRATE_MODE),
982 p->video_bitrate);
983 if (p->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR)
984 printk(", Peak %d", p->video_bitrate_peak);
985 printk("\n");
986 printk(KERN_INFO
987 "%s: Video: GOP Size %d, %d B-Frames, %sGOP Closure\n",
988 prefix,
989 p->video_gop_size, p->video_b_frames,
990 p->video_gop_closure ? "" : "No ");
991 if (p->video_temporal_decimation)
992 printk(KERN_INFO "%s: Video: Temporal Decimation %d\n",
993 prefix, p->video_temporal_decimation);
994
995 /* Audio */
996 printk(KERN_INFO "%s: Audio: %s, %s, %s, %s%s",
997 prefix,
998 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ),
999 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_ENCODING),
1000 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_L2_BITRATE),
1001 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_MODE),
1002 p->audio_mute ? " (muted)" : "");
1003 if (p->audio_mode == V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
1004 printk(", %s", cx2341x_menu_item(p,
1005 V4L2_CID_MPEG_AUDIO_MODE_EXTENSION));
1006 printk(", %s, %s\n",
1007 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_EMPHASIS),
1008 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_CRC));
1009
1010 /* Encoding filters */
1011 printk(KERN_INFO "%s: Spatial Filter: %s, Luma %s, Chroma %s, %d\n",
1012 prefix,
1013 cx2341x_menu_item(p,
1014 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE),
1015 cx2341x_menu_item(p,
1016 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE),
1017 cx2341x_menu_item(p,
1018 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE),
1019 p->video_spatial_filter);
1020
1021 if (p->width != 720 || p->height != (p->is_50hz ? 576 : 480))
1022 temporal = 0;
1023
1024 printk(KERN_INFO "%s: Temporal Filter: %s, %d\n",
1025 prefix,
1026 cx2341x_menu_item(p,
1027 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE),
1028 temporal);
1029 printk(KERN_INFO
1030 "%s: Median Filter: %s, Luma [%d, %d], Chroma [%d, %d]\n",
1031 prefix,
1032 cx2341x_menu_item(p,
1033 V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE),
1034 p->video_luma_median_filter_bottom,
1035 p->video_luma_median_filter_top,
1036 p->video_chroma_median_filter_bottom,
1037 p->video_chroma_median_filter_top);
1038 }
1039 EXPORT_SYMBOL(cx2341x_log_status);
1040
1041 /*
1042 * Local variables:
1043 * c-basic-offset: 8
1044 * End:
1045 */
1046
Linux for Ginger Game Console