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