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