drivers/media/video/cx2341x.c

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