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