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         case V4L2_CID_ROTATE:                   return "Rotate";
 435         case V4L2_CID_BG_COLOR:                 return "Background color";
 436
 437         /* MPEG controls */
 438         case V4L2_CID_MPEG_CLASS:               return "MPEG Encoder Controls";
 439         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
 440         case V4L2_CID_MPEG_AUDIO_ENCODING:      return "Audio Encoding";
 441         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    return "Audio Layer I Bitrate";
 442         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    return "Audio Layer II Bitrate";
 443         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    return "Audio Layer III Bitrate";
 444         case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:   return "Audio AAC Bitrate";
 445         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:   return "Audio AC-3 Bitrate";
 446         case V4L2_CID_MPEG_AUDIO_MODE:          return "Audio Stereo Mode";
 447         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
 448         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      return "Audio Emphasis";
 449         case V4L2_CID_MPEG_AUDIO_CRC:           return "Audio CRC";
 450         case V4L2_CID_MPEG_AUDIO_MUTE:          return "Audio Mute";
 451         case V4L2_CID_MPEG_VIDEO_ENCODING:      return "Video Encoding";
 452         case V4L2_CID_MPEG_VIDEO_ASPECT:        return "Video Aspect";
 453         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      return "Video B Frames";
 454         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      return "Video GOP Size";
 455         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   return "Video GOP Closure";
 456         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      return "Video Pulldown";
 457         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  return "Video Bitrate Mode";
 458         case V4L2_CID_MPEG_VIDEO_BITRATE:       return "Video Bitrate";
 459         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  return "Video Peak Bitrate";
 460         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
 461         case V4L2_CID_MPEG_VIDEO_MUTE:          return "Video Mute";
 462         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:      return "Video Mute YUV";
 463         case V4L2_CID_MPEG_STREAM_TYPE:         return "Stream Type";
 464         case V4L2_CID_MPEG_STREAM_PID_PMT:      return "Stream PMT Program ID";
 465         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    return "Stream Audio Program ID";
 466         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    return "Stream Video Program ID";
 467         case V4L2_CID_MPEG_STREAM_PID_PCR:      return "Stream PCR Program ID";
 468         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
 469         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
 470         case V4L2_CID_MPEG_STREAM_VBI_FMT:      return "Stream VBI Format";
 471
 472         /* CAMERA controls */
 473         case V4L2_CID_CAMERA_CLASS:             return "Camera Controls";
 474         case V4L2_CID_EXPOSURE_AUTO:            return "Auto Exposure";
 475         case V4L2_CID_EXPOSURE_ABSOLUTE:        return "Exposure Time, Absolute";
 476         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:   return "Exposure, Dynamic Framerate";
 477         case V4L2_CID_PAN_RELATIVE:             return "Pan, Relative";
 478         case V4L2_CID_TILT_RELATIVE:            return "Tilt, Relative";
 479         case V4L2_CID_PAN_RESET:                return "Pan, Reset";
 480         case V4L2_CID_TILT_RESET:               return "Tilt, Reset";
 481         case V4L2_CID_PAN_ABSOLUTE:             return "Pan, Absolute";
 482         case V4L2_CID_TILT_ABSOLUTE:            return "Tilt, Absolute";
 483         case V4L2_CID_FOCUS_ABSOLUTE:           return "Focus, Absolute";
 484         case V4L2_CID_FOCUS_RELATIVE:           return "Focus, Relative";
 485         case V4L2_CID_FOCUS_AUTO:               return "Focus, Automatic";
 486         case V4L2_CID_ZOOM_ABSOLUTE:            return "Zoom, Absolute";
 487         case V4L2_CID_ZOOM_RELATIVE:            return "Zoom, Relative";
 488         case V4L2_CID_ZOOM_CONTINUOUS:          return "Zoom, Continuous";
 489         case V4L2_CID_PRIVACY:                  return "Privacy";
 490
 491         /* FM Radio Modulator control */
 492         case V4L2_CID_FM_TX_CLASS:              return "FM Radio Modulator Controls";
 493         case V4L2_CID_RDS_TX_DEVIATION:         return "RDS Signal Deviation";
 494         case V4L2_CID_RDS_TX_PI:                return "RDS Program ID";
 495         case V4L2_CID_RDS_TX_PTY:               return "RDS Program Type";
 496         case V4L2_CID_RDS_TX_PS_NAME:           return "RDS PS Name";
 497         case V4L2_CID_RDS_TX_RADIO_TEXT:        return "RDS Radio Text";
 498         case V4L2_CID_AUDIO_LIMITER_ENABLED:    return "Audio Limiter Feature Enabled";
 499         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
 500         case V4L2_CID_AUDIO_LIMITER_DEVIATION:  return "Audio Limiter Deviation";
 501         case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Feature Enabled";
 502         case V4L2_CID_AUDIO_COMPRESSION_GAIN:   return "Audio Compression Gain";
 503         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
 504         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
 505         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
 506         case V4L2_CID_PILOT_TONE_ENABLED:       return "Pilot Tone Feature Enabled";
 507         case V4L2_CID_PILOT_TONE_DEVIATION:     return "Pilot Tone Deviation";
 508         case V4L2_CID_PILOT_TONE_FREQUENCY:     return "Pilot Tone Frequency";
 509         case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-emphasis settings";
 510         case V4L2_CID_TUNE_POWER_LEVEL:         return "Tune Power Level";
 511         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:   return "Tune Antenna Capacitor";
 512
 513         default:
 514                 return NULL;
 515         }
 516 }
 517 EXPORT_SYMBOL(v4l2_ctrl_get_name);
 518
 519 /* Fill in a struct v4l2_queryctrl */
 520 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
 521 {
 522         const char *name = v4l2_ctrl_get_name(qctrl->id);
 523
 524         qctrl->flags = 0;
 525         if (name == NULL)
 526                 return -EINVAL;
 527
 528         switch (qctrl->id) {
 529         case V4L2_CID_AUDIO_MUTE:
 530         case V4L2_CID_AUDIO_LOUDNESS:
 531         case V4L2_CID_AUTO_WHITE_BALANCE:
 532         case V4L2_CID_AUTOGAIN:
 533         case V4L2_CID_HFLIP:
 534         case V4L2_CID_VFLIP:
 535         case V4L2_CID_HUE_AUTO:
 536         case V4L2_CID_CHROMA_AGC:
 537         case V4L2_CID_COLOR_KILLER:
 538         case V4L2_CID_MPEG_AUDIO_MUTE:
 539         case V4L2_CID_MPEG_VIDEO_MUTE:
 540         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 541         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 542         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
 543         case V4L2_CID_FOCUS_AUTO:
 544         case V4L2_CID_PRIVACY:
 545         case V4L2_CID_AUDIO_LIMITER_ENABLED:
 546         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
 547         case V4L2_CID_PILOT_TONE_ENABLED:
 548                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
 549                 min = 0;
 550                 max = step = 1;
 551                 break;
 552         case V4L2_CID_PAN_RESET:
 553         case V4L2_CID_TILT_RESET:
 554                 qctrl->type = V4L2_CTRL_TYPE_BUTTON;
 555                 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
 556                 min = max = step = def = 0;
 557                 break;
 558         case V4L2_CID_POWER_LINE_FREQUENCY:
 559         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 560         case V4L2_CID_MPEG_AUDIO_ENCODING:
 561         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 562         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 563         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 564         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 565         case V4L2_CID_MPEG_AUDIO_MODE:
 566         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 567         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 568         case V4L2_CID_MPEG_AUDIO_CRC:
 569         case V4L2_CID_MPEG_VIDEO_ENCODING:
 570         case V4L2_CID_MPEG_VIDEO_ASPECT:
 571         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 572         case V4L2_CID_MPEG_STREAM_TYPE:
 573         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 574         case V4L2_CID_EXPOSURE_AUTO:
 575         case V4L2_CID_COLORFX:
 576         case V4L2_CID_TUNE_PREEMPHASIS:
 577                 qctrl->type = V4L2_CTRL_TYPE_MENU;
 578                 step = 1;
 579                 break;
 580         case V4L2_CID_RDS_TX_PS_NAME:
 581         case V4L2_CID_RDS_TX_RADIO_TEXT:
 582                 qctrl->type = V4L2_CTRL_TYPE_STRING;
 583                 break;
 584         case V4L2_CID_USER_CLASS:
 585         case V4L2_CID_CAMERA_CLASS:
 586         case V4L2_CID_MPEG_CLASS:
 587         case V4L2_CID_FM_TX_CLASS:
 588                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
 589                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
 590                 min = max = step = def = 0;
 591                 break;
 592         case V4L2_CID_BG_COLOR:
 593                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
 594                 step = 1;
 595                 min = 0;
 596                 /* Max is calculated as RGB888 that is 2^24 */
 597                 max = 0xFFFFFF;
 598                 break;
 599         default:
 600                 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
 601                 break;
 602         }
 603         switch (qctrl->id) {
 604         case V4L2_CID_MPEG_AUDIO_ENCODING:
 605         case V4L2_CID_MPEG_AUDIO_MODE:
 606         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 607         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 608         case V4L2_CID_MPEG_STREAM_TYPE:
 609                 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
 610                 break;
 611         case V4L2_CID_AUDIO_VOLUME:
 612         case V4L2_CID_AUDIO_BALANCE:
 613         case V4L2_CID_AUDIO_BASS:
 614         case V4L2_CID_AUDIO_TREBLE:
 615         case V4L2_CID_BRIGHTNESS:
 616         case V4L2_CID_CONTRAST:
 617         case V4L2_CID_SATURATION:
 618         case V4L2_CID_HUE:
 619         case V4L2_CID_RED_BALANCE:
 620         case V4L2_CID_BLUE_BALANCE:
 621         case V4L2_CID_GAMMA:
 622         case V4L2_CID_SHARPNESS:
 623         case V4L2_CID_RDS_TX_DEVIATION:
 624         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
 625         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
 626         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
 627         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
 628         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
 629         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
 630         case V4L2_CID_PILOT_TONE_DEVIATION:
 631         case V4L2_CID_PILOT_TONE_FREQUENCY:
 632         case V4L2_CID_TUNE_POWER_LEVEL:
 633         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
 634                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
 635                 break;
 636         case V4L2_CID_PAN_RELATIVE:
 637         case V4L2_CID_TILT_RELATIVE:
 638         case V4L2_CID_FOCUS_RELATIVE:
 639         case V4L2_CID_ZOOM_RELATIVE:
 640                 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
 641                 break;
 642         }
 643         qctrl->minimum = min;
 644         qctrl->maximum = max;
 645         qctrl->step = step;
 646         qctrl->default_value = def;
 647         qctrl->reserved[0] = qctrl->reserved[1] = 0;
 648         strlcpy(qctrl->name, name, sizeof(qctrl->name));
 649         return 0;
 650 }
 651 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
 652
 653 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
 654    the menu. The qctrl pointer may be NULL, in which case it is ignored.
 655    If menu_items is NULL, then the menu items are retrieved using
 656    v4l2_ctrl_get_menu. */
 657 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
 658                const char **menu_items)
 659 {
 660         int i;
 661
 662         qmenu->reserved = 0;
 663         if (menu_items == NULL)
 664                 menu_items = v4l2_ctrl_get_menu(qmenu->id);
 665         if (menu_items == NULL ||
 666             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
 667                 return -EINVAL;
 668         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
 669         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
 670                 return -EINVAL;
 671         strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
 672         return 0;
 673 }
 674 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
 675
 676 /* Fill in a struct v4l2_querymenu based on the specified array of valid
 677    menu items (terminated by V4L2_CTRL_MENU_IDS_END).
 678    Use this if there are 'holes' in the list of valid menu items. */
 679 int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
 680 {
 681         const char **menu_items = v4l2_ctrl_get_menu(qmenu->id);
 682
 683         qmenu->reserved = 0;
 684         if (menu_items == NULL || ids == NULL)
 685                 return -EINVAL;
 686         while (*ids != V4L2_CTRL_MENU_IDS_END) {
 687                 if (*ids++ == qmenu->index) {
 688                         strlcpy(qmenu->name, menu_items[qmenu->index],
 689                                         sizeof(qmenu->name));
 690                         return 0;
 691                 }
 692         }
 693         return -EINVAL;
 694 }
 695 EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
 696
 697 /* ctrl_classes points to an array of u32 pointers, the last element is
 698    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
 699    Each array must be sorted low to high and belong to the same control
 700    class. The array of u32 pointers must also be sorted, from low class IDs
 701    to high class IDs.
 702
 703    This function returns the first ID that follows after the given ID.
 704    When no more controls are available 0 is returned. */
 705 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
 706 {
 707         u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
 708         const u32 *pctrl;
 709
 710         if (ctrl_classes == NULL)
 711                 return 0;
 712
 713         /* if no query is desired, then check if the ID is part of ctrl_classes */
 714         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
 715                 /* find class */
 716                 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
 717                         ctrl_classes++;
 718                 if (*ctrl_classes == NULL)
 719                         return 0;
 720                 pctrl = *ctrl_classes;
 721                 /* find control ID */
 722                 while (*pctrl && *pctrl != id) pctrl++;
 723                 return *pctrl ? id : 0;
 724         }
 725         id &= V4L2_CTRL_ID_MASK;
 726         id++;   /* select next control */
 727         /* find first class that matches (or is greater than) the class of
 728            the ID */
 729         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
 730                 ctrl_classes++;
 731         /* no more classes */
 732         if (*ctrl_classes == NULL)
 733                 return 0;
 734         pctrl = *ctrl_classes;
 735         /* find first ctrl within the class that is >= ID */
 736         while (*pctrl && *pctrl < id) pctrl++;
 737         if (*pctrl)
 738                 return *pctrl;
 739         /* we are at the end of the controls of the current class. */
 740         /* continue with next class if available */
 741         ctrl_classes++;
 742         if (*ctrl_classes == NULL)
 743                 return 0;
 744         return **ctrl_classes;
 745 }
 746 EXPORT_SYMBOL(v4l2_ctrl_next);
 747
 748 int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
 749 {
 750         switch (match->type) {
 751         case V4L2_CHIP_MATCH_HOST:
 752                 return match->addr == 0;
 753         default:
 754                 return 0;
 755         }
 756 }
 757 EXPORT_SYMBOL(v4l2_chip_match_host);
 758
 759 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
 760 int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
 761 {
 762         int len;
 763
 764         if (c == NULL || match == NULL)
 765                 return 0;
 766
 767         switch (match->type) {
 768         case V4L2_CHIP_MATCH_I2C_DRIVER:
 769                 if (c->driver == NULL || c->driver->driver.name == NULL)
 770                         return 0;
 771                 len = strlen(c->driver->driver.name);
 772                 /* legacy drivers have a ' suffix, don't try to match that */
 773                 if (len && c->driver->driver.name[len - 1] == '\'')
 774                         len--;
 775                 return len && !strncmp(c->driver->driver.name, match->name, len);
 776         case V4L2_CHIP_MATCH_I2C_ADDR:
 777                 return c->addr == match->addr;
 778         default:
 779                 return 0;
 780         }
 781 }
 782 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
 783
 784 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
 785                 u32 ident, u32 revision)
 786 {
 787         if (!v4l2_chip_match_i2c_client(c, &chip->match))
 788                 return 0;
 789         if (chip->ident == V4L2_IDENT_NONE) {
 790                 chip->ident = ident;
 791                 chip->revision = revision;
 792         }
 793         else {
 794                 chip->ident = V4L2_IDENT_AMBIGUOUS;
 795                 chip->revision = 0;
 796         }
 797         return 0;
 798 }
 799 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
 800
 801 /* ----------------------------------------------------------------- */
 802
 803 /* I2C Helper functions */
 804
 805
 806 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
 807                 const struct v4l2_subdev_ops *ops)
 808 {
 809         v4l2_subdev_init(sd, ops);
 810         sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
 811         /* the owner is the same as the i2c_client's driver owner */
 812         sd->owner = client->driver->driver.owner;
 813         /* i2c_client and v4l2_subdev point to one another */
 814         v4l2_set_subdevdata(sd, client);
 815         i2c_set_clientdata(client, sd);
 816         /* initialize name */
 817         snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
 818                 client->driver->driver.name, i2c_adapter_id(client->adapter),
 819                 client->addr);
 820 }
 821 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
 822
 823
 824
 825 /* Load an i2c sub-device. */
 826 struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
 827                 struct i2c_adapter *adapter, const char *module_name,
 828                 struct i2c_board_info *info, const unsigned short *probe_addrs)
 829 {
 830         struct v4l2_subdev *sd = NULL;
 831         struct i2c_client *client;
 832
 833         BUG_ON(!v4l2_dev);
 834
 835         if (module_name)
 836                 request_module(module_name);
 837
 838         /* Create the i2c client */
 839         if (info->addr == 0 && probe_addrs)
 840                 client = i2c_new_probed_device(adapter, info, probe_addrs);
 841         else
 842                 client = i2c_new_device(adapter, info);
 843
 844         /* Note: by loading the module first we are certain that c->driver
 845            will be set if the driver was found. If the module was not loaded
 846            first, then the i2c core tries to delay-load the module for us,
 847            and then c->driver is still NULL until the module is finally
 848            loaded. This delay-load mechanism doesn't work if other drivers
 849            want to use the i2c device, so explicitly loading the module
 850            is the best alternative. */
 851         if (client == NULL || client->driver == NULL)
 852                 goto error;
 853
 854         /* Lock the module so we can safely get the v4l2_subdev pointer */
 855         if (!try_module_get(client->driver->driver.owner))
 856                 goto error;
 857         sd = i2c_get_clientdata(client);
 858
 859         /* Register with the v4l2_device which increases the module's
 860            use count as well. */
 861         if (v4l2_device_register_subdev(v4l2_dev, sd))
 862                 sd = NULL;
 863         /* Decrease the module use count to match the first try_module_get. */
 864         module_put(client->driver->driver.owner);
 865
 866         if (sd) {
 867                 /* We return errors from v4l2_subdev_call only if we have the
 868                    callback as the .s_config is not mandatory */
 869                 int err = v4l2_subdev_call(sd, core, s_config,
 870                                 info->irq, info->platform_data);
 871
 872                 if (err && err != -ENOIOCTLCMD) {
 873                         v4l2_device_unregister_subdev(sd);
 874                         sd = NULL;
 875                 }
 876         }
 877
 878 error:
 879         /* If we have a client but no subdev, then something went wrong and
 880            we must unregister the client. */
 881         if (client && sd == NULL)
 882                 i2c_unregister_device(client);
 883         return sd;
 884 }
 885 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
 886
 887 struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev,
 888                 struct i2c_adapter *adapter,
 889                 const char *module_name, const char *client_type,
 890                 int irq, void *platform_data,
 891                 u8 addr, const unsigned short *probe_addrs)
 892 {
 893         struct i2c_board_info info;
 894
 895         /* Setup the i2c board info with the device type and
 896            the device address. */
 897         memset(&info, 0, sizeof(info));
 898         strlcpy(info.type, client_type, sizeof(info.type));
 899         info.addr = addr;
 900         info.irq = irq;
 901         info.platform_data = platform_data;
 902
 903         return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, module_name,
 904                         &info, probe_addrs);
 905 }
 906 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_cfg);
 907
 908 /* Return i2c client address of v4l2_subdev. */
 909 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
 910 {
 911         struct i2c_client *client = v4l2_get_subdevdata(sd);
 912
 913         return client ? client->addr : I2C_CLIENT_END;
 914 }
 915 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
 916
 917 /* Return a list of I2C tuner addresses to probe. Use only if the tuner
 918    addresses are unknown. */
 919 const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
 920 {
 921         static const unsigned short radio_addrs[] = {
 922 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
 923                 0x10,
 924 #endif
 925                 0x60,
 926                 I2C_CLIENT_END
 927         };
 928         static const unsigned short demod_addrs[] = {
 929                 0x42, 0x43, 0x4a, 0x4b,
 930                 I2C_CLIENT_END
 931         };
 932         static const unsigned short tv_addrs[] = {
 933                 0x42, 0x43, 0x4a, 0x4b,         /* tda8290 */
 934                 0x60, 0x61, 0x62, 0x63, 0x64,
 935                 I2C_CLIENT_END
 936         };
 937
 938         switch (type) {
 939         case ADDRS_RADIO:
 940                 return radio_addrs;
 941         case ADDRS_DEMOD:
 942                 return demod_addrs;
 943         case ADDRS_TV:
 944                 return tv_addrs;
 945         case ADDRS_TV_WITH_DEMOD:
 946                 return tv_addrs + 4;
 947         }
 948         return NULL;
 949 }
 950 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
 951
 952 #endif /* defined(CONFIG_I2C) */
 953
 954 /* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
 955  * and max don't have to be aligned, but there must be at least one valid
 956  * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
 957  * of 16 between 17 and 31.  */
 958 static unsigned int clamp_align(unsigned int x, unsigned int min,
 959                                 unsigned int max, unsigned int align)
 960 {
 961         /* Bits that must be zero to be aligned */
 962         unsigned int mask = ~((1 << align) - 1);
 963
 964         /* Round to nearest aligned value */
 965         if (align)
 966                 x = (x + (1 << (align - 1))) & mask;
 967
 968         /* Clamp to aligned value of min and max */
 969         if (x < min)
 970                 x = (min + ~mask) & mask;
 971         else if (x > max)
 972                 x = max & mask;
 973
 974         return x;
 975 }
 976
 977 /* Bound an image to have a width between wmin and wmax, and height between
 978  * hmin and hmax, inclusive.  Additionally, the width will be a multiple of
 979  * 2^walign, the height will be a multiple of 2^halign, and the overall size
 980  * (width*height) will be a multiple of 2^salign.  The image may be shrunk
 981  * or enlarged to fit the alignment constraints.
 982  *
 983  * The width or height maximum must not be smaller than the corresponding
 984  * minimum.  The alignments must not be so high there are no possible image
 985  * sizes within the allowed bounds.  wmin and hmin must be at least 1
 986  * (don't use 0).  If you don't care about a certain alignment, specify 0,
 987  * as 2^0 is 1 and one byte alignment is equivalent to no alignment.  If
 988  * you only want to adjust downward, specify a maximum that's the same as
 989  * the initial value.
 990  */
 991 void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
 992                            unsigned int walign,
 993                            u32 *h, unsigned int hmin, unsigned int hmax,
 994                            unsigned int halign, unsigned int salign)
 995 {
 996         *w = clamp_align(*w, wmin, wmax, walign);
 997         *h = clamp_align(*h, hmin, hmax, halign);
 998
 999         /* Usually we don't need to align the size and are done now. */
1000         if (!salign)
1001                 return;
1002
1003         /* How much alignment do we have? */
1004         walign = __ffs(*w);
1005         halign = __ffs(*h);
1006         /* Enough to satisfy the image alignment? */
1007         if (walign + halign < salign) {
1008                 /* Max walign where there is still a valid width */
1009                 unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
1010                 /* Max halign where there is still a valid height */
1011                 unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
1012
1013                 /* up the smaller alignment until we have enough */
1014                 do {
1015                         if (halign >= hmaxa ||
1016                             (walign <= halign && walign < wmaxa)) {
1017                                 *w = clamp_align(*w, wmin, wmax, walign + 1);
1018                                 walign = __ffs(*w);
1019                         } else {
1020                                 *h = clamp_align(*h, hmin, hmax, halign + 1);
1021                                 halign = __ffs(*h);
1022                         }
1023                 } while (halign + walign < salign);
1024         }
1025 }
1026 EXPORT_SYMBOL_GPL(v4l_bound_align_image);
1027
1028 /**
1029  * v4l_fill_dv_preset_info - fill description of a digital video preset
1030  * @preset - preset value
1031  * @info - pointer to struct v4l2_dv_enum_preset
1032  *
1033  * drivers can use this helper function to fill description of dv preset
1034  * in info.
1035  */
1036 int v4l_fill_dv_preset_info(u32 preset, struct v4l2_dv_enum_preset *info)
1037 {
1038         static const struct v4l2_dv_preset_info {
1039                 u16 width;
1040                 u16 height;
1041                 const char *name;
1042         } dv_presets[] = {
1043                 { 0, 0, "Invalid" },            /* V4L2_DV_INVALID */
1044                 { 720,  480, "480p@59.94" },    /* V4L2_DV_480P59_94 */
1045                 { 720,  576, "576p@50" },       /* V4L2_DV_576P50 */
1046                 { 1280, 720, "720p@24" },       /* V4L2_DV_720P24 */
1047                 { 1280, 720, "720p@25" },       /* V4L2_DV_720P25 */
1048                 { 1280, 720, "720p@30" },       /* V4L2_DV_720P30 */
1049                 { 1280, 720, "720p@50" },       /* V4L2_DV_720P50 */
1050                 { 1280, 720, "720p@59.94" },    /* V4L2_DV_720P59_94 */
1051                 { 1280, 720, "720p@60" },       /* V4L2_DV_720P60 */
1052                 { 1920, 1080, "1080i@29.97" },  /* V4L2_DV_1080I29_97 */
1053                 { 1920, 1080, "1080i@30" },     /* V4L2_DV_1080I30 */
1054                 { 1920, 1080, "1080i@25" },     /* V4L2_DV_1080I25 */
1055                 { 1920, 1080, "1080i@50" },     /* V4L2_DV_1080I50 */
1056                 { 1920, 1080, "1080i@60" },     /* V4L2_DV_1080I60 */
1057                 { 1920, 1080, "1080p@24" },     /* V4L2_DV_1080P24 */
1058                 { 1920, 1080, "1080p@25" },     /* V4L2_DV_1080P25 */
1059                 { 1920, 1080, "1080p@30" },     /* V4L2_DV_1080P30 */
1060                 { 1920, 1080, "1080p@50" },     /* V4L2_DV_1080P50 */
1061                 { 1920, 1080, "1080p@60" },     /* V4L2_DV_1080P60 */
1062         };
1063
1064         if (info == NULL || preset >= ARRAY_SIZE(dv_presets))
1065                 return -EINVAL;
1066
1067         info->preset = preset;
1068         info->width = dv_presets[preset].width;
1069         info->height = dv_presets[preset].height;
1070         strlcpy(info->name, dv_presets[preset].name, sizeof(info->name));
1071         return 0;
1072 }
1073 EXPORT_SYMBOL_GPL(v4l_fill_dv_preset_info);