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         static const char *mpeg_stream_vbi_fmt[] = {
1105                 "No VBI",
1106                 "VBI in private packets, IVTV format",
1107                 NULL
1108         };
1109
1110         switch (id) {
1111                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1112                         return mpeg_audio_sampling_freq;
1113                 case V4L2_CID_MPEG_AUDIO_ENCODING:
1114                         return mpeg_audio_encoding;
1115                 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1116                         return mpeg_audio_l1_bitrate;
1117                 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1118                         return mpeg_audio_l2_bitrate;
1119                 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1120                         return mpeg_audio_l3_bitrate;
1121                 case V4L2_CID_MPEG_AUDIO_MODE:
1122                         return mpeg_audio_mode;
1123                 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1124                         return mpeg_audio_mode_extension;
1125                 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1126                         return mpeg_audio_emphasis;
1127                 case V4L2_CID_MPEG_AUDIO_CRC:
1128                         return mpeg_audio_crc;
1129                 case V4L2_CID_MPEG_VIDEO_ENCODING:
1130                         return mpeg_video_encoding;
1131                 case V4L2_CID_MPEG_VIDEO_ASPECT:
1132                         return mpeg_video_aspect;
1133                 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1134                         return mpeg_video_bitrate_mode;
1135                 case V4L2_CID_MPEG_STREAM_TYPE:
1136                         return mpeg_stream_type;
1137                 case V4L2_CID_MPEG_STREAM_VBI_FMT:
1138                         return mpeg_stream_vbi_fmt;
1139                 default:
1140                         return NULL;
1141         }
1142 }
1143
1144 /* Fill in a struct v4l2_queryctrl */
1145 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
1146 {
1147         const char *name;
1148
1149         qctrl->flags = 0;
1150         switch (qctrl->id) {
1151         /* USER controls */
1152         case V4L2_CID_USER_CLASS:       name = "User Controls"; break;
1153         case V4L2_CID_AUDIO_VOLUME:     name = "Volume"; break;
1154         case V4L2_CID_AUDIO_MUTE:       name = "Mute"; break;
1155         case V4L2_CID_AUDIO_BALANCE:    name = "Balance"; break;
1156         case V4L2_CID_AUDIO_BASS:       name = "Bass"; break;
1157         case V4L2_CID_AUDIO_TREBLE:     name = "Treble"; break;
1158         case V4L2_CID_AUDIO_LOUDNESS:   name = "Loudness"; break;
1159         case V4L2_CID_BRIGHTNESS:       name = "Brightness"; break;
1160         case V4L2_CID_CONTRAST:         name = "Contrast"; break;
1161         case V4L2_CID_SATURATION:       name = "Saturation"; break;
1162         case V4L2_CID_HUE:              name = "Hue"; break;
1163
1164         /* MPEG controls */
1165         case V4L2_CID_MPEG_CLASS:               name = "MPEG Encoder Controls"; break;
1166         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
1167         case V4L2_CID_MPEG_AUDIO_ENCODING:      name = "Audio Encoding Layer"; break;
1168         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    name = "Audio Layer I Bitrate"; break;
1169         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    name = "Audio Layer II Bitrate"; break;
1170         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    name = "Audio Layer III Bitrate"; break;
1171         case V4L2_CID_MPEG_AUDIO_MODE:          name = "Audio Stereo Mode"; break;
1172         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
1173         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      name = "Audio Emphasis"; break;
1174         case V4L2_CID_MPEG_AUDIO_CRC:           name = "Audio CRC"; break;
1175         case V4L2_CID_MPEG_VIDEO_ENCODING:      name = "Video Encoding"; break;
1176         case V4L2_CID_MPEG_VIDEO_ASPECT:        name = "Video Aspect"; break;
1177         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      name = "Video B Frames"; break;
1178         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      name = "Video GOP Size"; break;
1179         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   name = "Video GOP Closure"; break;
1180         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      name = "Video Pulldown"; break;
1181         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  name = "Video Bitrate Mode"; break;
1182         case V4L2_CID_MPEG_VIDEO_BITRATE:       name = "Video Bitrate"; break;
1183         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  name = "Video Peak Bitrate"; break;
1184         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
1185         case V4L2_CID_MPEG_STREAM_TYPE:         name = "Stream Type"; break;
1186         case V4L2_CID_MPEG_STREAM_PID_PMT:      name = "Stream PMT Program ID"; break;
1187         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    name = "Stream Audio Program ID"; break;
1188         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    name = "Stream Video Program ID"; break;
1189         case V4L2_CID_MPEG_STREAM_PID_PCR:      name = "Stream PCR Program ID"; break;
1190         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
1191         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
1192         case V4L2_CID_MPEG_STREAM_VBI_FMT:      name = "Stream VBI Format"; break;
1193
1194         default:
1195                 return -EINVAL;
1196         }
1197         switch (qctrl->id) {
1198         case V4L2_CID_AUDIO_MUTE:
1199         case V4L2_CID_AUDIO_LOUDNESS:
1200         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1201         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1202                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
1203                 min = 0;
1204                 max = step = 1;
1205                 break;
1206         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1207         case V4L2_CID_MPEG_AUDIO_ENCODING:
1208         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1209         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1210         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1211         case V4L2_CID_MPEG_AUDIO_MODE:
1212         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1213         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1214         case V4L2_CID_MPEG_AUDIO_CRC:
1215         case V4L2_CID_MPEG_VIDEO_ENCODING:
1216         case V4L2_CID_MPEG_VIDEO_ASPECT:
1217         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1218         case V4L2_CID_MPEG_STREAM_TYPE:
1219         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1220                 qctrl->type = V4L2_CTRL_TYPE_MENU;
1221                 step = 1;
1222                 break;
1223         case V4L2_CID_USER_CLASS:
1224         case V4L2_CID_MPEG_CLASS:
1225                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
1226                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1227                 min = max = step = def = 0;
1228                 break;
1229         default:
1230                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
1231                 break;
1232         }
1233         switch (qctrl->id) {
1234         case V4L2_CID_MPEG_AUDIO_ENCODING:
1235         case V4L2_CID_MPEG_AUDIO_MODE:
1236         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1237         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1238         case V4L2_CID_MPEG_STREAM_TYPE:
1239                 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
1240                 break;
1241         case V4L2_CID_AUDIO_VOLUME:
1242         case V4L2_CID_AUDIO_BALANCE:
1243         case V4L2_CID_AUDIO_BASS:
1244         case V4L2_CID_AUDIO_TREBLE:
1245         case V4L2_CID_BRIGHTNESS:
1246         case V4L2_CID_CONTRAST:
1247         case V4L2_CID_SATURATION:
1248         case V4L2_CID_HUE:
1249                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
1250                 break;
1251         }
1252         qctrl->minimum = min;
1253         qctrl->maximum = max;
1254         qctrl->step = step;
1255         qctrl->default_value = def;
1256         qctrl->reserved[0] = qctrl->reserved[1] = 0;
1257         snprintf(qctrl->name, sizeof(qctrl->name), name);
1258         return 0;
1259 }
1260
1261 /* Fill in a struct v4l2_queryctrl with standard values based on
1262    the control ID. */
1263 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
1264 {
1265         switch (qctrl->id) {
1266         /* USER controls */
1267         case V4L2_CID_USER_CLASS:
1268         case V4L2_CID_MPEG_CLASS:
1269                 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
1270         case V4L2_CID_AUDIO_VOLUME:
1271                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
1272         case V4L2_CID_AUDIO_MUTE:
1273         case V4L2_CID_AUDIO_LOUDNESS:
1274                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1275         case V4L2_CID_AUDIO_BALANCE:
1276         case V4L2_CID_AUDIO_BASS:
1277         case V4L2_CID_AUDIO_TREBLE:
1278                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
1279         case V4L2_CID_BRIGHTNESS:
1280                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
1281         case V4L2_CID_CONTRAST:
1282         case V4L2_CID_SATURATION:
1283                 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
1284         case V4L2_CID_HUE:
1285                 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
1286
1287         /* MPEG controls */
1288         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1289                 return v4l2_ctrl_query_fill(qctrl,
1290                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
1291                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
1292                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
1293         case V4L2_CID_MPEG_AUDIO_ENCODING:
1294                 return v4l2_ctrl_query_fill(qctrl,
1295                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
1296                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
1297                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
1298         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1299                 return v4l2_ctrl_query_fill(qctrl,
1300                                 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
1301                                 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
1302                                 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
1303         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1304                 return v4l2_ctrl_query_fill(qctrl,
1305                                 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
1306                                 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
1307                                 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
1308         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1309                 return v4l2_ctrl_query_fill(qctrl,
1310                                 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
1311                                 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
1312                                 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
1313         case V4L2_CID_MPEG_AUDIO_MODE:
1314                 return v4l2_ctrl_query_fill(qctrl,
1315                                 V4L2_MPEG_AUDIO_MODE_STEREO,
1316                                 V4L2_MPEG_AUDIO_MODE_MONO, 1,
1317                                 V4L2_MPEG_AUDIO_MODE_STEREO);
1318         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1319                 return v4l2_ctrl_query_fill(qctrl,
1320                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
1321                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
1322                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
1323         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1324                 return v4l2_ctrl_query_fill(qctrl,
1325                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
1326                                 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
1327                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
1328         case V4L2_CID_MPEG_AUDIO_CRC:
1329                 return v4l2_ctrl_query_fill(qctrl,
1330                                 V4L2_MPEG_AUDIO_CRC_NONE,
1331                                 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
1332                                 V4L2_MPEG_AUDIO_CRC_NONE);
1333         case V4L2_CID_MPEG_VIDEO_ENCODING:
1334                 return v4l2_ctrl_query_fill(qctrl,
1335                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
1336                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
1337                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
1338         case V4L2_CID_MPEG_VIDEO_ASPECT:
1339                 return v4l2_ctrl_query_fill(qctrl,
1340                                 V4L2_MPEG_VIDEO_ASPECT_1x1,
1341                                 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
1342                                 V4L2_MPEG_VIDEO_ASPECT_4x3);
1343         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1344                 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
1345         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1346                 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
1347         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1348                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
1349         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1350                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1351         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1352                 return v4l2_ctrl_query_fill(qctrl,
1353                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
1354                                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
1355                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1356         case V4L2_CID_MPEG_VIDEO_BITRATE:
1357                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
1358         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
1359                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
1360         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
1361                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1362         case V4L2_CID_MPEG_STREAM_TYPE:
1363                 return v4l2_ctrl_query_fill(qctrl,
1364                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
1365                                 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
1366                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1367         case V4L2_CID_MPEG_STREAM_PID_PMT:
1368                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
1369         case V4L2_CID_MPEG_STREAM_PID_AUDIO:
1370                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
1371         case V4L2_CID_MPEG_STREAM_PID_VIDEO:
1372                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
1373         case V4L2_CID_MPEG_STREAM_PID_PCR:
1374                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
1375         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
1376                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1377         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
1378                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1379         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1380                 return v4l2_ctrl_query_fill(qctrl,
1381                                 V4L2_MPEG_STREAM_VBI_FMT_NONE,
1382                                 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
1383                                 V4L2_MPEG_STREAM_VBI_FMT_NONE);
1384         default:
1385                 return -EINVAL;
1386         }
1387 }
1388
1389 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
1390    the menu. The qctrl pointer may be NULL, in which case it is ignored. */
1391 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
1392                const char **menu_items)
1393 {
1394         int i;
1395
1396         if (menu_items == NULL ||
1397             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
1398                 return -EINVAL;
1399         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
1400         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
1401                 return -EINVAL;
1402         snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
1403         qmenu->reserved = 0;
1404         return 0;
1405 }
1406
1407 /* ctrl_classes points to an array of u32 pointers, the last element is
1408    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
1409    Each array must be sorted low to high and belong to the same control
1410    class. The array of u32 pointer must also be sorted, from low class IDs
1411    to high class IDs.
1412
1413    This function returns the first ID that follows after the given ID.
1414    When no more controls are available 0 is returned. */
1415 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
1416 {
1417         u32 ctrl_class;
1418         const u32 *pctrl;
1419
1420         /* if no query is desired, then just return the control ID */
1421         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
1422                 return id;
1423         if (ctrl_classes == NULL)
1424                 return 0;
1425         id &= V4L2_CTRL_ID_MASK;
1426         ctrl_class = V4L2_CTRL_ID2CLASS(id);
1427         id++;   /* select next control */
1428         /* find first class that matches (or is greater than) the class of
1429            the ID */
1430         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
1431                 ctrl_classes++;
1432         /* no more classes */
1433         if (*ctrl_classes == NULL)
1434                 return 0;
1435         pctrl = *ctrl_classes;
1436         /* find first ctrl within the class that is >= ID */
1437         while (*pctrl && *pctrl < id) pctrl++;
1438         if (*pctrl)
1439                 return *pctrl;
1440         /* we are at the end of the controls of the current class. */
1441         /* continue with next class if available */
1442         ctrl_classes++;
1443         if (*ctrl_classes == NULL)
1444                 return 0;
1445         return **ctrl_classes;
1446 }
1447
1448 /* ----------------------------------------------------------------- */
1449
1450 EXPORT_SYMBOL(v4l2_video_std_construct);
1451
1452 EXPORT_SYMBOL(v4l2_prio_init);
1453 EXPORT_SYMBOL(v4l2_prio_change);
1454 EXPORT_SYMBOL(v4l2_prio_open);
1455 EXPORT_SYMBOL(v4l2_prio_close);
1456 EXPORT_SYMBOL(v4l2_prio_max);
1457 EXPORT_SYMBOL(v4l2_prio_check);
1458
1459 EXPORT_SYMBOL(v4l2_field_names);
1460 EXPORT_SYMBOL(v4l2_type_names);
1461 EXPORT_SYMBOL(v4l_printk_ioctl);
1462 EXPORT_SYMBOL(v4l_printk_ioctl_arg);
1463
1464 EXPORT_SYMBOL(v4l2_ctrl_next);
1465 EXPORT_SYMBOL(v4l2_ctrl_check);
1466 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
1467 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
1468 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
1469 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
1470
1471 /*
1472  * Local variables:
1473  * c-basic-offset: 8
1474  * End:
1475  */