git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/v4l2-common.c

   1 /*
   2  *      Video for Linux Two
   3  *
   4  *      A generic video device interface for the LINUX operating system
   5  *      using a set of device structures/vectors for low level operations.
   6  *
   7  *      This file replaces the videodev.c file that comes with the
   8  *      regular kernel distribution.
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  *
  15  * Author:      Bill Dirks <bill@thedirks.org>
  16  *              based on code by Alan Cox, <alan@cymru.net>
  17  *
  18  */
  19
  20 /*
  21  * Video capture interface for Linux
  22  *
  23  *      A generic video device interface for the LINUX operating system
  24  *      using a set of device structures/vectors for low level operations.
  25  *
  26  *              This program is free software; you can redistribute it and/or
  27  *              modify it under the terms of the GNU General Public License
  28  *              as published by the Free Software Foundation; either version
  29  *              2 of the License, or (at your option) any later version.
  30  *
  31  * Author:      Alan Cox, <alan@redhat.com>
  32  *
  33  * Fixes:
  34  */
  35
  36 /*
  37  * Video4linux 1/2 integration by Justin Schoeman
  38  * <justin@suntiger.ee.up.ac.za>
  39  * 2.4 PROCFS support ported from 2.4 kernels by
  40  *  Iñaki García Etxebarria <garetxe@euskalnet.net>
  41  * Makefile fix by "W. Michael Petullo" <mike@flyn.org>
  42  * 2.4 devfs support ported from 2.4 kernels by
  43  *  Dan Merillat <dan@merillat.org>
  44  * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
  45  */
  46
  47 #include <linux/module.h>
  48 #include <linux/types.h>
  49 #include <linux/kernel.h>
  50 #include <linux/smp_lock.h>
  51 #include <linux/mm.h>
  52 #include <linux/string.h>
  53 #include <linux/errno.h>
  54 #include <linux/i2c.h>
  55 #include <asm/uaccess.h>
  56 #include <asm/system.h>
  57 #include <asm/pgtable.h>
  58 #include <asm/io.h>
  59 #include <asm/div64.h>
  60 #include <linux/video_decoder.h>
  61 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
  62 #include <media/v4l2-common.h>
  63
  64 #ifdef CONFIG_KMOD
  65 #include <linux/kmod.h>
  66 #endif
  67
  68 #if defined(CONFIG_UST) || defined(CONFIG_UST_MODULE)
  69 #include <linux/ust.h>
  70 #endif
  71
  72
  73 #include <linux/videodev.h>
  74
  75 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
  76 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
  77 MODULE_LICENSE("GPL");
  78
  79 /*
  80  *
  81  *      V 4 L 2   D R I V E R   H E L P E R   A P I
  82  *
  83  */
  84
  85 /*
  86  *  Video Standard Operations (contributed by Michael Schimek)
  87  */
  88
  89
  90 char *v4l2_norm_to_name(v4l2_std_id id)
  91 {
  92         char *name;
  93         u32 myid = id;
  94
  95         /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
  96            64 bit comparations. So, on that architecture, with some gcc variants,
  97            compilation fails. Currently, the max value is 30bit wide.
  98          */
  99         BUG_ON(myid != id);
 100
 101         switch (myid) {
 102         case V4L2_STD_PAL:
 103                 name="PAL";             break;
 104         case V4L2_STD_PAL_BG:
 105                 name="PAL-BG";          break;
 106         case V4L2_STD_PAL_DK:
 107                 name="PAL-DK";          break;
 108         case V4L2_STD_PAL_B:
 109                 name="PAL-B";           break;
 110         case V4L2_STD_PAL_B1:
 111                 name="PAL-B1";          break;
 112         case V4L2_STD_PAL_G:
 113                 name="PAL-G";           break;
 114         case V4L2_STD_PAL_H:
 115                 name="PAL-H";           break;
 116         case V4L2_STD_PAL_I:
 117                 name="PAL-I";           break;
 118         case V4L2_STD_PAL_D:
 119                 name="PAL-D";           break;
 120         case V4L2_STD_PAL_D1:
 121                 name="PAL-D1";          break;
 122         case V4L2_STD_PAL_K:
 123                 name="PAL-K";           break;
 124         case V4L2_STD_PAL_M:
 125                 name="PAL-M";           break;
 126         case V4L2_STD_PAL_N:
 127                 name="PAL-N";           break;
 128         case V4L2_STD_PAL_Nc:
 129                 name="PAL-Nc";          break;
 130         case V4L2_STD_PAL_60:
 131                 name="PAL-60";          break;
 132         case V4L2_STD_NTSC:
 133                 name="NTSC";            break;
 134         case V4L2_STD_NTSC_M:
 135                 name="NTSC-M";          break;
 136         case V4L2_STD_NTSC_M_JP:
 137                 name="NTSC-M-JP";       break;
 138         case V4L2_STD_NTSC_443:
 139                 name="NTSC-443";        break;
 140         case V4L2_STD_NTSC_M_KR:
 141                 name="NTSC-M-KR";       break;
 142         case V4L2_STD_SECAM:
 143                 name="SECAM";           break;
 144         case V4L2_STD_SECAM_DK:
 145                 name="SECAM-DK";        break;
 146         case V4L2_STD_SECAM_B:
 147                 name="SECAM-B";         break;
 148         case V4L2_STD_SECAM_D:
 149                 name="SECAM-D";         break;
 150         case V4L2_STD_SECAM_G:
 151                 name="SECAM-G";         break;
 152         case V4L2_STD_SECAM_H:
 153                 name="SECAM-H";         break;
 154         case V4L2_STD_SECAM_K:
 155                 name="SECAM-K";         break;
 156         case V4L2_STD_SECAM_K1:
 157                 name="SECAM-K1";        break;
 158         case V4L2_STD_SECAM_L:
 159                 name="SECAM-L";         break;
 160         case V4L2_STD_SECAM_LC:
 161                 name="SECAM-LC";        break;
 162         default:
 163                 name="Unknown";         break;
 164         }
 165
 166         return name;
 167 }
 168
 169 /* Fill in the fields of a v4l2_standard structure according to the
 170    'id' and 'transmission' parameters.  Returns negative on error.  */
 171 int v4l2_video_std_construct(struct v4l2_standard *vs,
 172                              int id, char *name)
 173 {
 174         u32 index = vs->index;
 175
 176         memset(vs, 0, sizeof(struct v4l2_standard));
 177         vs->index = index;
 178         vs->id    = id;
 179         if (id & V4L2_STD_525_60) {
 180                 vs->frameperiod.numerator = 1001;
 181                 vs->frameperiod.denominator = 30000;
 182                 vs->framelines = 525;
 183         } else {
 184                 vs->frameperiod.numerator = 1;
 185                 vs->frameperiod.denominator = 25;
 186                 vs->framelines = 625;
 187         }
 188         strlcpy(vs->name,name,sizeof(vs->name));
 189         return 0;
 190 }
 191
 192 /* ----------------------------------------------------------------- */
 193 /* priority handling                                                 */
 194
 195 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND   || \
 196                               val == V4L2_PRIORITY_INTERACTIVE  || \
 197                               val == V4L2_PRIORITY_RECORD)
 198
 199 int v4l2_prio_init(struct v4l2_prio_state *global)
 200 {
 201         memset(global,0,sizeof(*global));
 202         return 0;
 203 }
 204
 205 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
 206                      enum v4l2_priority new)
 207 {
 208         if (!V4L2_PRIO_VALID(new))
 209                 return -EINVAL;
 210         if (*local == new)
 211                 return 0;
 212
 213         atomic_inc(&global->prios[new]);
 214         if (V4L2_PRIO_VALID(*local))
 215                 atomic_dec(&global->prios[*local]);
 216         *local = new;
 217         return 0;
 218 }
 219
 220 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 221 {
 222         return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
 223 }
 224
 225 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
 226 {
 227         if (V4L2_PRIO_VALID(*local))
 228                 atomic_dec(&global->prios[*local]);
 229         return 0;
 230 }
 231
 232 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
 233 {
 234         if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
 235                 return V4L2_PRIORITY_RECORD;
 236         if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
 237                 return V4L2_PRIORITY_INTERACTIVE;
 238         if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
 239                 return V4L2_PRIORITY_BACKGROUND;
 240         return V4L2_PRIORITY_UNSET;
 241 }
 242
 243 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
 244 {
 245         if (*local < v4l2_prio_max(global))
 246                 return -EBUSY;
 247         return 0;
 248 }
 249
 250
 251 /* ----------------------------------------------------------------- */
 252 /* some arrays for pretty-printing debug messages of enum types      */
 253
 254 char *v4l2_field_names[] = {
 255         [V4L2_FIELD_ANY]        = "any",
 256         [V4L2_FIELD_NONE]       = "none",
 257         [V4L2_FIELD_TOP]        = "top",
 258         [V4L2_FIELD_BOTTOM]     = "bottom",
 259         [V4L2_FIELD_INTERLACED] = "interlaced",
 260         [V4L2_FIELD_SEQ_TB]     = "seq-tb",
 261         [V4L2_FIELD_SEQ_BT]     = "seq-bt",
 262         [V4L2_FIELD_ALTERNATE]  = "alternate",
 263         [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
 264         [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
 265 };
 266
 267 char *v4l2_type_names[] = {
 268         [V4L2_BUF_TYPE_VIDEO_CAPTURE]      = "video-cap",
 269         [V4L2_BUF_TYPE_VIDEO_OVERLAY]      = "video-over",
 270         [V4L2_BUF_TYPE_VIDEO_OUTPUT]       = "video-out",
 271         [V4L2_BUF_TYPE_VBI_CAPTURE]        = "vbi-cap",
 272         [V4L2_BUF_TYPE_VBI_OUTPUT]         = "vbi-out",
 273         [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
 274         [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT]  = "sliced-vbi-out",
 275         [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "video-out-over",
 276 };
 277
 278
 279 #define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
 280
 281 /* ------------------------------------------------------------------ */
 282 /* debug help functions                                               */
 283
 284 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 285 static const char *v4l1_ioctls[] = {
 286         [_IOC_NR(VIDIOCGCAP)]       = "VIDIOCGCAP",
 287         [_IOC_NR(VIDIOCGCHAN)]      = "VIDIOCGCHAN",
 288         [_IOC_NR(VIDIOCSCHAN)]      = "VIDIOCSCHAN",
 289         [_IOC_NR(VIDIOCGTUNER)]     = "VIDIOCGTUNER",
 290         [_IOC_NR(VIDIOCSTUNER)]     = "VIDIOCSTUNER",
 291         [_IOC_NR(VIDIOCGPICT)]      = "VIDIOCGPICT",
 292         [_IOC_NR(VIDIOCSPICT)]      = "VIDIOCSPICT",
 293         [_IOC_NR(VIDIOCCAPTURE)]    = "VIDIOCCAPTURE",
 294         [_IOC_NR(VIDIOCGWIN)]       = "VIDIOCGWIN",
 295         [_IOC_NR(VIDIOCSWIN)]       = "VIDIOCSWIN",
 296         [_IOC_NR(VIDIOCGFBUF)]      = "VIDIOCGFBUF",
 297         [_IOC_NR(VIDIOCSFBUF)]      = "VIDIOCSFBUF",
 298         [_IOC_NR(VIDIOCKEY)]        = "VIDIOCKEY",
 299         [_IOC_NR(VIDIOCGFREQ)]      = "VIDIOCGFREQ",
 300         [_IOC_NR(VIDIOCSFREQ)]      = "VIDIOCSFREQ",
 301         [_IOC_NR(VIDIOCGAUDIO)]     = "VIDIOCGAUDIO",
 302         [_IOC_NR(VIDIOCSAUDIO)]     = "VIDIOCSAUDIO",
 303         [_IOC_NR(VIDIOCSYNC)]       = "VIDIOCSYNC",
 304         [_IOC_NR(VIDIOCMCAPTURE)]   = "VIDIOCMCAPTURE",
 305         [_IOC_NR(VIDIOCGMBUF)]      = "VIDIOCGMBUF",
 306         [_IOC_NR(VIDIOCGUNIT)]      = "VIDIOCGUNIT",
 307         [_IOC_NR(VIDIOCGCAPTURE)]   = "VIDIOCGCAPTURE",
 308         [_IOC_NR(VIDIOCSCAPTURE)]   = "VIDIOCSCAPTURE",
 309         [_IOC_NR(VIDIOCSPLAYMODE)]  = "VIDIOCSPLAYMODE",
 310         [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
 311         [_IOC_NR(VIDIOCGPLAYINFO)]  = "VIDIOCGPLAYINFO",
 312         [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
 313         [_IOC_NR(VIDIOCGVBIFMT)]    = "VIDIOCGVBIFMT",
 314         [_IOC_NR(VIDIOCSVBIFMT)]    = "VIDIOCSVBIFMT"
 315 };
 316 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
 317 #endif
 318
 319 static const char *v4l2_ioctls[] = {
 320         [_IOC_NR(VIDIOC_QUERYCAP)]         = "VIDIOC_QUERYCAP",
 321         [_IOC_NR(VIDIOC_RESERVED)]         = "VIDIOC_RESERVED",
 322         [_IOC_NR(VIDIOC_ENUM_FMT)]         = "VIDIOC_ENUM_FMT",
 323         [_IOC_NR(VIDIOC_G_FMT)]            = "VIDIOC_G_FMT",
 324         [_IOC_NR(VIDIOC_S_FMT)]            = "VIDIOC_S_FMT",
 325         [_IOC_NR(VIDIOC_G_MPEGCOMP)]       = "VIDIOC_G_MPEGCOMP",
 326         [_IOC_NR(VIDIOC_S_MPEGCOMP)]       = "VIDIOC_S_MPEGCOMP",
 327         [_IOC_NR(VIDIOC_REQBUFS)]          = "VIDIOC_REQBUFS",
 328         [_IOC_NR(VIDIOC_QUERYBUF)]         = "VIDIOC_QUERYBUF",
 329         [_IOC_NR(VIDIOC_G_FBUF)]           = "VIDIOC_G_FBUF",
 330         [_IOC_NR(VIDIOC_S_FBUF)]           = "VIDIOC_S_FBUF",
 331         [_IOC_NR(VIDIOC_OVERLAY)]          = "VIDIOC_OVERLAY",
 332         [_IOC_NR(VIDIOC_QBUF)]             = "VIDIOC_QBUF",
 333         [_IOC_NR(VIDIOC_DQBUF)]            = "VIDIOC_DQBUF",
 334         [_IOC_NR(VIDIOC_STREAMON)]         = "VIDIOC_STREAMON",
 335         [_IOC_NR(VIDIOC_STREAMOFF)]        = "VIDIOC_STREAMOFF",
 336         [_IOC_NR(VIDIOC_G_PARM)]           = "VIDIOC_G_PARM",
 337         [_IOC_NR(VIDIOC_S_PARM)]           = "VIDIOC_S_PARM",
 338         [_IOC_NR(VIDIOC_G_STD)]            = "VIDIOC_G_STD",
 339         [_IOC_NR(VIDIOC_S_STD)]            = "VIDIOC_S_STD",
 340         [_IOC_NR(VIDIOC_ENUMSTD)]          = "VIDIOC_ENUMSTD",
 341         [_IOC_NR(VIDIOC_ENUMINPUT)]        = "VIDIOC_ENUMINPUT",
 342         [_IOC_NR(VIDIOC_G_CTRL)]           = "VIDIOC_G_CTRL",
 343         [_IOC_NR(VIDIOC_S_CTRL)]           = "VIDIOC_S_CTRL",
 344         [_IOC_NR(VIDIOC_G_TUNER)]          = "VIDIOC_G_TUNER",
 345         [_IOC_NR(VIDIOC_S_TUNER)]          = "VIDIOC_S_TUNER",
 346         [_IOC_NR(VIDIOC_G_AUDIO)]          = "VIDIOC_G_AUDIO",
 347         [_IOC_NR(VIDIOC_S_AUDIO)]          = "VIDIOC_S_AUDIO",
 348         [_IOC_NR(VIDIOC_QUERYCTRL)]        = "VIDIOC_QUERYCTRL",
 349         [_IOC_NR(VIDIOC_QUERYMENU)]        = "VIDIOC_QUERYMENU",
 350         [_IOC_NR(VIDIOC_G_INPUT)]          = "VIDIOC_G_INPUT",
 351         [_IOC_NR(VIDIOC_S_INPUT)]          = "VIDIOC_S_INPUT",
 352         [_IOC_NR(VIDIOC_G_OUTPUT)]         = "VIDIOC_G_OUTPUT",
 353         [_IOC_NR(VIDIOC_S_OUTPUT)]         = "VIDIOC_S_OUTPUT",
 354         [_IOC_NR(VIDIOC_ENUMOUTPUT)]       = "VIDIOC_ENUMOUTPUT",
 355         [_IOC_NR(VIDIOC_G_AUDOUT)]         = "VIDIOC_G_AUDOUT",
 356         [_IOC_NR(VIDIOC_S_AUDOUT)]         = "VIDIOC_S_AUDOUT",
 357         [_IOC_NR(VIDIOC_G_MODULATOR)]      = "VIDIOC_G_MODULATOR",
 358         [_IOC_NR(VIDIOC_S_MODULATOR)]      = "VIDIOC_S_MODULATOR",
 359         [_IOC_NR(VIDIOC_G_FREQUENCY)]      = "VIDIOC_G_FREQUENCY",
 360         [_IOC_NR(VIDIOC_S_FREQUENCY)]      = "VIDIOC_S_FREQUENCY",
 361         [_IOC_NR(VIDIOC_CROPCAP)]          = "VIDIOC_CROPCAP",
 362         [_IOC_NR(VIDIOC_G_CROP)]           = "VIDIOC_G_CROP",
 363         [_IOC_NR(VIDIOC_S_CROP)]           = "VIDIOC_S_CROP",
 364         [_IOC_NR(VIDIOC_G_JPEGCOMP)]       = "VIDIOC_G_JPEGCOMP",
 365         [_IOC_NR(VIDIOC_S_JPEGCOMP)]       = "VIDIOC_S_JPEGCOMP",
 366         [_IOC_NR(VIDIOC_QUERYSTD)]         = "VIDIOC_QUERYSTD",
 367         [_IOC_NR(VIDIOC_TRY_FMT)]          = "VIDIOC_TRY_FMT",
 368         [_IOC_NR(VIDIOC_ENUMAUDIO)]        = "VIDIOC_ENUMAUDIO",
 369         [_IOC_NR(VIDIOC_ENUMAUDOUT)]       = "VIDIOC_ENUMAUDOUT",
 370         [_IOC_NR(VIDIOC_G_PRIORITY)]       = "VIDIOC_G_PRIORITY",
 371         [_IOC_NR(VIDIOC_S_PRIORITY)]       = "VIDIOC_S_PRIORITY",
 372         [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
 373         [_IOC_NR(VIDIOC_LOG_STATUS)]       = "VIDIOC_LOG_STATUS",
 374         [_IOC_NR(VIDIOC_G_EXT_CTRLS)]      = "VIDIOC_G_EXT_CTRLS",
 375         [_IOC_NR(VIDIOC_S_EXT_CTRLS)]      = "VIDIOC_S_EXT_CTRLS",
 376         [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)]    = "VIDIOC_TRY_EXT_CTRLS",
 377 #if 1
 378         [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)]  = "VIDIOC_ENUM_FRAMESIZES",
 379         [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
 380         [_IOC_NR(VIDIOC_G_ENC_INDEX)]      = "VIDIOC_G_ENC_INDEX",
 381         [_IOC_NR(VIDIOC_ENCODER_CMD)]      = "VIDIOC_ENCODER_CMD",
 382         [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)]  = "VIDIOC_TRY_ENCODER_CMD",
 383
 384         [_IOC_NR(VIDIOC_DBG_S_REGISTER)]   = "VIDIOC_DBG_S_REGISTER",
 385         [_IOC_NR(VIDIOC_DBG_G_REGISTER)]   = "VIDIOC_DBG_G_REGISTER",
 386 #endif
 387 };
 388 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 389
 390 static const char *v4l2_int_ioctls[] = {
 391 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 392         [_IOC_NR(DECODER_GET_CAPABILITIES)]    = "DECODER_GET_CAPABILITIES",
 393         [_IOC_NR(DECODER_GET_STATUS)]          = "DECODER_GET_STATUS",
 394         [_IOC_NR(DECODER_SET_NORM)]            = "DECODER_SET_NORM",
 395         [_IOC_NR(DECODER_SET_INPUT)]           = "DECODER_SET_INPUT",
 396         [_IOC_NR(DECODER_SET_OUTPUT)]          = "DECODER_SET_OUTPUT",
 397         [_IOC_NR(DECODER_ENABLE_OUTPUT)]       = "DECODER_ENABLE_OUTPUT",
 398         [_IOC_NR(DECODER_SET_PICTURE)]         = "DECODER_SET_PICTURE",
 399         [_IOC_NR(DECODER_SET_GPIO)]            = "DECODER_SET_GPIO",
 400         [_IOC_NR(DECODER_INIT)]                = "DECODER_INIT",
 401         [_IOC_NR(DECODER_SET_VBI_BYPASS)]      = "DECODER_SET_VBI_BYPASS",
 402         [_IOC_NR(DECODER_DUMP)]                = "DECODER_DUMP",
 403 #endif
 404         [_IOC_NR(AUDC_SET_RADIO)]              = "AUDC_SET_RADIO",
 405
 406         [_IOC_NR(TUNER_SET_TYPE_ADDR)]         = "TUNER_SET_TYPE_ADDR",
 407         [_IOC_NR(TUNER_SET_STANDBY)]           = "TUNER_SET_STANDBY",
 408         [_IOC_NR(TDA9887_SET_CONFIG)]          = "TDA9887_SET_CONFIG",
 409
 410         [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)]     = "VIDIOC_INT_S_TUNER_MODE",
 411         [_IOC_NR(VIDIOC_INT_RESET)]            = "VIDIOC_INT_RESET",
 412         [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
 413         [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)]  = "VIDIOC_INT_DECODE_VBI_LINE",
 414         [_IOC_NR(VIDIOC_INT_S_VBI_DATA)]       = "VIDIOC_INT_S_VBI_DATA",
 415         [_IOC_NR(VIDIOC_INT_G_VBI_DATA)]       = "VIDIOC_INT_G_VBI_DATA",
 416         [_IOC_NR(VIDIOC_INT_G_CHIP_IDENT)]     = "VIDIOC_INT_G_CHIP_IDENT",
 417         [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)]   = "VIDIOC_INT_I2S_CLOCK_FREQ",
 418         [_IOC_NR(VIDIOC_INT_S_STANDBY)]        = "VIDIOC_INT_S_STANDBY",
 419         [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)]  = "VIDIOC_INT_S_AUDIO_ROUTING",
 420         [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)]  = "VIDIOC_INT_G_AUDIO_ROUTING",
 421         [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)]  = "VIDIOC_INT_S_VIDEO_ROUTING",
 422         [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)]  = "VIDIOC_INT_G_VIDEO_ROUTING",
 423         [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)]   = "VIDIOC_INT_S_CRYSTAL_FREQ",
 424         [_IOC_NR(VIDIOC_INT_INIT)]             = "VIDIOC_INT_INIT",
 425         [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)]     = "VIDIOC_INT_G_STD_OUTPUT",
 426         [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)]     = "VIDIOC_INT_S_STD_OUTPUT",
 427 };
 428 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
 429
 430
 431 /* Common ioctl debug function. This function can be used by
 432    external ioctl messages as well as internal V4L ioctl */
 433 void v4l_printk_ioctl(unsigned int cmd)
 434 {
 435         char *dir;
 436
 437         switch (_IOC_DIR(cmd)) {
 438         case _IOC_NONE:              dir = "--"; break;
 439         case _IOC_READ:              dir = "r-"; break;
 440         case _IOC_WRITE:             dir = "-w"; break;
 441         case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
 442         default:                     dir = "*ERR*"; break;
 443         }
 444         switch (_IOC_TYPE(cmd)) {
 445         case 'd':
 446                 printk("v4l2_int ioctl %s, dir=%s (0x%08x)\n",
 447                        (_IOC_NR(cmd) < V4L2_INT_IOCTLS) ?
 448                        v4l2_int_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
 449                 break;
 450 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 451         case 'v':
 452                 printk("v4l1 ioctl %s, dir=%s (0x%08x)\n",
 453                        (_IOC_NR(cmd) < V4L1_IOCTLS) ?
 454                        v4l1_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
 455                 break;
 456 #endif
 457         case 'V':
 458                 printk("v4l2 ioctl %s, dir=%s (0x%08x)\n",
 459                        (_IOC_NR(cmd) < V4L2_IOCTLS) ?
 460                        v4l2_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
 461                 break;
 462
 463         default:
 464                 printk("unknown ioctl '%c', dir=%s, #%d (0x%08x)\n",
 465                        _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
 466         }
 467 }
 468
 469
 470 /* ----------------------------------------------------------------- */
 471
 472 /* Helper functions for control handling                             */
 473
 474 /* Check for correctness of the ctrl's value based on the data from
 475    struct v4l2_queryctrl and the available menu items. Note that
 476    menu_items may be NULL, in that case it is ignored. */
 477 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
 478                 const char **menu_items)
 479 {
 480         if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
 481                 return -EINVAL;
 482         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
 483                 return -EBUSY;
 484         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
 485             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
 486             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
 487                 return 0;
 488         if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
 489                 return -ERANGE;
 490         if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
 491                 if (menu_items[ctrl->value] == NULL ||
 492                     menu_items[ctrl->value][0] == '\0')
 493                         return -EINVAL;
 494         }
 495         return 0;
 496 }
 497
 498 /* Returns NULL or a character pointer array containing the menu for
 499    the given control ID. The pointer array ends with a NULL pointer.
 500    An empty string signifies a menu entry that is invalid. This allows
 501    drivers to disable certain options if it is not supported. */
 502 const char **v4l2_ctrl_get_menu(u32 id)
 503 {
 504         static const char *mpeg_audio_sampling_freq[] = {
 505                 "44.1 kHz",
 506                 "48 kHz",
 507                 "32 kHz",
 508                 NULL
 509         };
 510         static const char *mpeg_audio_encoding[] = {
 511                 "Layer I",
 512                 "Layer II",
 513                 "Layer III",
 514                 NULL
 515         };
 516         static const char *mpeg_audio_l1_bitrate[] = {
 517                 "32 kbps",
 518                 "64 kbps",
 519                 "96 kbps",
 520                 "128 kbps",
 521                 "160 kbps",
 522                 "192 kbps",
 523                 "224 kbps",
 524                 "256 kbps",
 525                 "288 kbps",
 526                 "320 kbps",
 527                 "352 kbps",
 528                 "384 kbps",
 529                 "416 kbps",
 530                 "448 kbps",
 531                 NULL
 532         };
 533         static const char *mpeg_audio_l2_bitrate[] = {
 534                 "32 kbps",
 535                 "48 kbps",
 536                 "56 kbps",
 537                 "64 kbps",
 538                 "80 kbps",
 539                 "96 kbps",
 540                 "112 kbps",
 541                 "128 kbps",
 542                 "160 kbps",
 543                 "192 kbps",
 544                 "224 kbps",
 545                 "256 kbps",
 546                 "320 kbps",
 547                 "384 kbps",
 548                 NULL
 549         };
 550         static const char *mpeg_audio_l3_bitrate[] = {
 551                 "32 kbps",
 552                 "40 kbps",
 553                 "48 kbps",
 554                 "56 kbps",
 555                 "64 kbps",
 556                 "80 kbps",
 557                 "96 kbps",
 558                 "112 kbps",
 559                 "128 kbps",
 560                 "160 kbps",
 561                 "192 kbps",
 562                 "224 kbps",
 563                 "256 kbps",
 564                 "320 kbps",
 565                 NULL
 566         };
 567         static const char *mpeg_audio_mode[] = {
 568                 "Stereo",
 569                 "Joint Stereo",
 570                 "Dual",
 571                 "Mono",
 572                 NULL
 573         };
 574         static const char *mpeg_audio_mode_extension[] = {
 575                 "Bound 4",
 576                 "Bound 8",
 577                 "Bound 12",
 578                 "Bound 16",
 579                 NULL
 580         };
 581         static const char *mpeg_audio_emphasis[] = {
 582                 "No Emphasis",
 583                 "50/15 us",
 584                 "CCITT J17",
 585                 NULL
 586         };
 587         static const char *mpeg_audio_crc[] = {
 588                 "No CRC",
 589                 "16-bit CRC",
 590                 NULL
 591         };
 592         static const char *mpeg_video_encoding[] = {
 593                 "MPEG-1",
 594                 "MPEG-2",
 595                 NULL
 596         };
 597         static const char *mpeg_video_aspect[] = {
 598                 "1x1",
 599                 "4x3",
 600                 "16x9",
 601                 "2.21x1",
 602                 NULL
 603         };
 604         static const char *mpeg_video_bitrate_mode[] = {
 605                 "Variable Bitrate",
 606                 "Constant Bitrate",
 607                 NULL
 608         };
 609         static const char *mpeg_stream_type[] = {
 610                 "MPEG-2 Program Stream",
 611                 "MPEG-2 Transport Stream",
 612                 "MPEG-1 System Stream",
 613                 "MPEG-2 DVD-compatible Stream",
 614                 "MPEG-1 VCD-compatible Stream",
 615                 "MPEG-2 SVCD-compatible Stream",
 616                 NULL
 617         };
 618         static const char *mpeg_stream_vbi_fmt[] = {
 619                 "No VBI",
 620                 "Private packet, IVTV format",
 621                 NULL
 622         };
 623
 624         switch (id) {
 625                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 626                         return mpeg_audio_sampling_freq;
 627                 case V4L2_CID_MPEG_AUDIO_ENCODING:
 628                         return mpeg_audio_encoding;
 629                 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 630                         return mpeg_audio_l1_bitrate;
 631                 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 632                         return mpeg_audio_l2_bitrate;
 633                 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 634                         return mpeg_audio_l3_bitrate;
 635                 case V4L2_CID_MPEG_AUDIO_MODE:
 636                         return mpeg_audio_mode;
 637                 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 638                         return mpeg_audio_mode_extension;
 639                 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 640                         return mpeg_audio_emphasis;
 641                 case V4L2_CID_MPEG_AUDIO_CRC:
 642                         return mpeg_audio_crc;
 643                 case V4L2_CID_MPEG_VIDEO_ENCODING:
 644                         return mpeg_video_encoding;
 645                 case V4L2_CID_MPEG_VIDEO_ASPECT:
 646                         return mpeg_video_aspect;
 647                 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 648                         return mpeg_video_bitrate_mode;
 649                 case V4L2_CID_MPEG_STREAM_TYPE:
 650                         return mpeg_stream_type;
 651                 case V4L2_CID_MPEG_STREAM_VBI_FMT:
 652                         return mpeg_stream_vbi_fmt;
 653                 default:
 654                         return NULL;
 655         }
 656 }
 657
 658 /* Fill in a struct v4l2_queryctrl */
 659 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
 660 {
 661         const char *name;
 662
 663         qctrl->flags = 0;
 664         switch (qctrl->id) {
 665         /* USER controls */
 666         case V4L2_CID_USER_CLASS:       name = "User Controls"; break;
 667         case V4L2_CID_AUDIO_VOLUME:     name = "Volume"; break;
 668         case V4L2_CID_AUDIO_MUTE:       name = "Mute"; break;
 669         case V4L2_CID_AUDIO_BALANCE:    name = "Balance"; break;
 670         case V4L2_CID_AUDIO_BASS:       name = "Bass"; break;
 671         case V4L2_CID_AUDIO_TREBLE:     name = "Treble"; break;
 672         case V4L2_CID_AUDIO_LOUDNESS:   name = "Loudness"; break;
 673         case V4L2_CID_BRIGHTNESS:       name = "Brightness"; break;
 674         case V4L2_CID_CONTRAST:         name = "Contrast"; break;
 675         case V4L2_CID_SATURATION:       name = "Saturation"; break;
 676         case V4L2_CID_HUE:              name = "Hue"; break;
 677
 678         /* MPEG controls */
 679         case V4L2_CID_MPEG_CLASS:               name = "MPEG Encoder Controls"; break;
 680         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
 681         case V4L2_CID_MPEG_AUDIO_ENCODING:      name = "Audio Encoding Layer"; break;
 682         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    name = "Audio Layer I Bitrate"; break;
 683         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    name = "Audio Layer II Bitrate"; break;
 684         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    name = "Audio Layer III Bitrate"; break;
 685         case V4L2_CID_MPEG_AUDIO_MODE:          name = "Audio Stereo Mode"; break;
 686         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
 687         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      name = "Audio Emphasis"; break;
 688         case V4L2_CID_MPEG_AUDIO_CRC:           name = "Audio CRC"; break;
 689         case V4L2_CID_MPEG_AUDIO_MUTE:          name = "Audio Mute"; break;
 690         case V4L2_CID_MPEG_VIDEO_ENCODING:      name = "Video Encoding"; break;
 691         case V4L2_CID_MPEG_VIDEO_ASPECT:        name = "Video Aspect"; break;
 692         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      name = "Video B Frames"; break;
 693         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      name = "Video GOP Size"; break;
 694         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   name = "Video GOP Closure"; break;
 695         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      name = "Video Pulldown"; break;
 696         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  name = "Video Bitrate Mode"; break;
 697         case V4L2_CID_MPEG_VIDEO_BITRATE:       name = "Video Bitrate"; break;
 698         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  name = "Video Peak Bitrate"; break;
 699         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
 700         case V4L2_CID_MPEG_VIDEO_MUTE:          name = "Video Mute"; break;
 701         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:      name = "Video Mute YUV"; break;
 702         case V4L2_CID_MPEG_STREAM_TYPE:         name = "Stream Type"; break;
 703         case V4L2_CID_MPEG_STREAM_PID_PMT:      name = "Stream PMT Program ID"; break;
 704         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    name = "Stream Audio Program ID"; break;
 705         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    name = "Stream Video Program ID"; break;
 706         case V4L2_CID_MPEG_STREAM_PID_PCR:      name = "Stream PCR Program ID"; break;
 707         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
 708         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
 709         case V4L2_CID_MPEG_STREAM_VBI_FMT:      name = "Stream VBI Format"; break;
 710
 711         default:
 712                 return -EINVAL;
 713         }
 714         switch (qctrl->id) {
 715         case V4L2_CID_AUDIO_MUTE:
 716         case V4L2_CID_AUDIO_LOUDNESS:
 717         case V4L2_CID_MPEG_AUDIO_MUTE:
 718         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 719         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 720                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
 721                 min = 0;
 722                 max = step = 1;
 723                 break;
 724         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 725         case V4L2_CID_MPEG_AUDIO_ENCODING:
 726         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 727         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 728         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 729         case V4L2_CID_MPEG_AUDIO_MODE:
 730         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 731         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 732         case V4L2_CID_MPEG_AUDIO_CRC:
 733         case V4L2_CID_MPEG_VIDEO_ENCODING:
 734         case V4L2_CID_MPEG_VIDEO_ASPECT:
 735         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 736         case V4L2_CID_MPEG_STREAM_TYPE:
 737         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 738                 qctrl->type = V4L2_CTRL_TYPE_MENU;
 739                 step = 1;
 740                 break;
 741         case V4L2_CID_USER_CLASS:
 742         case V4L2_CID_MPEG_CLASS:
 743                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
 744                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
 745                 min = max = step = def = 0;
 746                 break;
 747         default:
 748                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
 749                 break;
 750         }
 751         switch (qctrl->id) {
 752         case V4L2_CID_MPEG_AUDIO_ENCODING:
 753         case V4L2_CID_MPEG_AUDIO_MODE:
 754         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 755         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 756         case V4L2_CID_MPEG_STREAM_TYPE:
 757                 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
 758                 break;
 759         case V4L2_CID_AUDIO_VOLUME:
 760         case V4L2_CID_AUDIO_BALANCE:
 761         case V4L2_CID_AUDIO_BASS:
 762         case V4L2_CID_AUDIO_TREBLE:
 763         case V4L2_CID_BRIGHTNESS:
 764         case V4L2_CID_CONTRAST:
 765         case V4L2_CID_SATURATION:
 766         case V4L2_CID_HUE:
 767                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
 768                 break;
 769         }
 770         qctrl->minimum = min;
 771         qctrl->maximum = max;
 772         qctrl->step = step;
 773         qctrl->default_value = def;
 774         qctrl->reserved[0] = qctrl->reserved[1] = 0;
 775         snprintf(qctrl->name, sizeof(qctrl->name), name);
 776         return 0;
 777 }
 778
 779 /* Fill in a struct v4l2_queryctrl with standard values based on
 780    the control ID. */
 781 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
 782 {
 783         switch (qctrl->id) {
 784         /* USER controls */
 785         case V4L2_CID_USER_CLASS:
 786         case V4L2_CID_MPEG_CLASS:
 787                 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
 788         case V4L2_CID_AUDIO_VOLUME:
 789                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
 790         case V4L2_CID_AUDIO_MUTE:
 791         case V4L2_CID_AUDIO_LOUDNESS:
 792                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 793         case V4L2_CID_AUDIO_BALANCE:
 794         case V4L2_CID_AUDIO_BASS:
 795         case V4L2_CID_AUDIO_TREBLE:
 796                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
 797         case V4L2_CID_BRIGHTNESS:
 798                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
 799         case V4L2_CID_CONTRAST:
 800         case V4L2_CID_SATURATION:
 801                 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
 802         case V4L2_CID_HUE:
 803                 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
 804
 805         /* MPEG controls */
 806         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 807                 return v4l2_ctrl_query_fill(qctrl,
 808                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
 809                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
 810                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
 811         case V4L2_CID_MPEG_AUDIO_ENCODING:
 812                 return v4l2_ctrl_query_fill(qctrl,
 813                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
 814                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
 815                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
 816         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 817                 return v4l2_ctrl_query_fill(qctrl,
 818                                 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
 819                                 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
 820                                 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
 821         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 822                 return v4l2_ctrl_query_fill(qctrl,
 823                                 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
 824                                 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
 825                                 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
 826         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 827                 return v4l2_ctrl_query_fill(qctrl,
 828                                 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
 829                                 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
 830                                 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
 831         case V4L2_CID_MPEG_AUDIO_MODE:
 832                 return v4l2_ctrl_query_fill(qctrl,
 833                                 V4L2_MPEG_AUDIO_MODE_STEREO,
 834                                 V4L2_MPEG_AUDIO_MODE_MONO, 1,
 835                                 V4L2_MPEG_AUDIO_MODE_STEREO);
 836         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 837                 return v4l2_ctrl_query_fill(qctrl,
 838                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
 839                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
 840                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
 841         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 842                 return v4l2_ctrl_query_fill(qctrl,
 843                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
 844                                 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
 845                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
 846         case V4L2_CID_MPEG_AUDIO_CRC:
 847                 return v4l2_ctrl_query_fill(qctrl,
 848                                 V4L2_MPEG_AUDIO_CRC_NONE,
 849                                 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
 850                                 V4L2_MPEG_AUDIO_CRC_NONE);
 851         case V4L2_CID_MPEG_AUDIO_MUTE:
 852                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 853         case V4L2_CID_MPEG_VIDEO_ENCODING:
 854                 return v4l2_ctrl_query_fill(qctrl,
 855                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
 856                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
 857                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
 858         case V4L2_CID_MPEG_VIDEO_ASPECT:
 859                 return v4l2_ctrl_query_fill(qctrl,
 860                                 V4L2_MPEG_VIDEO_ASPECT_1x1,
 861                                 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
 862                                 V4L2_MPEG_VIDEO_ASPECT_4x3);
 863         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 864                 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
 865         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
 866                 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
 867         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 868                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
 869         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 870                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 871         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 872                 return v4l2_ctrl_query_fill(qctrl,
 873                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
 874                                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
 875                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
 876         case V4L2_CID_MPEG_VIDEO_BITRATE:
 877                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
 878         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
 879                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
 880         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
 881                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
 882         case V4L2_CID_MPEG_VIDEO_MUTE:
 883                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 884         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:  /* Init YUV (really YCbCr) to black */
 885                 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
 886         case V4L2_CID_MPEG_STREAM_TYPE:
 887                 return v4l2_ctrl_query_fill(qctrl,
 888                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
 889                                 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
 890                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
 891         case V4L2_CID_MPEG_STREAM_PID_PMT:
 892                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
 893         case V4L2_CID_MPEG_STREAM_PID_AUDIO:
 894                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
 895         case V4L2_CID_MPEG_STREAM_PID_VIDEO:
 896                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
 897         case V4L2_CID_MPEG_STREAM_PID_PCR:
 898                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
 899         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
 900                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
 901         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
 902                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
 903         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 904                 return v4l2_ctrl_query_fill(qctrl,
 905                                 V4L2_MPEG_STREAM_VBI_FMT_NONE,
 906                                 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
 907                                 V4L2_MPEG_STREAM_VBI_FMT_NONE);
 908         default:
 909                 return -EINVAL;
 910         }
 911 }
 912
 913 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
 914    the menu. The qctrl pointer may be NULL, in which case it is ignored. */
 915 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
 916                const char **menu_items)
 917 {
 918         int i;
 919
 920         if (menu_items == NULL ||
 921             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
 922                 return -EINVAL;
 923         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
 924         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
 925                 return -EINVAL;
 926         snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
 927         qmenu->reserved = 0;
 928         return 0;
 929 }
 930
 931 /* ctrl_classes points to an array of u32 pointers, the last element is
 932    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
 933    Each array must be sorted low to high and belong to the same control
 934    class. The array of u32 pointer must also be sorted, from low class IDs
 935    to high class IDs.
 936
 937    This function returns the first ID that follows after the given ID.
 938    When no more controls are available 0 is returned. */
 939 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
 940 {
 941         u32 ctrl_class;
 942         const u32 *pctrl;
 943
 944         /* if no query is desired, then just return the control ID */
 945         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
 946                 return id;
 947         if (ctrl_classes == NULL)
 948                 return 0;
 949         id &= V4L2_CTRL_ID_MASK;
 950         ctrl_class = V4L2_CTRL_ID2CLASS(id);
 951         id++;   /* select next control */
 952         /* find first class that matches (or is greater than) the class of
 953            the ID */
 954         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
 955                 ctrl_classes++;
 956         /* no more classes */
 957         if (*ctrl_classes == NULL)
 958                 return 0;
 959         pctrl = *ctrl_classes;
 960         /* find first ctrl within the class that is >= ID */
 961         while (*pctrl && *pctrl < id) pctrl++;
 962         if (*pctrl)
 963                 return *pctrl;
 964         /* we are at the end of the controls of the current class. */
 965         /* continue with next class if available */
 966         ctrl_classes++;
 967         if (*ctrl_classes == NULL)
 968                 return 0;
 969         return **ctrl_classes;
 970 }
 971
 972 int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 match_type, u32 match_chip)
 973 {
 974         switch (match_type) {
 975         case V4L2_CHIP_MATCH_I2C_DRIVER:
 976                 return (c != NULL && c->driver != NULL && c->driver->id == match_chip);
 977         case V4L2_CHIP_MATCH_I2C_ADDR:
 978                 return (c != NULL && c->addr == match_chip);
 979         default:
 980                 return 0;
 981         }
 982 }
 983
 984 int v4l2_chip_match_host(u32 match_type, u32 match_chip)
 985 {
 986         switch (match_type) {
 987         case V4L2_CHIP_MATCH_HOST:
 988                 return match_chip == 0;
 989         default:
 990                 return 0;
 991         }
 992 }
 993
 994 /* ----------------------------------------------------------------- */
 995
 996 EXPORT_SYMBOL(v4l2_norm_to_name);
 997 EXPORT_SYMBOL(v4l2_video_std_construct);
 998
 999 EXPORT_SYMBOL(v4l2_prio_init);
1000 EXPORT_SYMBOL(v4l2_prio_change);
1001 EXPORT_SYMBOL(v4l2_prio_open);
1002 EXPORT_SYMBOL(v4l2_prio_close);
1003 EXPORT_SYMBOL(v4l2_prio_max);
1004 EXPORT_SYMBOL(v4l2_prio_check);
1005
1006 EXPORT_SYMBOL(v4l2_field_names);
1007 EXPORT_SYMBOL(v4l2_type_names);
1008 EXPORT_SYMBOL(v4l_printk_ioctl);
1009
1010 EXPORT_SYMBOL(v4l2_ctrl_next);
1011 EXPORT_SYMBOL(v4l2_ctrl_check);
1012 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
1013 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
1014 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
1015 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
1016
1017 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
1018 EXPORT_SYMBOL(v4l2_chip_match_host);
1019
1020 /*
1021  * Local variables:
1022  * c-basic-offset: 8
1023  * End:
1024  */