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