drivers/media/video/v4l2-common.c

   1 /*
   2  *      Video for Linux Two
   3  *
   4  *      A generic video device interface for the LINUX operating system
   5  *      using a set of device structures/vectors for low level operations.
   6  *
   7  *      This file replaces the videodev.c file that comes with the
   8  *      regular kernel distribution.
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  *
  15  * Author:      Bill Dirks <bill@thedirks.org>
  16  *              based on code by Alan Cox, <alan@cymru.net>
  17  *
  18  */
  19
  20 /*
  21  * Video capture interface for Linux
  22  *
  23  *      A generic video device interface for the LINUX operating system
  24  *      using a set of device structures/vectors for low level operations.
  25  *
  26  *              This program is free software; you can redistribute it and/or
  27  *              modify it under the terms of the GNU General Public License
  28  *              as published by the Free Software Foundation; either version
  29  *              2 of the License, or (at your option) any later version.
  30  *
  31  * Author:      Alan Cox, <alan@redhat.com>
  32  *
  33  * Fixes:
  34  */
  35
  36 /*
  37  * Video4linux 1/2 integration by Justin Schoeman
  38  * <justin@suntiger.ee.up.ac.za>
  39  * 2.4 PROCFS support ported from 2.4 kernels by
  40  *  Iñaki García Etxebarria <garetxe@euskalnet.net>
  41  * Makefile fix by "W. Michael Petullo" <mike@flyn.org>
  42  * 2.4 devfs support ported from 2.4 kernels by
  43  *  Dan Merillat <dan@merillat.org>
  44  * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
  45  */
  46
  47 #include <linux/module.h>
  48 #include <linux/types.h>
  49 #include <linux/kernel.h>
  50 #include <linux/mm.h>
  51 #include <linux/string.h>
  52 #include <linux/errno.h>
  53 #include <linux/i2c.h>
  54 #include <asm/uaccess.h>
  55 #include <asm/system.h>
  56 #include <asm/pgtable.h>
  57 #include <asm/io.h>
  58 #include <asm/div64.h>
  59 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
  60 #include <media/v4l2-common.h>
  61 #include <media/v4l2-chip-ident.h>
  62
  63 #ifdef CONFIG_KMOD
  64 #include <linux/kmod.h>
  65 #endif
  66
  67 #include <linux/videodev.h>
  68
  69 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
  70 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
  71 MODULE_LICENSE("GPL");
  72
  73 /*
  74  *
  75  *      V 4 L 2   D R I V E R   H E L P E R   A P I
  76  *
  77  */
  78
  79 /*
  80  *  Video Standard Operations (contributed by Michael Schimek)
  81  */
  82
  83
  84 /* ----------------------------------------------------------------- */
  85 /* priority handling                                                 */
  86
  87 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND   || \
  88                               val == V4L2_PRIORITY_INTERACTIVE  || \
  89                               val == V4L2_PRIORITY_RECORD)
  90
  91 int v4l2_prio_init(struct v4l2_prio_state *global)
  92 {
  93         memset(global,0,sizeof(*global));
  94         return 0;
  95 }
  96 EXPORT_SYMBOL(v4l2_prio_init);
  97
  98 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
  99                      enum v4l2_priority new)
 100 {
 101         if (!V4L2_PRIO_VALID(new))
 102                 return -EINVAL;
 103         if (*local == new)
 104                 return 0;
 105
 106         atomic_inc(&global->prios[new]);
 107         if (V4L2_PRIO_VALID(*local))
 108                 atomic_dec(&global->prios[*local]);
 109         *local = new;
 110         return 0;
 111 }
 112 EXPORT_SYMBOL(v4l2_prio_change);
 113
 114 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 115 {
 116         return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
 117 }
 118 EXPORT_SYMBOL(v4l2_prio_open);
 119
 120 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
 121 {
 122         if (V4L2_PRIO_VALID(*local))
 123                 atomic_dec(&global->prios[*local]);
 124         return 0;
 125 }
 126 EXPORT_SYMBOL(v4l2_prio_close);
 127
 128 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
 129 {
 130         if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
 131                 return V4L2_PRIORITY_RECORD;
 132         if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
 133                 return V4L2_PRIORITY_INTERACTIVE;
 134         if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
 135                 return V4L2_PRIORITY_BACKGROUND;
 136         return V4L2_PRIORITY_UNSET;
 137 }
 138 EXPORT_SYMBOL(v4l2_prio_max);
 139
 140 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
 141 {
 142         if (*local < v4l2_prio_max(global))
 143                 return -EBUSY;
 144         return 0;
 145 }
 146 EXPORT_SYMBOL(v4l2_prio_check);
 147
 148 /* ----------------------------------------------------------------- */
 149
 150 /* Helper functions for control handling                             */
 151
 152 /* Check for correctness of the ctrl's value based on the data from
 153    struct v4l2_queryctrl and the available menu items. Note that
 154    menu_items may be NULL, in that case it is ignored. */
 155 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
 156                 const char **menu_items)
 157 {
 158         if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
 159                 return -EINVAL;
 160         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
 161                 return -EBUSY;
 162         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
 163             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
 164             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
 165                 return 0;
 166         if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
 167                 return -ERANGE;
 168         if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
 169                 if (menu_items[ctrl->value] == NULL ||
 170                     menu_items[ctrl->value][0] == '\0')
 171                         return -EINVAL;
 172         }
 173         return 0;
 174 }
 175 EXPORT_SYMBOL(v4l2_ctrl_check);
 176
 177 /* Returns NULL or a character pointer array containing the menu for
 178    the given control ID. The pointer array ends with a NULL pointer.
 179    An empty string signifies a menu entry that is invalid. This allows
 180    drivers to disable certain options if it is not supported. */
 181 const char **v4l2_ctrl_get_menu(u32 id)
 182 {
 183         static const char *mpeg_audio_sampling_freq[] = {
 184                 "44.1 kHz",
 185                 "48 kHz",
 186                 "32 kHz",
 187                 NULL
 188         };
 189         static const char *mpeg_audio_encoding[] = {
 190                 "Layer I",
 191                 "Layer II",
 192                 "Layer III",
 193                 NULL
 194         };
 195         static const char *mpeg_audio_l1_bitrate[] = {
 196                 "32 kbps",
 197                 "64 kbps",
 198                 "96 kbps",
 199                 "128 kbps",
 200                 "160 kbps",
 201                 "192 kbps",
 202                 "224 kbps",
 203                 "256 kbps",
 204                 "288 kbps",
 205                 "320 kbps",
 206                 "352 kbps",
 207                 "384 kbps",
 208                 "416 kbps",
 209                 "448 kbps",
 210                 NULL
 211         };
 212         static const char *mpeg_audio_l2_bitrate[] = {
 213                 "32 kbps",
 214                 "48 kbps",
 215                 "56 kbps",
 216                 "64 kbps",
 217                 "80 kbps",
 218                 "96 kbps",
 219                 "112 kbps",
 220                 "128 kbps",
 221                 "160 kbps",
 222                 "192 kbps",
 223                 "224 kbps",
 224                 "256 kbps",
 225                 "320 kbps",
 226                 "384 kbps",
 227                 NULL
 228         };
 229         static const char *mpeg_audio_l3_bitrate[] = {
 230                 "32 kbps",
 231                 "40 kbps",
 232                 "48 kbps",
 233                 "56 kbps",
 234                 "64 kbps",
 235                 "80 kbps",
 236                 "96 kbps",
 237                 "112 kbps",
 238                 "128 kbps",
 239                 "160 kbps",
 240                 "192 kbps",
 241                 "224 kbps",
 242                 "256 kbps",
 243                 "320 kbps",
 244                 NULL
 245         };
 246         static const char *mpeg_audio_mode[] = {
 247                 "Stereo",
 248                 "Joint Stereo",
 249                 "Dual",
 250                 "Mono",
 251                 NULL
 252         };
 253         static const char *mpeg_audio_mode_extension[] = {
 254                 "Bound 4",
 255                 "Bound 8",
 256                 "Bound 12",
 257                 "Bound 16",
 258                 NULL
 259         };
 260         static const char *mpeg_audio_emphasis[] = {
 261                 "No Emphasis",
 262                 "50/15 us",
 263                 "CCITT J17",
 264                 NULL
 265         };
 266         static const char *mpeg_audio_crc[] = {
 267                 "No CRC",
 268                 "16-bit CRC",
 269                 NULL
 270         };
 271         static const char *mpeg_video_encoding[] = {
 272                 "MPEG-1",
 273                 "MPEG-2",
 274                 NULL
 275         };
 276         static const char *mpeg_video_aspect[] = {
 277                 "1x1",
 278                 "4x3",
 279                 "16x9",
 280                 "2.21x1",
 281                 NULL
 282         };
 283         static const char *mpeg_video_bitrate_mode[] = {
 284                 "Variable Bitrate",
 285                 "Constant Bitrate",
 286                 NULL
 287         };
 288         static const char *mpeg_stream_type[] = {
 289                 "MPEG-2 Program Stream",
 290                 "MPEG-2 Transport Stream",
 291                 "MPEG-1 System Stream",
 292                 "MPEG-2 DVD-compatible Stream",
 293                 "MPEG-1 VCD-compatible Stream",
 294                 "MPEG-2 SVCD-compatible Stream",
 295                 NULL
 296         };
 297         static const char *mpeg_stream_vbi_fmt[] = {
 298                 "No VBI",
 299                 "Private packet, IVTV format",
 300                 NULL
 301         };
 302
 303         switch (id) {
 304                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 305                         return mpeg_audio_sampling_freq;
 306                 case V4L2_CID_MPEG_AUDIO_ENCODING:
 307                         return mpeg_audio_encoding;
 308                 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 309                         return mpeg_audio_l1_bitrate;
 310                 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 311                         return mpeg_audio_l2_bitrate;
 312                 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 313                         return mpeg_audio_l3_bitrate;
 314                 case V4L2_CID_MPEG_AUDIO_MODE:
 315                         return mpeg_audio_mode;
 316                 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 317                         return mpeg_audio_mode_extension;
 318                 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 319                         return mpeg_audio_emphasis;
 320                 case V4L2_CID_MPEG_AUDIO_CRC:
 321                         return mpeg_audio_crc;
 322                 case V4L2_CID_MPEG_VIDEO_ENCODING:
 323                         return mpeg_video_encoding;
 324                 case V4L2_CID_MPEG_VIDEO_ASPECT:
 325                         return mpeg_video_aspect;
 326                 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 327                         return mpeg_video_bitrate_mode;
 328                 case V4L2_CID_MPEG_STREAM_TYPE:
 329                         return mpeg_stream_type;
 330                 case V4L2_CID_MPEG_STREAM_VBI_FMT:
 331                         return mpeg_stream_vbi_fmt;
 332                 default:
 333                         return NULL;
 334         }
 335 }
 336 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
 337
 338 /* Fill in a struct v4l2_queryctrl */
 339 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
 340 {
 341         const char *name;
 342
 343         qctrl->flags = 0;
 344         switch (qctrl->id) {
 345         /* USER controls */
 346         case V4L2_CID_USER_CLASS:       name = "User Controls"; break;
 347         case V4L2_CID_AUDIO_VOLUME:     name = "Volume"; break;
 348         case V4L2_CID_AUDIO_MUTE:       name = "Mute"; break;
 349         case V4L2_CID_AUDIO_BALANCE:    name = "Balance"; break;
 350         case V4L2_CID_AUDIO_BASS:       name = "Bass"; break;
 351         case V4L2_CID_AUDIO_TREBLE:     name = "Treble"; break;
 352         case V4L2_CID_AUDIO_LOUDNESS:   name = "Loudness"; break;
 353         case V4L2_CID_BRIGHTNESS:       name = "Brightness"; break;
 354         case V4L2_CID_CONTRAST:         name = "Contrast"; break;
 355         case V4L2_CID_SATURATION:       name = "Saturation"; break;
 356         case V4L2_CID_HUE:              name = "Hue"; break;
 357
 358         /* MPEG controls */
 359         case V4L2_CID_MPEG_CLASS:               name = "MPEG Encoder Controls"; break;
 360         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
 361         case V4L2_CID_MPEG_AUDIO_ENCODING:      name = "Audio Encoding Layer"; break;
 362         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    name = "Audio Layer I Bitrate"; break;
 363         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    name = "Audio Layer II Bitrate"; break;
 364         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    name = "Audio Layer III Bitrate"; break;
 365         case V4L2_CID_MPEG_AUDIO_MODE:          name = "Audio Stereo Mode"; break;
 366         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
 367         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      name = "Audio Emphasis"; break;
 368         case V4L2_CID_MPEG_AUDIO_CRC:           name = "Audio CRC"; break;
 369         case V4L2_CID_MPEG_AUDIO_MUTE:          name = "Audio Mute"; break;
 370         case V4L2_CID_MPEG_VIDEO_ENCODING:      name = "Video Encoding"; break;
 371         case V4L2_CID_MPEG_VIDEO_ASPECT:        name = "Video Aspect"; break;
 372         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      name = "Video B Frames"; break;
 373         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      name = "Video GOP Size"; break;
 374         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   name = "Video GOP Closure"; break;
 375         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      name = "Video Pulldown"; break;
 376         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  name = "Video Bitrate Mode"; break;
 377         case V4L2_CID_MPEG_VIDEO_BITRATE:       name = "Video Bitrate"; break;
 378         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  name = "Video Peak Bitrate"; break;
 379         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
 380         case V4L2_CID_MPEG_VIDEO_MUTE:          name = "Video Mute"; break;
 381         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:      name = "Video Mute YUV"; break;
 382         case V4L2_CID_MPEG_STREAM_TYPE:         name = "Stream Type"; break;
 383         case V4L2_CID_MPEG_STREAM_PID_PMT:      name = "Stream PMT Program ID"; break;
 384         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    name = "Stream Audio Program ID"; break;
 385         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    name = "Stream Video Program ID"; break;
 386         case V4L2_CID_MPEG_STREAM_PID_PCR:      name = "Stream PCR Program ID"; break;
 387         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
 388         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
 389         case V4L2_CID_MPEG_STREAM_VBI_FMT:      name = "Stream VBI Format"; break;
 390
 391         default:
 392                 return -EINVAL;
 393         }
 394         switch (qctrl->id) {
 395         case V4L2_CID_AUDIO_MUTE:
 396         case V4L2_CID_AUDIO_LOUDNESS:
 397         case V4L2_CID_MPEG_AUDIO_MUTE:
 398         case V4L2_CID_MPEG_VIDEO_MUTE:
 399         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 400         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 401                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
 402                 min = 0;
 403                 max = step = 1;
 404                 break;
 405         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 406         case V4L2_CID_MPEG_AUDIO_ENCODING:
 407         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 408         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 409         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 410         case V4L2_CID_MPEG_AUDIO_MODE:
 411         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 412         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 413         case V4L2_CID_MPEG_AUDIO_CRC:
 414         case V4L2_CID_MPEG_VIDEO_ENCODING:
 415         case V4L2_CID_MPEG_VIDEO_ASPECT:
 416         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 417         case V4L2_CID_MPEG_STREAM_TYPE:
 418         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 419                 qctrl->type = V4L2_CTRL_TYPE_MENU;
 420                 step = 1;
 421                 break;
 422         case V4L2_CID_USER_CLASS:
 423         case V4L2_CID_MPEG_CLASS:
 424                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
 425                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
 426                 min = max = step = def = 0;
 427                 break;
 428         default:
 429                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
 430                 break;
 431         }
 432         switch (qctrl->id) {
 433         case V4L2_CID_MPEG_AUDIO_ENCODING:
 434         case V4L2_CID_MPEG_AUDIO_MODE:
 435         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 436         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 437         case V4L2_CID_MPEG_STREAM_TYPE:
 438                 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
 439                 break;
 440         case V4L2_CID_AUDIO_VOLUME:
 441         case V4L2_CID_AUDIO_BALANCE:
 442         case V4L2_CID_AUDIO_BASS:
 443         case V4L2_CID_AUDIO_TREBLE:
 444         case V4L2_CID_BRIGHTNESS:
 445         case V4L2_CID_CONTRAST:
 446         case V4L2_CID_SATURATION:
 447         case V4L2_CID_HUE:
 448                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
 449                 break;
 450         }
 451         qctrl->minimum = min;
 452         qctrl->maximum = max;
 453         qctrl->step = step;
 454         qctrl->default_value = def;
 455         qctrl->reserved[0] = qctrl->reserved[1] = 0;
 456         snprintf(qctrl->name, sizeof(qctrl->name), name);
 457         return 0;
 458 }
 459 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
 460
 461 /* Fill in a struct v4l2_queryctrl with standard values based on
 462    the control ID. */
 463 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
 464 {
 465         switch (qctrl->id) {
 466         /* USER controls */
 467         case V4L2_CID_USER_CLASS:
 468         case V4L2_CID_MPEG_CLASS:
 469                 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
 470         case V4L2_CID_AUDIO_VOLUME:
 471                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
 472         case V4L2_CID_AUDIO_MUTE:
 473         case V4L2_CID_AUDIO_LOUDNESS:
 474                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 475         case V4L2_CID_AUDIO_BALANCE:
 476         case V4L2_CID_AUDIO_BASS:
 477         case V4L2_CID_AUDIO_TREBLE:
 478                 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
 479         case V4L2_CID_BRIGHTNESS:
 480                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
 481         case V4L2_CID_CONTRAST:
 482         case V4L2_CID_SATURATION:
 483                 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
 484         case V4L2_CID_HUE:
 485                 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
 486
 487         /* MPEG controls */
 488         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 489                 return v4l2_ctrl_query_fill(qctrl,
 490                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
 491                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
 492                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
 493         case V4L2_CID_MPEG_AUDIO_ENCODING:
 494                 return v4l2_ctrl_query_fill(qctrl,
 495                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
 496                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
 497                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
 498         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 499                 return v4l2_ctrl_query_fill(qctrl,
 500                                 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
 501                                 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
 502                                 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
 503         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 504                 return v4l2_ctrl_query_fill(qctrl,
 505                                 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
 506                                 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
 507                                 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
 508         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 509                 return v4l2_ctrl_query_fill(qctrl,
 510                                 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
 511                                 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
 512                                 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
 513         case V4L2_CID_MPEG_AUDIO_MODE:
 514                 return v4l2_ctrl_query_fill(qctrl,
 515                                 V4L2_MPEG_AUDIO_MODE_STEREO,
 516                                 V4L2_MPEG_AUDIO_MODE_MONO, 1,
 517                                 V4L2_MPEG_AUDIO_MODE_STEREO);
 518         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 519                 return v4l2_ctrl_query_fill(qctrl,
 520                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
 521                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
 522                                 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
 523         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 524                 return v4l2_ctrl_query_fill(qctrl,
 525                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
 526                                 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
 527                                 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
 528         case V4L2_CID_MPEG_AUDIO_CRC:
 529                 return v4l2_ctrl_query_fill(qctrl,
 530                                 V4L2_MPEG_AUDIO_CRC_NONE,
 531                                 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
 532                                 V4L2_MPEG_AUDIO_CRC_NONE);
 533         case V4L2_CID_MPEG_AUDIO_MUTE:
 534                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 535         case V4L2_CID_MPEG_VIDEO_ENCODING:
 536                 return v4l2_ctrl_query_fill(qctrl,
 537                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
 538                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
 539                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
 540         case V4L2_CID_MPEG_VIDEO_ASPECT:
 541                 return v4l2_ctrl_query_fill(qctrl,
 542                                 V4L2_MPEG_VIDEO_ASPECT_1x1,
 543                                 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
 544                                 V4L2_MPEG_VIDEO_ASPECT_4x3);
 545         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 546                 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
 547         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
 548                 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
 549         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 550                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
 551         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 552                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 553         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 554                 return v4l2_ctrl_query_fill(qctrl,
 555                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
 556                                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
 557                                 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
 558         case V4L2_CID_MPEG_VIDEO_BITRATE:
 559                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
 560         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
 561                 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
 562         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
 563                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
 564         case V4L2_CID_MPEG_VIDEO_MUTE:
 565                 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
 566         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:  /* Init YUV (really YCbCr) to black */
 567                 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
 568         case V4L2_CID_MPEG_STREAM_TYPE:
 569                 return v4l2_ctrl_query_fill(qctrl,
 570                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
 571                                 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
 572                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
 573         case V4L2_CID_MPEG_STREAM_PID_PMT:
 574                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
 575         case V4L2_CID_MPEG_STREAM_PID_AUDIO:
 576                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
 577         case V4L2_CID_MPEG_STREAM_PID_VIDEO:
 578                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
 579         case V4L2_CID_MPEG_STREAM_PID_PCR:
 580                 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
 581         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
 582                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
 583         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
 584                 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
 585         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 586                 return v4l2_ctrl_query_fill(qctrl,
 587                                 V4L2_MPEG_STREAM_VBI_FMT_NONE,
 588                                 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
 589                                 V4L2_MPEG_STREAM_VBI_FMT_NONE);
 590         default:
 591                 return -EINVAL;
 592         }
 593 }
 594 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
 595
 596 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
 597    the menu. The qctrl pointer may be NULL, in which case it is ignored. */
 598 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
 599                const char **menu_items)
 600 {
 601         int i;
 602
 603         if (menu_items == NULL ||
 604             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
 605                 return -EINVAL;
 606         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
 607         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
 608                 return -EINVAL;
 609         snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
 610         qmenu->reserved = 0;
 611         return 0;
 612 }
 613 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
 614
 615 /* ctrl_classes points to an array of u32 pointers, the last element is
 616    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
 617    Each array must be sorted low to high and belong to the same control
 618    class. The array of u32 pointer must also be sorted, from low class IDs
 619    to high class IDs.
 620
 621    This function returns the first ID that follows after the given ID.
 622    When no more controls are available 0 is returned. */
 623 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
 624 {
 625         u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
 626         const u32 *pctrl;
 627
 628         if (ctrl_classes == NULL)
 629                 return 0;
 630
 631         /* if no query is desired, then check if the ID is part of ctrl_classes */
 632         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
 633                 /* find class */
 634                 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
 635                         ctrl_classes++;
 636                 if (*ctrl_classes == NULL)
 637                         return 0;
 638                 pctrl = *ctrl_classes;
 639                 /* find control ID */
 640                 while (*pctrl && *pctrl != id) pctrl++;
 641                 return *pctrl ? id : 0;
 642         }
 643         id &= V4L2_CTRL_ID_MASK;
 644         id++;   /* select next control */
 645         /* find first class that matches (or is greater than) the class of
 646            the ID */
 647         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
 648                 ctrl_classes++;
 649         /* no more classes */
 650         if (*ctrl_classes == NULL)
 651                 return 0;
 652         pctrl = *ctrl_classes;
 653         /* find first ctrl within the class that is >= ID */
 654         while (*pctrl && *pctrl < id) pctrl++;
 655         if (*pctrl)
 656                 return *pctrl;
 657         /* we are at the end of the controls of the current class. */
 658         /* continue with next class if available */
 659         ctrl_classes++;
 660         if (*ctrl_classes == NULL)
 661                 return 0;
 662         return **ctrl_classes;
 663 }
 664 EXPORT_SYMBOL(v4l2_ctrl_next);
 665
 666 int v4l2_chip_match_host(u32 match_type, u32 match_chip)
 667 {
 668         switch (match_type) {
 669         case V4L2_CHIP_MATCH_HOST:
 670                 return match_chip == 0;
 671         default:
 672                 return 0;
 673         }
 674 }
 675 EXPORT_SYMBOL(v4l2_chip_match_host);
 676
 677 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
 678 int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 match_type, u32 match_chip)
 679 {
 680         switch (match_type) {
 681         case V4L2_CHIP_MATCH_I2C_DRIVER:
 682                 return (c != NULL && c->driver != NULL && c->driver->id == match_chip);
 683         case V4L2_CHIP_MATCH_I2C_ADDR:
 684                 return (c != NULL && c->addr == match_chip);
 685         default:
 686                 return 0;
 687         }
 688 }
 689 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
 690
 691 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_chip_ident *chip,
 692                 u32 ident, u32 revision)
 693 {
 694         if (!v4l2_chip_match_i2c_client(c, chip->match_type, chip->match_chip))
 695                 return 0;
 696         if (chip->ident == V4L2_IDENT_NONE) {
 697                 chip->ident = ident;
 698                 chip->revision = revision;
 699         }
 700         else {
 701                 chip->ident = V4L2_IDENT_AMBIGUOUS;
 702                 chip->revision = 0;
 703         }
 704         return 0;
 705 }
 706 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
 707
 708 /* ----------------------------------------------------------------- */
 709
 710 /* Helper function for I2C legacy drivers */
 711
 712 int v4l2_i2c_attach(struct i2c_adapter *adapter, int address, struct i2c_driver *driver,
 713                 const char *name,
 714                 int (*probe)(struct i2c_client *, const struct i2c_device_id *))
 715 {
 716         struct i2c_client *client;
 717         int err;
 718
 719         client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 720         if (!client)
 721                 return -ENOMEM;
 722
 723         client->addr = address;
 724         client->adapter = adapter;
 725         client->driver = driver;
 726         strlcpy(client->name, name, sizeof(client->name));
 727
 728         err = probe(client, NULL);
 729         if (err == 0) {
 730                 i2c_attach_client(client);
 731         } else {
 732                 kfree(client);
 733         }
 734         return err != -ENOMEM ? 0 : err;
 735 }
 736 EXPORT_SYMBOL(v4l2_i2c_attach);
 737 #endif