SAFE public projects git trees. - safe/jmp/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 <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
  63 #ifdef CONFIG_KMOD
  64 #include <linux/kmod.h>
  65 #endif
  66
  67 #if defined(CONFIG_UST) || defined(CONFIG_UST_MODULE)
  68 #include <linux/ust.h>
  69 #endif
  70
  71
  72 #include <linux/videodev.h>
  73
  74 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
  75 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
  76 MODULE_LICENSE("GPL");
  77
  78 /*
  79  *
  80  *      V 4 L 2   D R I V E R   H E L P E R   A P I
  81  *
  82  */
  83
  84 /*
  85  *  Video Standard Operations (contributed by Michael Schimek)
  86  */
  87
  88
  89 char *v4l2_norm_to_name(v4l2_std_id id)
  90 {
  91         char *name;
  92         u32 myid = id;
  93
  94         /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
  95            64 bit comparations. So, on that architecture, with some gcc variants,
  96            compilation fails. Currently, the max value is 30bit wide.
  97          */
  98         BUG_ON(myid != id);
  99
 100         switch (myid) {
 101         case V4L2_STD_PAL:
 102                 name="PAL";             break;
 103         case V4L2_STD_PAL_BG:
 104                 name="PAL-BG";          break;
 105         case V4L2_STD_PAL_DK:
 106                 name="PAL-DK";          break;
 107         case V4L2_STD_PAL_B:
 108                 name="PAL-B";           break;
 109         case V4L2_STD_PAL_B1:
 110                 name="PAL-B1";          break;
 111         case V4L2_STD_PAL_G:
 112                 name="PAL-G";           break;
 113         case V4L2_STD_PAL_H:
 114                 name="PAL-H";           break;
 115         case V4L2_STD_PAL_I:
 116                 name="PAL-I";           break;
 117         case V4L2_STD_PAL_D:
 118                 name="PAL-D";           break;
 119         case V4L2_STD_PAL_D1:
 120                 name="PAL-D1";          break;
 121         case V4L2_STD_PAL_K:
 122                 name="PAL-K";           break;
 123         case V4L2_STD_PAL_M:
 124                 name="PAL-M";           break;
 125         case V4L2_STD_PAL_N:
 126                 name="PAL-N";           break;
 127         case V4L2_STD_PAL_Nc:
 128                 name="PAL-Nc";          break;
 129         case V4L2_STD_PAL_60:
 130                 name="PAL-60";          break;
 131         case V4L2_STD_NTSC:
 132                 name="NTSC";            break;
 133         case V4L2_STD_NTSC_M:
 134                 name="NTSC-M";          break;
 135         case V4L2_STD_NTSC_M_JP:
 136                 name="NTSC-M-JP";       break;
 137         case V4L2_STD_NTSC_443:
 138                 name="NTSC-443";        break;
 139         case V4L2_STD_NTSC_M_KR:
 140                 name="NTSC-M-KR";       break;
 141         case V4L2_STD_SECAM:
 142                 name="SECAM";           break;
 143         case V4L2_STD_SECAM_DK:
 144                 name="SECAM-DK";        break;
 145         case V4L2_STD_SECAM_B:
 146                 name="SECAM-B";         break;
 147         case V4L2_STD_SECAM_D:
 148                 name="SECAM-D";         break;
 149         case V4L2_STD_SECAM_G:
 150                 name="SECAM-G";         break;
 151         case V4L2_STD_SECAM_H:
 152                 name="SECAM-H";         break;
 153         case V4L2_STD_SECAM_K:
 154                 name="SECAM-K";         break;
 155         case V4L2_STD_SECAM_K1:
 156                 name="SECAM-K1";        break;
 157         case V4L2_STD_SECAM_L:
 158                 name="SECAM-L";         break;
 159         case V4L2_STD_SECAM_LC:
 160                 name="SECAM-LC";        break;
 161         default:
 162                 name="Unknown";         break;
 163         }
 164
 165         return name;
 166 }
 167
 168 /* Fill in the fields of a v4l2_standard structure according to the
 169    'id' and 'transmission' parameters.  Returns negative on error.  */
 170 int v4l2_video_std_construct(struct v4l2_standard *vs,
 171                              int id, char *name)
 172 {
 173         u32 index = vs->index;
 174
 175         memset(vs, 0, sizeof(struct v4l2_standard));
 176         vs->index = index;
 177         vs->id    = id;
 178         if (id & V4L2_STD_525_60) {
 179                 vs->frameperiod.numerator = 1001;
 180                 vs->frameperiod.denominator = 30000;
 181                 vs->framelines = 525;
 182         } else {
 183                 vs->frameperiod.numerator = 1;
 184                 vs->frameperiod.denominator = 25;
 185                 vs->framelines = 625;
 186         }
 187         strlcpy(vs->name,name,sizeof(vs->name));
 188         return 0;
 189 }
 190
 191 /* ----------------------------------------------------------------- */
 192 /* priority handling                                                 */
 193
 194 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND   || \
 195                               val == V4L2_PRIORITY_INTERACTIVE  || \
 196                               val == V4L2_PRIORITY_RECORD)
 197
 198 int v4l2_prio_init(struct v4l2_prio_state *global)
 199 {
 200         memset(global,0,sizeof(*global));
 201         return 0;
 202 }
 203
 204 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
 205                      enum v4l2_priority new)
 206 {
 207         if (!V4L2_PRIO_VALID(new))
 208                 return -EINVAL;
 209         if (*local == new)
 210                 return 0;
 211
 212         atomic_inc(&global->prios[new]);
 213         if (V4L2_PRIO_VALID(*local))
 214                 atomic_dec(&global->prios[*local]);
 215         *local = new;
 216         return 0;
 217 }
 218
 219 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 220 {
 221         return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
 222 }
 223
 224 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
 225 {
 226         if (V4L2_PRIO_VALID(*local))
 227                 atomic_dec(&global->prios[*local]);
 228         return 0;
 229 }
 230
 231 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
 232 {
 233         if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
 234                 return V4L2_PRIORITY_RECORD;
 235         if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
 236                 return V4L2_PRIORITY_INTERACTIVE;
 237         if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
 238                 return V4L2_PRIORITY_BACKGROUND;
 239         return V4L2_PRIORITY_UNSET;
 240 }
 241
 242 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
 243 {
 244         if (*local < v4l2_prio_max(global))
 245                 return -EBUSY;
 246         return 0;
 247 }
 248
 249
 250 /* ----------------------------------------------------------------- */
 251 /* some arrays for pretty-printing debug messages of enum types      */
 252
 253 char *v4l2_field_names[] = {
 254         [V4L2_FIELD_ANY]        = "any",
 255         [V4L2_FIELD_NONE]       = "none",
 256         [V4L2_FIELD_TOP]        = "top",
 257         [V4L2_FIELD_BOTTOM]     = "bottom",
 258         [V4L2_FIELD_INTERLACED] = "interlaced",
 259         [V4L2_FIELD_SEQ_TB]     = "seq-tb",
 260         [V4L2_FIELD_SEQ_BT]     = "seq-bt",
 261         [V4L2_FIELD_ALTERNATE]  = "alternate",
 262 };
 263
 264 char *v4l2_type_names[] = {
 265         [V4L2_BUF_TYPE_VIDEO_CAPTURE]      = "video-cap",
 266         [V4L2_BUF_TYPE_VIDEO_OVERLAY]      = "video-over",
 267         [V4L2_BUF_TYPE_VIDEO_OUTPUT]       = "video-out",
 268         [V4L2_BUF_TYPE_VBI_CAPTURE]        = "vbi-cap",
 269         [V4L2_BUF_TYPE_VBI_OUTPUT]         = "vbi-out",
 270         [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
 271         [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT]  = "slicec-vbi-out",
 272 };
 273
 274 static char *v4l2_memory_names[] = {
 275         [V4L2_MEMORY_MMAP]    = "mmap",
 276         [V4L2_MEMORY_USERPTR] = "userptr",
 277         [V4L2_MEMORY_OVERLAY] = "overlay",
 278 };
 279
 280 #define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
 281
 282 /* ------------------------------------------------------------------ */
 283 /* debug help functions                                               */
 284
 285 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 286 static const char *v4l1_ioctls[] = {
 287         [_IOC_NR(VIDIOCGCAP)]       = "VIDIOCGCAP",
 288         [_IOC_NR(VIDIOCGCHAN)]      = "VIDIOCGCHAN",
 289         [_IOC_NR(VIDIOCSCHAN)]      = "VIDIOCSCHAN",
 290         [_IOC_NR(VIDIOCGTUNER)]     = "VIDIOCGTUNER",
 291         [_IOC_NR(VIDIOCSTUNER)]     = "VIDIOCSTUNER",
 292         [_IOC_NR(VIDIOCGPICT)]      = "VIDIOCGPICT",
 293         [_IOC_NR(VIDIOCSPICT)]      = "VIDIOCSPICT",
 294         [_IOC_NR(VIDIOCCAPTURE)]    = "VIDIOCCAPTURE",
 295         [_IOC_NR(VIDIOCGWIN)]       = "VIDIOCGWIN",
 296         [_IOC_NR(VIDIOCSWIN)]       = "VIDIOCSWIN",
 297         [_IOC_NR(VIDIOCGFBUF)]      = "VIDIOCGFBUF",
 298         [_IOC_NR(VIDIOCSFBUF)]      = "VIDIOCSFBUF",
 299         [_IOC_NR(VIDIOCKEY)]        = "VIDIOCKEY",
 300         [_IOC_NR(VIDIOCGFREQ)]      = "VIDIOCGFREQ",
 301         [_IOC_NR(VIDIOCSFREQ)]      = "VIDIOCSFREQ",
 302         [_IOC_NR(VIDIOCGAUDIO)]     = "VIDIOCGAUDIO",
 303         [_IOC_NR(VIDIOCSAUDIO)]     = "VIDIOCSAUDIO",
 304         [_IOC_NR(VIDIOCSYNC)]       = "VIDIOCSYNC",
 305         [_IOC_NR(VIDIOCMCAPTURE)]   = "VIDIOCMCAPTURE",
 306         [_IOC_NR(VIDIOCGMBUF)]      = "VIDIOCGMBUF",
 307         [_IOC_NR(VIDIOCGUNIT)]      = "VIDIOCGUNIT",
 308         [_IOC_NR(VIDIOCGCAPTURE)]   = "VIDIOCGCAPTURE",
 309         [_IOC_NR(VIDIOCSCAPTURE)]   = "VIDIOCSCAPTURE",
 310         [_IOC_NR(VIDIOCSPLAYMODE)]  = "VIDIOCSPLAYMODE",
 311         [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
 312         [_IOC_NR(VIDIOCGPLAYINFO)]  = "VIDIOCGPLAYINFO",
 313         [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
 314         [_IOC_NR(VIDIOCGVBIFMT)]    = "VIDIOCGVBIFMT",
 315         [_IOC_NR(VIDIOCSVBIFMT)]    = "VIDIOCSVBIFMT"
 316 };
 317 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
 318 #endif
 319
 320 static const char *v4l2_ioctls[] = {
 321         [_IOC_NR(VIDIOC_QUERYCAP)]         = "VIDIOC_QUERYCAP",
 322         [_IOC_NR(VIDIOC_RESERVED)]         = "VIDIOC_RESERVED",
 323         [_IOC_NR(VIDIOC_ENUM_FMT)]         = "VIDIOC_ENUM_FMT",
 324         [_IOC_NR(VIDIOC_G_FMT)]            = "VIDIOC_G_FMT",
 325         [_IOC_NR(VIDIOC_S_FMT)]            = "VIDIOC_S_FMT",
 326         [_IOC_NR(VIDIOC_G_MPEGCOMP)]       = "VIDIOC_G_MPEGCOMP",
 327         [_IOC_NR(VIDIOC_S_MPEGCOMP)]       = "VIDIOC_S_MPEGCOMP",
 328         [_IOC_NR(VIDIOC_REQBUFS)]          = "VIDIOC_REQBUFS",
 329         [_IOC_NR(VIDIOC_QUERYBUF)]         = "VIDIOC_QUERYBUF",
 330         [_IOC_NR(VIDIOC_G_FBUF)]           = "VIDIOC_G_FBUF",
 331         [_IOC_NR(VIDIOC_S_FBUF)]           = "VIDIOC_S_FBUF",
 332         [_IOC_NR(VIDIOC_OVERLAY)]          = "VIDIOC_OVERLAY",
 333         [_IOC_NR(VIDIOC_QBUF)]             = "VIDIOC_QBUF",
 334         [_IOC_NR(VIDIOC_DQBUF)]            = "VIDIOC_DQBUF",
 335         [_IOC_NR(VIDIOC_STREAMON)]         = "VIDIOC_STREAMON",
 336         [_IOC_NR(VIDIOC_STREAMOFF)]        = "VIDIOC_STREAMOFF",
 337         [_IOC_NR(VIDIOC_G_PARM)]           = "VIDIOC_G_PARM",
 338         [_IOC_NR(VIDIOC_S_PARM)]           = "VIDIOC_S_PARM",
 339         [_IOC_NR(VIDIOC_G_STD)]            = "VIDIOC_G_STD",
 340         [_IOC_NR(VIDIOC_S_STD)]            = "VIDIOC_S_STD",
 341         [_IOC_NR(VIDIOC_ENUMSTD)]          = "VIDIOC_ENUMSTD",
 342         [_IOC_NR(VIDIOC_ENUMINPUT)]        = "VIDIOC_ENUMINPUT",
 343         [_IOC_NR(VIDIOC_G_CTRL)]           = "VIDIOC_G_CTRL",
 344         [_IOC_NR(VIDIOC_S_CTRL)]           = "VIDIOC_S_CTRL",
 345         [_IOC_NR(VIDIOC_G_TUNER)]          = "VIDIOC_G_TUNER",
 346         [_IOC_NR(VIDIOC_S_TUNER)]          = "VIDIOC_S_TUNER",
 347         [_IOC_NR(VIDIOC_G_AUDIO)]          = "VIDIOC_G_AUDIO",
 348         [_IOC_NR(VIDIOC_S_AUDIO)]          = "VIDIOC_S_AUDIO",
 349         [_IOC_NR(VIDIOC_QUERYCTRL)]        = "VIDIOC_QUERYCTRL",
 350         [_IOC_NR(VIDIOC_QUERYMENU)]        = "VIDIOC_QUERYMENU",
 351         [_IOC_NR(VIDIOC_G_INPUT)]          = "VIDIOC_G_INPUT",
 352         [_IOC_NR(VIDIOC_S_INPUT)]          = "VIDIOC_S_INPUT",
 353         [_IOC_NR(VIDIOC_G_OUTPUT)]         = "VIDIOC_G_OUTPUT",
 354         [_IOC_NR(VIDIOC_S_OUTPUT)]         = "VIDIOC_S_OUTPUT",
 355         [_IOC_NR(VIDIOC_ENUMOUTPUT)]       = "VIDIOC_ENUMOUTPUT",
 356         [_IOC_NR(VIDIOC_G_AUDOUT)]         = "VIDIOC_G_AUDOUT",
 357         [_IOC_NR(VIDIOC_S_AUDOUT)]         = "VIDIOC_S_AUDOUT",
 358         [_IOC_NR(VIDIOC_G_MODULATOR)]      = "VIDIOC_G_MODULATOR",
 359         [_IOC_NR(VIDIOC_S_MODULATOR)]      = "VIDIOC_S_MODULATOR",
 360         [_IOC_NR(VIDIOC_G_FREQUENCY)]      = "VIDIOC_G_FREQUENCY",
 361         [_IOC_NR(VIDIOC_S_FREQUENCY)]      = "VIDIOC_S_FREQUENCY",
 362         [_IOC_NR(VIDIOC_CROPCAP)]          = "VIDIOC_CROPCAP",
 363         [_IOC_NR(VIDIOC_G_CROP)]           = "VIDIOC_G_CROP",
 364         [_IOC_NR(VIDIOC_S_CROP)]           = "VIDIOC_S_CROP",
 365         [_IOC_NR(VIDIOC_G_JPEGCOMP)]       = "VIDIOC_G_JPEGCOMP",
 366         [_IOC_NR(VIDIOC_S_JPEGCOMP)]       = "VIDIOC_S_JPEGCOMP",
 367         [_IOC_NR(VIDIOC_QUERYSTD)]         = "VIDIOC_QUERYSTD",
 368         [_IOC_NR(VIDIOC_TRY_FMT)]          = "VIDIOC_TRY_FMT",
 369         [_IOC_NR(VIDIOC_ENUMAUDIO)]        = "VIDIOC_ENUMAUDIO",
 370         [_IOC_NR(VIDIOC_ENUMAUDOUT)]       = "VIDIOC_ENUMAUDOUT",
 371         [_IOC_NR(VIDIOC_G_PRIORITY)]       = "VIDIOC_G_PRIORITY",
 372         [_IOC_NR(VIDIOC_S_PRIORITY)]       = "VIDIOC_S_PRIORITY",
 373 #if 1
 374         [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
 375 #endif
 376         [_IOC_NR(VIDIOC_LOG_STATUS)]       = "VIDIOC_LOG_STATUS",
 377         [_IOC_NR(VIDIOC_G_EXT_CTRLS)]      = "VIDIOC_G_EXT_CTRLS",
 378         [_IOC_NR(VIDIOC_S_EXT_CTRLS)]      = "VIDIOC_S_EXT_CTRLS",
 379         [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)]    = "VIDIOC_TRY_EXT_CTRLS"
 380 };
 381 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 382
 383 static const char *v4l2_int_ioctls[] = {
 384 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 385         [_IOC_NR(DECODER_GET_CAPABILITIES)]    = "DECODER_GET_CAPABILITIES",
 386         [_IOC_NR(DECODER_GET_STATUS)]          = "DECODER_GET_STATUS",
 387         [_IOC_NR(DECODER_SET_NORM)]            = "DECODER_SET_NORM",
 388         [_IOC_NR(DECODER_SET_INPUT)]           = "DECODER_SET_INPUT",
 389         [_IOC_NR(DECODER_SET_OUTPUT)]          = "DECODER_SET_OUTPUT",
 390         [_IOC_NR(DECODER_ENABLE_OUTPUT)]       = "DECODER_ENABLE_OUTPUT",
 391         [_IOC_NR(DECODER_SET_PICTURE)]         = "DECODER_SET_PICTURE",
 392         [_IOC_NR(DECODER_SET_GPIO)]            = "DECODER_SET_GPIO",
 393         [_IOC_NR(DECODER_INIT)]                = "DECODER_INIT",
 394         [_IOC_NR(DECODER_SET_VBI_BYPASS)]      = "DECODER_SET_VBI_BYPASS",
 395         [_IOC_NR(DECODER_DUMP)]                = "DECODER_DUMP",
 396 #endif
 397         [_IOC_NR(AUDC_SET_RADIO)]              = "AUDC_SET_RADIO",
 398
 399         [_IOC_NR(TUNER_SET_TYPE_ADDR)]         = "TUNER_SET_TYPE_ADDR",
 400         [_IOC_NR(TUNER_SET_STANDBY)]           = "TUNER_SET_STANDBY",
 401         [_IOC_NR(TDA9887_SET_CONFIG)]          = "TDA9887_SET_CONFIG",
 402
 403         [_IOC_NR(VIDIOC_DBG_S_REGISTER)]       = "VIDIOC_DBG_S_REGISTER",
 404         [_IOC_NR(VIDIOC_DBG_G_REGISTER)]       = "VIDIOC_DBG_G_REGISTER",
 405
 406         [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)]     = "VIDIOC_INT_S_TUNER_MODE",
 407         [_IOC_NR(VIDIOC_INT_RESET)]            = "VIDIOC_INT_RESET",
 408         [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
 409         [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)]  = "VIDIOC_INT_DECODE_VBI_LINE",
 410         [_IOC_NR(VIDIOC_INT_S_VBI_DATA)]       = "VIDIOC_INT_S_VBI_DATA",
 411         [_IOC_NR(VIDIOC_INT_G_VBI_DATA)]       = "VIDIOC_INT_G_VBI_DATA",
 412         [_IOC_NR(VIDIOC_INT_G_CHIP_IDENT)]     = "VIDIOC_INT_G_CHIP_IDENT",
 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 };
 421 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
 422
 423 static void v4l_print_pix_fmt (char *s, struct v4l2_pix_format *fmt)
 424 {
 425         printk ("%s: width=%d, height=%d, format=%d, field=%s, "
 426                 "bytesperline=%d sizeimage=%d, colorspace=%d\n", s,
 427                 fmt->width,fmt->height,fmt->pixelformat,
 428                 prt_names(fmt->field,v4l2_field_names),
 429                 fmt->bytesperline,fmt->sizeimage,fmt->colorspace);
 430 };
 431
 432 /* Common ioctl debug function. This function can be used by
 433    external ioctl messages as well as internal V4L ioctl */
 434 void v4l_printk_ioctl(unsigned int cmd)
 435 {
 436         char *dir;
 437
 438         switch (_IOC_DIR(cmd)) {
 439         case _IOC_NONE:              dir = "--"; break;
 440         case _IOC_READ:              dir = "r-"; break;
 441         case _IOC_WRITE:             dir = "-w"; break;
 442         case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
 443         default:                     dir = "*ERR*"; break;
 444         }
 445         switch (_IOC_TYPE(cmd)) {
 446         case 'd':
 447                 printk("v4l2_int ioctl %s, dir=%s (0x%08x)\n",
 448                        (_IOC_NR(cmd) < V4L2_INT_IOCTLS) ?
 449                        v4l2_int_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
 450                 break;
 451 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 452         case 'v':
 453                 printk("v4l1 ioctl %s, dir=%s (0x%08x)\n",
 454                        (_IOC_NR(cmd) < V4L1_IOCTLS) ?
 455                        v4l1_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
 456                 break;
 457 #endif
 458         case 'V':
 459                 printk("v4l2 ioctl %s, dir=%s (0x%08x)\n",
 460                        (_IOC_NR(cmd) < V4L2_IOCTLS) ?
 461                        v4l2_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
 462                 break;
 463
 464         default:
 465                 printk("unknown ioctl '%c', dir=%s, #%d (0x%08x)\n",
 466                        _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
 467         }
 468 }
 469
 470 /* Common ioctl debug function. This function can be used by
 471    external ioctl messages as well as internal V4L ioctl and its
 472    arguments */
 473 void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
 474 {
 475         printk(s);
 476         printk(": ");
 477         v4l_printk_ioctl(cmd);
 478         switch (cmd) {
 479         case VIDIOC_INT_G_CHIP_IDENT:
 480         {
 481                 enum v4l2_chip_ident  *p=arg;
 482                 printk ("%s: chip ident=%d\n", s, *p);
 483                 break;
 484         }
 485         case VIDIOC_G_PRIORITY:
 486         case VIDIOC_S_PRIORITY:
 487         {
 488                 enum v4l2_priority *p=arg;
 489                 printk ("%s: priority=%d\n", s, *p);
 490                 break;
 491         }
 492         case VIDIOC_INT_S_TUNER_MODE:
 493         {
 494                 enum v4l2_tuner_type *p=arg;
 495                 printk ("%s: tuner type=%d\n", s, *p);
 496                 break;
 497         }
 498 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 499         case DECODER_SET_VBI_BYPASS:
 500         case DECODER_ENABLE_OUTPUT:
 501         case DECODER_GET_STATUS:
 502         case DECODER_SET_OUTPUT:
 503         case DECODER_SET_INPUT:
 504         case DECODER_SET_GPIO:
 505         case DECODER_SET_NORM:
 506         case VIDIOCCAPTURE:
 507         case VIDIOCSYNC:
 508         case VIDIOCSWRITEMODE:
 509 #endif
 510         case TUNER_SET_TYPE_ADDR:
 511         case TUNER_SET_STANDBY:
 512         case TDA9887_SET_CONFIG:
 513 #ifdef __OLD_VIDIOC_
 514         case VIDIOC_OVERLAY_OLD:
 515 #endif
 516         case VIDIOC_STREAMOFF:
 517         case VIDIOC_G_OUTPUT:
 518         case VIDIOC_S_OUTPUT:
 519         case VIDIOC_STREAMON:
 520         case VIDIOC_G_INPUT:
 521         case VIDIOC_OVERLAY:
 522         case VIDIOC_S_INPUT:
 523         {
 524                 int *p=arg;
 525                 printk ("%s: value=%d\n", s, *p);
 526                 break;
 527         }
 528         case VIDIOC_G_AUDIO:
 529         case VIDIOC_S_AUDIO:
 530         case VIDIOC_ENUMAUDIO:
 531 #ifdef __OLD_VIDIOC_
 532         case VIDIOC_G_AUDIO_OLD:
 533 #endif
 534         {
 535                 struct v4l2_audio *p=arg;
 536
 537                 printk ("%s: index=%d, name=%s, capability=%d, mode=%d\n",
 538                         s,p->index, p->name,p->capability, p->mode);
 539                 break;
 540         }
 541         case VIDIOC_G_AUDOUT:
 542         case VIDIOC_S_AUDOUT:
 543         case VIDIOC_ENUMAUDOUT:
 544 #ifdef __OLD_VIDIOC_
 545         case VIDIOC_G_AUDOUT_OLD:
 546 #endif
 547         {
 548                 struct v4l2_audioout *p=arg;
 549                 printk ("%s: index=%d, name=%s, capability=%d, mode=%d\n", s,
 550                                 p->index, p->name, p->capability,p->mode);
 551                 break;
 552         }
 553         case VIDIOC_QBUF:
 554         case VIDIOC_DQBUF:
 555         case VIDIOC_QUERYBUF:
 556         {
 557                 struct v4l2_buffer *p=arg;
 558                 struct v4l2_timecode *tc=&p->timecode;
 559                 printk ("%s: %02ld:%02d:%02d.%08ld index=%d, type=%s, "
 560                         "bytesused=%d, flags=0x%08x, "
 561                         "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx\n",
 562                                 s,
 563                                 (p->timestamp.tv_sec/3600),
 564                                 (int)(p->timestamp.tv_sec/60)%60,
 565                                 (int)(p->timestamp.tv_sec%60),
 566                                 p->timestamp.tv_usec,
 567                                 p->index,
 568                                 prt_names(p->type,v4l2_type_names),
 569                                 p->bytesused,p->flags,
 570                                 p->field,p->sequence,
 571                                 prt_names(p->memory,v4l2_memory_names),
 572                                 p->m.userptr);
 573                 printk ("%s: timecode= %02d:%02d:%02d type=%d, "
 574                         "flags=0x%08x, frames=%d, userbits=0x%08x\n",
 575                                 s,tc->hours,tc->minutes,tc->seconds,
 576                                 tc->type, tc->flags, tc->frames, *(__u32 *) tc->userbits);
 577                 break;
 578         }
 579         case VIDIOC_QUERYCAP:
 580         {
 581                 struct v4l2_capability *p=arg;
 582                 printk ("%s: driver=%s, card=%s, bus=%s, version=0x%08x, "
 583                         "capabilities=0x%08x\n", s,
 584                                 p->driver,p->card,p->bus_info,
 585                                 p->version,
 586                                 p->capabilities);
 587                 break;
 588         }
 589         case VIDIOC_G_CTRL:
 590         case VIDIOC_S_CTRL:
 591 #ifdef __OLD_VIDIOC_
 592         case VIDIOC_S_CTRL_OLD:
 593 #endif
 594         {
 595                 struct v4l2_control *p=arg;
 596                 printk ("%s: id=%d, value=%d\n", s, p->id, p->value);
 597                 break;
 598         }
 599         case VIDIOC_G_EXT_CTRLS:
 600         case VIDIOC_S_EXT_CTRLS:
 601         case VIDIOC_TRY_EXT_CTRLS:
 602         {
 603                 struct v4l2_ext_controls *p = arg;
 604                 int i;
 605
 606                 printk("%s: ctrl_class=%d, count=%d\n", s, p->ctrl_class, p->count);
 607                 for (i = 0; i < p->count; i++) {
 608                         struct v4l2_ext_control *c = &p->controls[i];
 609                         if (cmd == VIDIOC_G_EXT_CTRLS)
 610                                 printk("%s: id=%d\n", s, c->id);
 611                         else
 612                                 printk("%s: id=%d, value=%d\n", s, c->id, c->value);
 613                 }
 614                 break;
 615         }
 616         case VIDIOC_G_CROP:
 617         case VIDIOC_S_CROP:
 618         {
 619                 struct v4l2_crop *p=arg;
 620                 /*FIXME: Should also show rect structs */
 621                 printk ("%s: type=%d\n", s, p->type);
 622                 break;
 623         }
 624         case VIDIOC_CROPCAP:
 625 #ifdef __OLD_VIDIOC_
 626         case VIDIOC_CROPCAP_OLD:
 627 #endif
 628         {
 629                 struct v4l2_cropcap *p=arg;
 630                 /*FIXME: Should also show rect structs */
 631                 printk ("%s: type=%d\n", s, p->type);
 632                 break;
 633         }
 634         case VIDIOC_INT_DECODE_VBI_LINE:
 635         {
 636                 struct v4l2_decode_vbi_line *p=arg;
 637                 printk ("%s: is_second_field=%d, ptr=0x%08lx, line=%d, "
 638                         "type=%d\n", s,
 639                                 p->is_second_field,(unsigned long)p->p,p->line,p->type);
 640                 break;
 641         }
 642         case VIDIOC_ENUM_FMT:
 643         {
 644                 struct v4l2_fmtdesc *p=arg;
 645                 printk ("%s: index=%d, type=%d, flags=%d, description=%s,"
 646                         " pixelformat=%d\n", s,
 647                                 p->index, p->type, p->flags,p->description,
 648                                 p->pixelformat);
 649
 650                 break;
 651         }
 652         case VIDIOC_G_FMT:
 653         case VIDIOC_S_FMT:
 654         case VIDIOC_TRY_FMT:
 655         {
 656                 struct v4l2_format *p=arg;
 657                 printk ("%s: type=%s\n", s,
 658                                 prt_names(p->type,v4l2_type_names));
 659                 switch (p->type) {
 660                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 661                         v4l_print_pix_fmt (s, &p->fmt.pix);
 662                         break;
 663                 default:
 664                         break;
 665                 }
 666         }
 667         case VIDIOC_G_FBUF:
 668         case VIDIOC_S_FBUF:
 669         {
 670                 struct v4l2_framebuffer *p=arg;
 671                 printk ("%s: capability=%d, flags=%d, base=0x%08lx\n", s,
 672                                 p->capability,p->flags, (unsigned long)p->base);
 673                 v4l_print_pix_fmt (s, &p->fmt);
 674                 break;
 675         }
 676         case VIDIOC_G_FREQUENCY:
 677         case VIDIOC_S_FREQUENCY:
 678         {
 679                 struct v4l2_frequency *p=arg;
 680                 printk ("%s: tuner=%d, type=%d, frequency=%d\n", s,
 681                                 p->tuner,p->type,p->frequency);
 682                 break;
 683         }
 684         case VIDIOC_ENUMINPUT:
 685         {
 686                 struct v4l2_input *p=arg;
 687                 printk ("%s: index=%d, name=%s, type=%d, audioset=%d, "
 688                         "tuner=%d, std=%Ld, status=%d\n", s,
 689                                 p->index,p->name,p->type,p->audioset,
 690                                 p->tuner,
 691                                 (unsigned long long)p->std,
 692                                 p->status);
 693                 break;
 694         }
 695         case VIDIOC_G_JPEGCOMP:
 696         case VIDIOC_S_JPEGCOMP:
 697         {
 698                 struct v4l2_jpegcompression *p=arg;
 699                 printk ("%s: quality=%d, APPn=%d, APP_len=%d, COM_len=%d,"
 700                         " jpeg_markers=%d\n", s,
 701                                 p->quality,p->APPn,p->APP_len,
 702                                 p->COM_len,p->jpeg_markers);
 703                 break;
 704         }
 705         case VIDIOC_G_MODULATOR:
 706         case VIDIOC_S_MODULATOR:
 707         {
 708                 struct v4l2_modulator *p=arg;
 709                 printk ("%s: index=%d, name=%s, capability=%d, rangelow=%d,"
 710                         " rangehigh=%d, txsubchans=%d\n", s,
 711                                 p->index, p->name,p->capability,p->rangelow,
 712                                 p->rangehigh,p->txsubchans);
 713                 break;
 714         }
 715         case VIDIOC_G_MPEGCOMP:
 716         case VIDIOC_S_MPEGCOMP:
 717         {
 718                 struct v4l2_mpeg_compression *p=arg;
 719                 /*FIXME: Several fields not shown */
 720                 printk ("%s: ts_pid_pmt=%d, ts_pid_audio=%d, ts_pid_video=%d, "
 721                         "ts_pid_pcr=%d, ps_size=%d, au_sample_rate=%d, "
 722                         "au_pesid=%c, vi_frame_rate=%d, vi_frames_per_gop=%d, "
 723                         "vi_bframes_count=%d, vi_pesid=%c\n", s,
 724                                 p->ts_pid_pmt,p->ts_pid_audio, p->ts_pid_video,
 725                                 p->ts_pid_pcr, p->ps_size, p->au_sample_rate,
 726                                 p->au_pesid, p->vi_frame_rate,
 727                                 p->vi_frames_per_gop, p->vi_bframes_count,
 728                                 p->vi_pesid);
 729                 break;
 730         }
 731         case VIDIOC_ENUMOUTPUT:
 732         {
 733                 struct v4l2_output *p=arg;
 734                 printk ("%s: index=%d, name=%s,type=%d, audioset=%d, "
 735                         "modulator=%d, std=%Ld\n",
 736                                 s,p->index,p->name,p->type,p->audioset,
 737                                 p->modulator,
 738                                 (unsigned long long)p->std);
 739                 break;
 740         }
 741         case VIDIOC_QUERYCTRL:
 742         {
 743                 struct v4l2_queryctrl *p=arg;
 744                 printk ("%s: id=%d, type=%d, name=%s, min/max=%d/%d,"
 745                         " step=%d, default=%d, flags=0x%08x\n", s,
 746                                 p->id,p->type,p->name,p->minimum,p->maximum,
 747                                 p->step,p->default_value,p->flags);
 748                 break;
 749         }
 750         case VIDIOC_QUERYMENU:
 751         {
 752                 struct v4l2_querymenu *p=arg;
 753                 printk ("%s: id=%d, index=%d, name=%s\n", s,
 754                                 p->id,p->index,p->name);
 755                 break;
 756         }
 757 #ifdef CONFIG_VIDEO_ADV_DEBUG
 758         case VIDIOC_DBG_G_REGISTER:
 759         case VIDIOC_DBG_S_REGISTER:
 760         {
 761                 struct v4l2_register *p=arg;
 762                 printk ("%s: i2c_id=%d, reg=%llu, val=%u\n", s,
 763                                 p->i2c_id,(unsigned long long)p->reg,p->val);
 764
 765                 break;
 766         }
 767 #endif
 768         case VIDIOC_REQBUFS:
 769         {
 770                 struct v4l2_requestbuffers *p=arg;
 771                 printk ("%s: count=%d, type=%s, memory=%s\n", s,
 772                                 p->count,
 773                                 prt_names(p->type,v4l2_type_names),
 774                                 prt_names(p->memory,v4l2_memory_names));
 775                 break;
 776         }
 777         case VIDIOC_INT_S_AUDIO_ROUTING:
 778         case VIDIOC_INT_S_VIDEO_ROUTING:
 779         case VIDIOC_INT_G_AUDIO_ROUTING:
 780         case VIDIOC_INT_G_VIDEO_ROUTING:
 781         {
 782                 struct v4l2_routing  *p=arg;
 783                 printk ("%s: input=0x%x, output=0x%x\n", s, p->input, p->output);
 784                 break;
 785         }
 786         case VIDIOC_INT_S_CRYSTAL_FREQ:
 787         {
 788                 struct v4l2_crystal_freq *p=arg;
 789                 printk ("%s: freq=%u, flags=0x%x\n", s, p->freq, p->flags);
 790                 break;
 791         }
 792         case VIDIOC_G_SLICED_VBI_CAP:
 793         {
 794                 struct v4l2_sliced_vbi_cap *p=arg;
 795                 printk ("%s: service_set=%d\n", s,
 796                                 p->service_set);
 797                 break;
 798         }
 799         case VIDIOC_INT_S_VBI_DATA:
 800         case VIDIOC_INT_G_VBI_DATA:
 801         {
 802                 struct v4l2_sliced_vbi_data  *p=arg;
 803                 printk ("%s: id=%d, field=%d, line=%d\n", s,
 804                                 p->id, p->field, p->line);
 805                 break;
 806         }
 807         case VIDIOC_ENUMSTD:
 808         {
 809                 struct v4l2_standard *p=arg;
 810                 printk ("%s: index=%d, id=%Ld, name=%s, fps=%d/%d, "
 811                         "framelines=%d\n", s, p->index,
 812                                 (unsigned long long)p->id, p->name,
 813                                 p->frameperiod.numerator,
 814                                 p->frameperiod.denominator,
 815                                 p->framelines);
 816
 817                 break;
 818         }
 819         case VIDIOC_G_PARM:
 820         case VIDIOC_S_PARM:
 821 #ifdef __OLD_VIDIOC_
 822         case VIDIOC_S_PARM_OLD:
 823 #endif
 824         {
 825                 struct v4l2_streamparm *p=arg;
 826                 printk ("%s: type=%d\n", s, p->type);
 827
 828                 break;
 829         }
 830         case VIDIOC_G_TUNER:
 831         case VIDIOC_S_TUNER:
 832         {
 833                 struct v4l2_tuner *p=arg;
 834                 printk ("%s: index=%d, name=%s, type=%d, capability=%d, "
 835                         "rangelow=%d, rangehigh=%d, signal=%d, afc=%d, "
 836                         "rxsubchans=%d, audmode=%d\n", s,
 837                                 p->index, p->name, p->type,
 838                                 p->capability, p->rangelow,p->rangehigh,
 839                                 p->rxsubchans, p->audmode, p->signal,
 840                                 p->afc);
 841                 break;
 842         }
 843 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 844         case VIDIOCGVBIFMT:
 845         case VIDIOCSVBIFMT:
 846         {
 847                 struct vbi_format *p=arg;
 848                 printk ("%s: sampling_rate=%d, samples_per_line=%d, "
 849                         "sample_format=%d, start=%d/%d, count=%d/%d, flags=%d\n", s,
 850                                 p->sampling_rate,p->samples_per_line,
 851                                 p->sample_format,p->start[0],p->start[1],
 852                                 p->count[0],p->count[1],p->flags);
 853                 break;
 854         }
 855         case VIDIOCGAUDIO:
 856         case VIDIOCSAUDIO:
 857         {
 858                 struct video_audio *p=arg;
 859                 printk ("%s: audio=%d, volume=%d, bass=%d, treble=%d, "
 860                         "flags=%d, name=%s, mode=%d, balance=%d, step=%d\n",
 861                                 s,p->audio,p->volume,p->bass, p->treble,
 862                                 p->flags,p->name,p->mode,p->balance,p->step);
 863                 break;
 864         }
 865         case VIDIOCGFBUF:
 866         case VIDIOCSFBUF:
 867         {
 868                 struct video_buffer *p=arg;
 869                 printk ("%s: base=%08lx, height=%d, width=%d, depth=%d, "
 870                         "bytesperline=%d\n", s,
 871                                 (unsigned long) p->base, p->height, p->width,
 872                                 p->depth,p->bytesperline);
 873                 break;
 874         }
 875         case VIDIOCGCAP:
 876         {
 877                 struct video_capability *p=arg;
 878                 printk ("%s: name=%s, type=%d, channels=%d, audios=%d, "
 879                         "maxwidth=%d, maxheight=%d, minwidth=%d, minheight=%d\n",
 880                                 s,p->name,p->type,p->channels,p->audios,
 881                                 p->maxwidth,p->maxheight,p->minwidth,
 882                                 p->minheight);
 883
 884                 break;
 885         }
 886         case VIDIOCGCAPTURE:
 887         case VIDIOCSCAPTURE:
 888         {
 889                 struct video_capture *p=arg;
 890                 printk ("%s: x=%d, y=%d, width=%d, height=%d, decimation=%d,"
 891                         " flags=%d\n", s,
 892                                 p->x, p->y,p->width, p->height,
 893                                 p->decimation,p->flags);
 894                 break;
 895         }
 896         case VIDIOCGCHAN:
 897         case VIDIOCSCHAN:
 898         {
 899                 struct video_channel *p=arg;
 900                 printk ("%s: channel=%d, name=%s, tuners=%d, flags=%d, "
 901                         "type=%d, norm=%d\n", s,
 902                                 p->channel,p->name,p->tuners,
 903                                 p->flags,p->type,p->norm);
 904
 905                 break;
 906         }
 907         case VIDIOCSMICROCODE:
 908         {
 909                 struct video_code *p=arg;
 910                 printk ("%s: loadwhat=%s, datasize=%d\n", s,
 911                                 p->loadwhat,p->datasize);
 912                 break;
 913         }
 914         case DECODER_GET_CAPABILITIES:
 915         {
 916                 struct video_decoder_capability *p=arg;
 917                 printk ("%s: flags=%d, inputs=%d, outputs=%d\n", s,
 918                                 p->flags,p->inputs,p->outputs);
 919                 break;
 920         }
 921         case DECODER_INIT:
 922         {
 923                 struct video_decoder_init *p=arg;
 924                 printk ("%s: len=%c\n", s, p->len);
 925                 break;
 926         }
 927         case VIDIOCGPLAYINFO:
 928         {
 929                 struct video_info *p=arg;
 930                 printk ("%s: frame_count=%d, h_size=%d, v_size=%d, "
 931                         "smpte_timecode=%d, picture_type=%d, "
 932                         "temporal_reference=%d, user_data=%s\n", s,
 933                                 p->frame_count, p->h_size,
 934                                 p->v_size, p->smpte_timecode,
 935                                 p->picture_type, p->temporal_reference,
 936                                 p->user_data);
 937                 break;
 938         }
 939         case VIDIOCKEY:
 940         {
 941                 struct video_key *p=arg;
 942                 printk ("%s: key=%s, flags=%d\n", s,
 943                                 p->key, p->flags);
 944                 break;
 945         }
 946         case VIDIOCGMBUF:
 947         {
 948                 struct video_mbuf *p=arg;
 949                 printk ("%s: size=%d, frames=%d, offsets=0x%08lx\n", s,
 950                                 p->size,
 951                                 p->frames,
 952                                 (unsigned long)p->offsets);
 953                 break;
 954         }
 955         case VIDIOCMCAPTURE:
 956         {
 957                 struct video_mmap *p=arg;
 958                 printk ("%s: frame=%d, height=%d, width=%d, format=%d\n", s,
 959                                 p->frame,
 960                                 p->height, p->width,
 961                                 p->format);
 962                 break;
 963         }
 964         case VIDIOCGPICT:
 965         case VIDIOCSPICT:
 966         case DECODER_SET_PICTURE:
 967         {
 968                 struct video_picture *p=arg;
 969
 970                 printk ("%s: brightness=%d, hue=%d, colour=%d, contrast=%d,"
 971                         " whiteness=%d, depth=%d, palette=%d\n", s,
 972                                 p->brightness, p->hue, p->colour,
 973                                 p->contrast, p->whiteness, p->depth,
 974                                 p->palette);
 975                 break;
 976         }
 977         case VIDIOCSPLAYMODE:
 978         {
 979                 struct video_play_mode *p=arg;
 980                 printk ("%s: mode=%d, p1=%d, p2=%d\n", s,
 981                                 p->mode,p->p1,p->p2);
 982                 break;
 983         }
 984         case VIDIOCGTUNER:
 985         case VIDIOCSTUNER:
 986         {
 987                 struct video_tuner *p=arg;
 988                 printk ("%s: tuner=%d, name=%s, rangelow=%ld, rangehigh=%ld, "
 989                         "flags=%d, mode=%d, signal=%d\n", s,
 990                                 p->tuner, p->name,p->rangelow, p->rangehigh,
 991                                 p->flags,p->mode, p->signal);
 992                 break;
 993         }
 994         case VIDIOCGUNIT:
 995         {
 996                 struct video_unit *p=arg;
 997                 printk ("%s: video=%d, vbi=%d, radio=%d, audio=%d, "
 998                         "teletext=%d\n", s,
 999                                 p->video,p->vbi,p->radio,p->audio,p->teletext);
1000                 break;
1001         }
1002         case VIDIOCGWIN:
1003         case VIDIOCSWIN:
1004         {
1005                 struct video_window *p=arg;
1006                 printk ("%s: x=%d, y=%d, width=%d, height=%d, chromakey=%d,"
1007                         " flags=%d, clipcount=%d\n", s,
1008                                 p->x, p->y,p->width, p->height,
1009                                 p->chromakey,p->flags,
1010                                 p->clipcount);
1011                 break;
1012         }
1013         case VIDIOCGFREQ:
1014         case VIDIOCSFREQ:
1015         {
1016                 unsigned long *p=arg;
1017                 printk ("%s: value=%lu\n", s, *p);
1018                 break;
1019         }
1020 #endif
1021         case VIDIOC_INT_AUDIO_CLOCK_FREQ:
1022         case VIDIOC_INT_I2S_CLOCK_FREQ:
1023         case VIDIOC_INT_S_STANDBY:
1024         case VIDIOC_INT_RESET:
1025         {
1026                 u32 *p=arg;
1027
1028                 printk ("%s: value=%d\n", s, *p);
1029                 break;
1030         }
1031         case VIDIOC_G_STD:
1032         case VIDIOC_S_STD:
1033         case VIDIOC_QUERYSTD:
1034         {
1035                 v4l2_std_id *p=arg;
1036
1037                 printk ("%s: value=%Lu\n", s, (unsigned long long)*p);
1038                 break;
1039         }
1040         }
1041 }
1042
1043 /* ----------------------------------------------------------------- */
1044
1045 /* Helper functions for control handling                             */
1046
1047 /* Check for correctness of the ctrl's value based on the data from
1048    struct v4l2_queryctrl and the available menu items. Note that
1049    menu_items may be NULL, in that case it is ignored. */
1050 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
1051                 const char **menu_items)
1052 {
1053         if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
1054                 return -EINVAL;
1055         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1056                 return -EBUSY;
1057         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
1058             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
1059             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1060                 return 0;
1061         if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
1062                 return -ERANGE;
1063         if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
1064                 if (menu_items[ctrl->value] == NULL ||
1065                     menu_items[ctrl->value][0] == '\0')
1066                         return -EINVAL;
1067         }
1068         return 0;
1069 }
1070
1071 /* Returns NULL or a character pointer array containing the menu for
1072    the given control ID. The pointer array ends with a NULL pointer.
1073    An empty string signifies a menu entry that is invalid. This allows
1074    drivers to disable certain options if it is not supported. */
1075 const char **v4l2_ctrl_get_menu(u32 id)
1076 {
1077         static const char *mpeg_audio_sampling_freq[] = {
1078                 "44.1 kHz",
1079                 "48 kHz",
1080                 "32 kHz",
1081                 NULL
1082         };
1083         static const char *mpeg_audio_encoding[] = {
1084                 "Layer I",
1085                 "Layer II",
1086                 "Layer III",
1087                 NULL
1088         };
1089         static const char *mpeg_audio_l1_bitrate[] = {
1090                 "32 kbps",
1091                 "64 kbps",
1092                 "96 kbps",
1093                 "128 kbps",
1094                 "160 kbps",
1095                 "192 kbps",
1096                 "224 kbps",
1097                 "256 kbps",
1098                 "288 kbps",
1099                 "320 kbps",
1100                 "352 kbps",
1101                 "384 kbps",
1102                 "416 kbps",
1103                 "448 kbps",
1104                 NULL
1105         };
1106         static const char *mpeg_audio_l2_bitrate[] = {
1107                 "32 kbps",
1108                 "48 kbps",
1109                 "56 kbps",
1110                 "64 kbps",
1111                 "80 kbps",
1112                 "96 kbps",
1113                 "112 kbps",
1114                 "128 kbps",
1115                 "160 kbps",
1116                 "192 kbps",
1117                 "224 kbps",
1118                 "256 kbps",
1119                 "320 kbps",
1120                 "384 kbps",
1121                 NULL
1122         };
1123         static const char *mpeg_audio_l3_bitrate[] = {
1124                 "32 kbps",
1125                 "40 kbps",
1126                 "48 kbps",
1127                 "56 kbps",
1128                 "64 kbps",
1129                 "80 kbps",
1130                 "96 kbps",
1131                 "112 kbps",
1132                 "128 kbps",
1133                 "160 kbps",
1134                 "192 kbps",
1135                 "224 kbps",
1136                 "256 kbps",
1137                 "320 kbps",
1138                 NULL
1139         };
1140         static const char *mpeg_audio_mode[] = {
1141                 "Stereo",
1142                 "Joint Stereo",
1143                 "Dual",
1144                 "Mono",
1145                 NULL
1146         };
1147         static const char *mpeg_audio_mode_extension[] = {
1148                 "Bound 4",
1149                 "Bound 8",
1150                 "Bound 12",
1151                 "Bound 16",
1152                 NULL
1153         };
1154         static const char *mpeg_audio_emphasis[] = {
1155                 "No Emphasis",
1156                 "50/15 us",
1157                 "CCITT J17",
1158                 NULL
1159         };
1160         static const char *mpeg_audio_crc[] = {
1161                 "No CRC",
1162                 "16-bit CRC",
1163                 NULL
1164         };
1165         static const char *mpeg_video_encoding[] = {
1166                 "MPEG-1",
1167                 "MPEG-2",
1168                 NULL
1169         };
1170         static const char *mpeg_video_aspect[] = {
1171                 "1x1",
1172                 "4x3",
1173                 "16x9",
1174                 "2.21x1",
1175                 NULL
1176         };
1177         static const char *mpeg_video_bitrate_mode[] = {
1178                 "Variable Bitrate",
1179                 "Constant Bitrate",
1180                 NULL
1181         };
1182         static const char *mpeg_stream_type[] = {
1183                 "MPEG-2 Program Stream",
1184                 "MPEG-2 Transport Stream",
1185                 "MPEG-1 System Stream",
1186                 "MPEG-2 DVD-compatible Stream",
1187                 "MPEG-1 VCD-compatible Stream",
1188                 "MPEG-2 SVCD-compatible Stream",
1189                 NULL
1190         };
1191         static const char *mpeg_stream_vbi_fmt[] = {
1192                 "No VBI",
1193                 "Private packet, IVTV format",
1194                 NULL
1195         };
1196
1197         switch (id) {
1198                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1199                         return mpeg_audio_sampling_freq;
1200                 case V4L2_CID_MPEG_AUDIO_ENCODING:
1201                         return mpeg_audio_encoding;
1202                 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1203                         return mpeg_audio_l1_bitrate;
1204                 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1205                         return mpeg_audio_l2_bitrate;
1206                 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1207                         return mpeg_audio_l3_bitrate;
1208                 case V4L2_CID_MPEG_AUDIO_MODE:
1209                         return mpeg_audio_mode;
1210                 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1211                         return mpeg_audio_mode_extension;
1212                 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1213                         return mpeg_audio_emphasis;
1214                 case V4L2_CID_MPEG_AUDIO_CRC:
1215                         return mpeg_audio_crc;
1216                 case V4L2_CID_MPEG_VIDEO_ENCODING:
1217                         return mpeg_video_encoding;
1218                 case V4L2_CID_MPEG_VIDEO_ASPECT:
1219                         return mpeg_video_aspect;
1220                 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1221                         return mpeg_video_bitrate_mode;
1222                 case V4L2_CID_MPEG_STREAM_TYPE:
1223                         return mpeg_stream_type;
1224                 case V4L2_CID_MPEG_STREAM_VBI_FMT:
1225                         return mpeg_stream_vbi_fmt;
1226                 default:
1227                         return NULL;
1228         }
1229 }
1230
1231 /* Fill in a struct v4l2_queryctrl */
1232 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
1233 {
1234         const char *name;
1235
1236         qctrl->flags = 0;
1237         switch (qctrl->id) {
1238         /* USER controls */
1239         case V4L2_CID_USER_CLASS:       name = "User Controls"; break;
1240         case V4L2_CID_AUDIO_VOLUME:     name = "Volume"; break;
1241         case V4L2_CID_AUDIO_MUTE:       name = "Mute"; break;
1242         case V4L2_CID_AUDIO_BALANCE:    name = "Balance"; break;
1243         case V4L2_CID_AUDIO_BASS:       name = "Bass"; break;
1244         case V4L2_CID_AUDIO_TREBLE:     name = "Treble"; break;
1245         case V4L2_CID_AUDIO_LOUDNESS:   name = "Loudness"; break;
1246         case V4L2_CID_BRIGHTNESS:       name = "Brightness"; break;
1247         case V4L2_CID_CONTRAST:         name = "Contrast"; break;
1248         case V4L2_CID_SATURATION:       name = "Saturation"; break;
1249         case V4L2_CID_HUE:              name = "Hue"; break;
1250
1251         /* MPEG controls */
1252         case V4L2_CID_MPEG_CLASS:               name = "MPEG Encoder Controls"; break;
1253         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
1254         case V4L2_CID_MPEG_AUDIO_ENCODING:      name = "Audio Encoding Layer"; break;
1255         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    name = "Audio Layer I Bitrate"; break;
1256         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    name = "Audio Layer II Bitrate"; break;
1257         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    name = "Audio Layer III Bitrate"; break;
1258         case V4L2_CID_MPEG_AUDIO_MODE:          name = "Audio Stereo Mode"; break;
1259         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
1260         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      name = "Audio Emphasis"; break;
1261         case V4L2_CID_MPEG_AUDIO_CRC:           name = "Audio CRC"; break;
1262         case V4L2_CID_MPEG_VIDEO_ENCODING:      name = "Video Encoding"; break;
1263         case V4L2_CID_MPEG_VIDEO_ASPECT:        name = "Video Aspect"; break;
1264         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      name = "Video B Frames"; break;
1265         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      name = "Video GOP Size"; break;
1266         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   name = "Video GOP Closure"; break;
1267         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      name = "Video Pulldown"; break;
1268         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  name = "Video Bitrate Mode"; break;
1269         case V4L2_CID_MPEG_VIDEO_BITRATE:       name = "Video Bitrate"; break;
1270         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  name = "Video Peak Bitrate"; break;
1271         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
1272         case V4L2_CID_MPEG_STREAM_TYPE:         name = "Stream Type"; break;
1273         case V4L2_CID_MPEG_STREAM_PID_PMT:      name = "Stream PMT Program ID"; break;
1274         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    name = "Stream Audio Program ID"; break;
1275         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    name = "Stream Video Program ID"; break;
1276         case V4L2_CID_MPEG_STREAM_PID_PCR:      name = "Stream PCR Program ID"; break;
1277         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
1278         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
1279         case V4L2_CID_MPEG_STREAM_VBI_FMT:      name = "Stream VBI Format"; break;
1280
1281         default:
1282                 return -EINVAL;
1283         }
1284         switch (qctrl->id) {
1285         case V4L2_CID_AUDIO_MUTE:
1286         case V4L2_CID_AUDIO_LOUDNESS:
1287         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1288         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1289                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
1290                 min = 0;
1291                 max = step = 1;
1292                 break;
1293         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1294         case V4L2_CID_MPEG_AUDIO_ENCODING:
1295         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1296         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1297         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1298         case V4L2_CID_MPEG_AUDIO_MODE:
1299         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1300         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1301         case V4L2_CID_MPEG_AUDIO_CRC:
1302         case V4L2_CID_MPEG_VIDEO_ENCODING:
1303         case V4L2_CID_MPEG_VIDEO_ASPECT:
1304         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1305         case V4L2_CID_MPEG_STREAM_TYPE:
1306         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1307                 qctrl->type = V4L2_CTRL_TYPE_MENU;
1308                 step = 1;
1309                 break;
1310         case V4L2_CID_USER_CLASS:
1311         case V4L2_CID_MPEG_CLASS:
1312                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
1313                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1314                 min = max = step = def = 0;
1315                 break;
1316         default:
1317                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
1318                 break;
1319         }
1320         switch (qctrl->id) {
1321         case V4L2_CID_MPEG_AUDIO_ENCODING:
1322         case V4L2_CID_MPEG_AUDIO_MODE:
1323         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1324         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1325         case V4L2_CID_MPEG_STREAM_TYPE:
1326                 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
1327                 break;
1328         case V4L2_CID_AUDIO_VOLUME:
1329         case V4L2_CID_AUDIO_BALANCE:
1330         case V4L2_CID_AUDIO_BASS:
1331         case V4L2_CID_AUDIO_TREBLE:
1332         case V4L2_CID_BRIGHTNESS:
1333         case V4L2_CID_CONTRAST:
1334         case V4L2_CID_SATURATION:
1335         case V4L2_CID_HUE:
1336                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
1337                 break;
1338         }
1339         qctrl->minimum = min;
1340         qctrl->maximum = max;
1341         qctrl->step = step;
1342         qctrl->default_value = def;
1343         qctrl->reserved[0] = qctrl->reserved[1] = 0;
1344         snprintf(qctrl->name, sizeof(qctrl->name), name);
1345         return 0;
1346 }
1347
1348 /* Fill in a struct v4l2_queryctrl with standard values based on
1349    the control ID. */
1350 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
1351 {
1352         switch (qctrl->id) {
1353         /* USER controls */
1354         case V4L2_CID_USER_CLASS:
1355         case V4L2_CID_MPEG_CLASS:
1356                 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
1357         case V4L2_CID_AUDIO_VOLUME:
1358                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
1359         case V4L2_CID_AUDIO_MUTE:
1360         case V4L2_CID_AUDIO_LOUDNESS:
1361                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1362         case V4L2_CID_AUDIO_BALANCE:
1363         case V4L2_CID_AUDIO_BASS:
1364         case V4L2_CID_AUDIO_TREBLE:
1365                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
1366         case V4L2_CID_BRIGHTNESS:
1367                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
1368         case V4L2_CID_CONTRAST:
1369         case V4L2_CID_SATURATION:
1370                 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
1371         case V4L2_CID_HUE:
1372                 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
1373
1374         /* MPEG controls */
1375         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1376                 return v4l2_ctrl_query_fill(qctrl,
1377                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
1378                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
1379                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
1380         case V4L2_CID_MPEG_AUDIO_ENCODING:
1381                 return v4l2_ctrl_query_fill(qctrl,
1382                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
1383                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
1384                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
1385         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1386                 return v4l2_ctrl_query_fill(qctrl,
1387                                 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
1388                                 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
1389                                 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
1390         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1391                 return v4l2_ctrl_query_fill(qctrl,
1392                                 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
1393                                 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
1394                                 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
1395         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1396                 return v4l2_ctrl_query_fill(qctrl,
1397                                 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
1398                                 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
1399                                 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
1400         case V4L2_CID_MPEG_AUDIO_MODE:
1401                 return v4l2_ctrl_query_fill(qctrl,
1402                                 V4L2_MPEG_AUDIO_MODE_STEREO,
1403                                 V4L2_MPEG_AUDIO_MODE_MONO, 1,
1404                                 V4L2_MPEG_AUDIO_MODE_STEREO);
1405         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1406                 return v4l2_ctrl_query_fill(qctrl,
1407                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
1408                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
1409                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
1410         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1411                 return v4l2_ctrl_query_fill(qctrl,
1412                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
1413                                 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
1414                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
1415         case V4L2_CID_MPEG_AUDIO_CRC:
1416                 return v4l2_ctrl_query_fill(qctrl,
1417                                 V4L2_MPEG_AUDIO_CRC_NONE,
1418                                 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
1419                                 V4L2_MPEG_AUDIO_CRC_NONE);
1420         case V4L2_CID_MPEG_VIDEO_ENCODING:
1421                 return v4l2_ctrl_query_fill(qctrl,
1422                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
1423                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
1424                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
1425         case V4L2_CID_MPEG_VIDEO_ASPECT:
1426                 return v4l2_ctrl_query_fill(qctrl,
1427                                 V4L2_MPEG_VIDEO_ASPECT_1x1,
1428                                 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
1429                                 V4L2_MPEG_VIDEO_ASPECT_4x3);
1430         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1431                 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
1432         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1433                 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
1434         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1435                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
1436         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1437                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1438         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1439                 return v4l2_ctrl_query_fill(qctrl,
1440                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
1441                                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
1442                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1443         case V4L2_CID_MPEG_VIDEO_BITRATE:
1444                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
1445         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
1446                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
1447         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
1448                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1449         case V4L2_CID_MPEG_STREAM_TYPE:
1450                 return v4l2_ctrl_query_fill(qctrl,
1451                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
1452                                 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
1453                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1454         case V4L2_CID_MPEG_STREAM_PID_PMT:
1455                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
1456         case V4L2_CID_MPEG_STREAM_PID_AUDIO:
1457                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
1458         case V4L2_CID_MPEG_STREAM_PID_VIDEO:
1459                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
1460         case V4L2_CID_MPEG_STREAM_PID_PCR:
1461                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
1462         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
1463                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1464         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
1465                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1466         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1467                 return v4l2_ctrl_query_fill(qctrl,
1468                                 V4L2_MPEG_STREAM_VBI_FMT_NONE,
1469                                 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
1470                                 V4L2_MPEG_STREAM_VBI_FMT_NONE);
1471         default:
1472                 return -EINVAL;
1473         }
1474 }
1475
1476 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
1477    the menu. The qctrl pointer may be NULL, in which case it is ignored. */
1478 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
1479                const char **menu_items)
1480 {
1481         int i;
1482
1483         if (menu_items == NULL ||
1484             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
1485                 return -EINVAL;
1486         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
1487         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
1488                 return -EINVAL;
1489         snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
1490         qmenu->reserved = 0;
1491         return 0;
1492 }
1493
1494 /* ctrl_classes points to an array of u32 pointers, the last element is
1495    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
1496    Each array must be sorted low to high and belong to the same control
1497    class. The array of u32 pointer must also be sorted, from low class IDs
1498    to high class IDs.
1499
1500    This function returns the first ID that follows after the given ID.
1501    When no more controls are available 0 is returned. */
1502 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
1503 {
1504         u32 ctrl_class;
1505         const u32 *pctrl;
1506
1507         /* if no query is desired, then just return the control ID */
1508         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
1509                 return id;
1510         if (ctrl_classes == NULL)
1511                 return 0;
1512         id &= V4L2_CTRL_ID_MASK;
1513         ctrl_class = V4L2_CTRL_ID2CLASS(id);
1514         id++;   /* select next control */
1515         /* find first class that matches (or is greater than) the class of
1516            the ID */
1517         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
1518                 ctrl_classes++;
1519         /* no more classes */
1520         if (*ctrl_classes == NULL)
1521                 return 0;
1522         pctrl = *ctrl_classes;
1523         /* find first ctrl within the class that is >= ID */
1524         while (*pctrl && *pctrl < id) pctrl++;
1525         if (*pctrl)
1526                 return *pctrl;
1527         /* we are at the end of the controls of the current class. */
1528         /* continue with next class if available */
1529         ctrl_classes++;
1530         if (*ctrl_classes == NULL)
1531                 return 0;
1532         return **ctrl_classes;
1533 }
1534
1535 /* ----------------------------------------------------------------- */
1536
1537 EXPORT_SYMBOL(v4l2_norm_to_name);
1538 EXPORT_SYMBOL(v4l2_video_std_construct);
1539
1540 EXPORT_SYMBOL(v4l2_prio_init);
1541 EXPORT_SYMBOL(v4l2_prio_change);
1542 EXPORT_SYMBOL(v4l2_prio_open);
1543 EXPORT_SYMBOL(v4l2_prio_close);
1544 EXPORT_SYMBOL(v4l2_prio_max);
1545 EXPORT_SYMBOL(v4l2_prio_check);
1546
1547 EXPORT_SYMBOL(v4l2_field_names);
1548 EXPORT_SYMBOL(v4l2_type_names);
1549 EXPORT_SYMBOL(v4l_printk_ioctl);
1550 EXPORT_SYMBOL(v4l_printk_ioctl_arg);
1551
1552 EXPORT_SYMBOL(v4l2_ctrl_next);
1553 EXPORT_SYMBOL(v4l2_ctrl_check);
1554 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
1555 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
1556 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
1557 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
1558
1559 /*
1560  * Local variables:
1561  * c-basic-offset: 8
1562  * End:
1563  */