drivers/media/video/v4l2-ctrls.c

   1 /*
   2     V4L2 controls framework implementation.
   3
   4     Copyright (C) 2010  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <linux/ctype.h>
  22 #include <linux/slab.h>
  23 #include <linux/export.h>
  24 #include <media/v4l2-ioctl.h>
  25 #include <media/v4l2-device.h>
  26 #include <media/v4l2-ctrls.h>
  27 #include <media/v4l2-event.h>
  28 #include <media/v4l2-dev.h>
  29
  30 #define has_op(master, op) \
  31         (master->ops && master->ops->op)
  32 #define call_op(master, op) \
  33         (has_op(master, op) ? master->ops->op(master) : 0)
  34
  35 /* Internal temporary helper struct, one for each v4l2_ext_control */
  36 struct v4l2_ctrl_helper {
  37         /* Pointer to the control reference of the master control */
  38         struct v4l2_ctrl_ref *mref;
  39         /* The control corresponding to the v4l2_ext_control ID field. */
  40         struct v4l2_ctrl *ctrl;
  41         /* v4l2_ext_control index of the next control belonging to the
  42            same cluster, or 0 if there isn't any. */
  43         u32 next;
  44 };
  45
  46 /* Small helper function to determine if the autocluster is set to manual
  47    mode. */
  48 static bool is_cur_manual(const struct v4l2_ctrl *master)
  49 {
  50         return master->is_auto && master->cur.val == master->manual_mode_value;
  51 }
  52
  53 /* Same as above, but this checks the against the new value instead of the
  54    current value. */
  55 static bool is_new_manual(const struct v4l2_ctrl *master)
  56 {
  57         return master->is_auto && master->val == master->manual_mode_value;
  58 }
  59
  60 /* Returns NULL or a character pointer array containing the menu for
  61    the given control ID. The pointer array ends with a NULL pointer.
  62    An empty string signifies a menu entry that is invalid. This allows
  63    drivers to disable certain options if it is not supported. */
  64 const char * const *v4l2_ctrl_get_menu(u32 id)
  65 {
  66         static const char * const mpeg_audio_sampling_freq[] = {
  67                 "44.1 kHz",
  68                 "48 kHz",
  69                 "32 kHz",
  70                 NULL
  71         };
  72         static const char * const mpeg_audio_encoding[] = {
  73                 "MPEG-1/2 Layer I",
  74                 "MPEG-1/2 Layer II",
  75                 "MPEG-1/2 Layer III",
  76                 "MPEG-2/4 AAC",
  77                 "AC-3",
  78                 NULL
  79         };
  80         static const char * const mpeg_audio_l1_bitrate[] = {
  81                 "32 kbps",
  82                 "64 kbps",
  83                 "96 kbps",
  84                 "128 kbps",
  85                 "160 kbps",
  86                 "192 kbps",
  87                 "224 kbps",
  88                 "256 kbps",
  89                 "288 kbps",
  90                 "320 kbps",
  91                 "352 kbps",
  92                 "384 kbps",
  93                 "416 kbps",
  94                 "448 kbps",
  95                 NULL
  96         };
  97         static const char * const mpeg_audio_l2_bitrate[] = {
  98                 "32 kbps",
  99                 "48 kbps",
 100                 "56 kbps",
 101                 "64 kbps",
 102                 "80 kbps",
 103                 "96 kbps",
 104                 "112 kbps",
 105                 "128 kbps",
 106                 "160 kbps",
 107                 "192 kbps",
 108                 "224 kbps",
 109                 "256 kbps",
 110                 "320 kbps",
 111                 "384 kbps",
 112                 NULL
 113         };
 114         static const char * const mpeg_audio_l3_bitrate[] = {
 115                 "32 kbps",
 116                 "40 kbps",
 117                 "48 kbps",
 118                 "56 kbps",
 119                 "64 kbps",
 120                 "80 kbps",
 121                 "96 kbps",
 122                 "112 kbps",
 123                 "128 kbps",
 124                 "160 kbps",
 125                 "192 kbps",
 126                 "224 kbps",
 127                 "256 kbps",
 128                 "320 kbps",
 129                 NULL
 130         };
 131         static const char * const mpeg_audio_ac3_bitrate[] = {
 132                 "32 kbps",
 133                 "40 kbps",
 134                 "48 kbps",
 135                 "56 kbps",
 136                 "64 kbps",
 137                 "80 kbps",
 138                 "96 kbps",
 139                 "112 kbps",
 140                 "128 kbps",
 141                 "160 kbps",
 142                 "192 kbps",
 143                 "224 kbps",
 144                 "256 kbps",
 145                 "320 kbps",
 146                 "384 kbps",
 147                 "448 kbps",
 148                 "512 kbps",
 149                 "576 kbps",
 150                 "640 kbps",
 151                 NULL
 152         };
 153         static const char * const mpeg_audio_mode[] = {
 154                 "Stereo",
 155                 "Joint Stereo",
 156                 "Dual",
 157                 "Mono",
 158                 NULL
 159         };
 160         static const char * const mpeg_audio_mode_extension[] = {
 161                 "Bound 4",
 162                 "Bound 8",
 163                 "Bound 12",
 164                 "Bound 16",
 165                 NULL
 166         };
 167         static const char * const mpeg_audio_emphasis[] = {
 168                 "No Emphasis",
 169                 "50/15 us",
 170                 "CCITT J17",
 171                 NULL
 172         };
 173         static const char * const mpeg_audio_crc[] = {
 174                 "No CRC",
 175                 "16-bit CRC",
 176                 NULL
 177         };
 178         static const char * const mpeg_audio_dec_playback[] = {
 179                 "Auto",
 180                 "Stereo",
 181                 "Left",
 182                 "Right",
 183                 "Mono",
 184                 "Swapped Stereo",
 185                 NULL
 186         };
 187         static const char * const mpeg_video_encoding[] = {
 188                 "MPEG-1",
 189                 "MPEG-2",
 190                 "MPEG-4 AVC",
 191                 NULL
 192         };
 193         static const char * const mpeg_video_aspect[] = {
 194                 "1x1",
 195                 "4x3",
 196                 "16x9",
 197                 "2.21x1",
 198                 NULL
 199         };
 200         static const char * const mpeg_video_bitrate_mode[] = {
 201                 "Variable Bitrate",
 202                 "Constant Bitrate",
 203                 NULL
 204         };
 205         static const char * const mpeg_stream_type[] = {
 206                 "MPEG-2 Program Stream",
 207                 "MPEG-2 Transport Stream",
 208                 "MPEG-1 System Stream",
 209                 "MPEG-2 DVD-compatible Stream",
 210                 "MPEG-1 VCD-compatible Stream",
 211                 "MPEG-2 SVCD-compatible Stream",
 212                 NULL
 213         };
 214         static const char * const mpeg_stream_vbi_fmt[] = {
 215                 "No VBI",
 216                 "Private Packet, IVTV Format",
 217                 NULL
 218         };
 219         static const char * const camera_power_line_frequency[] = {
 220                 "Disabled",
 221                 "50 Hz",
 222                 "60 Hz",
 223                 "Auto",
 224                 NULL
 225         };
 226         static const char * const camera_exposure_auto[] = {
 227                 "Auto Mode",
 228                 "Manual Mode",
 229                 "Shutter Priority Mode",
 230                 "Aperture Priority Mode",
 231                 NULL
 232         };
 233         static const char * const camera_exposure_metering[] = {
 234                 "Average",
 235                 "Center Weighted",
 236                 "Spot",
 237                 NULL
 238         };
 239         static const char * const camera_auto_focus_range[] = {
 240                 "Auto",
 241                 "Normal",
 242                 "Macro",
 243                 "Infinity",
 244                 NULL
 245         };
 246         static const char * const colorfx[] = {
 247                 "None",
 248                 "Black & White",
 249                 "Sepia",
 250                 "Negative",
 251                 "Emboss",
 252                 "Sketch",
 253                 "Sky Blue",
 254                 "Grass Green",
 255                 "Skin Whiten",
 256                 "Vivid",
 257                 "Aqua",
 258                 "Art Freeze",
 259                 "Silhouette",
 260                 "Solarization",
 261                 "Antique",
 262                 "Set Cb/Cr",
 263                 NULL
 264         };
 265         static const char * const auto_n_preset_white_balance[] = {
 266                 "Manual",
 267                 "Auto",
 268                 "Incandescent",
 269                 "Fluorescent",
 270                 "Fluorescent H",
 271                 "Horizon",
 272                 "Daylight",
 273                 "Flash",
 274                 "Cloudy",
 275                 "Shade",
 276                 NULL,
 277         };
 278         static const char * const camera_iso_sensitivity_auto[] = {
 279                 "Manual",
 280                 "Auto",
 281                 NULL
 282         };
 283         static const char * const scene_mode[] = {
 284                 "None",
 285                 "Backlight",
 286                 "Beach/Snow",
 287                 "Candle Light",
 288                 "Dusk/Dawn",
 289                 "Fall Colors",
 290                 "Fireworks",
 291                 "Landscape",
 292                 "Night",
 293                 "Party/Indoor",
 294                 "Portrait",
 295                 "Sports",
 296                 "Sunset",
 297                 "Text",
 298                 NULL
 299         };
 300         static const char * const tune_preemphasis[] = {
 301                 "No Preemphasis",
 302                 "50 Microseconds",
 303                 "75 Microseconds",
 304                 NULL,
 305         };
 306         static const char * const header_mode[] = {
 307                 "Separate Buffer",
 308                 "Joined With 1st Frame",
 309                 NULL,
 310         };
 311         static const char * const multi_slice[] = {
 312                 "Single",
 313                 "Max Macroblocks",
 314                 "Max Bytes",
 315                 NULL,
 316         };
 317         static const char * const entropy_mode[] = {
 318                 "CAVLC",
 319                 "CABAC",
 320                 NULL,
 321         };
 322         static const char * const mpeg_h264_level[] = {
 323                 "1",
 324                 "1b",
 325                 "1.1",
 326                 "1.2",
 327                 "1.3",
 328                 "2",
 329                 "2.1",
 330                 "2.2",
 331                 "3",
 332                 "3.1",
 333                 "3.2",
 334                 "4",
 335                 "4.1",
 336                 "4.2",
 337                 "5",
 338                 "5.1",
 339                 NULL,
 340         };
 341         static const char * const h264_loop_filter[] = {
 342                 "Enabled",
 343                 "Disabled",
 344                 "Disabled at Slice Boundary",
 345                 NULL,
 346         };
 347         static const char * const h264_profile[] = {
 348                 "Baseline",
 349                 "Constrained Baseline",
 350                 "Main",
 351                 "Extended",
 352                 "High",
 353                 "High 10",
 354                 "High 422",
 355                 "High 444 Predictive",
 356                 "High 10 Intra",
 357                 "High 422 Intra",
 358                 "High 444 Intra",
 359                 "CAVLC 444 Intra",
 360                 "Scalable Baseline",
 361                 "Scalable High",
 362                 "Scalable High Intra",
 363                 "Multiview High",
 364                 NULL,
 365         };
 366         static const char * const vui_sar_idc[] = {
 367                 "Unspecified",
 368                 "1:1",
 369                 "12:11",
 370                 "10:11",
 371                 "16:11",
 372                 "40:33",
 373                 "24:11",
 374                 "20:11",
 375                 "32:11",
 376                 "80:33",
 377                 "18:11",
 378                 "15:11",
 379                 "64:33",
 380                 "160:99",
 381                 "4:3",
 382                 "3:2",
 383                 "2:1",
 384                 "Extended SAR",
 385                 NULL,
 386         };
 387         static const char * const mpeg_mpeg4_level[] = {
 388                 "0",
 389                 "0b",
 390                 "1",
 391                 "2",
 392                 "3",
 393                 "3b",
 394                 "4",
 395                 "5",
 396                 NULL,
 397         };
 398         static const char * const mpeg4_profile[] = {
 399                 "Simple",
 400                 "Advanced Simple",
 401                 "Core",
 402                 "Simple Scalable",
 403                 "Advanced Coding Efficency",
 404                 NULL,
 405         };
 406
 407         static const char * const flash_led_mode[] = {
 408                 "Off",
 409                 "Flash",
 410                 "Torch",
 411                 NULL,
 412         };
 413         static const char * const flash_strobe_source[] = {
 414                 "Software",
 415                 "External",
 416                 NULL,
 417         };
 418
 419         static const char * const jpeg_chroma_subsampling[] = {
 420                 "4:4:4",
 421                 "4:2:2",
 422                 "4:2:0",
 423                 "4:1:1",
 424                 "4:1:0",
 425                 "Gray",
 426                 NULL,
 427         };
 428
 429         switch (id) {
 430         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 431                 return mpeg_audio_sampling_freq;
 432         case V4L2_CID_MPEG_AUDIO_ENCODING:
 433                 return mpeg_audio_encoding;
 434         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 435                 return mpeg_audio_l1_bitrate;
 436         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 437                 return mpeg_audio_l2_bitrate;
 438         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 439                 return mpeg_audio_l3_bitrate;
 440         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 441                 return mpeg_audio_ac3_bitrate;
 442         case V4L2_CID_MPEG_AUDIO_MODE:
 443                 return mpeg_audio_mode;
 444         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 445                 return mpeg_audio_mode_extension;
 446         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 447                 return mpeg_audio_emphasis;
 448         case V4L2_CID_MPEG_AUDIO_CRC:
 449                 return mpeg_audio_crc;
 450         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
 451         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
 452                 return mpeg_audio_dec_playback;
 453         case V4L2_CID_MPEG_VIDEO_ENCODING:
 454                 return mpeg_video_encoding;
 455         case V4L2_CID_MPEG_VIDEO_ASPECT:
 456                 return mpeg_video_aspect;
 457         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 458                 return mpeg_video_bitrate_mode;
 459         case V4L2_CID_MPEG_STREAM_TYPE:
 460                 return mpeg_stream_type;
 461         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 462                 return mpeg_stream_vbi_fmt;
 463         case V4L2_CID_POWER_LINE_FREQUENCY:
 464                 return camera_power_line_frequency;
 465         case V4L2_CID_EXPOSURE_AUTO:
 466                 return camera_exposure_auto;
 467         case V4L2_CID_EXPOSURE_METERING:
 468                 return camera_exposure_metering;
 469         case V4L2_CID_AUTO_FOCUS_RANGE:
 470                 return camera_auto_focus_range;
 471         case V4L2_CID_COLORFX:
 472                 return colorfx;
 473         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
 474                 return auto_n_preset_white_balance;
 475         case V4L2_CID_ISO_SENSITIVITY_AUTO:
 476                 return camera_iso_sensitivity_auto;
 477         case V4L2_CID_SCENE_MODE:
 478                 return scene_mode;
 479         case V4L2_CID_TUNE_PREEMPHASIS:
 480                 return tune_preemphasis;
 481         case V4L2_CID_FLASH_LED_MODE:
 482                 return flash_led_mode;
 483         case V4L2_CID_FLASH_STROBE_SOURCE:
 484                 return flash_strobe_source;
 485         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
 486                 return header_mode;
 487         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
 488                 return multi_slice;
 489         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
 490                 return entropy_mode;
 491         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
 492                 return mpeg_h264_level;
 493         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
 494                 return h264_loop_filter;
 495         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
 496                 return h264_profile;
 497         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
 498                 return vui_sar_idc;
 499         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
 500                 return mpeg_mpeg4_level;
 501         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
 502                 return mpeg4_profile;
 503         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
 504                 return jpeg_chroma_subsampling;
 505
 506         default:
 507                 return NULL;
 508         }
 509 }
 510 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
 511
 512 /* Return the control name. */
 513 const char *v4l2_ctrl_get_name(u32 id)
 514 {
 515         switch (id) {
 516         /* USER controls */
 517         /* Keep the order of the 'case's the same as in videodev2.h! */
 518         case V4L2_CID_USER_CLASS:               return "User Controls";
 519         case V4L2_CID_BRIGHTNESS:               return "Brightness";
 520         case V4L2_CID_CONTRAST:                 return "Contrast";
 521         case V4L2_CID_SATURATION:               return "Saturation";
 522         case V4L2_CID_HUE:                      return "Hue";
 523         case V4L2_CID_AUDIO_VOLUME:             return "Volume";
 524         case V4L2_CID_AUDIO_BALANCE:            return "Balance";
 525         case V4L2_CID_AUDIO_BASS:               return "Bass";
 526         case V4L2_CID_AUDIO_TREBLE:             return "Treble";
 527         case V4L2_CID_AUDIO_MUTE:               return "Mute";
 528         case V4L2_CID_AUDIO_LOUDNESS:           return "Loudness";
 529         case V4L2_CID_BLACK_LEVEL:              return "Black Level";
 530         case V4L2_CID_AUTO_WHITE_BALANCE:       return "White Balance, Automatic";
 531         case V4L2_CID_DO_WHITE_BALANCE:         return "Do White Balance";
 532         case V4L2_CID_RED_BALANCE:              return "Red Balance";
 533         case V4L2_CID_BLUE_BALANCE:             return "Blue Balance";
 534         case V4L2_CID_GAMMA:                    return "Gamma";
 535         case V4L2_CID_EXPOSURE:                 return "Exposure";
 536         case V4L2_CID_AUTOGAIN:                 return "Gain, Automatic";
 537         case V4L2_CID_GAIN:                     return "Gain";
 538         case V4L2_CID_HFLIP:                    return "Horizontal Flip";
 539         case V4L2_CID_VFLIP:                    return "Vertical Flip";
 540         case V4L2_CID_HCENTER:                  return "Horizontal Center";
 541         case V4L2_CID_VCENTER:                  return "Vertical Center";
 542         case V4L2_CID_POWER_LINE_FREQUENCY:     return "Power Line Frequency";
 543         case V4L2_CID_HUE_AUTO:                 return "Hue, Automatic";
 544         case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
 545         case V4L2_CID_SHARPNESS:                return "Sharpness";
 546         case V4L2_CID_BACKLIGHT_COMPENSATION:   return "Backlight Compensation";
 547         case V4L2_CID_CHROMA_AGC:               return "Chroma AGC";
 548         case V4L2_CID_COLOR_KILLER:             return "Color Killer";
 549         case V4L2_CID_COLORFX:                  return "Color Effects";
 550         case V4L2_CID_AUTOBRIGHTNESS:           return "Brightness, Automatic";
 551         case V4L2_CID_BAND_STOP_FILTER:         return "Band-Stop Filter";
 552         case V4L2_CID_ROTATE:                   return "Rotate";
 553         case V4L2_CID_BG_COLOR:                 return "Background Color";
 554         case V4L2_CID_CHROMA_GAIN:              return "Chroma Gain";
 555         case V4L2_CID_ILLUMINATORS_1:           return "Illuminator 1";
 556         case V4L2_CID_ILLUMINATORS_2:           return "Illuminator 2";
 557         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:  return "Min Number of Capture Buffers";
 558         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:   return "Min Number of Output Buffers";
 559         case V4L2_CID_ALPHA_COMPONENT:          return "Alpha Component";
 560         case V4L2_CID_COLORFX_CBCR:             return "Color Effects, CbCr";
 561
 562         /* MPEG controls */
 563         /* Keep the order of the 'case's the same as in videodev2.h! */
 564         case V4L2_CID_MPEG_CLASS:               return "MPEG Encoder Controls";
 565         case V4L2_CID_MPEG_STREAM_TYPE:         return "Stream Type";
 566         case V4L2_CID_MPEG_STREAM_PID_PMT:      return "Stream PMT Program ID";
 567         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    return "Stream Audio Program ID";
 568         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    return "Stream Video Program ID";
 569         case V4L2_CID_MPEG_STREAM_PID_PCR:      return "Stream PCR Program ID";
 570         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
 571         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
 572         case V4L2_CID_MPEG_STREAM_VBI_FMT:      return "Stream VBI Format";
 573         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
 574         case V4L2_CID_MPEG_AUDIO_ENCODING:      return "Audio Encoding";
 575         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    return "Audio Layer I Bitrate";
 576         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    return "Audio Layer II Bitrate";
 577         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    return "Audio Layer III Bitrate";
 578         case V4L2_CID_MPEG_AUDIO_MODE:          return "Audio Stereo Mode";
 579         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
 580         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      return "Audio Emphasis";
 581         case V4L2_CID_MPEG_AUDIO_CRC:           return "Audio CRC";
 582         case V4L2_CID_MPEG_AUDIO_MUTE:          return "Audio Mute";
 583         case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:   return "Audio AAC Bitrate";
 584         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:   return "Audio AC-3 Bitrate";
 585         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:  return "Audio Playback";
 586         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
 587         case V4L2_CID_MPEG_VIDEO_ENCODING:      return "Video Encoding";
 588         case V4L2_CID_MPEG_VIDEO_ASPECT:        return "Video Aspect";
 589         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      return "Video B Frames";
 590         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      return "Video GOP Size";
 591         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   return "Video GOP Closure";
 592         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      return "Video Pulldown";
 593         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  return "Video Bitrate Mode";
 594         case V4L2_CID_MPEG_VIDEO_BITRATE:       return "Video Bitrate";
 595         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  return "Video Peak Bitrate";
 596         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
 597         case V4L2_CID_MPEG_VIDEO_MUTE:          return "Video Mute";
 598         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:      return "Video Mute YUV";
 599         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:       return "Decoder Slice Interface";
 600         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:  return "MPEG4 Loop Filter Enable";
 601         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:       return "Number of Intra Refresh MBs";
 602         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:               return "Frame Level Rate Control Enable";
 603         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:                  return "H264 MB Level Rate Control";
 604         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:                   return "Sequence Header Mode";
 605         case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC:                   return "Max Number of Reference Pics";
 606         case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:               return "H263 I-Frame QP Value";
 607         case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:               return "H263 P-Frame QP Value";
 608         case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:               return "H263 B-Frame QP Value";
 609         case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:                   return "H263 Minimum QP Value";
 610         case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:                   return "H263 Maximum QP Value";
 611         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:               return "H264 I-Frame QP Value";
 612         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:               return "H264 P-Frame QP Value";
 613         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:               return "H264 B-Frame QP Value";
 614         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:                   return "H264 Maximum QP Value";
 615         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:                   return "H264 Minimum QP Value";
 616         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:            return "H264 8x8 Transform Enable";
 617         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:                 return "H264 CPB Buffer Size";
 618         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:             return "H264 Entropy Mode";
 619         case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:                 return "H264 I-Frame Period";
 620         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:                    return "H264 Level";
 621         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:        return "H264 Loop Filter Alpha Offset";
 622         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:         return "H264 Loop Filter Beta Offset";
 623         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:         return "H264 Loop Filter Mode";
 624         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:                  return "H264 Profile";
 625         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:       return "Vertical Size of SAR";
 626         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:        return "Horizontal Size of SAR";
 627         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:           return "Aspect Ratio VUI Enable";
 628         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:              return "VUI Aspect Ratio IDC";
 629         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:              return "MPEG4 I-Frame QP Value";
 630         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:              return "MPEG4 P-Frame QP Value";
 631         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:              return "MPEG4 B-Frame QP Value";
 632         case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:                  return "MPEG4 Minimum QP Value";
 633         case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:                  return "MPEG4 Maximum QP Value";
 634         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:                   return "MPEG4 Level";
 635         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:                 return "MPEG4 Profile";
 636         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:                    return "Quarter Pixel Search Enable";
 637         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:         return "Maximum Bytes in a Slice";
 638         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:            return "Number of MBs in a Slice";
 639         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:              return "Slice Partitioning Method";
 640         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:                      return "VBV Buffer Size";
 641         case V4L2_CID_MPEG_VIDEO_DEC_PTS:                       return "Video Decoder PTS";
 642         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:                     return "Video Decoder Frame Count";
 643
 644         /* CAMERA controls */
 645         /* Keep the order of the 'case's the same as in videodev2.h! */
 646         case V4L2_CID_CAMERA_CLASS:             return "Camera Controls";
 647         case V4L2_CID_EXPOSURE_AUTO:            return "Auto Exposure";
 648         case V4L2_CID_EXPOSURE_ABSOLUTE:        return "Exposure Time, Absolute";
 649         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:   return "Exposure, Dynamic Framerate";
 650         case V4L2_CID_PAN_RELATIVE:             return "Pan, Relative";
 651         case V4L2_CID_TILT_RELATIVE:            return "Tilt, Relative";
 652         case V4L2_CID_PAN_RESET:                return "Pan, Reset";
 653         case V4L2_CID_TILT_RESET:               return "Tilt, Reset";
 654         case V4L2_CID_PAN_ABSOLUTE:             return "Pan, Absolute";
 655         case V4L2_CID_TILT_ABSOLUTE:            return "Tilt, Absolute";
 656         case V4L2_CID_FOCUS_ABSOLUTE:           return "Focus, Absolute";
 657         case V4L2_CID_FOCUS_RELATIVE:           return "Focus, Relative";
 658         case V4L2_CID_FOCUS_AUTO:               return "Focus, Automatic Continuous";
 659         case V4L2_CID_ZOOM_ABSOLUTE:            return "Zoom, Absolute";
 660         case V4L2_CID_ZOOM_RELATIVE:            return "Zoom, Relative";
 661         case V4L2_CID_ZOOM_CONTINUOUS:          return "Zoom, Continuous";
 662         case V4L2_CID_PRIVACY:                  return "Privacy";
 663         case V4L2_CID_IRIS_ABSOLUTE:            return "Iris, Absolute";
 664         case V4L2_CID_IRIS_RELATIVE:            return "Iris, Relative";
 665         case V4L2_CID_AUTO_EXPOSURE_BIAS:       return "Auto Exposure, Bias";
 666         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
 667         case V4L2_CID_WIDE_DYNAMIC_RANGE:       return "Wide Dynamic Range";
 668         case V4L2_CID_IMAGE_STABILIZATION:      return "Image Stabilization";
 669         case V4L2_CID_ISO_SENSITIVITY:          return "ISO Sensitivity";
 670         case V4L2_CID_ISO_SENSITIVITY_AUTO:     return "ISO Sensitivity, Auto";
 671         case V4L2_CID_EXPOSURE_METERING:        return "Exposure, Metering Mode";
 672         case V4L2_CID_SCENE_MODE:               return "Scene Mode";
 673         case V4L2_CID_3A_LOCK:                  return "3A Lock";
 674         case V4L2_CID_AUTO_FOCUS_START:         return "Auto Focus, Start";
 675         case V4L2_CID_AUTO_FOCUS_STOP:          return "Auto Focus, Stop";
 676         case V4L2_CID_AUTO_FOCUS_STATUS:        return "Auto Focus, Status";
 677         case V4L2_CID_AUTO_FOCUS_RANGE:         return "Auto Focus, Range";
 678
 679         /* FM Radio Modulator control */
 680         /* Keep the order of the 'case's the same as in videodev2.h! */
 681         case V4L2_CID_FM_TX_CLASS:              return "FM Radio Modulator Controls";
 682         case V4L2_CID_RDS_TX_DEVIATION:         return "RDS Signal Deviation";
 683         case V4L2_CID_RDS_TX_PI:                return "RDS Program ID";
 684         case V4L2_CID_RDS_TX_PTY:               return "RDS Program Type";
 685         case V4L2_CID_RDS_TX_PS_NAME:           return "RDS PS Name";
 686         case V4L2_CID_RDS_TX_RADIO_TEXT:        return "RDS Radio Text";
 687         case V4L2_CID_AUDIO_LIMITER_ENABLED:    return "Audio Limiter Feature Enabled";
 688         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
 689         case V4L2_CID_AUDIO_LIMITER_DEVIATION:  return "Audio Limiter Deviation";
 690         case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
 691         case V4L2_CID_AUDIO_COMPRESSION_GAIN:   return "Audio Compression Gain";
 692         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
 693         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
 694         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
 695         case V4L2_CID_PILOT_TONE_ENABLED:       return "Pilot Tone Feature Enabled";
 696         case V4L2_CID_PILOT_TONE_DEVIATION:     return "Pilot Tone Deviation";
 697         case V4L2_CID_PILOT_TONE_FREQUENCY:     return "Pilot Tone Frequency";
 698         case V4L2_CID_TUNE_PREEMPHASIS:         return "Pre-Emphasis";
 699         case V4L2_CID_TUNE_POWER_LEVEL:         return "Tune Power Level";
 700         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:   return "Tune Antenna Capacitor";
 701
 702         /* Flash controls */
 703         case V4L2_CID_FLASH_CLASS:              return "Flash Controls";
 704         case V4L2_CID_FLASH_LED_MODE:           return "LED Mode";
 705         case V4L2_CID_FLASH_STROBE_SOURCE:      return "Strobe Source";
 706         case V4L2_CID_FLASH_STROBE:             return "Strobe";
 707         case V4L2_CID_FLASH_STROBE_STOP:        return "Stop Strobe";
 708         case V4L2_CID_FLASH_STROBE_STATUS:      return "Strobe Status";
 709         case V4L2_CID_FLASH_TIMEOUT:            return "Strobe Timeout";
 710         case V4L2_CID_FLASH_INTENSITY:          return "Intensity, Flash Mode";
 711         case V4L2_CID_FLASH_TORCH_INTENSITY:    return "Intensity, Torch Mode";
 712         case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
 713         case V4L2_CID_FLASH_FAULT:              return "Faults";
 714         case V4L2_CID_FLASH_CHARGE:             return "Charge";
 715         case V4L2_CID_FLASH_READY:              return "Ready to Strobe";
 716
 717         /* JPEG encoder controls */
 718         /* Keep the order of the 'case's the same as in videodev2.h! */
 719         case V4L2_CID_JPEG_CLASS:               return "JPEG Compression Controls";
 720         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:  return "Chroma Subsampling";
 721         case V4L2_CID_JPEG_RESTART_INTERVAL:    return "Restart Interval";
 722         case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
 723         case V4L2_CID_JPEG_ACTIVE_MARKER:       return "Active Markers";
 724
 725         /* Image source controls */
 726         case V4L2_CID_IMAGE_SOURCE_CLASS:       return "Image Source Controls";
 727         case V4L2_CID_VBLANK:                   return "Vertical Blanking";
 728         case V4L2_CID_HBLANK:                   return "Horizontal Blanking";
 729         case V4L2_CID_ANALOGUE_GAIN:            return "Analogue Gain";
 730
 731         /* Image processing controls */
 732         case V4L2_CID_IMAGE_PROC_CLASS:         return "Image Processing Controls";
 733         case V4L2_CID_LINK_FREQ:                return "Link Frequency";
 734         case V4L2_CID_PIXEL_RATE:               return "Pixel Rate";
 735
 736         default:
 737                 return NULL;
 738         }
 739 }
 740 EXPORT_SYMBOL(v4l2_ctrl_get_name);
 741
 742 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
 743                     s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags)
 744 {
 745         *name = v4l2_ctrl_get_name(id);
 746         *flags = 0;
 747
 748         switch (id) {
 749         case V4L2_CID_AUDIO_MUTE:
 750         case V4L2_CID_AUDIO_LOUDNESS:
 751         case V4L2_CID_AUTO_WHITE_BALANCE:
 752         case V4L2_CID_AUTOGAIN:
 753         case V4L2_CID_HFLIP:
 754         case V4L2_CID_VFLIP:
 755         case V4L2_CID_HUE_AUTO:
 756         case V4L2_CID_CHROMA_AGC:
 757         case V4L2_CID_COLOR_KILLER:
 758         case V4L2_CID_AUTOBRIGHTNESS:
 759         case V4L2_CID_MPEG_AUDIO_MUTE:
 760         case V4L2_CID_MPEG_VIDEO_MUTE:
 761         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 762         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 763         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
 764         case V4L2_CID_FOCUS_AUTO:
 765         case V4L2_CID_PRIVACY:
 766         case V4L2_CID_AUDIO_LIMITER_ENABLED:
 767         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
 768         case V4L2_CID_PILOT_TONE_ENABLED:
 769         case V4L2_CID_ILLUMINATORS_1:
 770         case V4L2_CID_ILLUMINATORS_2:
 771         case V4L2_CID_FLASH_STROBE_STATUS:
 772         case V4L2_CID_FLASH_CHARGE:
 773         case V4L2_CID_FLASH_READY:
 774         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
 775         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
 776         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
 777         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
 778         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
 779         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
 780         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
 781         case V4L2_CID_WIDE_DYNAMIC_RANGE:
 782         case V4L2_CID_IMAGE_STABILIZATION:
 783                 *type = V4L2_CTRL_TYPE_BOOLEAN;
 784                 *min = 0;
 785                 *max = *step = 1;
 786                 break;
 787         case V4L2_CID_PAN_RESET:
 788         case V4L2_CID_TILT_RESET:
 789         case V4L2_CID_FLASH_STROBE:
 790         case V4L2_CID_FLASH_STROBE_STOP:
 791         case V4L2_CID_AUTO_FOCUS_START:
 792         case V4L2_CID_AUTO_FOCUS_STOP:
 793                 *type = V4L2_CTRL_TYPE_BUTTON;
 794                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
 795                 *min = *max = *step = *def = 0;
 796                 break;
 797         case V4L2_CID_POWER_LINE_FREQUENCY:
 798         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 799         case V4L2_CID_MPEG_AUDIO_ENCODING:
 800         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 801         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 802         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 803         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 804         case V4L2_CID_MPEG_AUDIO_MODE:
 805         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 806         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 807         case V4L2_CID_MPEG_AUDIO_CRC:
 808         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
 809         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
 810         case V4L2_CID_MPEG_VIDEO_ENCODING:
 811         case V4L2_CID_MPEG_VIDEO_ASPECT:
 812         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 813         case V4L2_CID_MPEG_STREAM_TYPE:
 814         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 815         case V4L2_CID_EXPOSURE_AUTO:
 816         case V4L2_CID_AUTO_FOCUS_RANGE:
 817         case V4L2_CID_COLORFX:
 818         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
 819         case V4L2_CID_TUNE_PREEMPHASIS:
 820         case V4L2_CID_FLASH_LED_MODE:
 821         case V4L2_CID_FLASH_STROBE_SOURCE:
 822         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
 823         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
 824         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
 825         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
 826         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
 827         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
 828         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
 829         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
 830         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
 831         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
 832         case V4L2_CID_ISO_SENSITIVITY_AUTO:
 833         case V4L2_CID_EXPOSURE_METERING:
 834         case V4L2_CID_SCENE_MODE:
 835                 *type = V4L2_CTRL_TYPE_MENU;
 836                 break;
 837         case V4L2_CID_LINK_FREQ:
 838                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
 839                 break;
 840         case V4L2_CID_RDS_TX_PS_NAME:
 841         case V4L2_CID_RDS_TX_RADIO_TEXT:
 842                 *type = V4L2_CTRL_TYPE_STRING;
 843                 break;
 844         case V4L2_CID_ISO_SENSITIVITY:
 845         case V4L2_CID_AUTO_EXPOSURE_BIAS:
 846                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
 847                 break;
 848         case V4L2_CID_USER_CLASS:
 849         case V4L2_CID_CAMERA_CLASS:
 850         case V4L2_CID_MPEG_CLASS:
 851         case V4L2_CID_FM_TX_CLASS:
 852         case V4L2_CID_FLASH_CLASS:
 853         case V4L2_CID_JPEG_CLASS:
 854         case V4L2_CID_IMAGE_SOURCE_CLASS:
 855         case V4L2_CID_IMAGE_PROC_CLASS:
 856                 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
 857                 /* You can neither read not write these */
 858                 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
 859                 *min = *max = *step = *def = 0;
 860                 break;
 861         case V4L2_CID_BG_COLOR:
 862                 *type = V4L2_CTRL_TYPE_INTEGER;
 863                 *step = 1;
 864                 *min = 0;
 865                 /* Max is calculated as RGB888 that is 2^24 */
 866                 *max = 0xFFFFFF;
 867                 break;
 868         case V4L2_CID_FLASH_FAULT:
 869         case V4L2_CID_JPEG_ACTIVE_MARKER:
 870         case V4L2_CID_3A_LOCK:
 871         case V4L2_CID_AUTO_FOCUS_STATUS:
 872                 *type = V4L2_CTRL_TYPE_BITMASK;
 873                 break;
 874         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
 875         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
 876                 *type = V4L2_CTRL_TYPE_INTEGER;
 877                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
 878                 break;
 879         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
 880         case V4L2_CID_MPEG_VIDEO_DEC_PTS:
 881                 *flags |= V4L2_CTRL_FLAG_VOLATILE;
 882                 /* Fall through */
 883         case V4L2_CID_PIXEL_RATE:
 884                 *type = V4L2_CTRL_TYPE_INTEGER64;
 885                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
 886                 *min = *max = *step = *def = 0;
 887                 break;
 888         default:
 889                 *type = V4L2_CTRL_TYPE_INTEGER;
 890                 break;
 891         }
 892         switch (id) {
 893         case V4L2_CID_MPEG_AUDIO_ENCODING:
 894         case V4L2_CID_MPEG_AUDIO_MODE:
 895         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 896         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 897         case V4L2_CID_MPEG_STREAM_TYPE:
 898                 *flags |= V4L2_CTRL_FLAG_UPDATE;
 899                 break;
 900         case V4L2_CID_AUDIO_VOLUME:
 901         case V4L2_CID_AUDIO_BALANCE:
 902         case V4L2_CID_AUDIO_BASS:
 903         case V4L2_CID_AUDIO_TREBLE:
 904         case V4L2_CID_BRIGHTNESS:
 905         case V4L2_CID_CONTRAST:
 906         case V4L2_CID_SATURATION:
 907         case V4L2_CID_HUE:
 908         case V4L2_CID_RED_BALANCE:
 909         case V4L2_CID_BLUE_BALANCE:
 910         case V4L2_CID_GAMMA:
 911         case V4L2_CID_SHARPNESS:
 912         case V4L2_CID_CHROMA_GAIN:
 913         case V4L2_CID_RDS_TX_DEVIATION:
 914         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
 915         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
 916         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
 917         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
 918         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
 919         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
 920         case V4L2_CID_PILOT_TONE_DEVIATION:
 921         case V4L2_CID_PILOT_TONE_FREQUENCY:
 922         case V4L2_CID_TUNE_POWER_LEVEL:
 923         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
 924                 *flags |= V4L2_CTRL_FLAG_SLIDER;
 925                 break;
 926         case V4L2_CID_PAN_RELATIVE:
 927         case V4L2_CID_TILT_RELATIVE:
 928         case V4L2_CID_FOCUS_RELATIVE:
 929         case V4L2_CID_IRIS_RELATIVE:
 930         case V4L2_CID_ZOOM_RELATIVE:
 931                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
 932                 break;
 933         case V4L2_CID_FLASH_STROBE_STATUS:
 934         case V4L2_CID_AUTO_FOCUS_STATUS:
 935         case V4L2_CID_FLASH_READY:
 936                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
 937                 break;
 938         }
 939 }
 940 EXPORT_SYMBOL(v4l2_ctrl_fill);
 941
 942 /* Helper function to determine whether the control type is compatible with
 943    VIDIOC_G/S_CTRL. */
 944 static bool type_is_int(const struct v4l2_ctrl *ctrl)
 945 {
 946         switch (ctrl->type) {
 947         case V4L2_CTRL_TYPE_INTEGER64:
 948         case V4L2_CTRL_TYPE_STRING:
 949                 /* Nope, these need v4l2_ext_control */
 950                 return false;
 951         default:
 952                 return true;
 953         }
 954 }
 955
 956 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
 957 {
 958         memset(ev->reserved, 0, sizeof(ev->reserved));
 959         ev->type = V4L2_EVENT_CTRL;
 960         ev->id = ctrl->id;
 961         ev->u.ctrl.changes = changes;
 962         ev->u.ctrl.type = ctrl->type;
 963         ev->u.ctrl.flags = ctrl->flags;
 964         if (ctrl->type == V4L2_CTRL_TYPE_STRING)
 965                 ev->u.ctrl.value64 = 0;
 966         else
 967                 ev->u.ctrl.value64 = ctrl->cur.val64;
 968         ev->u.ctrl.minimum = ctrl->minimum;
 969         ev->u.ctrl.maximum = ctrl->maximum;
 970         if (ctrl->type == V4L2_CTRL_TYPE_MENU
 971             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
 972                 ev->u.ctrl.step = 1;
 973         else
 974                 ev->u.ctrl.step = ctrl->step;
 975         ev->u.ctrl.default_value = ctrl->default_value;
 976 }
 977
 978 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
 979 {
 980         struct v4l2_event ev;
 981         struct v4l2_subscribed_event *sev;
 982
 983         if (list_empty(&ctrl->ev_subs))
 984                 return;
 985         fill_event(&ev, ctrl, changes);
 986
 987         list_for_each_entry(sev, &ctrl->ev_subs, node)
 988                 if (sev->fh != fh ||
 989                     (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
 990                         v4l2_event_queue_fh(sev->fh, &ev);
 991 }
 992
 993 /* Helper function: copy the current control value back to the caller */
 994 static int cur_to_user(struct v4l2_ext_control *c,
 995                        struct v4l2_ctrl *ctrl)
 996 {
 997         u32 len;
 998
 999         switch (ctrl->type) {
1000         case V4L2_CTRL_TYPE_STRING:
1001                 len = strlen(ctrl->cur.string);
1002                 if (c->size < len + 1) {
1003                         c->size = len + 1;
1004                         return -ENOSPC;
1005                 }
1006                 return copy_to_user(c->string, ctrl->cur.string,
1007                                                 len + 1) ? -EFAULT : 0;
1008         case V4L2_CTRL_TYPE_INTEGER64:
1009                 c->value64 = ctrl->cur.val64;
1010                 break;
1011         default:
1012                 c->value = ctrl->cur.val;
1013                 break;
1014         }
1015         return 0;
1016 }
1017
1018 /* Helper function: copy the caller-provider value as the new control value */
1019 static int user_to_new(struct v4l2_ext_control *c,
1020                        struct v4l2_ctrl *ctrl)
1021 {
1022         int ret;
1023         u32 size;
1024
1025         ctrl->is_new = 1;
1026         switch (ctrl->type) {
1027         case V4L2_CTRL_TYPE_INTEGER64:
1028                 ctrl->val64 = c->value64;
1029                 break;
1030         case V4L2_CTRL_TYPE_STRING:
1031                 size = c->size;
1032                 if (size == 0)
1033                         return -ERANGE;
1034                 if (size > ctrl->maximum + 1)
1035                         size = ctrl->maximum + 1;
1036                 ret = copy_from_user(ctrl->string, c->string, size);
1037                 if (!ret) {
1038                         char last = ctrl->string[size - 1];
1039
1040                         ctrl->string[size - 1] = 0;
1041                         /* If the string was longer than ctrl->maximum,
1042                            then return an error. */
1043                         if (strlen(ctrl->string) == ctrl->maximum && last)
1044                                 return -ERANGE;
1045                 }
1046                 return ret ? -EFAULT : 0;
1047         default:
1048                 ctrl->val = c->value;
1049                 break;
1050         }
1051         return 0;
1052 }
1053
1054 /* Helper function: copy the new control value back to the caller */
1055 static int new_to_user(struct v4l2_ext_control *c,
1056                        struct v4l2_ctrl *ctrl)
1057 {
1058         u32 len;
1059
1060         switch (ctrl->type) {
1061         case V4L2_CTRL_TYPE_STRING:
1062                 len = strlen(ctrl->string);
1063                 if (c->size < len + 1) {
1064                         c->size = ctrl->maximum + 1;
1065                         return -ENOSPC;
1066                 }
1067                 return copy_to_user(c->string, ctrl->string,
1068                                                 len + 1) ? -EFAULT : 0;
1069         case V4L2_CTRL_TYPE_INTEGER64:
1070                 c->value64 = ctrl->val64;
1071                 break;
1072         default:
1073                 c->value = ctrl->val;
1074                 break;
1075         }
1076         return 0;
1077 }
1078
1079 /* Copy the new value to the current value. */
1080 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
1081                                                 bool update_inactive)
1082 {
1083         bool changed = false;
1084
1085         if (ctrl == NULL)
1086                 return;
1087         switch (ctrl->type) {
1088         case V4L2_CTRL_TYPE_BUTTON:
1089                 changed = true;
1090                 break;
1091         case V4L2_CTRL_TYPE_STRING:
1092                 /* strings are always 0-terminated */
1093                 changed = strcmp(ctrl->string, ctrl->cur.string);
1094                 strcpy(ctrl->cur.string, ctrl->string);
1095                 break;
1096         case V4L2_CTRL_TYPE_INTEGER64:
1097                 changed = ctrl->val64 != ctrl->cur.val64;
1098                 ctrl->cur.val64 = ctrl->val64;
1099                 break;
1100         default:
1101                 changed = ctrl->val != ctrl->cur.val;
1102                 ctrl->cur.val = ctrl->val;
1103                 break;
1104         }
1105         if (update_inactive) {
1106                 /* Note: update_inactive can only be true for auto clusters. */
1107                 ctrl->flags &=
1108                         ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1109                 if (!is_cur_manual(ctrl->cluster[0])) {
1110                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1111                         if (ctrl->cluster[0]->has_volatiles)
1112                                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1113                 }
1114                 fh = NULL;
1115         }
1116         if (changed || update_inactive) {
1117                 /* If a control was changed that was not one of the controls
1118                    modified by the application, then send the event to all. */
1119                 if (!ctrl->is_new)
1120                         fh = NULL;
1121                 send_event(fh, ctrl,
1122                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) |
1123                         (update_inactive ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
1124         }
1125 }
1126
1127 /* Copy the current value to the new value */
1128 static void cur_to_new(struct v4l2_ctrl *ctrl)
1129 {
1130         if (ctrl == NULL)
1131                 return;
1132         switch (ctrl->type) {
1133         case V4L2_CTRL_TYPE_STRING:
1134                 /* strings are always 0-terminated */
1135                 strcpy(ctrl->string, ctrl->cur.string);
1136                 break;
1137         case V4L2_CTRL_TYPE_INTEGER64:
1138                 ctrl->val64 = ctrl->cur.val64;
1139                 break;
1140         default:
1141                 ctrl->val = ctrl->cur.val;
1142                 break;
1143         }
1144 }
1145
1146 /* Return non-zero if one or more of the controls in the cluster has a new
1147    value that differs from the current value. */
1148 static int cluster_changed(struct v4l2_ctrl *master)
1149 {
1150         int diff = 0;
1151         int i;
1152
1153         for (i = 0; !diff && i < master->ncontrols; i++) {
1154                 struct v4l2_ctrl *ctrl = master->cluster[i];
1155
1156                 if (ctrl == NULL)
1157                         continue;
1158                 switch (ctrl->type) {
1159                 case V4L2_CTRL_TYPE_BUTTON:
1160                         /* Button controls are always 'different' */
1161                         return 1;
1162                 case V4L2_CTRL_TYPE_STRING:
1163                         /* strings are always 0-terminated */
1164                         diff = strcmp(ctrl->string, ctrl->cur.string);
1165                         break;
1166                 case V4L2_CTRL_TYPE_INTEGER64:
1167                         diff = ctrl->val64 != ctrl->cur.val64;
1168                         break;
1169                 default:
1170                         diff = ctrl->val != ctrl->cur.val;
1171                         break;
1172                 }
1173         }
1174         return diff;
1175 }
1176
1177 /* Validate integer-type control */
1178 static int validate_new_int(const struct v4l2_ctrl *ctrl, s32 *pval)
1179 {
1180         s32 val = *pval;
1181         u32 offset;
1182
1183         switch (ctrl->type) {
1184         case V4L2_CTRL_TYPE_INTEGER:
1185                 /* Round towards the closest legal value */
1186                 val += ctrl->step / 2;
1187                 if (val < ctrl->minimum)
1188                         val = ctrl->minimum;
1189                 if (val > ctrl->maximum)
1190                         val = ctrl->maximum;
1191                 offset = val - ctrl->minimum;
1192                 offset = ctrl->step * (offset / ctrl->step);
1193                 val = ctrl->minimum + offset;
1194                 *pval = val;
1195                 return 0;
1196
1197         case V4L2_CTRL_TYPE_BOOLEAN:
1198                 *pval = !!val;
1199                 return 0;
1200
1201         case V4L2_CTRL_TYPE_MENU:
1202         case V4L2_CTRL_TYPE_INTEGER_MENU:
1203                 if (val < ctrl->minimum || val > ctrl->maximum)
1204                         return -ERANGE;
1205                 if (ctrl->menu_skip_mask & (1 << val))
1206                         return -EINVAL;
1207                 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1208                     ctrl->qmenu[val][0] == '\0')
1209                         return -EINVAL;
1210                 return 0;
1211
1212         case V4L2_CTRL_TYPE_BITMASK:
1213                 *pval &= ctrl->maximum;
1214                 return 0;
1215
1216         case V4L2_CTRL_TYPE_BUTTON:
1217         case V4L2_CTRL_TYPE_CTRL_CLASS:
1218                 *pval = 0;
1219                 return 0;
1220
1221         default:
1222                 return -EINVAL;
1223         }
1224 }
1225
1226 /* Validate a new control */
1227 static int validate_new(const struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
1228 {
1229         char *s = c->string;
1230         size_t len;
1231
1232         switch (ctrl->type) {
1233         case V4L2_CTRL_TYPE_INTEGER:
1234         case V4L2_CTRL_TYPE_BOOLEAN:
1235         case V4L2_CTRL_TYPE_MENU:
1236         case V4L2_CTRL_TYPE_INTEGER_MENU:
1237         case V4L2_CTRL_TYPE_BITMASK:
1238         case V4L2_CTRL_TYPE_BUTTON:
1239         case V4L2_CTRL_TYPE_CTRL_CLASS:
1240                 return validate_new_int(ctrl, &c->value);
1241
1242         case V4L2_CTRL_TYPE_INTEGER64:
1243                 return 0;
1244
1245         case V4L2_CTRL_TYPE_STRING:
1246                 len = strlen(s);
1247                 if (len < ctrl->minimum)
1248                         return -ERANGE;
1249                 if ((len - ctrl->minimum) % ctrl->step)
1250                         return -ERANGE;
1251                 return 0;
1252
1253         default:
1254                 return -EINVAL;
1255         }
1256 }
1257
1258 static inline u32 node2id(struct list_head *node)
1259 {
1260         return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1261 }
1262
1263 /* Set the handler's error code if it wasn't set earlier already */
1264 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1265 {
1266         if (hdl->error == 0)
1267                 hdl->error = err;
1268         return err;
1269 }
1270
1271 /* Initialize the handler */
1272 int v4l2_ctrl_handler_init(struct v4l2_ctrl_handler *hdl,
1273                            unsigned nr_of_controls_hint)
1274 {
1275         hdl->lock = &hdl->_lock;
1276         mutex_init(hdl->lock);
1277         INIT_LIST_HEAD(&hdl->ctrls);
1278         INIT_LIST_HEAD(&hdl->ctrl_refs);
1279         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1280         hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1281                                GFP_KERNEL);
1282         hdl->error = hdl->buckets ? 0 : -ENOMEM;
1283         return hdl->error;
1284 }
1285 EXPORT_SYMBOL(v4l2_ctrl_handler_init);
1286
1287 /* Free all controls and control refs */
1288 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1289 {
1290         struct v4l2_ctrl_ref *ref, *next_ref;
1291         struct v4l2_ctrl *ctrl, *next_ctrl;
1292         struct v4l2_subscribed_event *sev, *next_sev;
1293
1294         if (hdl == NULL || hdl->buckets == NULL)
1295                 return;
1296
1297         mutex_lock(hdl->lock);
1298         /* Free all nodes */
1299         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1300                 list_del(&ref->node);
1301                 kfree(ref);
1302         }
1303         /* Free all controls owned by the handler */
1304         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1305                 list_del(&ctrl->node);
1306                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1307                         list_del(&sev->node);
1308                 kfree(ctrl);
1309         }
1310         kfree(hdl->buckets);
1311         hdl->buckets = NULL;
1312         hdl->cached = NULL;
1313         hdl->error = 0;
1314         mutex_unlock(hdl->lock);
1315 }
1316 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1317
1318 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1319    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1320    with applications that do not use the NEXT_CTRL flag.
1321
1322    We just find the n-th private user control. It's O(N), but that should not
1323    be an issue in this particular case. */
1324 static struct v4l2_ctrl_ref *find_private_ref(
1325                 struct v4l2_ctrl_handler *hdl, u32 id)
1326 {
1327         struct v4l2_ctrl_ref *ref;
1328
1329         id -= V4L2_CID_PRIVATE_BASE;
1330         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1331                 /* Search for private user controls that are compatible with
1332                    VIDIOC_G/S_CTRL. */
1333                 if (V4L2_CTRL_ID2CLASS(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1334                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1335                         if (!type_is_int(ref->ctrl))
1336                                 continue;
1337                         if (id == 0)
1338                                 return ref;
1339                         id--;
1340                 }
1341         }
1342         return NULL;
1343 }
1344
1345 /* Find a control with the given ID. */
1346 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1347 {
1348         struct v4l2_ctrl_ref *ref;
1349         int bucket;
1350
1351         id &= V4L2_CTRL_ID_MASK;
1352
1353         /* Old-style private controls need special handling */
1354         if (id >= V4L2_CID_PRIVATE_BASE)
1355                 return find_private_ref(hdl, id);
1356         bucket = id % hdl->nr_of_buckets;
1357
1358         /* Simple optimization: cache the last control found */
1359         if (hdl->cached && hdl->cached->ctrl->id == id)
1360                 return hdl->cached;
1361
1362         /* Not in cache, search the hash */
1363         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1364         while (ref && ref->ctrl->id != id)
1365                 ref = ref->next;
1366
1367         if (ref)
1368                 hdl->cached = ref; /* cache it! */
1369         return ref;
1370 }
1371
1372 /* Find a control with the given ID. Take the handler's lock first. */
1373 static struct v4l2_ctrl_ref *find_ref_lock(
1374                 struct v4l2_ctrl_handler *hdl, u32 id)
1375 {
1376         struct v4l2_ctrl_ref *ref = NULL;
1377
1378         if (hdl) {
1379                 mutex_lock(hdl->lock);
1380                 ref = find_ref(hdl, id);
1381                 mutex_unlock(hdl->lock);
1382         }
1383         return ref;
1384 }
1385
1386 /* Find a control with the given ID. */
1387 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1388 {
1389         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1390
1391         return ref ? ref->ctrl : NULL;
1392 }
1393 EXPORT_SYMBOL(v4l2_ctrl_find);
1394
1395 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1396 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1397                            struct v4l2_ctrl *ctrl)
1398 {
1399         struct v4l2_ctrl_ref *ref;
1400         struct v4l2_ctrl_ref *new_ref;
1401         u32 id = ctrl->id;
1402         u32 class_ctrl = V4L2_CTRL_ID2CLASS(id) | 1;
1403         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
1404
1405         /* Automatically add the control class if it is not yet present. */
1406         if (id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1407                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1408                         return hdl->error;
1409
1410         if (hdl->error)
1411                 return hdl->error;
1412
1413         new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1414         if (!new_ref)
1415                 return handler_set_err(hdl, -ENOMEM);
1416         new_ref->ctrl = ctrl;
1417         if (ctrl->handler == hdl) {
1418                 /* By default each control starts in a cluster of its own.
1419                    new_ref->ctrl is basically a cluster array with one
1420                    element, so that's perfect to use as the cluster pointer.
1421                    But only do this for the handler that owns the control. */
1422                 ctrl->cluster = &new_ref->ctrl;
1423                 ctrl->ncontrols = 1;
1424         }
1425
1426         INIT_LIST_HEAD(&new_ref->node);
1427
1428         mutex_lock(hdl->lock);
1429
1430         /* Add immediately at the end of the list if the list is empty, or if
1431            the last element in the list has a lower ID.
1432            This ensures that when elements are added in ascending order the
1433            insertion is an O(1) operation. */
1434         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1435                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1436                 goto insert_in_hash;
1437         }
1438
1439         /* Find insert position in sorted list */
1440         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1441                 if (ref->ctrl->id < id)
1442                         continue;
1443                 /* Don't add duplicates */
1444                 if (ref->ctrl->id == id) {
1445                         kfree(new_ref);
1446                         goto unlock;
1447                 }
1448                 list_add(&new_ref->node, ref->node.prev);
1449                 break;
1450         }
1451
1452 insert_in_hash:
1453         /* Insert the control node in the hash */
1454         new_ref->next = hdl->buckets[bucket];
1455         hdl->buckets[bucket] = new_ref;
1456
1457 unlock:
1458         mutex_unlock(hdl->lock);
1459         return 0;
1460 }
1461
1462 /* Add a new control */
1463 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1464                         const struct v4l2_ctrl_ops *ops,
1465                         u32 id, const char *name, enum v4l2_ctrl_type type,
1466                         s32 min, s32 max, u32 step, s32 def,
1467                         u32 flags, const char * const *qmenu,
1468                         const s64 *qmenu_int, void *priv)
1469 {
1470         struct v4l2_ctrl *ctrl;
1471         unsigned sz_extra = 0;
1472
1473         if (hdl->error)
1474                 return NULL;
1475
1476         /* Sanity checks */
1477         if (id == 0 || name == NULL || id >= V4L2_CID_PRIVATE_BASE ||
1478             (type == V4L2_CTRL_TYPE_INTEGER && step == 0) ||
1479             (type == V4L2_CTRL_TYPE_BITMASK && max == 0) ||
1480             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1481             (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL) ||
1482             (type == V4L2_CTRL_TYPE_STRING && max == 0)) {
1483                 handler_set_err(hdl, -ERANGE);
1484                 return NULL;
1485         }
1486         if (type != V4L2_CTRL_TYPE_BITMASK && max < min) {
1487                 handler_set_err(hdl, -ERANGE);
1488                 return NULL;
1489         }
1490         if ((type == V4L2_CTRL_TYPE_INTEGER ||
1491              type == V4L2_CTRL_TYPE_MENU ||
1492              type == V4L2_CTRL_TYPE_INTEGER_MENU ||
1493              type == V4L2_CTRL_TYPE_BOOLEAN) &&
1494             (def < min || def > max)) {
1495                 handler_set_err(hdl, -ERANGE);
1496                 return NULL;
1497         }
1498         if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1499                 handler_set_err(hdl, -ERANGE);
1500                 return NULL;
1501         }
1502
1503         if (type == V4L2_CTRL_TYPE_BUTTON)
1504                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1505         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1506                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1507         else if (type == V4L2_CTRL_TYPE_STRING)
1508                 sz_extra += 2 * (max + 1);
1509
1510         ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1511         if (ctrl == NULL) {
1512                 handler_set_err(hdl, -ENOMEM);
1513                 return NULL;
1514         }
1515
1516         INIT_LIST_HEAD(&ctrl->node);
1517         INIT_LIST_HEAD(&ctrl->ev_subs);
1518         ctrl->handler = hdl;
1519         ctrl->ops = ops;
1520         ctrl->id = id;
1521         ctrl->name = name;
1522         ctrl->type = type;
1523         ctrl->flags = flags;
1524         ctrl->minimum = min;
1525         ctrl->maximum = max;
1526         ctrl->step = step;
1527         if (type == V4L2_CTRL_TYPE_MENU)
1528                 ctrl->qmenu = qmenu;
1529         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1530                 ctrl->qmenu_int = qmenu_int;
1531         ctrl->priv = priv;
1532         ctrl->cur.val = ctrl->val = ctrl->default_value = def;
1533
1534         if (ctrl->type == V4L2_CTRL_TYPE_STRING) {
1535                 ctrl->cur.string = (char *)&ctrl[1] + sz_extra - (max + 1);
1536                 ctrl->string = (char *)&ctrl[1] + sz_extra - 2 * (max + 1);
1537                 if (ctrl->minimum)
1538                         memset(ctrl->cur.string, ' ', ctrl->minimum);
1539         }
1540         if (handler_new_ref(hdl, ctrl)) {
1541                 kfree(ctrl);
1542                 return NULL;
1543         }
1544         mutex_lock(hdl->lock);
1545         list_add_tail(&ctrl->node, &hdl->ctrls);
1546         mutex_unlock(hdl->lock);
1547         return ctrl;
1548 }
1549
1550 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1551                         const struct v4l2_ctrl_config *cfg, void *priv)
1552 {
1553         bool is_menu;
1554         struct v4l2_ctrl *ctrl;
1555         const char *name = cfg->name;
1556         const char * const *qmenu = cfg->qmenu;
1557         const s64 *qmenu_int = cfg->qmenu_int;
1558         enum v4l2_ctrl_type type = cfg->type;
1559         u32 flags = cfg->flags;
1560         s32 min = cfg->min;
1561         s32 max = cfg->max;
1562         u32 step = cfg->step;
1563         s32 def = cfg->def;
1564
1565         if (name == NULL)
1566                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1567                                                                 &def, &flags);
1568
1569         is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
1570                    cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
1571         if (is_menu)
1572                 WARN_ON(step);
1573         else
1574                 WARN_ON(cfg->menu_skip_mask);
1575         if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
1576                 qmenu = v4l2_ctrl_get_menu(cfg->id);
1577         else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
1578                  qmenu_int == NULL) {
1579                 handler_set_err(hdl, -EINVAL);
1580                 return NULL;
1581         }
1582
1583         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->id, name,
1584                         type, min, max,
1585                         is_menu ? cfg->menu_skip_mask : step,
1586                         def, flags, qmenu, qmenu_int, priv);
1587         if (ctrl)
1588                 ctrl->is_private = cfg->is_private;
1589         return ctrl;
1590 }
1591 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1592
1593 /* Helper function for standard non-menu controls */
1594 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1595                         const struct v4l2_ctrl_ops *ops,
1596                         u32 id, s32 min, s32 max, u32 step, s32 def)
1597 {
1598         const char *name;
1599         enum v4l2_ctrl_type type;
1600         u32 flags;
1601
1602         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1603         if (type == V4L2_CTRL_TYPE_MENU
1604             || type == V4L2_CTRL_TYPE_INTEGER_MENU) {
1605                 handler_set_err(hdl, -EINVAL);
1606                 return NULL;
1607         }
1608         return v4l2_ctrl_new(hdl, ops, id, name, type,
1609                              min, max, step, def, flags, NULL, NULL, NULL);
1610 }
1611 EXPORT_SYMBOL(v4l2_ctrl_new_std);
1612
1613 /* Helper function for standard menu controls */
1614 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1615                         const struct v4l2_ctrl_ops *ops,
1616                         u32 id, s32 max, s32 mask, s32 def)
1617 {
1618         const char * const *qmenu = v4l2_ctrl_get_menu(id);
1619         const char *name;
1620         enum v4l2_ctrl_type type;
1621         s32 min;
1622         s32 step;
1623         u32 flags;
1624
1625         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1626         if (type != V4L2_CTRL_TYPE_MENU) {
1627                 handler_set_err(hdl, -EINVAL);
1628                 return NULL;
1629         }
1630         return v4l2_ctrl_new(hdl, ops, id, name, type,
1631                              0, max, mask, def, flags, qmenu, NULL, NULL);
1632 }
1633 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1634
1635 /* Helper function for standard integer menu controls */
1636 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
1637                         const struct v4l2_ctrl_ops *ops,
1638                         u32 id, s32 max, s32 def, const s64 *qmenu_int)
1639 {
1640         const char *name;
1641         enum v4l2_ctrl_type type;
1642         s32 min;
1643         s32 step;
1644         u32 flags;
1645
1646         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1647         if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
1648                 handler_set_err(hdl, -EINVAL);
1649                 return NULL;
1650         }
1651         return v4l2_ctrl_new(hdl, ops, id, name, type,
1652                              0, max, 0, def, flags, NULL, qmenu_int, NULL);
1653 }
1654 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
1655
1656 /* Add a control from another handler to this handler */
1657 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
1658                                           struct v4l2_ctrl *ctrl)
1659 {
1660         if (hdl == NULL || hdl->error)
1661                 return NULL;
1662         if (ctrl == NULL) {
1663                 handler_set_err(hdl, -EINVAL);
1664                 return NULL;
1665         }
1666         if (ctrl->handler == hdl)
1667                 return ctrl;
1668         return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
1669 }
1670 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
1671
1672 /* Add the controls from another handler to our own. */
1673 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1674                           struct v4l2_ctrl_handler *add)
1675 {
1676         struct v4l2_ctrl_ref *ref;
1677         int ret = 0;
1678
1679         /* Do nothing if either handler is NULL or if they are the same */
1680         if (!hdl || !add || hdl == add)
1681                 return 0;
1682         if (hdl->error)
1683                 return hdl->error;
1684         mutex_lock(add->lock);
1685         list_for_each_entry(ref, &add->ctrl_refs, node) {
1686                 struct v4l2_ctrl *ctrl = ref->ctrl;
1687
1688                 /* Skip handler-private controls. */
1689                 if (ctrl->is_private)
1690                         continue;
1691                 /* And control classes */
1692                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1693                         continue;
1694                 ret = handler_new_ref(hdl, ctrl);
1695                 if (ret)
1696                         break;
1697         }
1698         mutex_unlock(add->lock);
1699         return ret;
1700 }
1701 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1702
1703 /* Cluster controls */
1704 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1705 {
1706         bool has_volatiles = false;
1707         int i;
1708
1709         /* The first control is the master control and it must not be NULL */
1710         BUG_ON(ncontrols == 0 || controls[0] == NULL);
1711
1712         for (i = 0; i < ncontrols; i++) {
1713                 if (controls[i]) {
1714                         controls[i]->cluster = controls;
1715                         controls[i]->ncontrols = ncontrols;
1716                         if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1717                                 has_volatiles = true;
1718                 }
1719         }
1720         controls[0]->has_volatiles = has_volatiles;
1721 }
1722 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1723
1724 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1725                             u8 manual_val, bool set_volatile)
1726 {
1727         struct v4l2_ctrl *master = controls[0];
1728         u32 flag = 0;
1729         int i;
1730
1731         v4l2_ctrl_cluster(ncontrols, controls);
1732         WARN_ON(ncontrols <= 1);
1733         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1734         WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1735         master->is_auto = true;
1736         master->has_volatiles = set_volatile;
1737         master->manual_mode_value = manual_val;
1738         master->flags |= V4L2_CTRL_FLAG_UPDATE;
1739
1740         if (!is_cur_manual(master))
1741                 flag = V4L2_CTRL_FLAG_INACTIVE |
1742                         (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1743
1744         for (i = 1; i < ncontrols; i++)
1745                 if (controls[i])
1746                         controls[i]->flags |= flag;
1747 }
1748 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1749
1750 /* Activate/deactivate a control. */
1751 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1752 {
1753         /* invert since the actual flag is called 'inactive' */
1754         bool inactive = !active;
1755         bool old;
1756
1757         if (ctrl == NULL)
1758                 return;
1759
1760         if (inactive)
1761                 /* set V4L2_CTRL_FLAG_INACTIVE */
1762                 old = test_and_set_bit(4, &ctrl->flags);
1763         else
1764                 /* clear V4L2_CTRL_FLAG_INACTIVE */
1765                 old = test_and_clear_bit(4, &ctrl->flags);
1766         if (old != inactive)
1767                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1768 }
1769 EXPORT_SYMBOL(v4l2_ctrl_activate);
1770
1771 /* Grab/ungrab a control.
1772    Typically used when streaming starts and you want to grab controls,
1773    preventing the user from changing them.
1774
1775    Just call this and the framework will block any attempts to change
1776    these controls. */
1777 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1778 {
1779         bool old;
1780
1781         if (ctrl == NULL)
1782                 return;
1783
1784         v4l2_ctrl_lock(ctrl);
1785         if (grabbed)
1786                 /* set V4L2_CTRL_FLAG_GRABBED */
1787                 old = test_and_set_bit(1, &ctrl->flags);
1788         else
1789                 /* clear V4L2_CTRL_FLAG_GRABBED */
1790                 old = test_and_clear_bit(1, &ctrl->flags);
1791         if (old != grabbed)
1792                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1793         v4l2_ctrl_unlock(ctrl);
1794 }
1795 EXPORT_SYMBOL(v4l2_ctrl_grab);
1796
1797 /* Log the control name and value */
1798 static void log_ctrl(const struct v4l2_ctrl *ctrl,
1799                      const char *prefix, const char *colon)
1800 {
1801         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
1802                 return;
1803         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1804                 return;
1805
1806         printk(KERN_INFO "%s%s%s: ", prefix, colon, ctrl->name);
1807
1808         switch (ctrl->type) {
1809         case V4L2_CTRL_TYPE_INTEGER:
1810                 printk(KERN_CONT "%d", ctrl->cur.val);
1811                 break;
1812         case V4L2_CTRL_TYPE_BOOLEAN:
1813                 printk(KERN_CONT "%s", ctrl->cur.val ? "true" : "false");
1814                 break;
1815         case V4L2_CTRL_TYPE_MENU:
1816                 printk(KERN_CONT "%s", ctrl->qmenu[ctrl->cur.val]);
1817                 break;
1818         case V4L2_CTRL_TYPE_INTEGER_MENU:
1819                 printk(KERN_CONT "%lld", ctrl->qmenu_int[ctrl->cur.val]);
1820                 break;
1821         case V4L2_CTRL_TYPE_BITMASK:
1822                 printk(KERN_CONT "0x%08x", ctrl->cur.val);
1823                 break;
1824         case V4L2_CTRL_TYPE_INTEGER64:
1825                 printk(KERN_CONT "%lld", ctrl->cur.val64);
1826                 break;
1827         case V4L2_CTRL_TYPE_STRING:
1828                 printk(KERN_CONT "%s", ctrl->cur.string);
1829                 break;
1830         default:
1831                 printk(KERN_CONT "unknown type %d", ctrl->type);
1832                 break;
1833         }
1834         if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
1835                            V4L2_CTRL_FLAG_GRABBED |
1836                            V4L2_CTRL_FLAG_VOLATILE)) {
1837                 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
1838                         printk(KERN_CONT " inactive");
1839                 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1840                         printk(KERN_CONT " grabbed");
1841                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
1842                         printk(KERN_CONT " volatile");
1843         }
1844         printk(KERN_CONT "\n");
1845 }
1846
1847 /* Log all controls owned by the handler */
1848 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
1849                                   const char *prefix)
1850 {
1851         struct v4l2_ctrl *ctrl;
1852         const char *colon = "";
1853         int len;
1854
1855         if (hdl == NULL)
1856                 return;
1857         if (prefix == NULL)
1858                 prefix = "";
1859         len = strlen(prefix);
1860         if (len && prefix[len - 1] != ' ')
1861                 colon = ": ";
1862         mutex_lock(hdl->lock);
1863         list_for_each_entry(ctrl, &hdl->ctrls, node)
1864                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
1865                         log_ctrl(ctrl, prefix, colon);
1866         mutex_unlock(hdl->lock);
1867 }
1868 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
1869
1870 /* Call s_ctrl for all controls owned by the handler */
1871 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
1872 {
1873         struct v4l2_ctrl *ctrl;
1874         int ret = 0;
1875
1876         if (hdl == NULL)
1877                 return 0;
1878         mutex_lock(hdl->lock);
1879         list_for_each_entry(ctrl, &hdl->ctrls, node)
1880                 ctrl->done = false;
1881
1882         list_for_each_entry(ctrl, &hdl->ctrls, node) {
1883                 struct v4l2_ctrl *master = ctrl->cluster[0];
1884                 int i;
1885
1886                 /* Skip if this control was already handled by a cluster. */
1887                 /* Skip button controls and read-only controls. */
1888                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
1889                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
1890                         continue;
1891
1892                 for (i = 0; i < master->ncontrols; i++) {
1893                         if (master->cluster[i]) {
1894                                 cur_to_new(master->cluster[i]);
1895                                 master->cluster[i]->is_new = 1;
1896                                 master->cluster[i]->done = true;
1897                         }
1898                 }
1899                 ret = call_op(master, s_ctrl);
1900                 if (ret)
1901                         break;
1902         }
1903         mutex_unlock(hdl->lock);
1904         return ret;
1905 }
1906 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
1907
1908 /* Implement VIDIOC_QUERYCTRL */
1909 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
1910 {
1911         u32 id = qc->id & V4L2_CTRL_ID_MASK;
1912         struct v4l2_ctrl_ref *ref;
1913         struct v4l2_ctrl *ctrl;
1914
1915         if (hdl == NULL)
1916                 return -EINVAL;
1917
1918         mutex_lock(hdl->lock);
1919
1920         /* Try to find it */
1921         ref = find_ref(hdl, id);
1922
1923         if ((qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) && !list_empty(&hdl->ctrl_refs)) {
1924                 /* Find the next control with ID > qc->id */
1925
1926                 /* Did we reach the end of the control list? */
1927                 if (id >= node2id(hdl->ctrl_refs.prev)) {
1928                         ref = NULL; /* Yes, so there is no next control */
1929                 } else if (ref) {
1930                         /* We found a control with the given ID, so just get
1931                            the next one in the list. */
1932                         ref = list_entry(ref->node.next, typeof(*ref), node);
1933                 } else {
1934                         /* No control with the given ID exists, so start
1935                            searching for the next largest ID. We know there
1936                            is one, otherwise the first 'if' above would have
1937                            been true. */
1938                         list_for_each_entry(ref, &hdl->ctrl_refs, node)
1939                                 if (id < ref->ctrl->id)
1940                                         break;
1941                 }
1942         }
1943         mutex_unlock(hdl->lock);
1944         if (!ref)
1945                 return -EINVAL;
1946
1947         ctrl = ref->ctrl;
1948         memset(qc, 0, sizeof(*qc));
1949         if (id >= V4L2_CID_PRIVATE_BASE)
1950                 qc->id = id;
1951         else
1952                 qc->id = ctrl->id;
1953         strlcpy(qc->name, ctrl->name, sizeof(qc->name));
1954         qc->minimum = ctrl->minimum;
1955         qc->maximum = ctrl->maximum;
1956         qc->default_value = ctrl->default_value;
1957         if (ctrl->type == V4L2_CTRL_TYPE_MENU
1958             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1959                 qc->step = 1;
1960         else
1961                 qc->step = ctrl->step;
1962         qc->flags = ctrl->flags;
1963         qc->type = ctrl->type;
1964         return 0;
1965 }
1966 EXPORT_SYMBOL(v4l2_queryctrl);
1967
1968 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1969 {
1970         if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
1971                 return -EINVAL;
1972         return v4l2_queryctrl(sd->ctrl_handler, qc);
1973 }
1974 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
1975
1976 /* Implement VIDIOC_QUERYMENU */
1977 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
1978 {
1979         struct v4l2_ctrl *ctrl;
1980         u32 i = qm->index;
1981
1982         ctrl = v4l2_ctrl_find(hdl, qm->id);
1983         if (!ctrl)
1984                 return -EINVAL;
1985
1986         qm->reserved = 0;
1987         /* Sanity checks */
1988         switch (ctrl->type) {
1989         case V4L2_CTRL_TYPE_MENU:
1990                 if (ctrl->qmenu == NULL)
1991                         return -EINVAL;
1992                 break;
1993         case V4L2_CTRL_TYPE_INTEGER_MENU:
1994                 if (ctrl->qmenu_int == NULL)
1995                         return -EINVAL;
1996                 break;
1997         default:
1998                 return -EINVAL;
1999         }
2000
2001         if (i < ctrl->minimum || i > ctrl->maximum)
2002                 return -EINVAL;
2003
2004         /* Use mask to see if this menu item should be skipped */
2005         if (ctrl->menu_skip_mask & (1 << i))
2006                 return -EINVAL;
2007         /* Empty menu items should also be skipped */
2008         if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2009                 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2010                         return -EINVAL;
2011                 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2012         } else {
2013                 qm->value = ctrl->qmenu_int[i];
2014         }
2015         return 0;
2016 }
2017 EXPORT_SYMBOL(v4l2_querymenu);
2018
2019 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2020 {
2021         return v4l2_querymenu(sd->ctrl_handler, qm);
2022 }
2023 EXPORT_SYMBOL(v4l2_subdev_querymenu);
2024
2025
2026
2027 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2028
2029    It is not a fully atomic operation, just best-effort only. After all, if
2030    multiple controls have to be set through multiple i2c writes (for example)
2031    then some initial writes may succeed while others fail. Thus leaving the
2032    system in an inconsistent state. The question is how much effort you are
2033    willing to spend on trying to make something atomic that really isn't.
2034
2035    From the point of view of an application the main requirement is that
2036    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2037    error should be returned without actually affecting any controls.
2038
2039    If all the values are correct, then it is acceptable to just give up
2040    in case of low-level errors.
2041
2042    It is important though that the application can tell when only a partial
2043    configuration was done. The way we do that is through the error_idx field
2044    of struct v4l2_ext_controls: if that is equal to the count field then no
2045    controls were affected. Otherwise all controls before that index were
2046    successful in performing their 'get' or 'set' operation, the control at
2047    the given index failed, and you don't know what happened with the controls
2048    after the failed one. Since if they were part of a control cluster they
2049    could have been successfully processed (if a cluster member was encountered
2050    at index < error_idx), they could have failed (if a cluster member was at
2051    error_idx), or they may not have been processed yet (if the first cluster
2052    member appeared after error_idx).
2053
2054    It is all fairly theoretical, though. In practice all you can do is to
2055    bail out. If error_idx == count, then it is an application bug. If
2056    error_idx < count then it is only an application bug if the error code was
2057    EBUSY. That usually means that something started streaming just when you
2058    tried to set the controls. In all other cases it is a driver/hardware
2059    problem and all you can do is to retry or bail out.
2060
2061    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2062    never modifies controls the error_idx is just set to whatever control
2063    has an invalid value.
2064  */
2065
2066 /* Prepare for the extended g/s/try functions.
2067    Find the controls in the control array and do some basic checks. */
2068 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2069                              struct v4l2_ext_controls *cs,
2070                              struct v4l2_ctrl_helper *helpers)
2071 {
2072         struct v4l2_ctrl_helper *h;
2073         bool have_clusters = false;
2074         u32 i;
2075
2076         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2077                 struct v4l2_ext_control *c = &cs->controls[i];
2078                 struct v4l2_ctrl_ref *ref;
2079                 struct v4l2_ctrl *ctrl;
2080                 u32 id = c->id & V4L2_CTRL_ID_MASK;
2081
2082                 cs->error_idx = i;
2083
2084                 if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2085                         return -EINVAL;
2086
2087                 /* Old-style private controls are not allowed for
2088                    extended controls */
2089                 if (id >= V4L2_CID_PRIVATE_BASE)
2090                         return -EINVAL;
2091                 ref = find_ref_lock(hdl, id);
2092                 if (ref == NULL)
2093                         return -EINVAL;
2094                 ctrl = ref->ctrl;
2095                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2096                         return -EINVAL;
2097
2098                 if (ctrl->cluster[0]->ncontrols > 1)
2099                         have_clusters = true;
2100                 if (ctrl->cluster[0] != ctrl)
2101                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2102                 /* Store the ref to the master control of the cluster */
2103                 h->mref = ref;
2104                 h->ctrl = ctrl;
2105                 /* Initially set next to 0, meaning that there is no other
2106                    control in this helper array belonging to the same
2107                    cluster */
2108                 h->next = 0;
2109         }
2110
2111         /* We are done if there were no controls that belong to a multi-
2112            control cluster. */
2113         if (!have_clusters)
2114                 return 0;
2115
2116         /* The code below figures out in O(n) time which controls in the list
2117            belong to the same cluster. */
2118
2119         /* This has to be done with the handler lock taken. */
2120         mutex_lock(hdl->lock);
2121
2122         /* First zero the helper field in the master control references */
2123         for (i = 0; i < cs->count; i++)
2124                 helpers[i].mref->helper = NULL;
2125         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2126                 struct v4l2_ctrl_ref *mref = h->mref;
2127
2128                 /* If the mref->helper is set, then it points to an earlier
2129                    helper that belongs to the same cluster. */
2130                 if (mref->helper) {
2131                         /* Set the next field of mref->helper to the current
2132                            index: this means that that earlier helper now
2133                            points to the next helper in the same cluster. */
2134                         mref->helper->next = i;
2135                         /* mref should be set only for the first helper in the
2136                            cluster, clear the others. */
2137                         h->mref = NULL;
2138                 }
2139                 /* Point the mref helper to the current helper struct. */
2140                 mref->helper = h;
2141         }
2142         mutex_unlock(hdl->lock);
2143         return 0;
2144 }
2145
2146 /* Handles the corner case where cs->count == 0. It checks whether the
2147    specified control class exists. If that class ID is 0, then it checks
2148    whether there are any controls at all. */
2149 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2150 {
2151         if (ctrl_class == 0)
2152                 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2153         return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2154 }
2155
2156
2157
2158 /* Get extended controls. Allocates the helpers array if needed. */
2159 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2160 {
2161         struct v4l2_ctrl_helper helper[4];
2162         struct v4l2_ctrl_helper *helpers = helper;
2163         int ret;
2164         int i, j;
2165
2166         cs->error_idx = cs->count;
2167         cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2168
2169         if (hdl == NULL)
2170                 return -EINVAL;
2171
2172         if (cs->count == 0)
2173                 return class_check(hdl, cs->ctrl_class);
2174
2175         if (cs->count > ARRAY_SIZE(helper)) {
2176                 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2177                                         GFP_KERNEL);
2178                 if (helpers == NULL)
2179                         return -ENOMEM;
2180         }
2181
2182         ret = prepare_ext_ctrls(hdl, cs, helpers);
2183         cs->error_idx = cs->count;
2184
2185         for (i = 0; !ret && i < cs->count; i++)
2186                 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2187                         ret = -EACCES;
2188
2189         for (i = 0; !ret && i < cs->count; i++) {
2190                 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2191                                     struct v4l2_ctrl *ctrl) = cur_to_user;
2192                 struct v4l2_ctrl *master;
2193
2194                 if (helpers[i].mref == NULL)
2195                         continue;
2196
2197                 master = helpers[i].mref->ctrl;
2198                 cs->error_idx = i;
2199
2200                 v4l2_ctrl_lock(master);
2201
2202                 /* g_volatile_ctrl will update the new control values */
2203                 if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2204                         (master->has_volatiles && !is_cur_manual(master))) {
2205                         for (j = 0; j < master->ncontrols; j++)
2206                                 cur_to_new(master->cluster[j]);
2207                         ret = call_op(master, g_volatile_ctrl);
2208                         ctrl_to_user = new_to_user;
2209                 }
2210                 /* If OK, then copy the current (for non-volatile controls)
2211                    or the new (for volatile controls) control values to the
2212                    caller */
2213                 if (!ret) {
2214                         u32 idx = i;
2215
2216                         do {
2217                                 ret = ctrl_to_user(cs->controls + idx,
2218                                                    helpers[idx].ctrl);
2219                                 idx = helpers[idx].next;
2220                         } while (!ret && idx);
2221                 }
2222                 v4l2_ctrl_unlock(master);
2223         }
2224
2225         if (cs->count > ARRAY_SIZE(helper))
2226                 kfree(helpers);
2227         return ret;
2228 }
2229 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2230
2231 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2232 {
2233         return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2234 }
2235 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2236
2237 /* Helper function to get a single control */
2238 static int get_ctrl(struct v4l2_ctrl *ctrl, s32 *val)
2239 {
2240         struct v4l2_ctrl *master = ctrl->cluster[0];
2241         int ret = 0;
2242         int i;
2243
2244         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2245                 return -EACCES;
2246
2247         v4l2_ctrl_lock(master);
2248         /* g_volatile_ctrl will update the current control values */
2249         if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2250                 for (i = 0; i < master->ncontrols; i++)
2251                         cur_to_new(master->cluster[i]);
2252                 ret = call_op(master, g_volatile_ctrl);
2253                 *val = ctrl->val;
2254         } else {
2255                 *val = ctrl->cur.val;
2256         }
2257         v4l2_ctrl_unlock(master);
2258         return ret;
2259 }
2260
2261 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2262 {
2263         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2264
2265         if (ctrl == NULL || !type_is_int(ctrl))
2266                 return -EINVAL;
2267         return get_ctrl(ctrl, &control->value);
2268 }
2269 EXPORT_SYMBOL(v4l2_g_ctrl);
2270
2271 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2272 {
2273         return v4l2_g_ctrl(sd->ctrl_handler, control);
2274 }
2275 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2276
2277 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2278 {
2279         s32 val = 0;
2280
2281         /* It's a driver bug if this happens. */
2282         WARN_ON(!type_is_int(ctrl));
2283         get_ctrl(ctrl, &val);
2284         return val;
2285 }
2286 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2287
2288
2289 /* Core function that calls try/s_ctrl and ensures that the new value is
2290    copied to the current value on a set.
2291    Must be called with ctrl->handler->lock held. */
2292 static int try_or_set_cluster(struct v4l2_fh *fh,
2293                               struct v4l2_ctrl *master, bool set)
2294 {
2295         bool update_flag;
2296         int ret;
2297         int i;
2298
2299         /* Go through the cluster and either validate the new value or
2300            (if no new value was set), copy the current value to the new
2301            value, ensuring a consistent view for the control ops when
2302            called. */
2303         for (i = 0; i < master->ncontrols; i++) {
2304                 struct v4l2_ctrl *ctrl = master->cluster[i];
2305
2306                 if (ctrl == NULL)
2307                         continue;
2308
2309                 if (!ctrl->is_new) {
2310                         cur_to_new(ctrl);
2311                         continue;
2312                 }
2313                 /* Check again: it may have changed since the
2314                    previous check in try_or_set_ext_ctrls(). */
2315                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2316                         return -EBUSY;
2317         }
2318
2319         ret = call_op(master, try_ctrl);
2320
2321         /* Don't set if there is no change */
2322         if (ret || !set || !cluster_changed(master))
2323                 return ret;
2324         ret = call_op(master, s_ctrl);
2325         if (ret)
2326                 return ret;
2327
2328         /* If OK, then make the new values permanent. */
2329         update_flag = is_cur_manual(master) != is_new_manual(master);
2330         for (i = 0; i < master->ncontrols; i++)
2331                 new_to_cur(fh, master->cluster[i], update_flag && i > 0);
2332         return 0;
2333 }
2334
2335 /* Validate controls. */
2336 static int validate_ctrls(struct v4l2_ext_controls *cs,
2337                           struct v4l2_ctrl_helper *helpers, bool set)
2338 {
2339         unsigned i;
2340         int ret = 0;
2341
2342         cs->error_idx = cs->count;
2343         for (i = 0; i < cs->count; i++) {
2344                 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
2345
2346                 cs->error_idx = i;
2347
2348                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2349                         return -EACCES;
2350                 /* This test is also done in try_set_control_cluster() which
2351                    is called in atomic context, so that has the final say,
2352                    but it makes sense to do an up-front check as well. Once
2353                    an error occurs in try_set_control_cluster() some other
2354                    controls may have been set already and we want to do a
2355                    best-effort to avoid that. */
2356                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2357                         return -EBUSY;
2358                 ret = validate_new(ctrl, &cs->controls[i]);
2359                 if (ret)
2360                         return ret;
2361         }
2362         return 0;
2363 }
2364
2365 /* Obtain the current volatile values of an autocluster and mark them
2366    as new. */
2367 static void update_from_auto_cluster(struct v4l2_ctrl *master)
2368 {
2369         int i;
2370
2371         for (i = 0; i < master->ncontrols; i++)
2372                 cur_to_new(master->cluster[i]);
2373         if (!call_op(master, g_volatile_ctrl))
2374                 for (i = 1; i < master->ncontrols; i++)
2375                         if (master->cluster[i])
2376                                 master->cluster[i]->is_new = 1;
2377 }
2378
2379 /* Try or try-and-set controls */
2380 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2381                              struct v4l2_ext_controls *cs,
2382                              bool set)
2383 {
2384         struct v4l2_ctrl_helper helper[4];
2385         struct v4l2_ctrl_helper *helpers = helper;
2386         unsigned i, j;
2387         int ret;
2388
2389         cs->error_idx = cs->count;
2390         cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2391
2392         if (hdl == NULL)
2393                 return -EINVAL;
2394
2395         if (cs->count == 0)
2396                 return class_check(hdl, cs->ctrl_class);
2397
2398         if (cs->count > ARRAY_SIZE(helper)) {
2399                 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2400                                         GFP_KERNEL);
2401                 if (!helpers)
2402                         return -ENOMEM;
2403         }
2404         ret = prepare_ext_ctrls(hdl, cs, helpers);
2405         if (!ret)
2406                 ret = validate_ctrls(cs, helpers, set);
2407         if (ret && set)
2408                 cs->error_idx = cs->count;
2409         for (i = 0; !ret && i < cs->count; i++) {
2410                 struct v4l2_ctrl *master;
2411                 u32 idx = i;
2412
2413                 if (helpers[i].mref == NULL)
2414                         continue;
2415
2416                 cs->error_idx = i;
2417                 master = helpers[i].mref->ctrl;
2418                 v4l2_ctrl_lock(master);
2419
2420                 /* Reset the 'is_new' flags of the cluster */
2421                 for (j = 0; j < master->ncontrols; j++)
2422                         if (master->cluster[j])
2423                                 master->cluster[j]->is_new = 0;
2424
2425                 /* For volatile autoclusters that are currently in auto mode
2426                    we need to discover if it will be set to manual mode.
2427                    If so, then we have to copy the current volatile values
2428                    first since those will become the new manual values (which
2429                    may be overwritten by explicit new values from this set
2430                    of controls). */
2431                 if (master->is_auto && master->has_volatiles &&
2432                                                 !is_cur_manual(master)) {
2433                         /* Pick an initial non-manual value */
2434                         s32 new_auto_val = master->manual_mode_value + 1;
2435                         u32 tmp_idx = idx;
2436
2437                         do {
2438                                 /* Check if the auto control is part of the
2439                                    list, and remember the new value. */
2440                                 if (helpers[tmp_idx].ctrl == master)
2441                                         new_auto_val = cs->controls[tmp_idx].value;
2442                                 tmp_idx = helpers[tmp_idx].next;
2443                         } while (tmp_idx);
2444                         /* If the new value == the manual value, then copy
2445                            the current volatile values. */
2446                         if (new_auto_val == master->manual_mode_value)
2447                                 update_from_auto_cluster(master);
2448                 }
2449
2450                 /* Copy the new caller-supplied control values.
2451                    user_to_new() sets 'is_new' to 1. */
2452                 do {
2453                         ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
2454                         idx = helpers[idx].next;
2455                 } while (!ret && idx);
2456
2457                 if (!ret)
2458                         ret = try_or_set_cluster(fh, master, set);
2459
2460                 /* Copy the new values back to userspace. */
2461                 if (!ret) {
2462                         idx = i;
2463                         do {
2464                                 ret = new_to_user(cs->controls + idx,
2465                                                 helpers[idx].ctrl);
2466                                 idx = helpers[idx].next;
2467                         } while (!ret && idx);
2468                 }
2469                 v4l2_ctrl_unlock(master);
2470         }
2471
2472         if (cs->count > ARRAY_SIZE(helper))
2473                 kfree(helpers);
2474         return ret;
2475 }
2476
2477 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2478 {
2479         return try_set_ext_ctrls(NULL, hdl, cs, false);
2480 }
2481 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
2482
2483 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2484                                         struct v4l2_ext_controls *cs)
2485 {
2486         return try_set_ext_ctrls(fh, hdl, cs, true);
2487 }
2488 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
2489
2490 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2491 {
2492         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
2493 }
2494 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
2495
2496 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2497 {
2498         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
2499 }
2500 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
2501
2502 /* Helper function for VIDIOC_S_CTRL compatibility */
2503 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, s32 *val)
2504 {
2505         struct v4l2_ctrl *master = ctrl->cluster[0];
2506         int ret;
2507         int i;
2508
2509         ret = validate_new_int(ctrl, val);
2510         if (ret)
2511                 return ret;
2512
2513         v4l2_ctrl_lock(ctrl);
2514
2515         /* Reset the 'is_new' flags of the cluster */
2516         for (i = 0; i < master->ncontrols; i++)
2517                 if (master->cluster[i])
2518                         master->cluster[i]->is_new = 0;
2519
2520         /* For autoclusters with volatiles that are switched from auto to
2521            manual mode we have to update the current volatile values since
2522            those will become the initial manual values after such a switch. */
2523         if (master->is_auto && master->has_volatiles && ctrl == master &&
2524             !is_cur_manual(master) && *val == master->manual_mode_value)
2525                 update_from_auto_cluster(master);
2526         ctrl->val = *val;
2527         ctrl->is_new = 1;
2528         ret = try_or_set_cluster(fh, master, true);
2529         *val = ctrl->cur.val;
2530         v4l2_ctrl_unlock(ctrl);
2531         return ret;
2532 }
2533
2534 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2535                                         struct v4l2_control *control)
2536 {
2537         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2538
2539         if (ctrl == NULL || !type_is_int(ctrl))
2540                 return -EINVAL;
2541
2542         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2543                 return -EACCES;
2544
2545         return set_ctrl(fh, ctrl, &control->value);
2546 }
2547 EXPORT_SYMBOL(v4l2_s_ctrl);
2548
2549 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2550 {
2551         return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
2552 }
2553 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
2554
2555 int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
2556 {
2557         /* It's a driver bug if this happens. */
2558         WARN_ON(!type_is_int(ctrl));
2559         return set_ctrl(NULL, ctrl, &val);
2560 }
2561 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
2562
2563 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
2564 {
2565         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2566
2567         if (ctrl == NULL)
2568                 return -EINVAL;
2569
2570         v4l2_ctrl_lock(ctrl);
2571         list_add_tail(&sev->node, &ctrl->ev_subs);
2572         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
2573             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
2574                 struct v4l2_event ev;
2575                 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
2576
2577                 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
2578                         changes |= V4L2_EVENT_CTRL_CH_VALUE;
2579                 fill_event(&ev, ctrl, changes);
2580                 /* Mark the queue as active, allowing this initial
2581                    event to be accepted. */
2582                 sev->elems = elems;
2583                 v4l2_event_queue_fh(sev->fh, &ev);
2584         }
2585         v4l2_ctrl_unlock(ctrl);
2586         return 0;
2587 }
2588
2589 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
2590 {
2591         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2592
2593         v4l2_ctrl_lock(ctrl);
2594         list_del(&sev->node);
2595         v4l2_ctrl_unlock(ctrl);
2596 }
2597
2598 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
2599 {
2600         u32 old_changes = old->u.ctrl.changes;
2601
2602         old->u.ctrl = new->u.ctrl;
2603         old->u.ctrl.changes |= old_changes;
2604 }
2605 EXPORT_SYMBOL(v4l2_ctrl_replace);
2606
2607 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
2608 {
2609         new->u.ctrl.changes |= old->u.ctrl.changes;
2610 }
2611 EXPORT_SYMBOL(v4l2_ctrl_merge);
2612
2613 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
2614         .add = v4l2_ctrl_add_event,
2615         .del = v4l2_ctrl_del_event,
2616         .replace = v4l2_ctrl_replace,
2617         .merge = v4l2_ctrl_merge,
2618 };
2619 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
2620
2621 int v4l2_ctrl_log_status(struct file *file, void *fh)
2622 {
2623         struct video_device *vfd = video_devdata(file);
2624         struct v4l2_fh *vfh = file->private_data;
2625
2626         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
2627                 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
2628                         vfd->v4l2_dev->name);
2629         return 0;
2630 }
2631 EXPORT_SYMBOL(v4l2_ctrl_log_status);
2632
2633 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
2634                                 struct v4l2_event_subscription *sub)
2635 {
2636         if (sub->type == V4L2_EVENT_CTRL)
2637                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
2638         return -EINVAL;
2639 }
2640 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
2641
2642 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
2643 {
2644         struct v4l2_fh *fh = file->private_data;
2645
2646         if (v4l2_event_pending(fh))
2647                 return POLLPRI;
2648         poll_wait(file, &fh->wait, wait);
2649         return 0;
2650 }
2651 EXPORT_SYMBOL(v4l2_ctrl_poll);