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. In that case the is_volatile flag should be ignored. */
  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                 ctrl->flags &= ~V4L2_CTRL_FLAG_INACTIVE;
 941                 if (!is_cur_manual(ctrl->cluster[0]))
 942                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
 943         }
 944         if (changed || update_inactive) {
 945                 /* If a control was changed that was not one of the controls
 946                    modified by the application, then send the event to all. */
 947                 if (!ctrl->is_new)
 948                         fh = NULL;
 949                 send_event(fh, ctrl,
 950                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) |
 951                         (update_inactive ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
 952         }
 953 }
 954
 955 /* Copy the current value to the new value */
 956 static void cur_to_new(struct v4l2_ctrl *ctrl)
 957 {
 958         if (ctrl == NULL)
 959                 return;
 960         switch (ctrl->type) {
 961         case V4L2_CTRL_TYPE_STRING:
 962                 /* strings are always 0-terminated */
 963                 strcpy(ctrl->string, ctrl->cur.string);
 964                 break;
 965         case V4L2_CTRL_TYPE_INTEGER64:
 966                 ctrl->val64 = ctrl->cur.val64;
 967                 break;
 968         default:
 969                 ctrl->val = ctrl->cur.val;
 970                 break;
 971         }
 972 }
 973
 974 /* Return non-zero if one or more of the controls in the cluster has a new
 975    value that differs from the current value. */
 976 static int cluster_changed(struct v4l2_ctrl *master)
 977 {
 978         int diff = 0;
 979         int i;
 980
 981         for (i = 0; !diff && i < master->ncontrols; i++) {
 982                 struct v4l2_ctrl *ctrl = master->cluster[i];
 983
 984                 if (ctrl == NULL)
 985                         continue;
 986                 switch (ctrl->type) {
 987                 case V4L2_CTRL_TYPE_BUTTON:
 988                         /* Button controls are always 'different' */
 989                         return 1;
 990                 case V4L2_CTRL_TYPE_STRING:
 991                         /* strings are always 0-terminated */
 992                         diff = strcmp(ctrl->string, ctrl->cur.string);
 993                         break;
 994                 case V4L2_CTRL_TYPE_INTEGER64:
 995                         diff = ctrl->val64 != ctrl->cur.val64;
 996                         break;
 997                 default:
 998                         diff = ctrl->val != ctrl->cur.val;
 999                         break;
1000                 }
1001         }
1002         return diff;
1003 }
1004
1005 /* Validate integer-type control */
1006 static int validate_new_int(const struct v4l2_ctrl *ctrl, s32 *pval)
1007 {
1008         s32 val = *pval;
1009         u32 offset;
1010
1011         switch (ctrl->type) {
1012         case V4L2_CTRL_TYPE_INTEGER:
1013                 /* Round towards the closest legal value */
1014                 val += ctrl->step / 2;
1015                 if (val < ctrl->minimum)
1016                         val = ctrl->minimum;
1017                 if (val > ctrl->maximum)
1018                         val = ctrl->maximum;
1019                 offset = val - ctrl->minimum;
1020                 offset = ctrl->step * (offset / ctrl->step);
1021                 val = ctrl->minimum + offset;
1022                 *pval = val;
1023                 return 0;
1024
1025         case V4L2_CTRL_TYPE_BOOLEAN:
1026                 *pval = !!val;
1027                 return 0;
1028
1029         case V4L2_CTRL_TYPE_MENU:
1030                 if (val < ctrl->minimum || val > ctrl->maximum)
1031                         return -ERANGE;
1032                 if (ctrl->qmenu[val][0] == '\0' ||
1033                     (ctrl->menu_skip_mask & (1 << val)))
1034                         return -EINVAL;
1035                 return 0;
1036
1037         case V4L2_CTRL_TYPE_BITMASK:
1038                 *pval &= ctrl->maximum;
1039                 return 0;
1040
1041         case V4L2_CTRL_TYPE_BUTTON:
1042         case V4L2_CTRL_TYPE_CTRL_CLASS:
1043                 *pval = 0;
1044                 return 0;
1045
1046         default:
1047                 return -EINVAL;
1048         }
1049 }
1050
1051 /* Validate a new control */
1052 static int validate_new(const struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
1053 {
1054         char *s = c->string;
1055         size_t len;
1056
1057         switch (ctrl->type) {
1058         case V4L2_CTRL_TYPE_INTEGER:
1059         case V4L2_CTRL_TYPE_BOOLEAN:
1060         case V4L2_CTRL_TYPE_MENU:
1061         case V4L2_CTRL_TYPE_BITMASK:
1062         case V4L2_CTRL_TYPE_BUTTON:
1063         case V4L2_CTRL_TYPE_CTRL_CLASS:
1064                 return validate_new_int(ctrl, &c->value);
1065
1066         case V4L2_CTRL_TYPE_INTEGER64:
1067                 return 0;
1068
1069         case V4L2_CTRL_TYPE_STRING:
1070                 len = strlen(s);
1071                 if (len < ctrl->minimum)
1072                         return -ERANGE;
1073                 if ((len - ctrl->minimum) % ctrl->step)
1074                         return -ERANGE;
1075                 return 0;
1076
1077         default:
1078                 return -EINVAL;
1079         }
1080 }
1081
1082 static inline u32 node2id(struct list_head *node)
1083 {
1084         return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1085 }
1086
1087 /* Set the handler's error code if it wasn't set earlier already */
1088 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1089 {
1090         if (hdl->error == 0)
1091                 hdl->error = err;
1092         return err;
1093 }
1094
1095 /* Initialize the handler */
1096 int v4l2_ctrl_handler_init(struct v4l2_ctrl_handler *hdl,
1097                            unsigned nr_of_controls_hint)
1098 {
1099         mutex_init(&hdl->lock);
1100         INIT_LIST_HEAD(&hdl->ctrls);
1101         INIT_LIST_HEAD(&hdl->ctrl_refs);
1102         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1103         hdl->buckets = kzalloc(sizeof(hdl->buckets[0]) * hdl->nr_of_buckets,
1104                                                                 GFP_KERNEL);
1105         hdl->error = hdl->buckets ? 0 : -ENOMEM;
1106         return hdl->error;
1107 }
1108 EXPORT_SYMBOL(v4l2_ctrl_handler_init);
1109
1110 /* Free all controls and control refs */
1111 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1112 {
1113         struct v4l2_ctrl_ref *ref, *next_ref;
1114         struct v4l2_ctrl *ctrl, *next_ctrl;
1115         struct v4l2_subscribed_event *sev, *next_sev;
1116
1117         if (hdl == NULL || hdl->buckets == NULL)
1118                 return;
1119
1120         mutex_lock(&hdl->lock);
1121         /* Free all nodes */
1122         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1123                 list_del(&ref->node);
1124                 kfree(ref);
1125         }
1126         /* Free all controls owned by the handler */
1127         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1128                 list_del(&ctrl->node);
1129                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1130                         list_del(&sev->node);
1131                 kfree(ctrl);
1132         }
1133         kfree(hdl->buckets);
1134         hdl->buckets = NULL;
1135         hdl->cached = NULL;
1136         hdl->error = 0;
1137         mutex_unlock(&hdl->lock);
1138 }
1139 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1140
1141 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1142    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1143    with applications that do not use the NEXT_CTRL flag.
1144
1145    We just find the n-th private user control. It's O(N), but that should not
1146    be an issue in this particular case. */
1147 static struct v4l2_ctrl_ref *find_private_ref(
1148                 struct v4l2_ctrl_handler *hdl, u32 id)
1149 {
1150         struct v4l2_ctrl_ref *ref;
1151
1152         id -= V4L2_CID_PRIVATE_BASE;
1153         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1154                 /* Search for private user controls that are compatible with
1155                    VIDIOC_G/S_CTRL. */
1156                 if (V4L2_CTRL_ID2CLASS(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1157                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1158                         if (!type_is_int(ref->ctrl))
1159                                 continue;
1160                         if (id == 0)
1161                                 return ref;
1162                         id--;
1163                 }
1164         }
1165         return NULL;
1166 }
1167
1168 /* Find a control with the given ID. */
1169 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1170 {
1171         struct v4l2_ctrl_ref *ref;
1172         int bucket;
1173
1174         id &= V4L2_CTRL_ID_MASK;
1175
1176         /* Old-style private controls need special handling */
1177         if (id >= V4L2_CID_PRIVATE_BASE)
1178                 return find_private_ref(hdl, id);
1179         bucket = id % hdl->nr_of_buckets;
1180
1181         /* Simple optimization: cache the last control found */
1182         if (hdl->cached && hdl->cached->ctrl->id == id)
1183                 return hdl->cached;
1184
1185         /* Not in cache, search the hash */
1186         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1187         while (ref && ref->ctrl->id != id)
1188                 ref = ref->next;
1189
1190         if (ref)
1191                 hdl->cached = ref; /* cache it! */
1192         return ref;
1193 }
1194
1195 /* Find a control with the given ID. Take the handler's lock first. */
1196 static struct v4l2_ctrl_ref *find_ref_lock(
1197                 struct v4l2_ctrl_handler *hdl, u32 id)
1198 {
1199         struct v4l2_ctrl_ref *ref = NULL;
1200
1201         if (hdl) {
1202                 mutex_lock(&hdl->lock);
1203                 ref = find_ref(hdl, id);
1204                 mutex_unlock(&hdl->lock);
1205         }
1206         return ref;
1207 }
1208
1209 /* Find a control with the given ID. */
1210 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1211 {
1212         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1213
1214         return ref ? ref->ctrl : NULL;
1215 }
1216 EXPORT_SYMBOL(v4l2_ctrl_find);
1217
1218 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1219 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1220                            struct v4l2_ctrl *ctrl)
1221 {
1222         struct v4l2_ctrl_ref *ref;
1223         struct v4l2_ctrl_ref *new_ref;
1224         u32 id = ctrl->id;
1225         u32 class_ctrl = V4L2_CTRL_ID2CLASS(id) | 1;
1226         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
1227
1228         /* Automatically add the control class if it is not yet present. */
1229         if (id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1230                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1231                         return hdl->error;
1232
1233         if (hdl->error)
1234                 return hdl->error;
1235
1236         new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1237         if (!new_ref)
1238                 return handler_set_err(hdl, -ENOMEM);
1239         new_ref->ctrl = ctrl;
1240         if (ctrl->handler == hdl) {
1241                 /* By default each control starts in a cluster of its own.
1242                    new_ref->ctrl is basically a cluster array with one
1243                    element, so that's perfect to use as the cluster pointer.
1244                    But only do this for the handler that owns the control. */
1245                 ctrl->cluster = &new_ref->ctrl;
1246                 ctrl->ncontrols = 1;
1247         }
1248
1249         INIT_LIST_HEAD(&new_ref->node);
1250
1251         mutex_lock(&hdl->lock);
1252
1253         /* Add immediately at the end of the list if the list is empty, or if
1254            the last element in the list has a lower ID.
1255            This ensures that when elements are added in ascending order the
1256            insertion is an O(1) operation. */
1257         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1258                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1259                 goto insert_in_hash;
1260         }
1261
1262         /* Find insert position in sorted list */
1263         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1264                 if (ref->ctrl->id < id)
1265                         continue;
1266                 /* Don't add duplicates */
1267                 if (ref->ctrl->id == id) {
1268                         kfree(new_ref);
1269                         goto unlock;
1270                 }
1271                 list_add(&new_ref->node, ref->node.prev);
1272                 break;
1273         }
1274
1275 insert_in_hash:
1276         /* Insert the control node in the hash */
1277         new_ref->next = hdl->buckets[bucket];
1278         hdl->buckets[bucket] = new_ref;
1279
1280 unlock:
1281         mutex_unlock(&hdl->lock);
1282         return 0;
1283 }
1284
1285 /* Add a new control */
1286 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1287                         const struct v4l2_ctrl_ops *ops,
1288                         u32 id, const char *name, enum v4l2_ctrl_type type,
1289                         s32 min, s32 max, u32 step, s32 def,
1290                         u32 flags, const char * const *qmenu, void *priv)
1291 {
1292         struct v4l2_ctrl *ctrl;
1293         unsigned sz_extra = 0;
1294
1295         if (hdl->error)
1296                 return NULL;
1297
1298         /* Sanity checks */
1299         if (id == 0 || name == NULL || id >= V4L2_CID_PRIVATE_BASE ||
1300             (type == V4L2_CTRL_TYPE_INTEGER && step == 0) ||
1301             (type == V4L2_CTRL_TYPE_BITMASK && max == 0) ||
1302             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1303             (type == V4L2_CTRL_TYPE_STRING && max == 0)) {
1304                 handler_set_err(hdl, -ERANGE);
1305                 return NULL;
1306         }
1307         if (type != V4L2_CTRL_TYPE_BITMASK && max < min) {
1308                 handler_set_err(hdl, -ERANGE);
1309                 return NULL;
1310         }
1311         if ((type == V4L2_CTRL_TYPE_INTEGER ||
1312              type == V4L2_CTRL_TYPE_MENU ||
1313              type == V4L2_CTRL_TYPE_BOOLEAN) &&
1314             (def < min || def > max)) {
1315                 handler_set_err(hdl, -ERANGE);
1316                 return NULL;
1317         }
1318         if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1319                 handler_set_err(hdl, -ERANGE);
1320                 return NULL;
1321         }
1322
1323         if (type == V4L2_CTRL_TYPE_BUTTON)
1324                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1325         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1326                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1327         else if (type == V4L2_CTRL_TYPE_STRING)
1328                 sz_extra += 2 * (max + 1);
1329
1330         ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1331         if (ctrl == NULL) {
1332                 handler_set_err(hdl, -ENOMEM);
1333                 return NULL;
1334         }
1335
1336         INIT_LIST_HEAD(&ctrl->node);
1337         INIT_LIST_HEAD(&ctrl->ev_subs);
1338         ctrl->handler = hdl;
1339         ctrl->ops = ops;
1340         ctrl->id = id;
1341         ctrl->name = name;
1342         ctrl->type = type;
1343         ctrl->flags = flags;
1344         ctrl->minimum = min;
1345         ctrl->maximum = max;
1346         ctrl->step = step;
1347         ctrl->qmenu = qmenu;
1348         ctrl->priv = priv;
1349         ctrl->cur.val = ctrl->val = ctrl->default_value = def;
1350
1351         if (ctrl->type == V4L2_CTRL_TYPE_STRING) {
1352                 ctrl->cur.string = (char *)&ctrl[1] + sz_extra - (max + 1);
1353                 ctrl->string = (char *)&ctrl[1] + sz_extra - 2 * (max + 1);
1354                 if (ctrl->minimum)
1355                         memset(ctrl->cur.string, ' ', ctrl->minimum);
1356         }
1357         if (handler_new_ref(hdl, ctrl)) {
1358                 kfree(ctrl);
1359                 return NULL;
1360         }
1361         mutex_lock(&hdl->lock);
1362         list_add_tail(&ctrl->node, &hdl->ctrls);
1363         mutex_unlock(&hdl->lock);
1364         return ctrl;
1365 }
1366
1367 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1368                         const struct v4l2_ctrl_config *cfg, void *priv)
1369 {
1370         bool is_menu;
1371         struct v4l2_ctrl *ctrl;
1372         const char *name = cfg->name;
1373         const char * const *qmenu = cfg->qmenu;
1374         enum v4l2_ctrl_type type = cfg->type;
1375         u32 flags = cfg->flags;
1376         s32 min = cfg->min;
1377         s32 max = cfg->max;
1378         u32 step = cfg->step;
1379         s32 def = cfg->def;
1380
1381         if (name == NULL)
1382                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1383                                                                 &def, &flags);
1384
1385         is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU);
1386         if (is_menu)
1387                 WARN_ON(step);
1388         else
1389                 WARN_ON(cfg->menu_skip_mask);
1390         if (is_menu && qmenu == NULL)
1391                 qmenu = v4l2_ctrl_get_menu(cfg->id);
1392
1393         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->id, name,
1394                         type, min, max,
1395                         is_menu ? cfg->menu_skip_mask : step,
1396                         def, flags, qmenu, priv);
1397         if (ctrl) {
1398                 ctrl->is_private = cfg->is_private;
1399                 ctrl->is_volatile = cfg->is_volatile;
1400         }
1401         return ctrl;
1402 }
1403 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1404
1405 /* Helper function for standard non-menu controls */
1406 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1407                         const struct v4l2_ctrl_ops *ops,
1408                         u32 id, s32 min, s32 max, u32 step, s32 def)
1409 {
1410         const char *name;
1411         enum v4l2_ctrl_type type;
1412         u32 flags;
1413
1414         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1415         if (type == V4L2_CTRL_TYPE_MENU) {
1416                 handler_set_err(hdl, -EINVAL);
1417                 return NULL;
1418         }
1419         return v4l2_ctrl_new(hdl, ops, id, name, type,
1420                                     min, max, step, def, flags, NULL, NULL);
1421 }
1422 EXPORT_SYMBOL(v4l2_ctrl_new_std);
1423
1424 /* Helper function for standard menu controls */
1425 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1426                         const struct v4l2_ctrl_ops *ops,
1427                         u32 id, s32 max, s32 mask, s32 def)
1428 {
1429         const char * const *qmenu = v4l2_ctrl_get_menu(id);
1430         const char *name;
1431         enum v4l2_ctrl_type type;
1432         s32 min;
1433         s32 step;
1434         u32 flags;
1435
1436         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1437         if (type != V4L2_CTRL_TYPE_MENU) {
1438                 handler_set_err(hdl, -EINVAL);
1439                 return NULL;
1440         }
1441         return v4l2_ctrl_new(hdl, ops, id, name, type,
1442                                     0, max, mask, def, flags, qmenu, NULL);
1443 }
1444 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1445
1446 /* Add a control from another handler to this handler */
1447 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
1448                                           struct v4l2_ctrl *ctrl)
1449 {
1450         if (hdl == NULL || hdl->error)
1451                 return NULL;
1452         if (ctrl == NULL) {
1453                 handler_set_err(hdl, -EINVAL);
1454                 return NULL;
1455         }
1456         if (ctrl->handler == hdl)
1457                 return ctrl;
1458         return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
1459 }
1460 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
1461
1462 /* Add the controls from another handler to our own. */
1463 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1464                           struct v4l2_ctrl_handler *add)
1465 {
1466         struct v4l2_ctrl *ctrl;
1467         int ret = 0;
1468
1469         /* Do nothing if either handler is NULL or if they are the same */
1470         if (!hdl || !add || hdl == add)
1471                 return 0;
1472         if (hdl->error)
1473                 return hdl->error;
1474         mutex_lock(&add->lock);
1475         list_for_each_entry(ctrl, &add->ctrls, node) {
1476                 /* Skip handler-private controls. */
1477                 if (ctrl->is_private)
1478                         continue;
1479                 /* And control classes */
1480                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1481                         continue;
1482                 ret = handler_new_ref(hdl, ctrl);
1483                 if (ret)
1484                         break;
1485         }
1486         mutex_unlock(&add->lock);
1487         return ret;
1488 }
1489 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1490
1491 /* Cluster controls */
1492 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1493 {
1494         int i;
1495
1496         /* The first control is the master control and it must not be NULL */
1497         BUG_ON(ncontrols == 0 || controls[0] == NULL);
1498
1499         for (i = 0; i < ncontrols; i++) {
1500                 if (controls[i]) {
1501                         controls[i]->cluster = controls;
1502                         controls[i]->ncontrols = ncontrols;
1503                 }
1504         }
1505 }
1506 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1507
1508 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1509                             u8 manual_val, bool set_volatile)
1510 {
1511         struct v4l2_ctrl *master = controls[0];
1512         u32 flag;
1513         int i;
1514
1515         v4l2_ctrl_cluster(ncontrols, controls);
1516         WARN_ON(ncontrols <= 1);
1517         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1518         master->is_auto = true;
1519         master->manual_mode_value = manual_val;
1520         master->flags |= V4L2_CTRL_FLAG_UPDATE;
1521         flag = is_cur_manual(master) ? 0 : V4L2_CTRL_FLAG_INACTIVE;
1522
1523         for (i = 1; i < ncontrols; i++)
1524                 if (controls[i]) {
1525                         controls[i]->is_volatile = set_volatile;
1526                         controls[i]->flags |= flag;
1527                 }
1528 }
1529 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1530
1531 /* Activate/deactivate a control. */
1532 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1533 {
1534         /* invert since the actual flag is called 'inactive' */
1535         bool inactive = !active;
1536         bool old;
1537
1538         if (ctrl == NULL)
1539                 return;
1540
1541         if (inactive)
1542                 /* set V4L2_CTRL_FLAG_INACTIVE */
1543                 old = test_and_set_bit(4, &ctrl->flags);
1544         else
1545                 /* clear V4L2_CTRL_FLAG_INACTIVE */
1546                 old = test_and_clear_bit(4, &ctrl->flags);
1547         if (old != inactive)
1548                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1549 }
1550 EXPORT_SYMBOL(v4l2_ctrl_activate);
1551
1552 /* Grab/ungrab a control.
1553    Typically used when streaming starts and you want to grab controls,
1554    preventing the user from changing them.
1555
1556    Just call this and the framework will block any attempts to change
1557    these controls. */
1558 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1559 {
1560         bool old;
1561
1562         if (ctrl == NULL)
1563                 return;
1564
1565         v4l2_ctrl_lock(ctrl);
1566         if (grabbed)
1567                 /* set V4L2_CTRL_FLAG_GRABBED */
1568                 old = test_and_set_bit(1, &ctrl->flags);
1569         else
1570                 /* clear V4L2_CTRL_FLAG_GRABBED */
1571                 old = test_and_clear_bit(1, &ctrl->flags);
1572         if (old != grabbed)
1573                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1574         v4l2_ctrl_unlock(ctrl);
1575 }
1576 EXPORT_SYMBOL(v4l2_ctrl_grab);
1577
1578 /* Log the control name and value */
1579 static void log_ctrl(const struct v4l2_ctrl *ctrl,
1580                      const char *prefix, const char *colon)
1581 {
1582         int fl_inact = ctrl->flags & V4L2_CTRL_FLAG_INACTIVE;
1583         int fl_grabbed = ctrl->flags & V4L2_CTRL_FLAG_GRABBED;
1584
1585         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
1586                 return;
1587         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1588                 return;
1589
1590         printk(KERN_INFO "%s%s%s: ", prefix, colon, ctrl->name);
1591
1592         switch (ctrl->type) {
1593         case V4L2_CTRL_TYPE_INTEGER:
1594                 printk(KERN_CONT "%d", ctrl->cur.val);
1595                 break;
1596         case V4L2_CTRL_TYPE_BOOLEAN:
1597                 printk(KERN_CONT "%s", ctrl->cur.val ? "true" : "false");
1598                 break;
1599         case V4L2_CTRL_TYPE_MENU:
1600                 printk(KERN_CONT "%s", ctrl->qmenu[ctrl->cur.val]);
1601                 break;
1602         case V4L2_CTRL_TYPE_BITMASK:
1603                 printk(KERN_CONT "0x%08x", ctrl->cur.val);
1604                 break;
1605         case V4L2_CTRL_TYPE_INTEGER64:
1606                 printk(KERN_CONT "%lld", ctrl->cur.val64);
1607                 break;
1608         case V4L2_CTRL_TYPE_STRING:
1609                 printk(KERN_CONT "%s", ctrl->cur.string);
1610                 break;
1611         default:
1612                 printk(KERN_CONT "unknown type %d", ctrl->type);
1613                 break;
1614         }
1615         if (fl_inact && fl_grabbed)
1616                 printk(KERN_CONT " (inactive, grabbed)\n");
1617         else if (fl_inact)
1618                 printk(KERN_CONT " (inactive)\n");
1619         else if (fl_grabbed)
1620                 printk(KERN_CONT " (grabbed)\n");
1621         else
1622                 printk(KERN_CONT "\n");
1623 }
1624
1625 /* Log all controls owned by the handler */
1626 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
1627                                   const char *prefix)
1628 {
1629         struct v4l2_ctrl *ctrl;
1630         const char *colon = "";
1631         int len;
1632
1633         if (hdl == NULL)
1634                 return;
1635         if (prefix == NULL)
1636                 prefix = "";
1637         len = strlen(prefix);
1638         if (len && prefix[len - 1] != ' ')
1639                 colon = ": ";
1640         mutex_lock(&hdl->lock);
1641         list_for_each_entry(ctrl, &hdl->ctrls, node)
1642                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
1643                         log_ctrl(ctrl, prefix, colon);
1644         mutex_unlock(&hdl->lock);
1645 }
1646 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
1647
1648 /* Call s_ctrl for all controls owned by the handler */
1649 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
1650 {
1651         struct v4l2_ctrl *ctrl;
1652         int ret = 0;
1653
1654         if (hdl == NULL)
1655                 return 0;
1656         mutex_lock(&hdl->lock);
1657         list_for_each_entry(ctrl, &hdl->ctrls, node)
1658                 ctrl->done = false;
1659
1660         list_for_each_entry(ctrl, &hdl->ctrls, node) {
1661                 struct v4l2_ctrl *master = ctrl->cluster[0];
1662                 int i;
1663
1664                 /* Skip if this control was already handled by a cluster. */
1665                 /* Skip button controls and read-only controls. */
1666                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
1667                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
1668                         continue;
1669
1670                 for (i = 0; i < master->ncontrols; i++) {
1671                         if (master->cluster[i]) {
1672                                 cur_to_new(master->cluster[i]);
1673                                 master->cluster[i]->is_new = 1;
1674                                 master->cluster[i]->done = true;
1675                         }
1676                 }
1677                 ret = call_op(master, s_ctrl);
1678                 if (ret)
1679                         break;
1680         }
1681         mutex_unlock(&hdl->lock);
1682         return ret;
1683 }
1684 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
1685
1686 /* Implement VIDIOC_QUERYCTRL */
1687 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
1688 {
1689         u32 id = qc->id & V4L2_CTRL_ID_MASK;
1690         struct v4l2_ctrl_ref *ref;
1691         struct v4l2_ctrl *ctrl;
1692
1693         if (hdl == NULL)
1694                 return -EINVAL;
1695
1696         mutex_lock(&hdl->lock);
1697
1698         /* Try to find it */
1699         ref = find_ref(hdl, id);
1700
1701         if ((qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) && !list_empty(&hdl->ctrl_refs)) {
1702                 /* Find the next control with ID > qc->id */
1703
1704                 /* Did we reach the end of the control list? */
1705                 if (id >= node2id(hdl->ctrl_refs.prev)) {
1706                         ref = NULL; /* Yes, so there is no next control */
1707                 } else if (ref) {
1708                         /* We found a control with the given ID, so just get
1709                            the next one in the list. */
1710                         ref = list_entry(ref->node.next, typeof(*ref), node);
1711                 } else {
1712                         /* No control with the given ID exists, so start
1713                            searching for the next largest ID. We know there
1714                            is one, otherwise the first 'if' above would have
1715                            been true. */
1716                         list_for_each_entry(ref, &hdl->ctrl_refs, node)
1717                                 if (id < ref->ctrl->id)
1718                                         break;
1719                 }
1720         }
1721         mutex_unlock(&hdl->lock);
1722         if (!ref)
1723                 return -EINVAL;
1724
1725         ctrl = ref->ctrl;
1726         memset(qc, 0, sizeof(*qc));
1727         if (id >= V4L2_CID_PRIVATE_BASE)
1728                 qc->id = id;
1729         else
1730                 qc->id = ctrl->id;
1731         strlcpy(qc->name, ctrl->name, sizeof(qc->name));
1732         qc->minimum = ctrl->minimum;
1733         qc->maximum = ctrl->maximum;
1734         qc->default_value = ctrl->default_value;
1735         if (ctrl->type == V4L2_CTRL_TYPE_MENU)
1736                 qc->step = 1;
1737         else
1738                 qc->step = ctrl->step;
1739         qc->flags = ctrl->flags;
1740         qc->type = ctrl->type;
1741         return 0;
1742 }
1743 EXPORT_SYMBOL(v4l2_queryctrl);
1744
1745 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1746 {
1747         if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
1748                 return -EINVAL;
1749         return v4l2_queryctrl(sd->ctrl_handler, qc);
1750 }
1751 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
1752
1753 /* Implement VIDIOC_QUERYMENU */
1754 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
1755 {
1756         struct v4l2_ctrl *ctrl;
1757         u32 i = qm->index;
1758
1759         ctrl = v4l2_ctrl_find(hdl, qm->id);
1760         if (!ctrl)
1761                 return -EINVAL;
1762
1763         qm->reserved = 0;
1764         /* Sanity checks */
1765         if (ctrl->qmenu == NULL ||
1766             i < ctrl->minimum || i > ctrl->maximum)
1767                 return -EINVAL;
1768         /* Use mask to see if this menu item should be skipped */
1769         if (ctrl->menu_skip_mask & (1 << i))
1770                 return -EINVAL;
1771         /* Empty menu items should also be skipped */
1772         if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
1773                 return -EINVAL;
1774         strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
1775         return 0;
1776 }
1777 EXPORT_SYMBOL(v4l2_querymenu);
1778
1779 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
1780 {
1781         return v4l2_querymenu(sd->ctrl_handler, qm);
1782 }
1783 EXPORT_SYMBOL(v4l2_subdev_querymenu);
1784
1785
1786
1787 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
1788
1789    It is not a fully atomic operation, just best-effort only. After all, if
1790    multiple controls have to be set through multiple i2c writes (for example)
1791    then some initial writes may succeed while others fail. Thus leaving the
1792    system in an inconsistent state. The question is how much effort you are
1793    willing to spend on trying to make something atomic that really isn't.
1794
1795    From the point of view of an application the main requirement is that
1796    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
1797    error should be returned without actually affecting any controls.
1798
1799    If all the values are correct, then it is acceptable to just give up
1800    in case of low-level errors.
1801
1802    It is important though that the application can tell when only a partial
1803    configuration was done. The way we do that is through the error_idx field
1804    of struct v4l2_ext_controls: if that is equal to the count field then no
1805    controls were affected. Otherwise all controls before that index were
1806    successful in performing their 'get' or 'set' operation, the control at
1807    the given index failed, and you don't know what happened with the controls
1808    after the failed one. Since if they were part of a control cluster they
1809    could have been successfully processed (if a cluster member was encountered
1810    at index < error_idx), they could have failed (if a cluster member was at
1811    error_idx), or they may not have been processed yet (if the first cluster
1812    member appeared after error_idx).
1813
1814    It is all fairly theoretical, though. In practice all you can do is to
1815    bail out. If error_idx == count, then it is an application bug. If
1816    error_idx < count then it is only an application bug if the error code was
1817    EBUSY. That usually means that something started streaming just when you
1818    tried to set the controls. In all other cases it is a driver/hardware
1819    problem and all you can do is to retry or bail out.
1820
1821    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
1822    never modifies controls the error_idx is just set to whatever control
1823    has an invalid value.
1824  */
1825
1826 /* Prepare for the extended g/s/try functions.
1827    Find the controls in the control array and do some basic checks. */
1828 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
1829                              struct v4l2_ext_controls *cs,
1830                              struct v4l2_ctrl_helper *helpers)
1831 {
1832         struct v4l2_ctrl_helper *h;
1833         bool have_clusters = false;
1834         u32 i;
1835
1836         for (i = 0, h = helpers; i < cs->count; i++, h++) {
1837                 struct v4l2_ext_control *c = &cs->controls[i];
1838                 struct v4l2_ctrl_ref *ref;
1839                 struct v4l2_ctrl *ctrl;
1840                 u32 id = c->id & V4L2_CTRL_ID_MASK;
1841
1842                 cs->error_idx = i;
1843
1844                 if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
1845                         return -EINVAL;
1846
1847                 /* Old-style private controls are not allowed for
1848                    extended controls */
1849                 if (id >= V4L2_CID_PRIVATE_BASE)
1850                         return -EINVAL;
1851                 ref = find_ref_lock(hdl, id);
1852                 if (ref == NULL)
1853                         return -EINVAL;
1854                 ctrl = ref->ctrl;
1855                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
1856                         return -EINVAL;
1857
1858                 if (ctrl->cluster[0]->ncontrols > 1)
1859                         have_clusters = true;
1860                 if (ctrl->cluster[0] != ctrl)
1861                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
1862                 /* Store the ref to the master control of the cluster */
1863                 h->mref = ref;
1864                 h->ctrl = ctrl;
1865                 /* Initially set next to 0, meaning that there is no other
1866                    control in this helper array belonging to the same
1867                    cluster */
1868                 h->next = 0;
1869         }
1870
1871         /* We are done if there were no controls that belong to a multi-
1872            control cluster. */
1873         if (!have_clusters)
1874                 return 0;
1875
1876         /* The code below figures out in O(n) time which controls in the list
1877            belong to the same cluster. */
1878
1879         /* This has to be done with the handler lock taken. */
1880         mutex_lock(&hdl->lock);
1881
1882         /* First zero the helper field in the master control references */
1883         for (i = 0; i < cs->count; i++)
1884                 helpers[i].mref->helper = 0;
1885         for (i = 0, h = helpers; i < cs->count; i++, h++) {
1886                 struct v4l2_ctrl_ref *mref = h->mref;
1887
1888                 /* If the mref->helper is set, then it points to an earlier
1889                    helper that belongs to the same cluster. */
1890                 if (mref->helper) {
1891                         /* Set the next field of mref->helper to the current
1892                            index: this means that that earlier helper now
1893                            points to the next helper in the same cluster. */
1894                         mref->helper->next = i;
1895                         /* mref should be set only for the first helper in the
1896                            cluster, clear the others. */
1897                         h->mref = NULL;
1898                 }
1899                 /* Point the mref helper to the current helper struct. */
1900                 mref->helper = h;
1901         }
1902         mutex_unlock(&hdl->lock);
1903         return 0;
1904 }
1905
1906 /* Handles the corner case where cs->count == 0. It checks whether the
1907    specified control class exists. If that class ID is 0, then it checks
1908    whether there are any controls at all. */
1909 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
1910 {
1911         if (ctrl_class == 0)
1912                 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
1913         return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
1914 }
1915
1916
1917
1918 /* Get extended controls. Allocates the helpers array if needed. */
1919 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
1920 {
1921         struct v4l2_ctrl_helper helper[4];
1922         struct v4l2_ctrl_helper *helpers = helper;
1923         int ret;
1924         int i, j;
1925
1926         cs->error_idx = cs->count;
1927         cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
1928
1929         if (hdl == NULL)
1930                 return -EINVAL;
1931
1932         if (cs->count == 0)
1933                 return class_check(hdl, cs->ctrl_class);
1934
1935         if (cs->count > ARRAY_SIZE(helper)) {
1936                 helpers = kmalloc(sizeof(helper[0]) * cs->count, GFP_KERNEL);
1937                 if (helpers == NULL)
1938                         return -ENOMEM;
1939         }
1940
1941         ret = prepare_ext_ctrls(hdl, cs, helpers);
1942         cs->error_idx = cs->count;
1943
1944         for (i = 0; !ret && i < cs->count; i++)
1945                 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
1946                         ret = -EACCES;
1947
1948         for (i = 0; !ret && i < cs->count; i++) {
1949                 int (*ctrl_to_user)(struct v4l2_ext_control *c,
1950                                     struct v4l2_ctrl *ctrl) = cur_to_user;
1951                 struct v4l2_ctrl *master;
1952
1953                 if (helpers[i].mref == NULL)
1954                         continue;
1955
1956                 master = helpers[i].mref->ctrl;
1957                 cs->error_idx = i;
1958
1959                 v4l2_ctrl_lock(master);
1960
1961                 /* g_volatile_ctrl will update the new control values */
1962                 if (has_op(master, g_volatile_ctrl) && !is_cur_manual(master)) {
1963                         for (j = 0; j < master->ncontrols; j++)
1964                                 cur_to_new(master->cluster[j]);
1965                         ret = call_op(master, g_volatile_ctrl);
1966                         ctrl_to_user = new_to_user;
1967                 }
1968                 /* If OK, then copy the current (for non-volatile controls)
1969                    or the new (for volatile controls) control values to the
1970                    caller */
1971                 if (!ret) {
1972                         u32 idx = i;
1973
1974                         do {
1975                                 ret = ctrl_to_user(cs->controls + idx,
1976                                                    helpers[idx].ctrl);
1977                                 idx = helpers[idx].next;
1978                         } while (!ret && idx);
1979                 }
1980                 v4l2_ctrl_unlock(master);
1981         }
1982
1983         if (cs->count > ARRAY_SIZE(helper))
1984                 kfree(helpers);
1985         return ret;
1986 }
1987 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
1988
1989 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
1990 {
1991         return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
1992 }
1993 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
1994
1995 /* Helper function to get a single control */
1996 static int get_ctrl(struct v4l2_ctrl *ctrl, s32 *val)
1997 {
1998         struct v4l2_ctrl *master = ctrl->cluster[0];
1999         int ret = 0;
2000         int i;
2001
2002         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2003                 return -EACCES;
2004
2005         v4l2_ctrl_lock(master);
2006         /* g_volatile_ctrl will update the current control values */
2007         if (ctrl->is_volatile && !is_cur_manual(master)) {
2008                 for (i = 0; i < master->ncontrols; i++)
2009                         cur_to_new(master->cluster[i]);
2010                 ret = call_op(master, g_volatile_ctrl);
2011                 *val = ctrl->val;
2012         } else {
2013                 *val = ctrl->cur.val;
2014         }
2015         v4l2_ctrl_unlock(master);
2016         return ret;
2017 }
2018
2019 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2020 {
2021         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2022
2023         if (ctrl == NULL || !type_is_int(ctrl))
2024                 return -EINVAL;
2025         return get_ctrl(ctrl, &control->value);
2026 }
2027 EXPORT_SYMBOL(v4l2_g_ctrl);
2028
2029 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2030 {
2031         return v4l2_g_ctrl(sd->ctrl_handler, control);
2032 }
2033 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2034
2035 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2036 {
2037         s32 val = 0;
2038
2039         /* It's a driver bug if this happens. */
2040         WARN_ON(!type_is_int(ctrl));
2041         get_ctrl(ctrl, &val);
2042         return val;
2043 }
2044 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2045
2046
2047 /* Core function that calls try/s_ctrl and ensures that the new value is
2048    copied to the current value on a set.
2049    Must be called with ctrl->handler->lock held. */
2050 static int try_or_set_cluster(struct v4l2_fh *fh,
2051                               struct v4l2_ctrl *master, bool set)
2052 {
2053         bool update_flag;
2054         int ret;
2055         int i;
2056
2057         /* Go through the cluster and either validate the new value or
2058            (if no new value was set), copy the current value to the new
2059            value, ensuring a consistent view for the control ops when
2060            called. */
2061         for (i = 0; i < master->ncontrols; i++) {
2062                 struct v4l2_ctrl *ctrl = master->cluster[i];
2063
2064                 if (ctrl == NULL)
2065                         continue;
2066
2067                 if (!ctrl->is_new) {
2068                         cur_to_new(ctrl);
2069                         continue;
2070                 }
2071                 /* Check again: it may have changed since the
2072                    previous check in try_or_set_ext_ctrls(). */
2073                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2074                         return -EBUSY;
2075         }
2076
2077         ret = call_op(master, try_ctrl);
2078
2079         /* Don't set if there is no change */
2080         if (ret || !set || !cluster_changed(master))
2081                 return ret;
2082         ret = call_op(master, s_ctrl);
2083         if (ret)
2084                 return ret;
2085
2086         /* If OK, then make the new values permanent. */
2087         update_flag = is_cur_manual(master) != is_new_manual(master);
2088         for (i = 0; i < master->ncontrols; i++)
2089                 new_to_cur(fh, master->cluster[i], update_flag && i > 0);
2090         return 0;
2091 }
2092
2093 /* Validate controls. */
2094 static int validate_ctrls(struct v4l2_ext_controls *cs,
2095                           struct v4l2_ctrl_helper *helpers, bool set)
2096 {
2097         unsigned i;
2098         int ret = 0;
2099
2100         cs->error_idx = cs->count;
2101         for (i = 0; i < cs->count; i++) {
2102                 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
2103
2104                 cs->error_idx = i;
2105
2106                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2107                         return -EACCES;
2108                 /* This test is also done in try_set_control_cluster() which
2109                    is called in atomic context, so that has the final say,
2110                    but it makes sense to do an up-front check as well. Once
2111                    an error occurs in try_set_control_cluster() some other
2112                    controls may have been set already and we want to do a
2113                    best-effort to avoid that. */
2114                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2115                         return -EBUSY;
2116                 ret = validate_new(ctrl, &cs->controls[i]);
2117                 if (ret)
2118                         return ret;
2119         }
2120         return 0;
2121 }
2122
2123 /* Try or try-and-set controls */
2124 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2125                              struct v4l2_ext_controls *cs,
2126                              bool set)
2127 {
2128         struct v4l2_ctrl_helper helper[4];
2129         struct v4l2_ctrl_helper *helpers = helper;
2130         unsigned i, j;
2131         int ret;
2132
2133         cs->error_idx = cs->count;
2134         cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2135
2136         if (hdl == NULL)
2137                 return -EINVAL;
2138
2139         if (cs->count == 0)
2140                 return class_check(hdl, cs->ctrl_class);
2141
2142         if (cs->count > ARRAY_SIZE(helper)) {
2143                 helpers = kmalloc(sizeof(helper[0]) * cs->count, GFP_KERNEL);
2144                 if (!helpers)
2145                         return -ENOMEM;
2146         }
2147         ret = prepare_ext_ctrls(hdl, cs, helpers);
2148         if (!ret)
2149                 ret = validate_ctrls(cs, helpers, set);
2150         if (ret && set)
2151                 cs->error_idx = cs->count;
2152         for (i = 0; !ret && i < cs->count; i++) {
2153                 struct v4l2_ctrl *master;
2154                 u32 idx = i;
2155
2156                 if (helpers[i].mref == NULL)
2157                         continue;
2158
2159                 cs->error_idx = i;
2160                 master = helpers[i].mref->ctrl;
2161                 v4l2_ctrl_lock(master);
2162
2163                 /* Reset the 'is_new' flags of the cluster */
2164                 for (j = 0; j < master->ncontrols; j++)
2165                         if (master->cluster[j])
2166                                 master->cluster[j]->is_new = 0;
2167
2168                 /* Copy the new caller-supplied control values.
2169                    user_to_new() sets 'is_new' to 1. */
2170                 do {
2171                         ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
2172                         idx = helpers[idx].next;
2173                 } while (!ret && idx);
2174
2175                 if (!ret)
2176                         ret = try_or_set_cluster(fh, master, set);
2177
2178                 /* Copy the new values back to userspace. */
2179                 if (!ret) {
2180                         idx = i;
2181                         do {
2182                                 ret = new_to_user(cs->controls + idx,
2183                                                 helpers[idx].ctrl);
2184                                 idx = helpers[idx].next;
2185                         } while (!ret && idx);
2186                 }
2187                 v4l2_ctrl_unlock(master);
2188         }
2189
2190         if (cs->count > ARRAY_SIZE(helper))
2191                 kfree(helpers);
2192         return ret;
2193 }
2194
2195 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2196 {
2197         return try_set_ext_ctrls(NULL, hdl, cs, false);
2198 }
2199 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
2200
2201 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2202                                         struct v4l2_ext_controls *cs)
2203 {
2204         return try_set_ext_ctrls(fh, hdl, cs, true);
2205 }
2206 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
2207
2208 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2209 {
2210         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
2211 }
2212 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
2213
2214 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2215 {
2216         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
2217 }
2218 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
2219
2220 /* Helper function for VIDIOC_S_CTRL compatibility */
2221 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, s32 *val)
2222 {
2223         struct v4l2_ctrl *master = ctrl->cluster[0];
2224         int ret;
2225         int i;
2226
2227         ret = validate_new_int(ctrl, val);
2228         if (ret)
2229                 return ret;
2230
2231         v4l2_ctrl_lock(ctrl);
2232
2233         /* Reset the 'is_new' flags of the cluster */
2234         for (i = 0; i < master->ncontrols; i++)
2235                 if (master->cluster[i])
2236                         master->cluster[i]->is_new = 0;
2237
2238         ctrl->val = *val;
2239         ctrl->is_new = 1;
2240         ret = try_or_set_cluster(fh, master, true);
2241         *val = ctrl->cur.val;
2242         v4l2_ctrl_unlock(ctrl);
2243         return ret;
2244 }
2245
2246 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2247                                         struct v4l2_control *control)
2248 {
2249         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2250
2251         if (ctrl == NULL || !type_is_int(ctrl))
2252                 return -EINVAL;
2253
2254         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2255                 return -EACCES;
2256
2257         return set_ctrl(fh, ctrl, &control->value);
2258 }
2259 EXPORT_SYMBOL(v4l2_s_ctrl);
2260
2261 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2262 {
2263         return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
2264 }
2265 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
2266
2267 int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
2268 {
2269         /* It's a driver bug if this happens. */
2270         WARN_ON(!type_is_int(ctrl));
2271         return set_ctrl(NULL, ctrl, &val);
2272 }
2273 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
2274
2275 void v4l2_ctrl_add_event(struct v4l2_ctrl *ctrl,
2276                                 struct v4l2_subscribed_event *sev)
2277 {
2278         v4l2_ctrl_lock(ctrl);
2279         list_add_tail(&sev->node, &ctrl->ev_subs);
2280         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
2281             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
2282                 struct v4l2_event ev;
2283                 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
2284
2285                 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
2286                         changes |= V4L2_EVENT_CTRL_CH_VALUE;
2287                 fill_event(&ev, ctrl, changes);
2288                 v4l2_event_queue_fh(sev->fh, &ev);
2289         }
2290         v4l2_ctrl_unlock(ctrl);
2291 }
2292 EXPORT_SYMBOL(v4l2_ctrl_add_event);
2293
2294 void v4l2_ctrl_del_event(struct v4l2_ctrl *ctrl,
2295                                 struct v4l2_subscribed_event *sev)
2296 {
2297         v4l2_ctrl_lock(ctrl);
2298         list_del(&sev->node);
2299         v4l2_ctrl_unlock(ctrl);
2300 }
2301 EXPORT_SYMBOL(v4l2_ctrl_del_event);