drivers/media/video/v4l2-ctrls.c

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