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