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 cx2341x_get_name(u32 id)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 cx2341x_get_menu(u32 id)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 cx2341x_ctrl_fill(u32 id,const char ** name,enum v4l2_ctrl_type * type,s32 * min,s32 * max,s32 * step,s32 * def,u32 * flags)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. */ cx2341x_get_ctrl(const struct cx2341x_mpeg_params * params,struct v4l2_ext_control * ctrl)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. */ cx2341x_set_ctrl(struct cx2341x_mpeg_params * params,int busy,struct v4l2_ext_control * ctrl)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 cx2341x_ctrl_query_fill(struct v4l2_queryctrl * qctrl,s32 min,s32 max,s32 step,s32 def)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 cx2341x_ctrl_query(const struct cx2341x_mpeg_params * params,struct v4l2_queryctrl * qctrl)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 cx2341x_ctrl_get_menu(const struct cx2341x_mpeg_params * p,u32 id)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 cx2341x_calc_audio_properties(struct cx2341x_mpeg_params * params)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. */ v4l2_ctrl_check(struct v4l2_ext_control * ctrl,struct v4l2_queryctrl * qctrl,const char * const * menu_items)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 cx2341x_ext_ctrls(struct cx2341x_mpeg_params * params,int busy,struct v4l2_ext_controls * ctrls,unsigned int cmd)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 cx2341x_fill_defaults(struct cx2341x_mpeg_params * p)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 cx2341x_api(void * priv,cx2341x_mbox_func func,u32 cmd,int args,...)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 cx2341x_update(void * priv,cx2341x_mbox_func func,const struct cx2341x_mpeg_params * old,const struct cx2341x_mpeg_params * new)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 cx2341x_menu_item(const struct cx2341x_mpeg_params * p,u32 id)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 cx2341x_log_status(const struct cx2341x_mpeg_params * p,const char * prefix)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 to_cxhdl(struct v4l2_ctrl * ctrl)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 cx2341x_hdl_api(struct cx2341x_handler * hdl,u32 cmd,int args,...)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 */ cx2341x_neq(struct v4l2_ctrl * ctrl)1316 static inline int cx2341x_neq(struct v4l2_ctrl *ctrl) 1317 { 1318 return ctrl && ctrl->val != ctrl->cur.val; 1319 } 1320 cx2341x_try_ctrl(struct v4l2_ctrl * ctrl)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 cx2341x_s_ctrl(struct v4l2_ctrl * ctrl)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 cx2341x_ctrl_new_custom(struct v4l2_ctrl_handler * hdl,u32 id,s32 min,s32 max,s32 step,s32 def)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 cx2341x_ctrl_new_std(struct v4l2_ctrl_handler * hdl,u32 id,s32 min,s32 max,s32 step,s32 def)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 cx2341x_ctrl_new_menu(struct v4l2_ctrl_handler * hdl,u32 id,s32 max,s32 mask,s32 def)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 cx2341x_handler_init(struct cx2341x_handler * cxhdl,unsigned nr_of_controls_hint)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 cx2341x_handler_set_50hz(struct cx2341x_handler * cxhdl,int is_50hz)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 cx2341x_handler_setup(struct cx2341x_handler * cxhdl)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 cx2341x_handler_set_busy(struct cx2341x_handler * cxhdl,int busy)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); 1779