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

   1 /*
   2  *      Video for Linux Two
   3  *
   4  *      A generic video device interface for the LINUX operating system
   5  *      using a set of device structures/vectors for low level operations.
   6  *
   7  *      This file replaces the videodev.c file that comes with the
   8  *      regular kernel distribution.
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  *
  15  * Author:      Bill Dirks <bdirks@pacbell.net>
  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/sched.h>
  51 #include <linux/smp_lock.h>
  52 #include <linux/mm.h>
  53 #include <linux/string.h>
  54 #include <linux/errno.h>
  55 #include <asm/uaccess.h>
  56 #include <asm/system.h>
  57 #include <asm/pgtable.h>
  58 #include <asm/io.h>
  59 #include <asm/div64.h>
  60 #include <linux/video_decoder.h>
  61 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
  62 #include <media/v4l2-common.h>
  63
  64 #ifdef CONFIG_KMOD
  65 #include <linux/kmod.h>
  66 #endif
  67
  68 #if defined(CONFIG_UST) || defined(CONFIG_UST_MODULE)
  69 #include <linux/ust.h>
  70 #endif
  71
  72
  73 #include <linux/videodev.h>
  74
  75 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
  76 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
  77 MODULE_LICENSE("GPL");
  78
  79 /*
  80  *
  81  *      V 4 L 2   D R I V E R   H E L P E R   A P I
  82  *
  83  */
  84
  85 /*
  86  *  Video Standard Operations (contributed by Michael Schimek)
  87  */
  88
  89
  90 char *v4l2_norm_to_name(v4l2_std_id id)
  91 {
  92         char *name;
  93         u32 myid = id;
  94
  95         /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
  96            64 bit comparations. So, on that architecture, with some gcc variants,
  97            compilation fails. Currently, the max value is 30bit wide.
  98          */
  99         BUG_ON(myid != id);
 100
 101         switch (myid) {
 102         case V4L2_STD_PAL:
 103                 name="PAL";             break;
 104         case V4L2_STD_PAL_BG:
 105                 name="PAL-BG";          break;
 106         case V4L2_STD_PAL_DK:
 107                 name="PAL-DK";          break;
 108         case V4L2_STD_PAL_B:
 109                 name="PAL-B";           break;
 110         case V4L2_STD_PAL_B1:
 111                 name="PAL-B1";          break;
 112         case V4L2_STD_PAL_G:
 113                 name="PAL-G";           break;
 114         case V4L2_STD_PAL_H:
 115                 name="PAL-H";           break;
 116         case V4L2_STD_PAL_I:
 117                 name="PAL-I";           break;
 118         case V4L2_STD_PAL_D:
 119                 name="PAL-D";           break;
 120         case V4L2_STD_PAL_D1:
 121                 name="PAL-D1";          break;
 122         case V4L2_STD_PAL_K:
 123                 name="PAL-K";           break;
 124         case V4L2_STD_PAL_M:
 125                 name="PAL-M";           break;
 126         case V4L2_STD_PAL_N:
 127                 name="PAL-N";           break;
 128         case V4L2_STD_PAL_Nc:
 129                 name="PAL-Nc";          break;
 130         case V4L2_STD_PAL_60:
 131                 name="PAL-60";          break;
 132         case V4L2_STD_NTSC:
 133                 name="NTSC";            break;
 134         case V4L2_STD_NTSC_M:
 135                 name="NTSC-M";          break;
 136         case V4L2_STD_NTSC_M_JP:
 137                 name="NTSC-M-JP";       break;
 138         case V4L2_STD_NTSC_443:
 139                 name="NTSC-443";        break;
 140         case V4L2_STD_NTSC_M_KR:
 141                 name="NTSC-M-KR";       break;
 142         case V4L2_STD_SECAM:
 143                 name="SECAM";           break;
 144         case V4L2_STD_SECAM_DK:
 145                 name="SECAM-DK";        break;
 146         case V4L2_STD_SECAM_B:
 147                 name="SECAM-B";         break;
 148         case V4L2_STD_SECAM_D:
 149                 name="SECAM-D";         break;
 150         case V4L2_STD_SECAM_G:
 151                 name="SECAM-G";         break;
 152         case V4L2_STD_SECAM_H:
 153                 name="SECAM-H";         break;
 154         case V4L2_STD_SECAM_K:
 155                 name="SECAM-K";         break;
 156         case V4L2_STD_SECAM_K1:
 157                 name="SECAM-K1";        break;
 158         case V4L2_STD_SECAM_L:
 159                 name="SECAM-L";         break;
 160         case V4L2_STD_SECAM_LC:
 161                 name="SECAM-LC";        break;
 162         default:
 163                 name="Unknown";         break;
 164         }
 165
 166         return name;
 167 }
 168
 169 /* Fill in the fields of a v4l2_standard structure according to the
 170    'id' and 'transmission' parameters.  Returns negative on error.  */
 171 int v4l2_video_std_construct(struct v4l2_standard *vs,
 172                              int id, char *name)
 173 {
 174         u32 index = vs->index;
 175
 176         memset(vs, 0, sizeof(struct v4l2_standard));
 177         vs->index = index;
 178         vs->id    = id;
 179         if (id & V4L2_STD_525_60) {
 180                 vs->frameperiod.numerator = 1001;
 181                 vs->frameperiod.denominator = 30000;
 182                 vs->framelines = 525;
 183         } else {
 184                 vs->frameperiod.numerator = 1;
 185                 vs->frameperiod.denominator = 25;
 186                 vs->framelines = 625;
 187         }
 188         strlcpy(vs->name,name,sizeof(vs->name));
 189         return 0;
 190 }
 191
 192 /* ----------------------------------------------------------------- */
 193 /* priority handling                                                 */
 194
 195 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND   || \
 196                               val == V4L2_PRIORITY_INTERACTIVE  || \
 197                               val == V4L2_PRIORITY_RECORD)
 198
 199 int v4l2_prio_init(struct v4l2_prio_state *global)
 200 {
 201         memset(global,0,sizeof(*global));
 202         return 0;
 203 }
 204
 205 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
 206                      enum v4l2_priority new)
 207 {
 208         if (!V4L2_PRIO_VALID(new))
 209                 return -EINVAL;
 210         if (*local == new)
 211                 return 0;
 212
 213         atomic_inc(&global->prios[new]);
 214         if (V4L2_PRIO_VALID(*local))
 215                 atomic_dec(&global->prios[*local]);
 216         *local = new;
 217         return 0;
 218 }
 219
 220 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 221 {
 222         return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
 223 }
 224
 225 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
 226 {
 227         if (V4L2_PRIO_VALID(*local))
 228                 atomic_dec(&global->prios[*local]);
 229         return 0;
 230 }
 231
 232 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
 233 {
 234         if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
 235                 return V4L2_PRIORITY_RECORD;
 236         if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
 237                 return V4L2_PRIORITY_INTERACTIVE;
 238         if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
 239                 return V4L2_PRIORITY_BACKGROUND;
 240         return V4L2_PRIORITY_UNSET;
 241 }
 242
 243 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
 244 {
 245         if (*local < v4l2_prio_max(global))
 246                 return -EBUSY;
 247         return 0;
 248 }
 249
 250
 251 /* ----------------------------------------------------------------- */
 252 /* some arrays for pretty-printing debug messages of enum types      */
 253
 254 char *v4l2_field_names[] = {
 255         [V4L2_FIELD_ANY]        = "any",
 256         [V4L2_FIELD_NONE]       = "none",
 257         [V4L2_FIELD_TOP]        = "top",
 258         [V4L2_FIELD_BOTTOM]     = "bottom",
 259         [V4L2_FIELD_INTERLACED] = "interlaced",
 260         [V4L2_FIELD_SEQ_TB]     = "seq-tb",
 261         [V4L2_FIELD_SEQ_BT]     = "seq-bt",
 262         [V4L2_FIELD_ALTERNATE]  = "alternate",
 263 };
 264
 265 char *v4l2_type_names[] = {
 266         [V4L2_BUF_TYPE_VIDEO_CAPTURE]      = "video-cap",
 267         [V4L2_BUF_TYPE_VIDEO_OVERLAY]      = "video-over",
 268         [V4L2_BUF_TYPE_VIDEO_OUTPUT]       = "video-out",
 269         [V4L2_BUF_TYPE_VBI_CAPTURE]        = "vbi-cap",
 270         [V4L2_BUF_TYPE_VBI_OUTPUT]         = "vbi-out",
 271         [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
 272         [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT]  = "slicec-vbi-out",
 273 };
 274
 275 static char *v4l2_memory_names[] = {
 276         [V4L2_MEMORY_MMAP]    = "mmap",
 277         [V4L2_MEMORY_USERPTR] = "userptr",
 278         [V4L2_MEMORY_OVERLAY] = "overlay",
 279 };
 280
 281 #define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
 282
 283 /* ------------------------------------------------------------------ */
 284 /* debug help functions                                               */
 285
 286 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 287 static const char *v4l1_ioctls[] = {
 288         [_IOC_NR(VIDIOCGCAP)]       = "VIDIOCGCAP",
 289         [_IOC_NR(VIDIOCGCHAN)]      = "VIDIOCGCHAN",
 290         [_IOC_NR(VIDIOCSCHAN)]      = "VIDIOCSCHAN",
 291         [_IOC_NR(VIDIOCGTUNER)]     = "VIDIOCGTUNER",
 292         [_IOC_NR(VIDIOCSTUNER)]     = "VIDIOCSTUNER",
 293         [_IOC_NR(VIDIOCGPICT)]      = "VIDIOCGPICT",
 294         [_IOC_NR(VIDIOCSPICT)]      = "VIDIOCSPICT",
 295         [_IOC_NR(VIDIOCCAPTURE)]    = "VIDIOCCAPTURE",
 296         [_IOC_NR(VIDIOCGWIN)]       = "VIDIOCGWIN",
 297         [_IOC_NR(VIDIOCSWIN)]       = "VIDIOCSWIN",
 298         [_IOC_NR(VIDIOCGFBUF)]      = "VIDIOCGFBUF",
 299         [_IOC_NR(VIDIOCSFBUF)]      = "VIDIOCSFBUF",
 300         [_IOC_NR(VIDIOCKEY)]        = "VIDIOCKEY",
 301         [_IOC_NR(VIDIOCGFREQ)]      = "VIDIOCGFREQ",
 302         [_IOC_NR(VIDIOCSFREQ)]      = "VIDIOCSFREQ",
 303         [_IOC_NR(VIDIOCGAUDIO)]     = "VIDIOCGAUDIO",
 304         [_IOC_NR(VIDIOCSAUDIO)]     = "VIDIOCSAUDIO",
 305         [_IOC_NR(VIDIOCSYNC)]       = "VIDIOCSYNC",
 306         [_IOC_NR(VIDIOCMCAPTURE)]   = "VIDIOCMCAPTURE",
 307         [_IOC_NR(VIDIOCGMBUF)]      = "VIDIOCGMBUF",
 308         [_IOC_NR(VIDIOCGUNIT)]      = "VIDIOCGUNIT",
 309         [_IOC_NR(VIDIOCGCAPTURE)]   = "VIDIOCGCAPTURE",
 310         [_IOC_NR(VIDIOCSCAPTURE)]   = "VIDIOCSCAPTURE",
 311         [_IOC_NR(VIDIOCSPLAYMODE)]  = "VIDIOCSPLAYMODE",
 312         [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
 313         [_IOC_NR(VIDIOCGPLAYINFO)]  = "VIDIOCGPLAYINFO",
 314         [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
 315         [_IOC_NR(VIDIOCGVBIFMT)]    = "VIDIOCGVBIFMT",
 316         [_IOC_NR(VIDIOCSVBIFMT)]    = "VIDIOCSVBIFMT"
 317 };
 318 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
 319 #endif
 320
 321 static const char *v4l2_ioctls[] = {
 322         [_IOC_NR(VIDIOC_QUERYCAP)]         = "VIDIOC_QUERYCAP",
 323         [_IOC_NR(VIDIOC_RESERVED)]         = "VIDIOC_RESERVED",
 324         [_IOC_NR(VIDIOC_ENUM_FMT)]         = "VIDIOC_ENUM_FMT",
 325         [_IOC_NR(VIDIOC_G_FMT)]            = "VIDIOC_G_FMT",
 326         [_IOC_NR(VIDIOC_S_FMT)]            = "VIDIOC_S_FMT",
 327         [_IOC_NR(VIDIOC_G_MPEGCOMP)]       = "VIDIOC_G_MPEGCOMP",
 328         [_IOC_NR(VIDIOC_S_MPEGCOMP)]       = "VIDIOC_S_MPEGCOMP",
 329         [_IOC_NR(VIDIOC_REQBUFS)]          = "VIDIOC_REQBUFS",
 330         [_IOC_NR(VIDIOC_QUERYBUF)]         = "VIDIOC_QUERYBUF",
 331         [_IOC_NR(VIDIOC_G_FBUF)]           = "VIDIOC_G_FBUF",
 332         [_IOC_NR(VIDIOC_S_FBUF)]           = "VIDIOC_S_FBUF",
 333         [_IOC_NR(VIDIOC_OVERLAY)]          = "VIDIOC_OVERLAY",
 334         [_IOC_NR(VIDIOC_QBUF)]             = "VIDIOC_QBUF",
 335         [_IOC_NR(VIDIOC_DQBUF)]            = "VIDIOC_DQBUF",
 336         [_IOC_NR(VIDIOC_STREAMON)]         = "VIDIOC_STREAMON",
 337         [_IOC_NR(VIDIOC_STREAMOFF)]        = "VIDIOC_STREAMOFF",
 338         [_IOC_NR(VIDIOC_G_PARM)]           = "VIDIOC_G_PARM",
 339         [_IOC_NR(VIDIOC_S_PARM)]           = "VIDIOC_S_PARM",
 340         [_IOC_NR(VIDIOC_G_STD)]            = "VIDIOC_G_STD",
 341         [_IOC_NR(VIDIOC_S_STD)]            = "VIDIOC_S_STD",
 342         [_IOC_NR(VIDIOC_ENUMSTD)]          = "VIDIOC_ENUMSTD",
 343         [_IOC_NR(VIDIOC_ENUMINPUT)]        = "VIDIOC_ENUMINPUT",
 344         [_IOC_NR(VIDIOC_G_CTRL)]           = "VIDIOC_G_CTRL",
 345         [_IOC_NR(VIDIOC_S_CTRL)]           = "VIDIOC_S_CTRL",
 346         [_IOC_NR(VIDIOC_G_TUNER)]          = "VIDIOC_G_TUNER",
 347         [_IOC_NR(VIDIOC_S_TUNER)]          = "VIDIOC_S_TUNER",
 348         [_IOC_NR(VIDIOC_G_AUDIO)]          = "VIDIOC_G_AUDIO",
 349         [_IOC_NR(VIDIOC_S_AUDIO)]          = "VIDIOC_S_AUDIO",
 350         [_IOC_NR(VIDIOC_QUERYCTRL)]        = "VIDIOC_QUERYCTRL",
 351         [_IOC_NR(VIDIOC_QUERYMENU)]        = "VIDIOC_QUERYMENU",
 352         [_IOC_NR(VIDIOC_G_INPUT)]          = "VIDIOC_G_INPUT",
 353         [_IOC_NR(VIDIOC_S_INPUT)]          = "VIDIOC_S_INPUT",
 354         [_IOC_NR(VIDIOC_G_OUTPUT)]         = "VIDIOC_G_OUTPUT",
 355         [_IOC_NR(VIDIOC_S_OUTPUT)]         = "VIDIOC_S_OUTPUT",
 356         [_IOC_NR(VIDIOC_ENUMOUTPUT)]       = "VIDIOC_ENUMOUTPUT",
 357         [_IOC_NR(VIDIOC_G_AUDOUT)]         = "VIDIOC_G_AUDOUT",
 358         [_IOC_NR(VIDIOC_S_AUDOUT)]         = "VIDIOC_S_AUDOUT",
 359         [_IOC_NR(VIDIOC_G_MODULATOR)]      = "VIDIOC_G_MODULATOR",
 360         [_IOC_NR(VIDIOC_S_MODULATOR)]      = "VIDIOC_S_MODULATOR",
 361         [_IOC_NR(VIDIOC_G_FREQUENCY)]      = "VIDIOC_G_FREQUENCY",
 362         [_IOC_NR(VIDIOC_S_FREQUENCY)]      = "VIDIOC_S_FREQUENCY",
 363         [_IOC_NR(VIDIOC_CROPCAP)]          = "VIDIOC_CROPCAP",
 364         [_IOC_NR(VIDIOC_G_CROP)]           = "VIDIOC_G_CROP",
 365         [_IOC_NR(VIDIOC_S_CROP)]           = "VIDIOC_S_CROP",
 366         [_IOC_NR(VIDIOC_G_JPEGCOMP)]       = "VIDIOC_G_JPEGCOMP",
 367         [_IOC_NR(VIDIOC_S_JPEGCOMP)]       = "VIDIOC_S_JPEGCOMP",
 368         [_IOC_NR(VIDIOC_QUERYSTD)]         = "VIDIOC_QUERYSTD",
 369         [_IOC_NR(VIDIOC_TRY_FMT)]          = "VIDIOC_TRY_FMT",
 370         [_IOC_NR(VIDIOC_ENUMAUDIO)]        = "VIDIOC_ENUMAUDIO",
 371         [_IOC_NR(VIDIOC_ENUMAUDOUT)]       = "VIDIOC_ENUMAUDOUT",
 372         [_IOC_NR(VIDIOC_G_PRIORITY)]       = "VIDIOC_G_PRIORITY",
 373         [_IOC_NR(VIDIOC_S_PRIORITY)]       = "VIDIOC_S_PRIORITY",
 374 #if 1
 375         [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
 376 #endif
 377         [_IOC_NR(VIDIOC_LOG_STATUS)]       = "VIDIOC_LOG_STATUS",
 378         [_IOC_NR(VIDIOC_G_EXT_CTRLS)]      = "VIDIOC_G_EXT_CTRLS",
 379         [_IOC_NR(VIDIOC_S_EXT_CTRLS)]      = "VIDIOC_S_EXT_CTRLS",
 380         [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)]    = "VIDIOC_TRY_EXT_CTRLS"
 381 };
 382 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 383
 384 static const char *v4l2_int_ioctls[] = {
 385 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 386         [_IOC_NR(DECODER_GET_CAPABILITIES)]    = "DECODER_GET_CAPABILITIES",
 387         [_IOC_NR(DECODER_GET_STATUS)]          = "DECODER_GET_STATUS",
 388         [_IOC_NR(DECODER_SET_NORM)]            = "DECODER_SET_NORM",
 389         [_IOC_NR(DECODER_SET_INPUT)]           = "DECODER_SET_INPUT",
 390         [_IOC_NR(DECODER_SET_OUTPUT)]          = "DECODER_SET_OUTPUT",
 391         [_IOC_NR(DECODER_ENABLE_OUTPUT)]       = "DECODER_ENABLE_OUTPUT",
 392         [_IOC_NR(DECODER_SET_PICTURE)]         = "DECODER_SET_PICTURE",
 393         [_IOC_NR(DECODER_SET_GPIO)]            = "DECODER_SET_GPIO",
 394         [_IOC_NR(DECODER_INIT)]                = "DECODER_INIT",
 395         [_IOC_NR(DECODER_SET_VBI_BYPASS)]      = "DECODER_SET_VBI_BYPASS",
 396         [_IOC_NR(DECODER_DUMP)]                = "DECODER_DUMP",
 397 #endif
 398         [_IOC_NR(AUDC_SET_RADIO)]              = "AUDC_SET_RADIO",
 399
 400         [_IOC_NR(TUNER_SET_TYPE_ADDR)]         = "TUNER_SET_TYPE_ADDR",
 401         [_IOC_NR(TUNER_SET_STANDBY)]           = "TUNER_SET_STANDBY",
 402         [_IOC_NR(TDA9887_SET_CONFIG)]          = "TDA9887_SET_CONFIG",
 403
 404         [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)]     = "VIDIOC_INT_S_TUNER_MODE",
 405         [_IOC_NR(VIDIOC_INT_S_REGISTER)]       = "VIDIOC_INT_S_REGISTER",
 406         [_IOC_NR(VIDIOC_INT_G_REGISTER)]       = "VIDIOC_INT_G_REGISTER",
 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         case VIDIOC_INT_G_REGISTER:
 758         case VIDIOC_INT_S_REGISTER:
 759         {
 760                 struct v4l2_register *p=arg;
 761                 printk ("%s: i2c_id=%d, reg=%lu, val=%d\n", s,
 762                                 p->i2c_id,p->reg,p->val);
 763
 764                 break;
 765         }
 766         case VIDIOC_REQBUFS:
 767         {
 768                 struct v4l2_requestbuffers *p=arg;
 769                 printk ("%s: count=%d, type=%s, memory=%s\n", s,
 770                                 p->count,
 771                                 prt_names(p->type,v4l2_type_names),
 772                                 prt_names(p->memory,v4l2_memory_names));
 773                 break;
 774         }
 775         case VIDIOC_INT_S_AUDIO_ROUTING:
 776         case VIDIOC_INT_S_VIDEO_ROUTING:
 777         case VIDIOC_INT_G_AUDIO_ROUTING:
 778         case VIDIOC_INT_G_VIDEO_ROUTING:
 779         {
 780                 struct v4l2_routing  *p=arg;
 781                 printk ("%s: input=0x%x, output=0x%x\n", s, p->input, p->output);
 782                 break;
 783         }
 784         case VIDIOC_INT_S_CRYSTAL_FREQ:
 785         {
 786                 struct v4l2_crystal_freq *p=arg;
 787                 printk ("%s: freq=%u, flags=0x%x\n", s, p->freq, p->flags);
 788                 break;
 789         }
 790         case VIDIOC_G_SLICED_VBI_CAP:
 791         {
 792                 struct v4l2_sliced_vbi_cap *p=arg;
 793                 printk ("%s: service_set=%d\n", s,
 794                                 p->service_set);
 795                 break;
 796         }
 797         case VIDIOC_INT_S_VBI_DATA:
 798         case VIDIOC_INT_G_VBI_DATA:
 799         {
 800                 struct v4l2_sliced_vbi_data  *p=arg;
 801                 printk ("%s: id=%d, field=%d, line=%d\n", s,
 802                                 p->id, p->field, p->line);
 803                 break;
 804         }
 805         case VIDIOC_ENUMSTD:
 806         {
 807                 struct v4l2_standard *p=arg;
 808                 printk ("%s: index=%d, id=%Ld, name=%s, fps=%d/%d, "
 809                         "framelines=%d\n", s, p->index,
 810                                 (unsigned long long)p->id, p->name,
 811                                 p->frameperiod.numerator,
 812                                 p->frameperiod.denominator,
 813                                 p->framelines);
 814
 815                 break;
 816         }
 817         case VIDIOC_G_PARM:
 818         case VIDIOC_S_PARM:
 819 #ifdef __OLD_VIDIOC_
 820         case VIDIOC_S_PARM_OLD:
 821 #endif
 822         {
 823                 struct v4l2_streamparm *p=arg;
 824                 printk ("%s: type=%d\n", s, p->type);
 825
 826                 break;
 827         }
 828         case VIDIOC_G_TUNER:
 829         case VIDIOC_S_TUNER:
 830         {
 831                 struct v4l2_tuner *p=arg;
 832                 printk ("%s: index=%d, name=%s, type=%d, capability=%d, "
 833                         "rangelow=%d, rangehigh=%d, signal=%d, afc=%d, "
 834                         "rxsubchans=%d, audmode=%d\n", s,
 835                                 p->index, p->name, p->type,
 836                                 p->capability, p->rangelow,p->rangehigh,
 837                                 p->rxsubchans, p->audmode, p->signal,
 838                                 p->afc);
 839                 break;
 840         }
 841 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 842         case VIDIOCGVBIFMT:
 843         case VIDIOCSVBIFMT:
 844         {
 845                 struct vbi_format *p=arg;
 846                 printk ("%s: sampling_rate=%d, samples_per_line=%d, "
 847                         "sample_format=%d, start=%d/%d, count=%d/%d, flags=%d\n", s,
 848                                 p->sampling_rate,p->samples_per_line,
 849                                 p->sample_format,p->start[0],p->start[1],
 850                                 p->count[0],p->count[1],p->flags);
 851                 break;
 852         }
 853         case VIDIOCGAUDIO:
 854         case VIDIOCSAUDIO:
 855         {
 856                 struct video_audio *p=arg;
 857                 printk ("%s: audio=%d, volume=%d, bass=%d, treble=%d, "
 858                         "flags=%d, name=%s, mode=%d, balance=%d, step=%d\n",
 859                                 s,p->audio,p->volume,p->bass, p->treble,
 860                                 p->flags,p->name,p->mode,p->balance,p->step);
 861                 break;
 862         }
 863         case VIDIOCGFBUF:
 864         case VIDIOCSFBUF:
 865         {
 866                 struct video_buffer *p=arg;
 867                 printk ("%s: base=%08lx, height=%d, width=%d, depth=%d, "
 868                         "bytesperline=%d\n", s,
 869                                 (unsigned long) p->base, p->height, p->width,
 870                                 p->depth,p->bytesperline);
 871                 break;
 872         }
 873         case VIDIOCGCAP:
 874         {
 875                 struct video_capability *p=arg;
 876                 printk ("%s: name=%s, type=%d, channels=%d, audios=%d, "
 877                         "maxwidth=%d, maxheight=%d, minwidth=%d, minheight=%d\n",
 878                                 s,p->name,p->type,p->channels,p->audios,
 879                                 p->maxwidth,p->maxheight,p->minwidth,
 880                                 p->minheight);
 881
 882                 break;
 883         }
 884         case VIDIOCGCAPTURE:
 885         case VIDIOCSCAPTURE:
 886         {
 887                 struct video_capture *p=arg;
 888                 printk ("%s: x=%d, y=%d, width=%d, height=%d, decimation=%d,"
 889                         " flags=%d\n", s,
 890                                 p->x, p->y,p->width, p->height,
 891                                 p->decimation,p->flags);
 892                 break;
 893         }
 894         case VIDIOCGCHAN:
 895         case VIDIOCSCHAN:
 896         {
 897                 struct video_channel *p=arg;
 898                 printk ("%s: channel=%d, name=%s, tuners=%d, flags=%d, "
 899                         "type=%d, norm=%d\n", s,
 900                                 p->channel,p->name,p->tuners,
 901                                 p->flags,p->type,p->norm);
 902
 903                 break;
 904         }
 905         case VIDIOCSMICROCODE:
 906         {
 907                 struct video_code *p=arg;
 908                 printk ("%s: loadwhat=%s, datasize=%d\n", s,
 909                                 p->loadwhat,p->datasize);
 910                 break;
 911         }
 912         case DECODER_GET_CAPABILITIES:
 913         {
 914                 struct video_decoder_capability *p=arg;
 915                 printk ("%s: flags=%d, inputs=%d, outputs=%d\n", s,
 916                                 p->flags,p->inputs,p->outputs);
 917                 break;
 918         }
 919         case DECODER_INIT:
 920         {
 921                 struct video_decoder_init *p=arg;
 922                 printk ("%s: len=%c\n", s, p->len);
 923                 break;
 924         }
 925         case VIDIOCGPLAYINFO:
 926         {
 927                 struct video_info *p=arg;
 928                 printk ("%s: frame_count=%d, h_size=%d, v_size=%d, "
 929                         "smpte_timecode=%d, picture_type=%d, "
 930                         "temporal_reference=%d, user_data=%s\n", s,
 931                                 p->frame_count, p->h_size,
 932                                 p->v_size, p->smpte_timecode,
 933                                 p->picture_type, p->temporal_reference,
 934                                 p->user_data);
 935                 break;
 936         }
 937         case VIDIOCKEY:
 938         {
 939                 struct video_key *p=arg;
 940                 printk ("%s: key=%s, flags=%d\n", s,
 941                                 p->key, p->flags);
 942                 break;
 943         }
 944         case VIDIOCGMBUF:
 945         {
 946                 struct video_mbuf *p=arg;
 947                 printk ("%s: size=%d, frames=%d, offsets=0x%08lx\n", s,
 948                                 p->size,
 949                                 p->frames,
 950                                 (unsigned long)p->offsets);
 951                 break;
 952         }
 953         case VIDIOCMCAPTURE:
 954         {
 955                 struct video_mmap *p=arg;
 956                 printk ("%s: frame=%d, height=%d, width=%d, format=%d\n", s,
 957                                 p->frame,
 958                                 p->height, p->width,
 959                                 p->format);
 960                 break;
 961         }
 962         case VIDIOCGPICT:
 963         case VIDIOCSPICT:
 964         case DECODER_SET_PICTURE:
 965         {
 966                 struct video_picture *p=arg;
 967
 968                 printk ("%s: brightness=%d, hue=%d, colour=%d, contrast=%d,"
 969                         " whiteness=%d, depth=%d, palette=%d\n", s,
 970                                 p->brightness, p->hue, p->colour,
 971                                 p->contrast, p->whiteness, p->depth,
 972                                 p->palette);
 973                 break;
 974         }
 975         case VIDIOCSPLAYMODE:
 976         {
 977                 struct video_play_mode *p=arg;
 978                 printk ("%s: mode=%d, p1=%d, p2=%d\n", s,
 979                                 p->mode,p->p1,p->p2);
 980                 break;
 981         }
 982         case VIDIOCGTUNER:
 983         case VIDIOCSTUNER:
 984         {
 985                 struct video_tuner *p=arg;
 986                 printk ("%s: tuner=%d, name=%s, rangelow=%ld, rangehigh=%ld, "
 987                         "flags=%d, mode=%d, signal=%d\n", s,
 988                                 p->tuner, p->name,p->rangelow, p->rangehigh,
 989                                 p->flags,p->mode, p->signal);
 990                 break;
 991         }
 992         case VIDIOCGUNIT:
 993         {
 994                 struct video_unit *p=arg;
 995                 printk ("%s: video=%d, vbi=%d, radio=%d, audio=%d, "
 996                         "teletext=%d\n", s,
 997                                 p->video,p->vbi,p->radio,p->audio,p->teletext);
 998                 break;
 999         }
1000         case VIDIOCGWIN:
1001         case VIDIOCSWIN:
1002         {
1003                 struct video_window *p=arg;
1004                 printk ("%s: x=%d, y=%d, width=%d, height=%d, chromakey=%d,"
1005                         " flags=%d, clipcount=%d\n", s,
1006                                 p->x, p->y,p->width, p->height,
1007                                 p->chromakey,p->flags,
1008                                 p->clipcount);
1009                 break;
1010         }
1011         case VIDIOCGFREQ:
1012         case VIDIOCSFREQ:
1013         {
1014                 unsigned long *p=arg;
1015                 printk ("%s: value=%lu\n", s, *p);
1016                 break;
1017         }
1018 #endif
1019         case VIDIOC_INT_AUDIO_CLOCK_FREQ:
1020         case VIDIOC_INT_I2S_CLOCK_FREQ:
1021         case VIDIOC_INT_S_STANDBY:
1022         case VIDIOC_INT_RESET:
1023         {
1024                 u32 *p=arg;
1025
1026                 printk ("%s: value=%d\n", s, *p);
1027                 break;
1028         }
1029         case VIDIOC_G_STD:
1030         case VIDIOC_S_STD:
1031         case VIDIOC_QUERYSTD:
1032         {
1033                 v4l2_std_id *p=arg;
1034
1035                 printk ("%s: value=%Lu\n", s, (unsigned long long)*p);
1036                 break;
1037         }
1038         }
1039 }
1040
1041 /* ----------------------------------------------------------------- */
1042
1043 /* Helper functions for control handling                             */
1044
1045 /* Check for correctness of the ctrl's value based on the data from
1046    struct v4l2_queryctrl and the available menu items. Note that
1047    menu_items may be NULL, in that case it is ignored. */
1048 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
1049                 const char **menu_items)
1050 {
1051         if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
1052                 return -EINVAL;
1053         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1054                 return -EBUSY;
1055         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
1056             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
1057             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1058                 return 0;
1059         if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
1060                 return -ERANGE;
1061         if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
1062                 if (menu_items[ctrl->value] == NULL ||
1063                     menu_items[ctrl->value][0] == '\0')
1064                         return -EINVAL;
1065         }
1066         return 0;
1067 }
1068
1069 /* Returns NULL or a character pointer array containing the menu for
1070    the given control ID. The pointer array ends with a NULL pointer.
1071    An empty string signifies a menu entry that is invalid. This allows
1072    drivers to disable certain options if it is not supported. */
1073 const char **v4l2_ctrl_get_menu(u32 id)
1074 {
1075         static const char *mpeg_audio_sampling_freq[] = {
1076                 "44.1 kHz",
1077                 "48 kHz",
1078                 "32 kHz",
1079                 NULL
1080         };
1081         static const char *mpeg_audio_encoding[] = {
1082                 "Layer I",
1083                 "Layer II",
1084                 "Layer III",
1085                 NULL
1086         };
1087         static const char *mpeg_audio_l1_bitrate[] = {
1088                 "32 kbps",
1089                 "64 kbps",
1090                 "96 kbps",
1091                 "128 kbps",
1092                 "160 kbps",
1093                 "192 kbps",
1094                 "224 kbps",
1095                 "256 kbps",
1096                 "288 kbps",
1097                 "320 kbps",
1098                 "352 kbps",
1099                 "384 kbps",
1100                 "416 kbps",
1101                 "448 kbps",
1102                 NULL
1103         };
1104         static const char *mpeg_audio_l2_bitrate[] = {
1105                 "32 kbps",
1106                 "48 kbps",
1107                 "56 kbps",
1108                 "64 kbps",
1109                 "80 kbps",
1110                 "96 kbps",
1111                 "112 kbps",
1112                 "128 kbps",
1113                 "160 kbps",
1114                 "192 kbps",
1115                 "224 kbps",
1116                 "256 kbps",
1117                 "320 kbps",
1118                 "384 kbps",
1119                 NULL
1120         };
1121         static const char *mpeg_audio_l3_bitrate[] = {
1122                 "32 kbps",
1123                 "40 kbps",
1124                 "48 kbps",
1125                 "56 kbps",
1126                 "64 kbps",
1127                 "80 kbps",
1128                 "96 kbps",
1129                 "112 kbps",
1130                 "128 kbps",
1131                 "160 kbps",
1132                 "192 kbps",
1133                 "224 kbps",
1134                 "256 kbps",
1135                 "320 kbps",
1136                 NULL
1137         };
1138         static const char *mpeg_audio_mode[] = {
1139                 "Stereo",
1140                 "Joint Stereo",
1141                 "Dual",
1142                 "Mono",
1143                 NULL
1144         };
1145         static const char *mpeg_audio_mode_extension[] = {
1146                 "Bound 4",
1147                 "Bound 8",
1148                 "Bound 12",
1149                 "Bound 16",
1150                 NULL
1151         };
1152         static const char *mpeg_audio_emphasis[] = {
1153                 "No Emphasis",
1154                 "50/15 us",
1155                 "CCITT J17",
1156                 NULL
1157         };
1158         static const char *mpeg_audio_crc[] = {
1159                 "No CRC",
1160                 "16-bit CRC",
1161                 NULL
1162         };
1163         static const char *mpeg_video_encoding[] = {
1164                 "MPEG-1",
1165                 "MPEG-2",
1166                 NULL
1167         };
1168         static const char *mpeg_video_aspect[] = {
1169                 "1x1",
1170                 "4x3",
1171                 "16x9",
1172                 "2.21x1",
1173                 NULL
1174         };
1175         static const char *mpeg_video_bitrate_mode[] = {
1176                 "Variable Bitrate",
1177                 "Constant Bitrate",
1178                 NULL
1179         };
1180         static const char *mpeg_stream_type[] = {
1181                 "MPEG-2 Program Stream",
1182                 "MPEG-2 Transport Stream",
1183                 "MPEG-1 System Stream",
1184                 "MPEG-2 DVD-compatible Stream",
1185                 "MPEG-1 VCD-compatible Stream",
1186                 "MPEG-2 SVCD-compatible Stream",
1187                 NULL
1188         };
1189         static const char *mpeg_stream_vbi_fmt[] = {
1190                 "No VBI",
1191                 "Private packet, IVTV format",
1192                 NULL
1193         };
1194
1195         switch (id) {
1196                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1197                         return mpeg_audio_sampling_freq;
1198                 case V4L2_CID_MPEG_AUDIO_ENCODING:
1199                         return mpeg_audio_encoding;
1200                 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1201                         return mpeg_audio_l1_bitrate;
1202                 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1203                         return mpeg_audio_l2_bitrate;
1204                 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1205                         return mpeg_audio_l3_bitrate;
1206                 case V4L2_CID_MPEG_AUDIO_MODE:
1207                         return mpeg_audio_mode;
1208                 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1209                         return mpeg_audio_mode_extension;
1210                 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1211                         return mpeg_audio_emphasis;
1212                 case V4L2_CID_MPEG_AUDIO_CRC:
1213                         return mpeg_audio_crc;
1214                 case V4L2_CID_MPEG_VIDEO_ENCODING:
1215                         return mpeg_video_encoding;
1216                 case V4L2_CID_MPEG_VIDEO_ASPECT:
1217                         return mpeg_video_aspect;
1218                 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1219                         return mpeg_video_bitrate_mode;
1220                 case V4L2_CID_MPEG_STREAM_TYPE:
1221                         return mpeg_stream_type;
1222                 case V4L2_CID_MPEG_STREAM_VBI_FMT:
1223                         return mpeg_stream_vbi_fmt;
1224                 default:
1225                         return NULL;
1226         }
1227 }
1228
1229 /* Fill in a struct v4l2_queryctrl */
1230 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
1231 {
1232         const char *name;
1233
1234         qctrl->flags = 0;
1235         switch (qctrl->id) {
1236         /* USER controls */
1237         case V4L2_CID_USER_CLASS:       name = "User Controls"; break;
1238         case V4L2_CID_AUDIO_VOLUME:     name = "Volume"; break;
1239         case V4L2_CID_AUDIO_MUTE:       name = "Mute"; break;
1240         case V4L2_CID_AUDIO_BALANCE:    name = "Balance"; break;
1241         case V4L2_CID_AUDIO_BASS:       name = "Bass"; break;
1242         case V4L2_CID_AUDIO_TREBLE:     name = "Treble"; break;
1243         case V4L2_CID_AUDIO_LOUDNESS:   name = "Loudness"; break;
1244         case V4L2_CID_BRIGHTNESS:       name = "Brightness"; break;
1245         case V4L2_CID_CONTRAST:         name = "Contrast"; break;
1246         case V4L2_CID_SATURATION:       name = "Saturation"; break;
1247         case V4L2_CID_HUE:              name = "Hue"; break;
1248
1249         /* MPEG controls */
1250         case V4L2_CID_MPEG_CLASS:               name = "MPEG Encoder Controls"; break;
1251         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
1252         case V4L2_CID_MPEG_AUDIO_ENCODING:      name = "Audio Encoding Layer"; break;
1253         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    name = "Audio Layer I Bitrate"; break;
1254         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    name = "Audio Layer II Bitrate"; break;
1255         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    name = "Audio Layer III Bitrate"; break;
1256         case V4L2_CID_MPEG_AUDIO_MODE:          name = "Audio Stereo Mode"; break;
1257         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
1258         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      name = "Audio Emphasis"; break;
1259         case V4L2_CID_MPEG_AUDIO_CRC:           name = "Audio CRC"; break;
1260         case V4L2_CID_MPEG_VIDEO_ENCODING:      name = "Video Encoding"; break;
1261         case V4L2_CID_MPEG_VIDEO_ASPECT:        name = "Video Aspect"; break;
1262         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      name = "Video B Frames"; break;
1263         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      name = "Video GOP Size"; break;
1264         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   name = "Video GOP Closure"; break;
1265         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      name = "Video Pulldown"; break;
1266         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  name = "Video Bitrate Mode"; break;
1267         case V4L2_CID_MPEG_VIDEO_BITRATE:       name = "Video Bitrate"; break;
1268         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  name = "Video Peak Bitrate"; break;
1269         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
1270         case V4L2_CID_MPEG_STREAM_TYPE:         name = "Stream Type"; break;
1271         case V4L2_CID_MPEG_STREAM_PID_PMT:      name = "Stream PMT Program ID"; break;
1272         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    name = "Stream Audio Program ID"; break;
1273         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    name = "Stream Video Program ID"; break;
1274         case V4L2_CID_MPEG_STREAM_PID_PCR:      name = "Stream PCR Program ID"; break;
1275         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
1276         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
1277         case V4L2_CID_MPEG_STREAM_VBI_FMT:      name = "Stream VBI Format"; break;
1278
1279         default:
1280                 return -EINVAL;
1281         }
1282         switch (qctrl->id) {
1283         case V4L2_CID_AUDIO_MUTE:
1284         case V4L2_CID_AUDIO_LOUDNESS:
1285         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1286         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1287                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
1288                 min = 0;
1289                 max = step = 1;
1290                 break;
1291         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1292         case V4L2_CID_MPEG_AUDIO_ENCODING:
1293         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1294         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1295         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1296         case V4L2_CID_MPEG_AUDIO_MODE:
1297         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1298         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1299         case V4L2_CID_MPEG_AUDIO_CRC:
1300         case V4L2_CID_MPEG_VIDEO_ENCODING:
1301         case V4L2_CID_MPEG_VIDEO_ASPECT:
1302         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1303         case V4L2_CID_MPEG_STREAM_TYPE:
1304         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1305                 qctrl->type = V4L2_CTRL_TYPE_MENU;
1306                 step = 1;
1307                 break;
1308         case V4L2_CID_USER_CLASS:
1309         case V4L2_CID_MPEG_CLASS:
1310                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
1311                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1312                 min = max = step = def = 0;
1313                 break;
1314         default:
1315                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
1316                 break;
1317         }
1318         switch (qctrl->id) {
1319         case V4L2_CID_MPEG_AUDIO_ENCODING:
1320         case V4L2_CID_MPEG_AUDIO_MODE:
1321         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1322         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1323         case V4L2_CID_MPEG_STREAM_TYPE:
1324                 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
1325                 break;
1326         case V4L2_CID_AUDIO_VOLUME:
1327         case V4L2_CID_AUDIO_BALANCE:
1328         case V4L2_CID_AUDIO_BASS:
1329         case V4L2_CID_AUDIO_TREBLE:
1330         case V4L2_CID_BRIGHTNESS:
1331         case V4L2_CID_CONTRAST:
1332         case V4L2_CID_SATURATION:
1333         case V4L2_CID_HUE:
1334                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
1335                 break;
1336         }
1337         qctrl->minimum = min;
1338         qctrl->maximum = max;
1339         qctrl->step = step;
1340         qctrl->default_value = def;
1341         qctrl->reserved[0] = qctrl->reserved[1] = 0;
1342         snprintf(qctrl->name, sizeof(qctrl->name), name);
1343         return 0;
1344 }
1345
1346 /* Fill in a struct v4l2_queryctrl with standard values based on
1347    the control ID. */
1348 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
1349 {
1350         switch (qctrl->id) {
1351         /* USER controls */
1352         case V4L2_CID_USER_CLASS:
1353         case V4L2_CID_MPEG_CLASS:
1354                 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
1355         case V4L2_CID_AUDIO_VOLUME:
1356                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
1357         case V4L2_CID_AUDIO_MUTE:
1358         case V4L2_CID_AUDIO_LOUDNESS:
1359                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1360         case V4L2_CID_AUDIO_BALANCE:
1361         case V4L2_CID_AUDIO_BASS:
1362         case V4L2_CID_AUDIO_TREBLE:
1363                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
1364         case V4L2_CID_BRIGHTNESS:
1365                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
1366         case V4L2_CID_CONTRAST:
1367         case V4L2_CID_SATURATION:
1368                 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
1369         case V4L2_CID_HUE:
1370                 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
1371
1372         /* MPEG controls */
1373         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1374                 return v4l2_ctrl_query_fill(qctrl,
1375                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
1376                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
1377                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
1378         case V4L2_CID_MPEG_AUDIO_ENCODING:
1379                 return v4l2_ctrl_query_fill(qctrl,
1380                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
1381                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
1382                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
1383         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1384                 return v4l2_ctrl_query_fill(qctrl,
1385                                 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
1386                                 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
1387                                 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
1388         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1389                 return v4l2_ctrl_query_fill(qctrl,
1390                                 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
1391                                 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
1392                                 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
1393         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1394                 return v4l2_ctrl_query_fill(qctrl,
1395                                 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
1396                                 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
1397                                 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
1398         case V4L2_CID_MPEG_AUDIO_MODE:
1399                 return v4l2_ctrl_query_fill(qctrl,
1400                                 V4L2_MPEG_AUDIO_MODE_STEREO,
1401                                 V4L2_MPEG_AUDIO_MODE_MONO, 1,
1402                                 V4L2_MPEG_AUDIO_MODE_STEREO);
1403         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1404                 return v4l2_ctrl_query_fill(qctrl,
1405                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
1406                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
1407                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
1408         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1409                 return v4l2_ctrl_query_fill(qctrl,
1410                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
1411                                 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
1412                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
1413         case V4L2_CID_MPEG_AUDIO_CRC:
1414                 return v4l2_ctrl_query_fill(qctrl,
1415                                 V4L2_MPEG_AUDIO_CRC_NONE,
1416                                 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
1417                                 V4L2_MPEG_AUDIO_CRC_NONE);
1418         case V4L2_CID_MPEG_VIDEO_ENCODING:
1419                 return v4l2_ctrl_query_fill(qctrl,
1420                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
1421                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
1422                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
1423         case V4L2_CID_MPEG_VIDEO_ASPECT:
1424                 return v4l2_ctrl_query_fill(qctrl,
1425                                 V4L2_MPEG_VIDEO_ASPECT_1x1,
1426                                 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
1427                                 V4L2_MPEG_VIDEO_ASPECT_4x3);
1428         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1429                 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
1430         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1431                 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
1432         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1433                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
1434         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1435                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1436         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1437                 return v4l2_ctrl_query_fill(qctrl,
1438                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
1439                                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
1440                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1441         case V4L2_CID_MPEG_VIDEO_BITRATE:
1442                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
1443         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
1444                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
1445         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
1446                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1447         case V4L2_CID_MPEG_STREAM_TYPE:
1448                 return v4l2_ctrl_query_fill(qctrl,
1449                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
1450                                 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
1451                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1452         case V4L2_CID_MPEG_STREAM_PID_PMT:
1453                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
1454         case V4L2_CID_MPEG_STREAM_PID_AUDIO:
1455                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
1456         case V4L2_CID_MPEG_STREAM_PID_VIDEO:
1457                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
1458         case V4L2_CID_MPEG_STREAM_PID_PCR:
1459                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
1460         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
1461                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1462         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
1463                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1464         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1465                 return v4l2_ctrl_query_fill(qctrl,
1466                                 V4L2_MPEG_STREAM_VBI_FMT_NONE,
1467                                 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
1468                                 V4L2_MPEG_STREAM_VBI_FMT_NONE);
1469         default:
1470                 return -EINVAL;
1471         }
1472 }
1473
1474 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
1475    the menu. The qctrl pointer may be NULL, in which case it is ignored. */
1476 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
1477                const char **menu_items)
1478 {
1479         int i;
1480
1481         if (menu_items == NULL ||
1482             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
1483                 return -EINVAL;
1484         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
1485         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
1486                 return -EINVAL;
1487         snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
1488         qmenu->reserved = 0;
1489         return 0;
1490 }
1491
1492 /* ctrl_classes points to an array of u32 pointers, the last element is
1493    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
1494    Each array must be sorted low to high and belong to the same control
1495    class. The array of u32 pointer must also be sorted, from low class IDs
1496    to high class IDs.
1497
1498    This function returns the first ID that follows after the given ID.
1499    When no more controls are available 0 is returned. */
1500 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
1501 {
1502         u32 ctrl_class;
1503         const u32 *pctrl;
1504
1505         /* if no query is desired, then just return the control ID */
1506         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
1507                 return id;
1508         if (ctrl_classes == NULL)
1509                 return 0;
1510         id &= V4L2_CTRL_ID_MASK;
1511         ctrl_class = V4L2_CTRL_ID2CLASS(id);
1512         id++;   /* select next control */
1513         /* find first class that matches (or is greater than) the class of
1514            the ID */
1515         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
1516                 ctrl_classes++;
1517         /* no more classes */
1518         if (*ctrl_classes == NULL)
1519                 return 0;
1520         pctrl = *ctrl_classes;
1521         /* find first ctrl within the class that is >= ID */
1522         while (*pctrl && *pctrl < id) pctrl++;
1523         if (*pctrl)
1524                 return *pctrl;
1525         /* we are at the end of the controls of the current class. */
1526         /* continue with next class if available */
1527         ctrl_classes++;
1528         if (*ctrl_classes == NULL)
1529                 return 0;
1530         return **ctrl_classes;
1531 }
1532
1533 /* ----------------------------------------------------------------- */
1534
1535 EXPORT_SYMBOL(v4l2_norm_to_name);
1536 EXPORT_SYMBOL(v4l2_video_std_construct);
1537
1538 EXPORT_SYMBOL(v4l2_prio_init);
1539 EXPORT_SYMBOL(v4l2_prio_change);
1540 EXPORT_SYMBOL(v4l2_prio_open);
1541 EXPORT_SYMBOL(v4l2_prio_close);
1542 EXPORT_SYMBOL(v4l2_prio_max);
1543 EXPORT_SYMBOL(v4l2_prio_check);
1544
1545 EXPORT_SYMBOL(v4l2_field_names);
1546 EXPORT_SYMBOL(v4l2_type_names);
1547 EXPORT_SYMBOL(v4l_printk_ioctl);
1548 EXPORT_SYMBOL(v4l_printk_ioctl_arg);
1549
1550 EXPORT_SYMBOL(v4l2_ctrl_next);
1551 EXPORT_SYMBOL(v4l2_ctrl_check);
1552 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
1553 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
1554 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
1555 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
1556
1557 /*
1558  * Local variables:
1559  * c-basic-offset: 8
1560  * End:
1561  */