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