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