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@lxorguk.ukuu.org.uk>
  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-device.h>
  62 #include <media/v4l2-chip-ident.h>
  63
  64 #include <linux/videodev2.h>
  65
  66 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
  67 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
  68 MODULE_LICENSE("GPL");
  69
  70 /*
  71  *
  72  *      V 4 L 2   D R I V E R   H E L P E R   A P I
  73  *
  74  */
  75
  76 /*
  77  *  Video Standard Operations (contributed by Michael Schimek)
  78  */
  79
  80
  81 /* ----------------------------------------------------------------- */
  82 /* priority handling                                                 */
  83
  84 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND   || \
  85                               val == V4L2_PRIORITY_INTERACTIVE  || \
  86                               val == V4L2_PRIORITY_RECORD)
  87
  88 int v4l2_prio_init(struct v4l2_prio_state *global)
  89 {
  90         memset(global,0,sizeof(*global));
  91         return 0;
  92 }
  93 EXPORT_SYMBOL(v4l2_prio_init);
  94
  95 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
  96                      enum v4l2_priority new)
  97 {
  98         if (!V4L2_PRIO_VALID(new))
  99                 return -EINVAL;
 100         if (*local == new)
 101                 return 0;
 102
 103         atomic_inc(&global->prios[new]);
 104         if (V4L2_PRIO_VALID(*local))
 105                 atomic_dec(&global->prios[*local]);
 106         *local = new;
 107         return 0;
 108 }
 109 EXPORT_SYMBOL(v4l2_prio_change);
 110
 111 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 112 {
 113         return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
 114 }
 115 EXPORT_SYMBOL(v4l2_prio_open);
 116
 117 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
 118 {
 119         if (V4L2_PRIO_VALID(*local))
 120                 atomic_dec(&global->prios[*local]);
 121         return 0;
 122 }
 123 EXPORT_SYMBOL(v4l2_prio_close);
 124
 125 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
 126 {
 127         if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
 128                 return V4L2_PRIORITY_RECORD;
 129         if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
 130                 return V4L2_PRIORITY_INTERACTIVE;
 131         if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
 132                 return V4L2_PRIORITY_BACKGROUND;
 133         return V4L2_PRIORITY_UNSET;
 134 }
 135 EXPORT_SYMBOL(v4l2_prio_max);
 136
 137 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
 138 {
 139         if (*local < v4l2_prio_max(global))
 140                 return -EBUSY;
 141         return 0;
 142 }
 143 EXPORT_SYMBOL(v4l2_prio_check);
 144
 145 /* ----------------------------------------------------------------- */
 146
 147 /* Helper functions for control handling                             */
 148
 149 /* Check for correctness of the ctrl's value based on the data from
 150    struct v4l2_queryctrl and the available menu items. Note that
 151    menu_items may be NULL, in that case it is ignored. */
 152 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
 153                 const char **menu_items)
 154 {
 155         if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
 156                 return -EINVAL;
 157         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
 158                 return -EBUSY;
 159         if (qctrl->type == V4L2_CTRL_TYPE_STRING)
 160                 return 0;
 161         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
 162             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
 163             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
 164                 return 0;
 165         if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
 166                 return -ERANGE;
 167         if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
 168                 if (menu_items[ctrl->value] == NULL ||
 169                     menu_items[ctrl->value][0] == '\0')
 170                         return -EINVAL;
 171         }
 172         return 0;
 173 }
 174 EXPORT_SYMBOL(v4l2_ctrl_check);
 175
 176 /* Returns NULL or a character pointer array containing the menu for
 177    the given control ID. The pointer array ends with a NULL pointer.
 178    An empty string signifies a menu entry that is invalid. This allows
 179    drivers to disable certain options if it is not supported. */
 180 const char **v4l2_ctrl_get_menu(u32 id)
 181 {
 182         static const char *mpeg_audio_sampling_freq[] = {
 183                 "44.1 kHz",
 184                 "48 kHz",
 185                 "32 kHz",
 186                 NULL
 187         };
 188         static const char *mpeg_audio_encoding[] = {
 189                 "MPEG-1/2 Layer I",
 190                 "MPEG-1/2 Layer II",
 191                 "MPEG-1/2 Layer III",
 192                 "MPEG-2/4 AAC",
 193                 "AC-3",
 194                 NULL
 195         };
 196         static const char *mpeg_audio_l1_bitrate[] = {
 197                 "32 kbps",
 198                 "64 kbps",
 199                 "96 kbps",
 200                 "128 kbps",
 201                 "160 kbps",
 202                 "192 kbps",
 203                 "224 kbps",
 204                 "256 kbps",
 205                 "288 kbps",
 206                 "320 kbps",
 207                 "352 kbps",
 208                 "384 kbps",
 209                 "416 kbps",
 210                 "448 kbps",
 211                 NULL
 212         };
 213         static const char *mpeg_audio_l2_bitrate[] = {
 214                 "32 kbps",
 215                 "48 kbps",
 216                 "56 kbps",
 217                 "64 kbps",
 218                 "80 kbps",
 219                 "96 kbps",
 220                 "112 kbps",
 221                 "128 kbps",
 222                 "160 kbps",
 223                 "192 kbps",
 224                 "224 kbps",
 225                 "256 kbps",
 226                 "320 kbps",
 227                 "384 kbps",
 228                 NULL
 229         };
 230         static const char *mpeg_audio_l3_bitrate[] = {
 231                 "32 kbps",
 232                 "40 kbps",
 233                 "48 kbps",
 234                 "56 kbps",
 235                 "64 kbps",
 236                 "80 kbps",
 237                 "96 kbps",
 238                 "112 kbps",
 239                 "128 kbps",
 240                 "160 kbps",
 241                 "192 kbps",
 242                 "224 kbps",
 243                 "256 kbps",
 244                 "320 kbps",
 245                 NULL
 246         };
 247         static const char *mpeg_audio_ac3_bitrate[] = {
 248                 "32 kbps",
 249                 "40 kbps",
 250                 "48 kbps",
 251                 "56 kbps",
 252                 "64 kbps",
 253                 "80 kbps",
 254                 "96 kbps",
 255                 "112 kbps",
 256                 "128 kbps",
 257                 "160 kbps",
 258                 "192 kbps",
 259                 "224 kbps",
 260                 "256 kbps",
 261                 "320 kbps",
 262                 "384 kbps",
 263                 "448 kbps",
 264                 "512 kbps",
 265                 "576 kbps",
 266                 "640 kbps",
 267                 NULL
 268         };
 269         static const char *mpeg_audio_mode[] = {
 270                 "Stereo",
 271                 "Joint Stereo",
 272                 "Dual",
 273                 "Mono",
 274                 NULL
 275         };
 276         static const char *mpeg_audio_mode_extension[] = {
 277                 "Bound 4",
 278                 "Bound 8",
 279                 "Bound 12",
 280                 "Bound 16",
 281                 NULL
 282         };
 283         static const char *mpeg_audio_emphasis[] = {
 284                 "No Emphasis",
 285                 "50/15 us",
 286                 "CCITT J17",
 287                 NULL
 288         };
 289         static const char *mpeg_audio_crc[] = {
 290                 "No CRC",
 291                 "16-bit CRC",
 292                 NULL
 293         };
 294         static const char *mpeg_video_encoding[] = {
 295                 "MPEG-1",
 296                 "MPEG-2",
 297                 "MPEG-4 AVC",
 298                 NULL
 299         };
 300         static const char *mpeg_video_aspect[] = {
 301                 "1x1",
 302                 "4x3",
 303                 "16x9",
 304                 "2.21x1",
 305                 NULL
 306         };
 307         static const char *mpeg_video_bitrate_mode[] = {
 308                 "Variable Bitrate",
 309                 "Constant Bitrate",
 310                 NULL
 311         };
 312         static const char *mpeg_stream_type[] = {
 313                 "MPEG-2 Program Stream",
 314                 "MPEG-2 Transport Stream",
 315                 "MPEG-1 System Stream",
 316                 "MPEG-2 DVD-compatible Stream",
 317                 "MPEG-1 VCD-compatible Stream",
 318                 "MPEG-2 SVCD-compatible Stream",
 319                 NULL
 320         };
 321         static const char *mpeg_stream_vbi_fmt[] = {
 322                 "No VBI",
 323                 "Private packet, IVTV format",
 324                 NULL
 325         };
 326         static const char *camera_power_line_frequency[] = {
 327                 "Disabled",
 328                 "50 Hz",
 329                 "60 Hz",
 330                 NULL
 331         };
 332         static const char *camera_exposure_auto[] = {
 333                 "Auto Mode",
 334                 "Manual Mode",
 335                 "Shutter Priority Mode",
 336                 "Aperture Priority Mode",
 337                 NULL
 338         };
 339         static const char *colorfx[] = {
 340                 "None",
 341                 "Black & White",
 342                 "Sepia",
 343                 NULL
 344         };
 345         static const char *tune_preemphasis[] = {
 346                 "No preemphasis",
 347                 "50 useconds",
 348                 "75 useconds",
 349                 NULL,
 350         };
 351
 352         switch (id) {
 353                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 354                         return mpeg_audio_sampling_freq;
 355                 case V4L2_CID_MPEG_AUDIO_ENCODING:
 356                         return mpeg_audio_encoding;
 357                 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 358                         return mpeg_audio_l1_bitrate;
 359                 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 360                         return mpeg_audio_l2_bitrate;
 361                 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 362                         return mpeg_audio_l3_bitrate;
 363                 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 364                         return mpeg_audio_ac3_bitrate;
 365                 case V4L2_CID_MPEG_AUDIO_MODE:
 366                         return mpeg_audio_mode;
 367                 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 368                         return mpeg_audio_mode_extension;
 369                 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 370                         return mpeg_audio_emphasis;
 371                 case V4L2_CID_MPEG_AUDIO_CRC:
 372                         return mpeg_audio_crc;
 373                 case V4L2_CID_MPEG_VIDEO_ENCODING:
 374                         return mpeg_video_encoding;
 375                 case V4L2_CID_MPEG_VIDEO_ASPECT:
 376                         return mpeg_video_aspect;
 377                 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 378                         return mpeg_video_bitrate_mode;
 379                 case V4L2_CID_MPEG_STREAM_TYPE:
 380                         return mpeg_stream_type;
 381                 case V4L2_CID_MPEG_STREAM_VBI_FMT:
 382                         return mpeg_stream_vbi_fmt;
 383                 case V4L2_CID_POWER_LINE_FREQUENCY:
 384                         return camera_power_line_frequency;
 385                 case V4L2_CID_EXPOSURE_AUTO:
 386                         return camera_exposure_auto;
 387                 case V4L2_CID_COLORFX:
 388                         return colorfx;
 389                 case V4L2_CID_TUNE_PREEMPHASIS:
 390                         return tune_preemphasis;
 391                 default:
 392                         return NULL;
 393         }
 394 }
 395 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
 396
 397 /* Return the control name. */
 398 const char *v4l2_ctrl_get_name(u32 id)
 399 {
 400         switch (id) {
 401         /* USER controls */
 402         case V4L2_CID_USER_CLASS:               return "User Controls";
 403         case V4L2_CID_BRIGHTNESS:               return "Brightness";
 404         case V4L2_CID_CONTRAST:                 return "Contrast";
 405         case V4L2_CID_SATURATION:               return "Saturation";
 406         case V4L2_CID_HUE:                      return "Hue";
 407         case V4L2_CID_AUDIO_VOLUME:             return "Volume";
 408         case V4L2_CID_AUDIO_BALANCE:            return "Balance";
 409         case V4L2_CID_AUDIO_BASS:               return "Bass";
 410         case V4L2_CID_AUDIO_TREBLE:             return "Treble";
 411         case V4L2_CID_AUDIO_MUTE:               return "Mute";
 412         case V4L2_CID_AUDIO_LOUDNESS:           return "Loudness";
 413         case V4L2_CID_BLACK_LEVEL:              return "Black Level";
 414         case V4L2_CID_AUTO_WHITE_BALANCE:       return "White Balance, Automatic";
 415         case V4L2_CID_DO_WHITE_BALANCE:         return "Do White Balance";
 416         case V4L2_CID_RED_BALANCE:              return "Red Balance";
 417         case V4L2_CID_BLUE_BALANCE:             return "Blue Balance";
 418         case V4L2_CID_GAMMA:                    return "Gamma";
 419         case V4L2_CID_EXPOSURE:                 return "Exposure";
 420         case V4L2_CID_AUTOGAIN:                 return "Gain, Automatic";
 421         case V4L2_CID_GAIN:                     return "Gain";
 422         case V4L2_CID_HFLIP:                    return "Horizontal Flip";
 423         case V4L2_CID_VFLIP:                    return "Vertical Flip";
 424         case V4L2_CID_HCENTER:                  return "Horizontal Center";
 425         case V4L2_CID_VCENTER:                  return "Vertical Center";
 426         case V4L2_CID_POWER_LINE_FREQUENCY:     return "Power Line Frequency";
 427         case V4L2_CID_HUE_AUTO:                 return "Hue, Automatic";
 428         case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
 429         case V4L2_CID_SHARPNESS:                return "Sharpness";
 430         case V4L2_CID_BACKLIGHT_COMPENSATION:   return "Backlight Compensation";
 431         case V4L2_CID_CHROMA_AGC:               return "Chroma AGC";
 432         case V4L2_CID_COLOR_KILLER:             return "Color Killer";
 433         case V4L2_CID_COLORFX:                  return "Color Effects";
 434
 435         /* MPEG controls */
 436         case V4L2_CID_MPEG_CLASS:               return "MPEG Encoder Controls";
 437         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
 438         case V4L2_CID_MPEG_AUDIO_ENCODING:      return "Audio Encoding";
 439         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    return "Audio Layer I Bitrate";
 440         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    return "Audio Layer II Bitrate";
 441         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    return "Audio Layer III Bitrate";
 442         case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:   return "Audio AAC Bitrate";
 443         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:   return "Audio AC-3 Bitrate";
 444         case V4L2_CID_MPEG_AUDIO_MODE:          return "Audio Stereo Mode";
 445         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
 446         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      return "Audio Emphasis";
 447         case V4L2_CID_MPEG_AUDIO_CRC:           return "Audio CRC";
 448         case V4L2_CID_MPEG_AUDIO_MUTE:          return "Audio Mute";
 449         case V4L2_CID_MPEG_VIDEO_ENCODING:      return "Video Encoding";
 450         case V4L2_CID_MPEG_VIDEO_ASPECT:        return "Video Aspect";
 451         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      return "Video B Frames";
 452         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      return "Video GOP Size";
 453         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   return "Video GOP Closure";
 454         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      return "Video Pulldown";
 455         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  return "Video Bitrate Mode";
 456         case V4L2_CID_MPEG_VIDEO_BITRATE:       return "Video Bitrate";
 457         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  return "Video Peak Bitrate";
 458         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
 459         case V4L2_CID_MPEG_VIDEO_MUTE:          return "Video Mute";
 460         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:      return "Video Mute YUV";
 461         case V4L2_CID_MPEG_STREAM_TYPE:         return "Stream Type";
 462         case V4L2_CID_MPEG_STREAM_PID_PMT:      return "Stream PMT Program ID";
 463         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    return "Stream Audio Program ID";
 464         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    return "Stream Video Program ID";
 465         case V4L2_CID_MPEG_STREAM_PID_PCR:      return "Stream PCR Program ID";
 466         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
 467         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
 468         case V4L2_CID_MPEG_STREAM_VBI_FMT:      return "Stream VBI Format";
 469
 470         /* CAMERA controls */
 471         case V4L2_CID_CAMERA_CLASS:             return "Camera Controls";
 472         case V4L2_CID_EXPOSURE_AUTO:            return "Auto Exposure";
 473         case V4L2_CID_EXPOSURE_ABSOLUTE:        return "Exposure Time, Absolute";
 474         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:   return "Exposure, Dynamic Framerate";
 475         case V4L2_CID_PAN_RELATIVE:             return "Pan, Relative";
 476         case V4L2_CID_TILT_RELATIVE:            return "Tilt, Relative";
 477         case V4L2_CID_PAN_RESET:                return "Pan, Reset";
 478         case V4L2_CID_TILT_RESET:               return "Tilt, Reset";
 479         case V4L2_CID_PAN_ABSOLUTE:             return "Pan, Absolute";
 480         case V4L2_CID_TILT_ABSOLUTE:            return "Tilt, Absolute";
 481         case V4L2_CID_FOCUS_ABSOLUTE:           return "Focus, Absolute";
 482         case V4L2_CID_FOCUS_RELATIVE:           return "Focus, Relative";
 483         case V4L2_CID_FOCUS_AUTO:               return "Focus, Automatic";
 484         case V4L2_CID_ZOOM_ABSOLUTE:            return "Zoom, Absolute";
 485         case V4L2_CID_ZOOM_RELATIVE:            return "Zoom, Relative";
 486         case V4L2_CID_ZOOM_CONTINUOUS:          return "Zoom, Continuous";
 487         case V4L2_CID_PRIVACY:                  return "Privacy";
 488
 489         /* FM Radio Modulator control */
 490         case V4L2_CID_FM_TX_CLASS:              return "FM Radio Modulator Controls";
 491         case V4L2_CID_RDS_TX_DEVIATION:         return "RDS Signal Deviation";
 492         case V4L2_CID_RDS_TX_PI:                return "RDS Program ID";
 493         case V4L2_CID_RDS_TX_PTY:               return "RDS Program Type";
 494         case V4L2_CID_RDS_TX_PS_NAME:           return "RDS PS Name";
 495         case V4L2_CID_RDS_TX_RADIO_TEXT:        return "RDS Radio Text";
 496         case V4L2_CID_AUDIO_LIMITER_ENABLED:    return "Audio Limiter Feature Enabled";
 497         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
 498         case V4L2_CID_AUDIO_LIMITER_DEVIATION:  return "Audio Limiter Deviation";
 499         case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Feature Enabled";
 500         case V4L2_CID_AUDIO_COMPRESSION_GAIN:   return "Audio Compression Gain";
 501         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
 502         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
 503         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
 504         case V4L2_CID_PILOT_TONE_ENABLED:       return "Pilot Tone Feature Enabled";
 505         case V4L2_CID_PILOT_TONE_DEVIATION:     return "Pilot Tone Deviation";
 506         case V4L2_CID_PILOT_TONE_FREQUENCY:     return "Pilot Tone Frequency";
 507         case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-emphasis settings";
 508         case V4L2_CID_TUNE_POWER_LEVEL:         return "Tune Power Level";
 509         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:   return "Tune Antenna Capacitor";
 510
 511         default:
 512                 return NULL;
 513         }
 514 }
 515 EXPORT_SYMBOL(v4l2_ctrl_get_name);
 516
 517 /* Fill in a struct v4l2_queryctrl */
 518 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
 519 {
 520         const char *name = v4l2_ctrl_get_name(qctrl->id);
 521
 522         qctrl->flags = 0;
 523         if (name == NULL)
 524                 return -EINVAL;
 525
 526         switch (qctrl->id) {
 527         case V4L2_CID_AUDIO_MUTE:
 528         case V4L2_CID_AUDIO_LOUDNESS:
 529         case V4L2_CID_AUTO_WHITE_BALANCE:
 530         case V4L2_CID_AUTOGAIN:
 531         case V4L2_CID_HFLIP:
 532         case V4L2_CID_VFLIP:
 533         case V4L2_CID_HUE_AUTO:
 534         case V4L2_CID_CHROMA_AGC:
 535         case V4L2_CID_COLOR_KILLER:
 536         case V4L2_CID_MPEG_AUDIO_MUTE:
 537         case V4L2_CID_MPEG_VIDEO_MUTE:
 538         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 539         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 540         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
 541         case V4L2_CID_FOCUS_AUTO:
 542         case V4L2_CID_PRIVACY:
 543         case V4L2_CID_AUDIO_LIMITER_ENABLED:
 544         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
 545         case V4L2_CID_PILOT_TONE_ENABLED:
 546                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
 547                 min = 0;
 548                 max = step = 1;
 549                 break;
 550         case V4L2_CID_PAN_RESET:
 551         case V4L2_CID_TILT_RESET:
 552                 qctrl->type = V4L2_CTRL_TYPE_BUTTON;
 553                 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
 554                 min = max = step = def = 0;
 555                 break;
 556         case V4L2_CID_POWER_LINE_FREQUENCY:
 557         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 558         case V4L2_CID_MPEG_AUDIO_ENCODING:
 559         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 560         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 561         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 562         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 563         case V4L2_CID_MPEG_AUDIO_MODE:
 564         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 565         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 566         case V4L2_CID_MPEG_AUDIO_CRC:
 567         case V4L2_CID_MPEG_VIDEO_ENCODING:
 568         case V4L2_CID_MPEG_VIDEO_ASPECT:
 569         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 570         case V4L2_CID_MPEG_STREAM_TYPE:
 571         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 572         case V4L2_CID_EXPOSURE_AUTO:
 573         case V4L2_CID_COLORFX:
 574         case V4L2_CID_TUNE_PREEMPHASIS:
 575                 qctrl->type = V4L2_CTRL_TYPE_MENU;
 576                 step = 1;
 577                 break;
 578         case V4L2_CID_RDS_TX_PS_NAME:
 579         case V4L2_CID_RDS_TX_RADIO_TEXT:
 580                 qctrl->type = V4L2_CTRL_TYPE_STRING;
 581                 break;
 582         case V4L2_CID_USER_CLASS:
 583         case V4L2_CID_CAMERA_CLASS:
 584         case V4L2_CID_MPEG_CLASS:
 585         case V4L2_CID_FM_TX_CLASS:
 586                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
 587                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
 588                 min = max = step = def = 0;
 589                 break;
 590         default:
 591                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
 592                 break;
 593         }
 594         switch (qctrl->id) {
 595         case V4L2_CID_MPEG_AUDIO_ENCODING:
 596         case V4L2_CID_MPEG_AUDIO_MODE:
 597         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 598         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 599         case V4L2_CID_MPEG_STREAM_TYPE:
 600                 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
 601                 break;
 602         case V4L2_CID_AUDIO_VOLUME:
 603         case V4L2_CID_AUDIO_BALANCE:
 604         case V4L2_CID_AUDIO_BASS:
 605         case V4L2_CID_AUDIO_TREBLE:
 606         case V4L2_CID_BRIGHTNESS:
 607         case V4L2_CID_CONTRAST:
 608         case V4L2_CID_SATURATION:
 609         case V4L2_CID_HUE:
 610         case V4L2_CID_RED_BALANCE:
 611         case V4L2_CID_BLUE_BALANCE:
 612         case V4L2_CID_GAMMA:
 613         case V4L2_CID_SHARPNESS:
 614         case V4L2_CID_RDS_TX_DEVIATION:
 615         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
 616         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
 617         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
 618         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
 619         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
 620         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
 621         case V4L2_CID_PILOT_TONE_DEVIATION:
 622         case V4L2_CID_PILOT_TONE_FREQUENCY:
 623         case V4L2_CID_TUNE_POWER_LEVEL:
 624         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
 625                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
 626                 break;
 627         case V4L2_CID_PAN_RELATIVE:
 628         case V4L2_CID_TILT_RELATIVE:
 629         case V4L2_CID_FOCUS_RELATIVE:
 630         case V4L2_CID_ZOOM_RELATIVE:
 631                 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
 632                 break;
 633         }
 634         qctrl->minimum = min;
 635         qctrl->maximum = max;
 636         qctrl->step = step;
 637         qctrl->default_value = def;
 638         qctrl->reserved[0] = qctrl->reserved[1] = 0;
 639         strlcpy(qctrl->name, name, sizeof(qctrl->name));
 640         return 0;
 641 }
 642 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
 643
 644 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
 645    the menu. The qctrl pointer may be NULL, in which case it is ignored.
 646    If menu_items is NULL, then the menu items are retrieved using
 647    v4l2_ctrl_get_menu. */
 648 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
 649                const char **menu_items)
 650 {
 651         int i;
 652
 653         qmenu->reserved = 0;
 654         if (menu_items == NULL)
 655                 menu_items = v4l2_ctrl_get_menu(qmenu->id);
 656         if (menu_items == NULL ||
 657             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
 658                 return -EINVAL;
 659         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
 660         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
 661                 return -EINVAL;
 662         strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
 663         return 0;
 664 }
 665 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
 666
 667 /* Fill in a struct v4l2_querymenu based on the specified array of valid
 668    menu items (terminated by V4L2_CTRL_MENU_IDS_END).
 669    Use this if there are 'holes' in the list of valid menu items. */
 670 int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
 671 {
 672         const char **menu_items = v4l2_ctrl_get_menu(qmenu->id);
 673
 674         qmenu->reserved = 0;
 675         if (menu_items == NULL || ids == NULL)
 676                 return -EINVAL;
 677         while (*ids != V4L2_CTRL_MENU_IDS_END) {
 678                 if (*ids++ == qmenu->index) {
 679                         strlcpy(qmenu->name, menu_items[qmenu->index],
 680                                         sizeof(qmenu->name));
 681                         return 0;
 682                 }
 683         }
 684         return -EINVAL;
 685 }
 686 EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
 687
 688 /* ctrl_classes points to an array of u32 pointers, the last element is
 689    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
 690    Each array must be sorted low to high and belong to the same control
 691    class. The array of u32 pointers must also be sorted, from low class IDs
 692    to high class IDs.
 693
 694    This function returns the first ID that follows after the given ID.
 695    When no more controls are available 0 is returned. */
 696 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
 697 {
 698         u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
 699         const u32 *pctrl;
 700
 701         if (ctrl_classes == NULL)
 702                 return 0;
 703
 704         /* if no query is desired, then check if the ID is part of ctrl_classes */
 705         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
 706                 /* find class */
 707                 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
 708                         ctrl_classes++;
 709                 if (*ctrl_classes == NULL)
 710                         return 0;
 711                 pctrl = *ctrl_classes;
 712                 /* find control ID */
 713                 while (*pctrl && *pctrl != id) pctrl++;
 714                 return *pctrl ? id : 0;
 715         }
 716         id &= V4L2_CTRL_ID_MASK;
 717         id++;   /* select next control */
 718         /* find first class that matches (or is greater than) the class of
 719            the ID */
 720         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
 721                 ctrl_classes++;
 722         /* no more classes */
 723         if (*ctrl_classes == NULL)
 724                 return 0;
 725         pctrl = *ctrl_classes;
 726         /* find first ctrl within the class that is >= ID */
 727         while (*pctrl && *pctrl < id) pctrl++;
 728         if (*pctrl)
 729                 return *pctrl;
 730         /* we are at the end of the controls of the current class. */
 731         /* continue with next class if available */
 732         ctrl_classes++;
 733         if (*ctrl_classes == NULL)
 734                 return 0;
 735         return **ctrl_classes;
 736 }
 737 EXPORT_SYMBOL(v4l2_ctrl_next);
 738
 739 int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
 740 {
 741         switch (match->type) {
 742         case V4L2_CHIP_MATCH_HOST:
 743                 return match->addr == 0;
 744         default:
 745                 return 0;
 746         }
 747 }
 748 EXPORT_SYMBOL(v4l2_chip_match_host);
 749
 750 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
 751 int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
 752 {
 753         int len;
 754
 755         if (c == NULL || match == NULL)
 756                 return 0;
 757
 758         switch (match->type) {
 759         case V4L2_CHIP_MATCH_I2C_DRIVER:
 760                 if (c->driver == NULL || c->driver->driver.name == NULL)
 761                         return 0;
 762                 len = strlen(c->driver->driver.name);
 763                 /* legacy drivers have a ' suffix, don't try to match that */
 764                 if (len && c->driver->driver.name[len - 1] == '\'')
 765                         len--;
 766                 return len && !strncmp(c->driver->driver.name, match->name, len);
 767         case V4L2_CHIP_MATCH_I2C_ADDR:
 768                 return c->addr == match->addr;
 769         default:
 770                 return 0;
 771         }
 772 }
 773 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
 774
 775 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
 776                 u32 ident, u32 revision)
 777 {
 778         if (!v4l2_chip_match_i2c_client(c, &chip->match))
 779                 return 0;
 780         if (chip->ident == V4L2_IDENT_NONE) {
 781                 chip->ident = ident;
 782                 chip->revision = revision;
 783         }
 784         else {
 785                 chip->ident = V4L2_IDENT_AMBIGUOUS;
 786                 chip->revision = 0;
 787         }
 788         return 0;
 789 }
 790 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
 791
 792 /* ----------------------------------------------------------------- */
 793
 794 /* I2C Helper functions */
 795
 796
 797 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
 798                 const struct v4l2_subdev_ops *ops)
 799 {
 800         v4l2_subdev_init(sd, ops);
 801         sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
 802         /* the owner is the same as the i2c_client's driver owner */
 803         sd->owner = client->driver->driver.owner;
 804         /* i2c_client and v4l2_subdev point to one another */
 805         v4l2_set_subdevdata(sd, client);
 806         i2c_set_clientdata(client, sd);
 807         /* initialize name */
 808         snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
 809                 client->driver->driver.name, i2c_adapter_id(client->adapter),
 810                 client->addr);
 811 }
 812 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
 813
 814
 815
 816 /* Load an i2c sub-device. */
 817 struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
 818                 struct i2c_adapter *adapter, const char *module_name,
 819                 struct i2c_board_info *info, const unsigned short *probe_addrs)
 820 {
 821         struct v4l2_subdev *sd = NULL;
 822         struct i2c_client *client;
 823
 824         BUG_ON(!v4l2_dev);
 825
 826         if (module_name)
 827                 request_module(module_name);
 828
 829         /* Create the i2c client */
 830         if (info->addr == 0 && probe_addrs)
 831                 client = i2c_new_probed_device(adapter, info, probe_addrs);
 832         else
 833                 client = i2c_new_device(adapter, info);
 834
 835         /* Note: by loading the module first we are certain that c->driver
 836            will be set if the driver was found. If the module was not loaded
 837            first, then the i2c core tries to delay-load the module for us,
 838            and then c->driver is still NULL until the module is finally
 839            loaded. This delay-load mechanism doesn't work if other drivers
 840            want to use the i2c device, so explicitly loading the module
 841            is the best alternative. */
 842         if (client == NULL || client->driver == NULL)
 843                 goto error;
 844
 845         /* Lock the module so we can safely get the v4l2_subdev pointer */
 846         if (!try_module_get(client->driver->driver.owner))
 847                 goto error;
 848         sd = i2c_get_clientdata(client);
 849
 850         /* Register with the v4l2_device which increases the module's
 851            use count as well. */
 852         if (v4l2_device_register_subdev(v4l2_dev, sd))
 853                 sd = NULL;
 854         /* Decrease the module use count to match the first try_module_get. */
 855         module_put(client->driver->driver.owner);
 856
 857         if (sd) {
 858                 /* We return errors from v4l2_subdev_call only if we have the
 859                    callback as the .s_config is not mandatory */
 860                 int err = v4l2_subdev_call(sd, core, s_config,
 861                                 info->irq, info->platform_data);
 862
 863                 if (err && err != -ENOIOCTLCMD) {
 864                         v4l2_device_unregister_subdev(sd);
 865                         sd = NULL;
 866                 }
 867         }
 868
 869 error:
 870         /* If we have a client but no subdev, then something went wrong and
 871            we must unregister the client. */
 872         if (client && sd == NULL)
 873                 i2c_unregister_device(client);
 874         return sd;
 875 }
 876 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
 877
 878 struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev,
 879                 struct i2c_adapter *adapter,
 880                 const char *module_name, const char *client_type,
 881                 int irq, void *platform_data,
 882                 u8 addr, const unsigned short *probe_addrs)
 883 {
 884         struct i2c_board_info info;
 885
 886         /* Setup the i2c board info with the device type and
 887            the device address. */
 888         memset(&info, 0, sizeof(info));
 889         strlcpy(info.type, client_type, sizeof(info.type));
 890         info.addr = addr;
 891         info.irq = irq;
 892         info.platform_data = platform_data;
 893
 894         return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, module_name,
 895                         &info, probe_addrs);
 896 }
 897 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_cfg);
 898
 899 /* Return i2c client address of v4l2_subdev. */
 900 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
 901 {
 902         struct i2c_client *client = v4l2_get_subdevdata(sd);
 903
 904         return client ? client->addr : I2C_CLIENT_END;
 905 }
 906 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
 907
 908 /* Return a list of I2C tuner addresses to probe. Use only if the tuner
 909    addresses are unknown. */
 910 const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
 911 {
 912         static const unsigned short radio_addrs[] = {
 913 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
 914                 0x10,
 915 #endif
 916                 0x60,
 917                 I2C_CLIENT_END
 918         };
 919         static const unsigned short demod_addrs[] = {
 920                 0x42, 0x43, 0x4a, 0x4b,
 921                 I2C_CLIENT_END
 922         };
 923         static const unsigned short tv_addrs[] = {
 924                 0x42, 0x43, 0x4a, 0x4b,         /* tda8290 */
 925                 0x60, 0x61, 0x62, 0x63, 0x64,
 926                 I2C_CLIENT_END
 927         };
 928
 929         switch (type) {
 930         case ADDRS_RADIO:
 931                 return radio_addrs;
 932         case ADDRS_DEMOD:
 933                 return demod_addrs;
 934         case ADDRS_TV:
 935                 return tv_addrs;
 936         case ADDRS_TV_WITH_DEMOD:
 937                 return tv_addrs + 4;
 938         }
 939         return NULL;
 940 }
 941 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
 942
 943 #endif /* defined(CONFIG_I2C) */
 944
 945 /* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
 946  * and max don't have to be aligned, but there must be at least one valid
 947  * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
 948  * of 16 between 17 and 31.  */
 949 static unsigned int clamp_align(unsigned int x, unsigned int min,
 950                                 unsigned int max, unsigned int align)
 951 {
 952         /* Bits that must be zero to be aligned */
 953         unsigned int mask = ~((1 << align) - 1);
 954
 955         /* Round to nearest aligned value */
 956         if (align)
 957                 x = (x + (1 << (align - 1))) & mask;
 958
 959         /* Clamp to aligned value of min and max */
 960         if (x < min)
 961                 x = (min + ~mask) & mask;
 962         else if (x > max)
 963                 x = max & mask;
 964
 965         return x;
 966 }
 967
 968 /* Bound an image to have a width between wmin and wmax, and height between
 969  * hmin and hmax, inclusive.  Additionally, the width will be a multiple of
 970  * 2^walign, the height will be a multiple of 2^halign, and the overall size
 971  * (width*height) will be a multiple of 2^salign.  The image may be shrunk
 972  * or enlarged to fit the alignment constraints.
 973  *
 974  * The width or height maximum must not be smaller than the corresponding
 975  * minimum.  The alignments must not be so high there are no possible image
 976  * sizes within the allowed bounds.  wmin and hmin must be at least 1
 977  * (don't use 0).  If you don't care about a certain alignment, specify 0,
 978  * as 2^0 is 1 and one byte alignment is equivalent to no alignment.  If
 979  * you only want to adjust downward, specify a maximum that's the same as
 980  * the initial value.
 981  */
 982 void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
 983                            unsigned int walign,
 984                            u32 *h, unsigned int hmin, unsigned int hmax,
 985                            unsigned int halign, unsigned int salign)
 986 {
 987         *w = clamp_align(*w, wmin, wmax, walign);
 988         *h = clamp_align(*h, hmin, hmax, halign);
 989
 990         /* Usually we don't need to align the size and are done now. */
 991         if (!salign)
 992                 return;
 993
 994         /* How much alignment do we have? */
 995         walign = __ffs(*w);
 996         halign = __ffs(*h);
 997         /* Enough to satisfy the image alignment? */
 998         if (walign + halign < salign) {
 999                 /* Max walign where there is still a valid width */
1000                 unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
1001                 /* Max halign where there is still a valid height */
1002                 unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
1003
1004                 /* up the smaller alignment until we have enough */
1005                 do {
1006                         if (halign >= hmaxa ||
1007                             (walign <= halign && walign < wmaxa)) {
1008                                 *w = clamp_align(*w, wmin, wmax, walign + 1);
1009                                 walign = __ffs(*w);
1010                         } else {
1011                                 *h = clamp_align(*h, hmin, hmax, halign + 1);
1012                                 halign = __ffs(*h);
1013                         }
1014                 } while (halign + walign < salign);
1015         }
1016 }
1017 EXPORT_SYMBOL_GPL(v4l_bound_align_image);