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