drivers/media/v4l2-core/v4l2-ctrls.c

   1 /*
   2     V4L2 controls framework implementation.
   3
   4     Copyright (C) 2010  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <linux/ctype.h>
  22 #include <linux/slab.h>
  23 #include <linux/export.h>
  24 #include <media/v4l2-ioctl.h>
  25 #include <media/v4l2-device.h>
  26 #include <media/v4l2-ctrls.h>
  27 #include <media/v4l2-event.h>
  28 #include <media/v4l2-dev.h>
  29
  30 #define has_op(master, op) \
  31         (master->ops && master->ops->op)
  32 #define call_op(master, op) \
  33         (has_op(master, op) ? master->ops->op(master) : 0)
  34
  35 /* Internal temporary helper struct, one for each v4l2_ext_control */
  36 struct v4l2_ctrl_helper {
  37         /* Pointer to the control reference of the master control */
  38         struct v4l2_ctrl_ref *mref;
  39         /* The control corresponding to the v4l2_ext_control ID field. */
  40         struct v4l2_ctrl *ctrl;
  41         /* v4l2_ext_control index of the next control belonging to the
  42            same cluster, or 0 if there isn't any. */
  43         u32 next;
  44 };
  45
  46 /* Small helper function to determine if the autocluster is set to manual
  47    mode. */
  48 static bool is_cur_manual(const struct v4l2_ctrl *master)
  49 {
  50         return master->is_auto && master->cur.val == master->manual_mode_value;
  51 }
  52
  53 /* Same as above, but this checks the against the new value instead of the
  54    current value. */
  55 static bool is_new_manual(const struct v4l2_ctrl *master)
  56 {
  57         return master->is_auto && master->val == master->manual_mode_value;
  58 }
  59
  60 /* Returns NULL or a character pointer array containing the menu for
  61    the given control ID. The pointer array ends with a NULL pointer.
  62    An empty string signifies a menu entry that is invalid. This allows
  63    drivers to disable certain options if it is not supported. */
  64 const char * const *v4l2_ctrl_get_menu(u32 id)
  65 {
  66         static const char * const mpeg_audio_sampling_freq[] = {
  67                 "44.1 kHz",
  68                 "48 kHz",
  69                 "32 kHz",
  70                 NULL
  71         };
  72         static const char * const mpeg_audio_encoding[] = {
  73                 "MPEG-1/2 Layer I",
  74                 "MPEG-1/2 Layer II",
  75                 "MPEG-1/2 Layer III",
  76                 "MPEG-2/4 AAC",
  77                 "AC-3",
  78                 NULL
  79         };
  80         static const char * const mpeg_audio_l1_bitrate[] = {
  81                 "32 kbps",
  82                 "64 kbps",
  83                 "96 kbps",
  84                 "128 kbps",
  85                 "160 kbps",
  86                 "192 kbps",
  87                 "224 kbps",
  88                 "256 kbps",
  89                 "288 kbps",
  90                 "320 kbps",
  91                 "352 kbps",
  92                 "384 kbps",
  93                 "416 kbps",
  94                 "448 kbps",
  95                 NULL
  96         };
  97         static const char * const mpeg_audio_l2_bitrate[] = {
  98                 "32 kbps",
  99                 "48 kbps",
 100                 "56 kbps",
 101                 "64 kbps",
 102                 "80 kbps",
 103                 "96 kbps",
 104                 "112 kbps",
 105                 "128 kbps",
 106                 "160 kbps",
 107                 "192 kbps",
 108                 "224 kbps",
 109                 "256 kbps",
 110                 "320 kbps",
 111                 "384 kbps",
 112                 NULL
 113         };
 114         static const char * const mpeg_audio_l3_bitrate[] = {
 115                 "32 kbps",
 116                 "40 kbps",
 117                 "48 kbps",
 118                 "56 kbps",
 119                 "64 kbps",
 120                 "80 kbps",
 121                 "96 kbps",
 122                 "112 kbps",
 123                 "128 kbps",
 124                 "160 kbps",
 125                 "192 kbps",
 126                 "224 kbps",
 127                 "256 kbps",
 128                 "320 kbps",
 129                 NULL
 130         };
 131         static const char * const mpeg_audio_ac3_bitrate[] = {
 132                 "32 kbps",
 133                 "40 kbps",
 134                 "48 kbps",
 135                 "56 kbps",
 136                 "64 kbps",
 137                 "80 kbps",
 138                 "96 kbps",
 139                 "112 kbps",
 140                 "128 kbps",
 141                 "160 kbps",
 142                 "192 kbps",
 143                 "224 kbps",
 144                 "256 kbps",
 145                 "320 kbps",
 146                 "384 kbps",
 147                 "448 kbps",
 148                 "512 kbps",
 149                 "576 kbps",
 150                 "640 kbps",
 151                 NULL
 152         };
 153         static const char * const mpeg_audio_mode[] = {
 154                 "Stereo",
 155                 "Joint Stereo",
 156                 "Dual",
 157                 "Mono",
 158                 NULL
 159         };
 160         static const char * const mpeg_audio_mode_extension[] = {
 161                 "Bound 4",
 162                 "Bound 8",
 163                 "Bound 12",
 164                 "Bound 16",
 165                 NULL
 166         };
 167         static const char * const mpeg_audio_emphasis[] = {
 168                 "No Emphasis",
 169                 "50/15 us",
 170                 "CCITT J17",
 171                 NULL
 172         };
 173         static const char * const mpeg_audio_crc[] = {
 174                 "No CRC",
 175                 "16-bit CRC",
 176                 NULL
 177         };
 178         static const char * const mpeg_audio_dec_playback[] = {
 179                 "Auto",
 180                 "Stereo",
 181                 "Left",
 182                 "Right",
 183                 "Mono",
 184                 "Swapped Stereo",
 185                 NULL
 186         };
 187         static const char * const mpeg_video_encoding[] = {
 188                 "MPEG-1",
 189                 "MPEG-2",
 190                 "MPEG-4 AVC",
 191                 NULL
 192         };
 193         static const char * const mpeg_video_aspect[] = {
 194                 "1x1",
 195                 "4x3",
 196                 "16x9",
 197                 "2.21x1",
 198                 NULL
 199         };
 200         static const char * const mpeg_video_bitrate_mode[] = {
 201                 "Variable Bitrate",
 202                 "Constant Bitrate",
 203                 NULL
 204         };
 205         static const char * const mpeg_stream_type[] = {
 206                 "MPEG-2 Program Stream",
 207                 "MPEG-2 Transport Stream",
 208                 "MPEG-1 System Stream",
 209                 "MPEG-2 DVD-compatible Stream",
 210                 "MPEG-1 VCD-compatible Stream",
 211                 "MPEG-2 SVCD-compatible Stream",
 212                 NULL
 213         };
 214         static const char * const mpeg_stream_vbi_fmt[] = {
 215                 "No VBI",
 216                 "Private Packet, IVTV Format",
 217                 NULL
 218         };
 219         static const char * const camera_power_line_frequency[] = {
 220                 "Disabled",
 221                 "50 Hz",
 222                 "60 Hz",
 223                 "Auto",
 224                 NULL
 225         };
 226         static const char * const camera_exposure_auto[] = {
 227                 "Auto Mode",
 228                 "Manual Mode",
 229                 "Shutter Priority Mode",
 230                 "Aperture Priority Mode",
 231                 NULL
 232         };
 233         static const char * const camera_exposure_metering[] = {
 234                 "Average",
 235                 "Center Weighted",
 236                 "Spot",
 237                 "Matrix",
 238                 NULL
 239         };
 240         static const char * const camera_auto_focus_range[] = {
 241                 "Auto",
 242                 "Normal",
 243                 "Macro",
 244                 "Infinity",
 245                 NULL
 246         };
 247         static const char * const colorfx[] = {
 248                 "None",
 249                 "Black & White",
 250                 "Sepia",
 251                 "Negative",
 252                 "Emboss",
 253                 "Sketch",
 254                 "Sky Blue",
 255                 "Grass Green",
 256                 "Skin Whiten",
 257                 "Vivid",
 258                 "Aqua",
 259                 "Art Freeze",
 260                 "Silhouette",
 261                 "Solarization",
 262                 "Antique",
 263                 "Set Cb/Cr",
 264                 NULL
 265         };
 266         static const char * const auto_n_preset_white_balance[] = {
 267                 "Manual",
 268                 "Auto",
 269                 "Incandescent",
 270                 "Fluorescent",
 271                 "Fluorescent H",
 272                 "Horizon",
 273                 "Daylight",
 274                 "Flash",
 275                 "Cloudy",
 276                 "Shade",
 277                 NULL,
 278         };
 279         static const char * const camera_iso_sensitivity_auto[] = {
 280                 "Manual",
 281                 "Auto",
 282                 NULL
 283         };
 284         static const char * const scene_mode[] = {
 285                 "None",
 286                 "Backlight",
 287                 "Beach/Snow",
 288                 "Candle Light",
 289                 "Dusk/Dawn",
 290                 "Fall Colors",
 291                 "Fireworks",
 292                 "Landscape",
 293                 "Night",
 294                 "Party/Indoor",
 295                 "Portrait",
 296                 "Sports",
 297                 "Sunset",
 298                 "Text",
 299                 NULL
 300         };
 301         static const char * const tune_emphasis[] = {
 302                 "None",
 303                 "50 Microseconds",
 304                 "75 Microseconds",
 305                 NULL,
 306         };
 307         static const char * const header_mode[] = {
 308                 "Separate Buffer",
 309                 "Joined With 1st Frame",
 310                 NULL,
 311         };
 312         static const char * const multi_slice[] = {
 313                 "Single",
 314                 "Max Macroblocks",
 315                 "Max Bytes",
 316                 NULL,
 317         };
 318         static const char * const entropy_mode[] = {
 319                 "CAVLC",
 320                 "CABAC",
 321                 NULL,
 322         };
 323         static const char * const mpeg_h264_level[] = {
 324                 "1",
 325                 "1b",
 326                 "1.1",
 327                 "1.2",
 328                 "1.3",
 329                 "2",
 330                 "2.1",
 331                 "2.2",
 332                 "3",
 333                 "3.1",
 334                 "3.2",
 335                 "4",
 336                 "4.1",
 337                 "4.2",
 338                 "5",
 339                 "5.1",
 340                 NULL,
 341         };
 342         static const char * const h264_loop_filter[] = {
 343                 "Enabled",
 344                 "Disabled",
 345                 "Disabled at Slice Boundary",
 346                 NULL,
 347         };
 348         static const char * const h264_profile[] = {
 349                 "Baseline",
 350                 "Constrained Baseline",
 351                 "Main",
 352                 "Extended",
 353                 "High",
 354                 "High 10",
 355                 "High 422",
 356                 "High 444 Predictive",
 357                 "High 10 Intra",
 358                 "High 422 Intra",
 359                 "High 444 Intra",
 360                 "CAVLC 444 Intra",
 361                 "Scalable Baseline",
 362                 "Scalable High",
 363                 "Scalable High Intra",
 364                 "Multiview High",
 365                 NULL,
 366         };
 367         static const char * const vui_sar_idc[] = {
 368                 "Unspecified",
 369                 "1:1",
 370                 "12:11",
 371                 "10:11",
 372                 "16:11",
 373                 "40:33",
 374                 "24:11",
 375                 "20:11",
 376                 "32:11",
 377                 "80:33",
 378                 "18:11",
 379                 "15:11",
 380                 "64:33",
 381                 "160:99",
 382                 "4:3",
 383                 "3:2",
 384                 "2:1",
 385                 "Extended SAR",
 386                 NULL,
 387         };
 388         static const char * const h264_fp_arrangement_type[] = {
 389                 "Checkerboard",
 390                 "Column",
 391                 "Row",
 392                 "Side by Side",
 393                 "Top Bottom",
 394                 "Temporal",
 395                 NULL,
 396         };
 397         static const char * const h264_fmo_map_type[] = {
 398                 "Interleaved Slices",
 399                 "Scattered Slices",
 400                 "Foreground with Leftover",
 401                 "Box Out",
 402                 "Raster Scan",
 403                 "Wipe Scan",
 404                 "Explicit",
 405                 NULL,
 406         };
 407         static const char * const mpeg_mpeg4_level[] = {
 408                 "0",
 409                 "0b",
 410                 "1",
 411                 "2",
 412                 "3",
 413                 "3b",
 414                 "4",
 415                 "5",
 416                 NULL,
 417         };
 418         static const char * const mpeg4_profile[] = {
 419                 "Simple",
 420                 "Advanced Simple",
 421                 "Core",
 422                 "Simple Scalable",
 423                 "Advanced Coding Efficiency",
 424                 NULL,
 425         };
 426
 427         static const char * const vpx_golden_frame_sel[] = {
 428                 "Use Previous Frame",
 429                 "Use Previous Specific Frame",
 430                 NULL,
 431         };
 432
 433         static const char * const flash_led_mode[] = {
 434                 "Off",
 435                 "Flash",
 436                 "Torch",
 437                 NULL,
 438         };
 439         static const char * const flash_strobe_source[] = {
 440                 "Software",
 441                 "External",
 442                 NULL,
 443         };
 444
 445         static const char * const jpeg_chroma_subsampling[] = {
 446                 "4:4:4",
 447                 "4:2:2",
 448                 "4:2:0",
 449                 "4:1:1",
 450                 "4:1:0",
 451                 "Gray",
 452                 NULL,
 453         };
 454         static const char * const dv_tx_mode[] = {
 455                 "DVI-D",
 456                 "HDMI",
 457                 NULL,
 458         };
 459         static const char * const dv_rgb_range[] = {
 460                 "Automatic",
 461                 "RGB limited range (16-235)",
 462                 "RGB full range (0-255)",
 463                 NULL,
 464         };
 465         static const char * const detect_md_mode[] = {
 466                 "Disabled",
 467                 "Global",
 468                 "Threshold Grid",
 469                 "Region Grid",
 470                 NULL,
 471         };
 472
 473
 474         switch (id) {
 475         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 476                 return mpeg_audio_sampling_freq;
 477         case V4L2_CID_MPEG_AUDIO_ENCODING:
 478                 return mpeg_audio_encoding;
 479         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 480                 return mpeg_audio_l1_bitrate;
 481         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 482                 return mpeg_audio_l2_bitrate;
 483         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 484                 return mpeg_audio_l3_bitrate;
 485         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 486                 return mpeg_audio_ac3_bitrate;
 487         case V4L2_CID_MPEG_AUDIO_MODE:
 488                 return mpeg_audio_mode;
 489         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 490                 return mpeg_audio_mode_extension;
 491         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 492                 return mpeg_audio_emphasis;
 493         case V4L2_CID_MPEG_AUDIO_CRC:
 494                 return mpeg_audio_crc;
 495         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
 496         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
 497                 return mpeg_audio_dec_playback;
 498         case V4L2_CID_MPEG_VIDEO_ENCODING:
 499                 return mpeg_video_encoding;
 500         case V4L2_CID_MPEG_VIDEO_ASPECT:
 501                 return mpeg_video_aspect;
 502         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 503                 return mpeg_video_bitrate_mode;
 504         case V4L2_CID_MPEG_STREAM_TYPE:
 505                 return mpeg_stream_type;
 506         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 507                 return mpeg_stream_vbi_fmt;
 508         case V4L2_CID_POWER_LINE_FREQUENCY:
 509                 return camera_power_line_frequency;
 510         case V4L2_CID_EXPOSURE_AUTO:
 511                 return camera_exposure_auto;
 512         case V4L2_CID_EXPOSURE_METERING:
 513                 return camera_exposure_metering;
 514         case V4L2_CID_AUTO_FOCUS_RANGE:
 515                 return camera_auto_focus_range;
 516         case V4L2_CID_COLORFX:
 517                 return colorfx;
 518         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
 519                 return auto_n_preset_white_balance;
 520         case V4L2_CID_ISO_SENSITIVITY_AUTO:
 521                 return camera_iso_sensitivity_auto;
 522         case V4L2_CID_SCENE_MODE:
 523                 return scene_mode;
 524         case V4L2_CID_TUNE_PREEMPHASIS:
 525                 return tune_emphasis;
 526         case V4L2_CID_TUNE_DEEMPHASIS:
 527                 return tune_emphasis;
 528         case V4L2_CID_FLASH_LED_MODE:
 529                 return flash_led_mode;
 530         case V4L2_CID_FLASH_STROBE_SOURCE:
 531                 return flash_strobe_source;
 532         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
 533                 return header_mode;
 534         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
 535                 return multi_slice;
 536         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
 537                 return entropy_mode;
 538         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
 539                 return mpeg_h264_level;
 540         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
 541                 return h264_loop_filter;
 542         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
 543                 return h264_profile;
 544         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
 545                 return vui_sar_idc;
 546         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
 547                 return h264_fp_arrangement_type;
 548         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
 549                 return h264_fmo_map_type;
 550         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
 551                 return mpeg_mpeg4_level;
 552         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
 553                 return mpeg4_profile;
 554         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
 555                 return vpx_golden_frame_sel;
 556         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
 557                 return jpeg_chroma_subsampling;
 558         case V4L2_CID_DV_TX_MODE:
 559                 return dv_tx_mode;
 560         case V4L2_CID_DV_TX_RGB_RANGE:
 561         case V4L2_CID_DV_RX_RGB_RANGE:
 562                 return dv_rgb_range;
 563         case V4L2_CID_DETECT_MD_MODE:
 564                 return detect_md_mode;
 565
 566         default:
 567                 return NULL;
 568         }
 569 }
 570 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
 571
 572 #define __v4l2_qmenu_int_len(arr, len) ({ *(len) = ARRAY_SIZE(arr); arr; })
 573 /*
 574  * Returns NULL or an s64 type array containing the menu for given
 575  * control ID. The total number of the menu items is returned in @len.
 576  */
 577 const s64 *v4l2_ctrl_get_int_menu(u32 id, u32 *len)
 578 {
 579         static const s64 qmenu_int_vpx_num_partitions[] = {
 580                 1, 2, 4, 8,
 581         };
 582
 583         static const s64 qmenu_int_vpx_num_ref_frames[] = {
 584                 1, 2, 3,
 585         };
 586
 587         switch (id) {
 588         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
 589                 return __v4l2_qmenu_int_len(qmenu_int_vpx_num_partitions, len);
 590         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
 591                 return __v4l2_qmenu_int_len(qmenu_int_vpx_num_ref_frames, len);
 592         default:
 593                 *len = 0;
 594                 return NULL;
 595         }
 596 }
 597 EXPORT_SYMBOL(v4l2_ctrl_get_int_menu);
 598
 599 /* Return the control name. */
 600 const char *v4l2_ctrl_get_name(u32 id)
 601 {
 602         switch (id) {
 603         /* USER controls */
 604         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 605         case V4L2_CID_USER_CLASS:               return "User Controls";
 606         case V4L2_CID_BRIGHTNESS:               return "Brightness";
 607         case V4L2_CID_CONTRAST:                 return "Contrast";
 608         case V4L2_CID_SATURATION:               return "Saturation";
 609         case V4L2_CID_HUE:                      return "Hue";
 610         case V4L2_CID_AUDIO_VOLUME:             return "Volume";
 611         case V4L2_CID_AUDIO_BALANCE:            return "Balance";
 612         case V4L2_CID_AUDIO_BASS:               return "Bass";
 613         case V4L2_CID_AUDIO_TREBLE:             return "Treble";
 614         case V4L2_CID_AUDIO_MUTE:               return "Mute";
 615         case V4L2_CID_AUDIO_LOUDNESS:           return "Loudness";
 616         case V4L2_CID_BLACK_LEVEL:              return "Black Level";
 617         case V4L2_CID_AUTO_WHITE_BALANCE:       return "White Balance, Automatic";
 618         case V4L2_CID_DO_WHITE_BALANCE:         return "Do White Balance";
 619         case V4L2_CID_RED_BALANCE:              return "Red Balance";
 620         case V4L2_CID_BLUE_BALANCE:             return "Blue Balance";
 621         case V4L2_CID_GAMMA:                    return "Gamma";
 622         case V4L2_CID_EXPOSURE:                 return "Exposure";
 623         case V4L2_CID_AUTOGAIN:                 return "Gain, Automatic";
 624         case V4L2_CID_GAIN:                     return "Gain";
 625         case V4L2_CID_HFLIP:                    return "Horizontal Flip";
 626         case V4L2_CID_VFLIP:                    return "Vertical Flip";
 627         case V4L2_CID_POWER_LINE_FREQUENCY:     return "Power Line Frequency";
 628         case V4L2_CID_HUE_AUTO:                 return "Hue, Automatic";
 629         case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
 630         case V4L2_CID_SHARPNESS:                return "Sharpness";
 631         case V4L2_CID_BACKLIGHT_COMPENSATION:   return "Backlight Compensation";
 632         case V4L2_CID_CHROMA_AGC:               return "Chroma AGC";
 633         case V4L2_CID_COLOR_KILLER:             return "Color Killer";
 634         case V4L2_CID_COLORFX:                  return "Color Effects";
 635         case V4L2_CID_AUTOBRIGHTNESS:           return "Brightness, Automatic";
 636         case V4L2_CID_BAND_STOP_FILTER:         return "Band-Stop Filter";
 637         case V4L2_CID_ROTATE:                   return "Rotate";
 638         case V4L2_CID_BG_COLOR:                 return "Background Color";
 639         case V4L2_CID_CHROMA_GAIN:              return "Chroma Gain";
 640         case V4L2_CID_ILLUMINATORS_1:           return "Illuminator 1";
 641         case V4L2_CID_ILLUMINATORS_2:           return "Illuminator 2";
 642         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:  return "Min Number of Capture Buffers";
 643         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:   return "Min Number of Output Buffers";
 644         case V4L2_CID_ALPHA_COMPONENT:          return "Alpha Component";
 645         case V4L2_CID_COLORFX_CBCR:             return "Color Effects, CbCr";
 646
 647         /* Codec controls */
 648         /* The MPEG controls are applicable to all codec controls
 649          * and the 'MPEG' part of the define is historical */
 650         /* Keep the order of the 'case's the same as in videodev2.h! */
 651         case V4L2_CID_MPEG_CLASS:               return "Codec Controls";
 652         case V4L2_CID_MPEG_STREAM_TYPE:         return "Stream Type";
 653         case V4L2_CID_MPEG_STREAM_PID_PMT:      return "Stream PMT Program ID";
 654         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    return "Stream Audio Program ID";
 655         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    return "Stream Video Program ID";
 656         case V4L2_CID_MPEG_STREAM_PID_PCR:      return "Stream PCR Program ID";
 657         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
 658         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
 659         case V4L2_CID_MPEG_STREAM_VBI_FMT:      return "Stream VBI Format";
 660         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
 661         case V4L2_CID_MPEG_AUDIO_ENCODING:      return "Audio Encoding";
 662         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    return "Audio Layer I Bitrate";
 663         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    return "Audio Layer II Bitrate";
 664         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    return "Audio Layer III Bitrate";
 665         case V4L2_CID_MPEG_AUDIO_MODE:          return "Audio Stereo Mode";
 666         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
 667         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      return "Audio Emphasis";
 668         case V4L2_CID_MPEG_AUDIO_CRC:           return "Audio CRC";
 669         case V4L2_CID_MPEG_AUDIO_MUTE:          return "Audio Mute";
 670         case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:   return "Audio AAC Bitrate";
 671         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:   return "Audio AC-3 Bitrate";
 672         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:  return "Audio Playback";
 673         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
 674         case V4L2_CID_MPEG_VIDEO_ENCODING:      return "Video Encoding";
 675         case V4L2_CID_MPEG_VIDEO_ASPECT:        return "Video Aspect";
 676         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      return "Video B Frames";
 677         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      return "Video GOP Size";
 678         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   return "Video GOP Closure";
 679         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      return "Video Pulldown";
 680         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  return "Video Bitrate Mode";
 681         case V4L2_CID_MPEG_VIDEO_BITRATE:       return "Video Bitrate";
 682         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  return "Video Peak Bitrate";
 683         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
 684         case V4L2_CID_MPEG_VIDEO_MUTE:          return "Video Mute";
 685         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:      return "Video Mute YUV";
 686         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:       return "Decoder Slice Interface";
 687         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:  return "MPEG4 Loop Filter Enable";
 688         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:       return "Number of Intra Refresh MBs";
 689         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:               return "Frame Level Rate Control Enable";
 690         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:                  return "H264 MB Level Rate Control";
 691         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:                   return "Sequence Header Mode";
 692         case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC:                   return "Max Number of Reference Pics";
 693         case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:               return "H263 I-Frame QP Value";
 694         case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:               return "H263 P-Frame QP Value";
 695         case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:               return "H263 B-Frame QP Value";
 696         case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:                   return "H263 Minimum QP Value";
 697         case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:                   return "H263 Maximum QP Value";
 698         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:               return "H264 I-Frame QP Value";
 699         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:               return "H264 P-Frame QP Value";
 700         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:               return "H264 B-Frame QP Value";
 701         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:                   return "H264 Maximum QP Value";
 702         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:                   return "H264 Minimum QP Value";
 703         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:            return "H264 8x8 Transform Enable";
 704         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:                 return "H264 CPB Buffer Size";
 705         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:             return "H264 Entropy Mode";
 706         case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:                 return "H264 I-Frame Period";
 707         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:                    return "H264 Level";
 708         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:        return "H264 Loop Filter Alpha Offset";
 709         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:         return "H264 Loop Filter Beta Offset";
 710         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:         return "H264 Loop Filter Mode";
 711         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:                  return "H264 Profile";
 712         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:       return "Vertical Size of SAR";
 713         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:        return "Horizontal Size of SAR";
 714         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:           return "Aspect Ratio VUI Enable";
 715         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:              return "VUI Aspect Ratio IDC";
 716         case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING:        return "H264 Enable Frame Packing SEI";
 717         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0:   return "H264 Set Curr. Frame as Frame0";
 718         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:  return "H264 FP Arrangement Type";
 719         case V4L2_CID_MPEG_VIDEO_H264_FMO:                      return "H264 Flexible MB Ordering";
 720         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:             return "H264 Map Type for FMO";
 721         case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP:          return "H264 FMO Number of Slice Groups";
 722         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION:     return "H264 FMO Direction of Change";
 723         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE:          return "H264 FMO Size of 1st Slice Grp";
 724         case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH:           return "H264 FMO No. of Consecutive MBs";
 725         case V4L2_CID_MPEG_VIDEO_H264_ASO:                      return "H264 Arbitrary Slice Ordering";
 726         case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER:          return "H264 ASO Slice Order";
 727         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING:      return "Enable H264 Hierarchical Coding";
 728         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type";
 729         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
 730         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
 731                                                                 return "H264 Set QP Value for HC Layers";
 732         case V4L2_CID_MPEG_VIDEO_H264_SPS:                      return "H264 SPS";
 733         case V4L2_CID_MPEG_VIDEO_H264_PPS:                      return "H264 PPS";
 734         case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX:           return "H264 Scaling Matrix";
 735         case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAM:              return "H264 Slice Parameters";
 736         case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAM:             return "H264 Decode Parameters";
 737         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:              return "MPEG4 I-Frame QP Value";
 738         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:              return "MPEG4 P-Frame QP Value";
 739         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:              return "MPEG4 B-Frame QP Value";
 740         case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:                  return "MPEG4 Minimum QP Value";
 741         case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:                  return "MPEG4 Maximum QP Value";
 742         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:                   return "MPEG4 Level";
 743         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:                 return "MPEG4 Profile";
 744         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:                    return "Quarter Pixel Search Enable";
 745         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:         return "Maximum Bytes in a Slice";
 746         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:            return "Number of MBs in a Slice";
 747         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:              return "Slice Partitioning Method";
 748         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:                      return "VBV Buffer Size";
 749         case V4L2_CID_MPEG_VIDEO_DEC_PTS:                       return "Video Decoder PTS";
 750         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:                     return "Video Decoder Frame Count";
 751         case V4L2_CID_MPEG_VIDEO_VBV_DELAY:                     return "Initial Delay for VBV Control";
 752         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:             return "Horizontal MV Search Range";
 753         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:             return "Vertical MV Search Range";
 754         case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:             return "Repeat Sequence Header";
 755         case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:               return "Force Key Frame";
 756
 757         /* VPX controls */
 758         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:            return "VPX Number of Partitions";
 759         case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4:           return "VPX Intra Mode Decision Disable";
 760         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:            return "VPX No. of Refs for P Frame";
 761         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL:              return "VPX Loop Filter Level Range";
 762         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS:          return "VPX Deblocking Effect Control";
 763         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD:   return "VPX Golden Frame Refresh Period";
 764         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:          return "VPX Golden Frame Indicator";
 765         case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:                    return "VPX Minimum QP Value";
 766         case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:                    return "VPX Maximum QP Value";
 767         case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP:                return "VPX I-Frame QP Value";
 768         case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP:                return "VPX P-Frame QP Value";
 769         case V4L2_CID_MPEG_VIDEO_VPX_PROFILE:                   return "VPX Profile";
 770
 771         case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HDR:                 return "VP8 Frame Header";
 772
 773         /* CAMERA controls */
 774         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 775         case V4L2_CID_CAMERA_CLASS:             return "Camera Controls";
 776         case V4L2_CID_EXPOSURE_AUTO:            return "Auto Exposure";
 777         case V4L2_CID_EXPOSURE_ABSOLUTE:        return "Exposure Time, Absolute";
 778         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:   return "Exposure, Dynamic Framerate";
 779         case V4L2_CID_PAN_RELATIVE:             return "Pan, Relative";
 780         case V4L2_CID_TILT_RELATIVE:            return "Tilt, Relative";
 781         case V4L2_CID_PAN_RESET:                return "Pan, Reset";
 782         case V4L2_CID_TILT_RESET:               return "Tilt, Reset";
 783         case V4L2_CID_PAN_ABSOLUTE:             return "Pan, Absolute";
 784         case V4L2_CID_TILT_ABSOLUTE:            return "Tilt, Absolute";
 785         case V4L2_CID_FOCUS_ABSOLUTE:           return "Focus, Absolute";
 786         case V4L2_CID_FOCUS_RELATIVE:           return "Focus, Relative";
 787         case V4L2_CID_FOCUS_AUTO:               return "Focus, Automatic Continuous";
 788         case V4L2_CID_ZOOM_ABSOLUTE:            return "Zoom, Absolute";
 789         case V4L2_CID_ZOOM_RELATIVE:            return "Zoom, Relative";
 790         case V4L2_CID_ZOOM_CONTINUOUS:          return "Zoom, Continuous";
 791         case V4L2_CID_PRIVACY:                  return "Privacy";
 792         case V4L2_CID_IRIS_ABSOLUTE:            return "Iris, Absolute";
 793         case V4L2_CID_IRIS_RELATIVE:            return "Iris, Relative";
 794         case V4L2_CID_AUTO_EXPOSURE_BIAS:       return "Auto Exposure, Bias";
 795         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
 796         case V4L2_CID_WIDE_DYNAMIC_RANGE:       return "Wide Dynamic Range";
 797         case V4L2_CID_IMAGE_STABILIZATION:      return "Image Stabilization";
 798         case V4L2_CID_ISO_SENSITIVITY:          return "ISO Sensitivity";
 799         case V4L2_CID_ISO_SENSITIVITY_AUTO:     return "ISO Sensitivity, Auto";
 800         case V4L2_CID_EXPOSURE_METERING:        return "Exposure, Metering Mode";
 801         case V4L2_CID_SCENE_MODE:               return "Scene Mode";
 802         case V4L2_CID_3A_LOCK:                  return "3A Lock";
 803         case V4L2_CID_AUTO_FOCUS_START:         return "Auto Focus, Start";
 804         case V4L2_CID_AUTO_FOCUS_STOP:          return "Auto Focus, Stop";
 805         case V4L2_CID_AUTO_FOCUS_STATUS:        return "Auto Focus, Status";
 806         case V4L2_CID_AUTO_FOCUS_RANGE:         return "Auto Focus, Range";
 807         case V4L2_CID_PAN_SPEED:                return "Pan, Speed";
 808         case V4L2_CID_TILT_SPEED:               return "Tilt, Speed";
 809
 810         /* FM Radio Modulator controls */
 811         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 812         case V4L2_CID_FM_TX_CLASS:              return "FM Radio Modulator Controls";
 813         case V4L2_CID_RDS_TX_DEVIATION:         return "RDS Signal Deviation";
 814         case V4L2_CID_RDS_TX_PI:                return "RDS Program ID";
 815         case V4L2_CID_RDS_TX_PTY:               return "RDS Program Type";
 816         case V4L2_CID_RDS_TX_PS_NAME:           return "RDS PS Name";
 817         case V4L2_CID_RDS_TX_RADIO_TEXT:        return "RDS Radio Text";
 818         case V4L2_CID_RDS_TX_MONO_STEREO:       return "RDS Stereo";
 819         case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:   return "RDS Artificial Head";
 820         case V4L2_CID_RDS_TX_COMPRESSED:        return "RDS Compressed";
 821         case V4L2_CID_RDS_TX_DYNAMIC_PTY:       return "RDS Dynamic PTY";
 822         case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
 823         case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:   return "RDS Traffic Program";
 824         case V4L2_CID_RDS_TX_MUSIC_SPEECH:      return "RDS Music";
 825         case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:  return "RDS Enable Alt Frequencies";
 826         case V4L2_CID_RDS_TX_ALT_FREQS:         return "RDS Alternate Frequencies";
 827         case V4L2_CID_AUDIO_LIMITER_ENABLED:    return "Audio Limiter Feature Enabled";
 828         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
 829         case V4L2_CID_AUDIO_LIMITER_DEVIATION:  return "Audio Limiter Deviation";
 830         case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
 831         case V4L2_CID_AUDIO_COMPRESSION_GAIN:   return "Audio Compression Gain";
 832         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
 833         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
 834         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
 835         case V4L2_CID_PILOT_TONE_ENABLED:       return "Pilot Tone Feature Enabled";
 836         case V4L2_CID_PILOT_TONE_DEVIATION:     return "Pilot Tone Deviation";
 837         case V4L2_CID_PILOT_TONE_FREQUENCY:     return "Pilot Tone Frequency";
 838         case V4L2_CID_TUNE_PREEMPHASIS:         return "Pre-Emphasis";
 839         case V4L2_CID_TUNE_POWER_LEVEL:         return "Tune Power Level";
 840         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:   return "Tune Antenna Capacitor";
 841
 842         /* Flash controls */
 843         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 844         case V4L2_CID_FLASH_CLASS:              return "Flash Controls";
 845         case V4L2_CID_FLASH_LED_MODE:           return "LED Mode";
 846         case V4L2_CID_FLASH_STROBE_SOURCE:      return "Strobe Source";
 847         case V4L2_CID_FLASH_STROBE:             return "Strobe";
 848         case V4L2_CID_FLASH_STROBE_STOP:        return "Stop Strobe";
 849         case V4L2_CID_FLASH_STROBE_STATUS:      return "Strobe Status";
 850         case V4L2_CID_FLASH_TIMEOUT:            return "Strobe Timeout";
 851         case V4L2_CID_FLASH_INTENSITY:          return "Intensity, Flash Mode";
 852         case V4L2_CID_FLASH_TORCH_INTENSITY:    return "Intensity, Torch Mode";
 853         case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
 854         case V4L2_CID_FLASH_FAULT:              return "Faults";
 855         case V4L2_CID_FLASH_CHARGE:             return "Charge";
 856         case V4L2_CID_FLASH_READY:              return "Ready to Strobe";
 857
 858         /* JPEG encoder controls */
 859         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 860         case V4L2_CID_JPEG_CLASS:               return "JPEG Compression Controls";
 861         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:  return "Chroma Subsampling";
 862         case V4L2_CID_JPEG_RESTART_INTERVAL:    return "Restart Interval";
 863         case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
 864         case V4L2_CID_JPEG_ACTIVE_MARKER:       return "Active Markers";
 865
 866         /* Image source controls */
 867         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 868         case V4L2_CID_IMAGE_SOURCE_CLASS:       return "Image Source Controls";
 869         case V4L2_CID_VBLANK:                   return "Vertical Blanking";
 870         case V4L2_CID_HBLANK:                   return "Horizontal Blanking";
 871         case V4L2_CID_ANALOGUE_GAIN:            return "Analogue Gain";
 872         case V4L2_CID_TEST_PATTERN_RED:         return "Red Pixel Value";
 873         case V4L2_CID_TEST_PATTERN_GREENR:      return "Green (Red) Pixel Value";
 874         case V4L2_CID_TEST_PATTERN_BLUE:        return "Blue Pixel Value";
 875         case V4L2_CID_TEST_PATTERN_GREENB:      return "Green (Blue) Pixel Value";
 876
 877         /* Image processing controls */
 878         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 879         case V4L2_CID_IMAGE_PROC_CLASS:         return "Image Processing Controls";
 880         case V4L2_CID_LINK_FREQ:                return "Link Frequency";
 881         case V4L2_CID_PIXEL_RATE:               return "Pixel Rate";
 882         case V4L2_CID_TEST_PATTERN:             return "Test Pattern";
 883
 884         /* DV controls */
 885         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 886         case V4L2_CID_DV_CLASS:                 return "Digital Video Controls";
 887         case V4L2_CID_DV_TX_HOTPLUG:            return "Hotplug Present";
 888         case V4L2_CID_DV_TX_RXSENSE:            return "RxSense Present";
 889         case V4L2_CID_DV_TX_EDID_PRESENT:       return "EDID Present";
 890         case V4L2_CID_DV_TX_MODE:               return "Transmit Mode";
 891         case V4L2_CID_DV_TX_RGB_RANGE:          return "Tx RGB Quantization Range";
 892         case V4L2_CID_DV_RX_POWER_PRESENT:      return "Power Present";
 893         case V4L2_CID_DV_RX_RGB_RANGE:          return "Rx RGB Quantization Range";
 894
 895         case V4L2_CID_FM_RX_CLASS:              return "FM Radio Receiver Controls";
 896         case V4L2_CID_TUNE_DEEMPHASIS:          return "De-Emphasis";
 897         case V4L2_CID_RDS_RECEPTION:            return "RDS Reception";
 898         case V4L2_CID_RF_TUNER_CLASS:           return "RF Tuner Controls";
 899         case V4L2_CID_RF_TUNER_RF_GAIN:         return "RF Gain";
 900         case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:   return "LNA Gain, Auto";
 901         case V4L2_CID_RF_TUNER_LNA_GAIN:        return "LNA Gain";
 902         case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO: return "Mixer Gain, Auto";
 903         case V4L2_CID_RF_TUNER_MIXER_GAIN:      return "Mixer Gain";
 904         case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:    return "IF Gain, Auto";
 905         case V4L2_CID_RF_TUNER_IF_GAIN:         return "IF Gain";
 906         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:  return "Bandwidth, Auto";
 907         case V4L2_CID_RF_TUNER_BANDWIDTH:       return "Bandwidth";
 908         case V4L2_CID_RF_TUNER_PLL_LOCK:        return "PLL Lock";
 909         case V4L2_CID_RDS_RX_PTY:               return "RDS Program Type";
 910         case V4L2_CID_RDS_RX_PS_NAME:           return "RDS PS Name";
 911         case V4L2_CID_RDS_RX_RADIO_TEXT:        return "RDS Radio Text";
 912         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
 913         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:   return "RDS Traffic Program";
 914         case V4L2_CID_RDS_RX_MUSIC_SPEECH:      return "RDS Music";
 915
 916         /* Detection controls */
 917         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 918         case V4L2_CID_DETECT_CLASS:             return "Detection Controls";
 919         case V4L2_CID_DETECT_MD_MODE:           return "Motion Detection Mode";
 920         case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: return "MD Global Threshold";
 921         case V4L2_CID_DETECT_MD_THRESHOLD_GRID: return "MD Threshold Grid";
 922         case V4L2_CID_DETECT_MD_REGION_GRID:    return "MD Region Grid";
 923         default:
 924                 return NULL;
 925         }
 926 }
 927 EXPORT_SYMBOL(v4l2_ctrl_get_name);
 928
 929 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
 930                     s64 *min, s64 *max, u64 *step, s64 *def, u32 *flags)
 931 {
 932         *name = v4l2_ctrl_get_name(id);
 933         *flags = 0;
 934
 935         switch (id) {
 936         case V4L2_CID_AUDIO_MUTE:
 937         case V4L2_CID_AUDIO_LOUDNESS:
 938         case V4L2_CID_AUTO_WHITE_BALANCE:
 939         case V4L2_CID_AUTOGAIN:
 940         case V4L2_CID_HFLIP:
 941         case V4L2_CID_VFLIP:
 942         case V4L2_CID_HUE_AUTO:
 943         case V4L2_CID_CHROMA_AGC:
 944         case V4L2_CID_COLOR_KILLER:
 945         case V4L2_CID_AUTOBRIGHTNESS:
 946         case V4L2_CID_MPEG_AUDIO_MUTE:
 947         case V4L2_CID_MPEG_VIDEO_MUTE:
 948         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 949         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 950         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
 951         case V4L2_CID_FOCUS_AUTO:
 952         case V4L2_CID_PRIVACY:
 953         case V4L2_CID_AUDIO_LIMITER_ENABLED:
 954         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
 955         case V4L2_CID_PILOT_TONE_ENABLED:
 956         case V4L2_CID_ILLUMINATORS_1:
 957         case V4L2_CID_ILLUMINATORS_2:
 958         case V4L2_CID_FLASH_STROBE_STATUS:
 959         case V4L2_CID_FLASH_CHARGE:
 960         case V4L2_CID_FLASH_READY:
 961         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
 962         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
 963         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
 964         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
 965         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
 966         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
 967         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
 968         case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
 969         case V4L2_CID_WIDE_DYNAMIC_RANGE:
 970         case V4L2_CID_IMAGE_STABILIZATION:
 971         case V4L2_CID_RDS_RECEPTION:
 972         case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
 973         case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
 974         case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:
 975         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
 976         case V4L2_CID_RF_TUNER_PLL_LOCK:
 977         case V4L2_CID_RDS_TX_MONO_STEREO:
 978         case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
 979         case V4L2_CID_RDS_TX_COMPRESSED:
 980         case V4L2_CID_RDS_TX_DYNAMIC_PTY:
 981         case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
 982         case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
 983         case V4L2_CID_RDS_TX_MUSIC_SPEECH:
 984         case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
 985         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
 986         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
 987         case V4L2_CID_RDS_RX_MUSIC_SPEECH:
 988                 *type = V4L2_CTRL_TYPE_BOOLEAN;
 989                 *min = 0;
 990                 *max = *step = 1;
 991                 break;
 992         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
 993         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
 994                 *type = V4L2_CTRL_TYPE_INTEGER;
 995                 break;
 996         case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
 997         case V4L2_CID_PAN_RESET:
 998         case V4L2_CID_TILT_RESET:
 999         case V4L2_CID_FLASH_STROBE:
1000         case V4L2_CID_FLASH_STROBE_STOP:
1001         case V4L2_CID_AUTO_FOCUS_START:
1002         case V4L2_CID_AUTO_FOCUS_STOP:
1003                 *type = V4L2_CTRL_TYPE_BUTTON;
1004                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1005                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1006                 *min = *max = *step = *def = 0;
1007                 break;
1008         case V4L2_CID_POWER_LINE_FREQUENCY:
1009         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1010         case V4L2_CID_MPEG_AUDIO_ENCODING:
1011         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1012         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1013         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1014         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
1015         case V4L2_CID_MPEG_AUDIO_MODE:
1016         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1017         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1018         case V4L2_CID_MPEG_AUDIO_CRC:
1019         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
1020         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
1021         case V4L2_CID_MPEG_VIDEO_ENCODING:
1022         case V4L2_CID_MPEG_VIDEO_ASPECT:
1023         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1024         case V4L2_CID_MPEG_STREAM_TYPE:
1025         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1026         case V4L2_CID_EXPOSURE_AUTO:
1027         case V4L2_CID_AUTO_FOCUS_RANGE:
1028         case V4L2_CID_COLORFX:
1029         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1030         case V4L2_CID_TUNE_PREEMPHASIS:
1031         case V4L2_CID_FLASH_LED_MODE:
1032         case V4L2_CID_FLASH_STROBE_SOURCE:
1033         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1034         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1035         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1036         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1037         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1038         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1039         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1040         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1041         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1042         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1043         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1044         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1045         case V4L2_CID_ISO_SENSITIVITY_AUTO:
1046         case V4L2_CID_EXPOSURE_METERING:
1047         case V4L2_CID_SCENE_MODE:
1048         case V4L2_CID_DV_TX_MODE:
1049         case V4L2_CID_DV_TX_RGB_RANGE:
1050         case V4L2_CID_DV_RX_RGB_RANGE:
1051         case V4L2_CID_TEST_PATTERN:
1052         case V4L2_CID_TUNE_DEEMPHASIS:
1053         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1054         case V4L2_CID_DETECT_MD_MODE:
1055                 *type = V4L2_CTRL_TYPE_MENU;
1056                 break;
1057         case V4L2_CID_LINK_FREQ:
1058                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1059                 break;
1060         case V4L2_CID_RDS_TX_PS_NAME:
1061         case V4L2_CID_RDS_TX_RADIO_TEXT:
1062         case V4L2_CID_RDS_RX_PS_NAME:
1063         case V4L2_CID_RDS_RX_RADIO_TEXT:
1064                 *type = V4L2_CTRL_TYPE_STRING;
1065                 break;
1066         case V4L2_CID_ISO_SENSITIVITY:
1067         case V4L2_CID_AUTO_EXPOSURE_BIAS:
1068         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1069         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1070                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1071                 break;
1072         case V4L2_CID_USER_CLASS:
1073         case V4L2_CID_CAMERA_CLASS:
1074         case V4L2_CID_MPEG_CLASS:
1075         case V4L2_CID_FM_TX_CLASS:
1076         case V4L2_CID_FLASH_CLASS:
1077         case V4L2_CID_JPEG_CLASS:
1078         case V4L2_CID_IMAGE_SOURCE_CLASS:
1079         case V4L2_CID_IMAGE_PROC_CLASS:
1080         case V4L2_CID_DV_CLASS:
1081         case V4L2_CID_FM_RX_CLASS:
1082         case V4L2_CID_RF_TUNER_CLASS:
1083         case V4L2_CID_DETECT_CLASS:
1084                 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
1085                 /* You can neither read not write these */
1086                 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1087                 *min = *max = *step = *def = 0;
1088                 break;
1089         case V4L2_CID_BG_COLOR:
1090                 *type = V4L2_CTRL_TYPE_INTEGER;
1091                 *step = 1;
1092                 *min = 0;
1093                 /* Max is calculated as RGB888 that is 2^24 */
1094                 *max = 0xFFFFFF;
1095                 break;
1096         case V4L2_CID_FLASH_FAULT:
1097         case V4L2_CID_JPEG_ACTIVE_MARKER:
1098         case V4L2_CID_3A_LOCK:
1099         case V4L2_CID_AUTO_FOCUS_STATUS:
1100         case V4L2_CID_DV_TX_HOTPLUG:
1101         case V4L2_CID_DV_TX_RXSENSE:
1102         case V4L2_CID_DV_TX_EDID_PRESENT:
1103         case V4L2_CID_DV_RX_POWER_PRESENT:
1104                 *type = V4L2_CTRL_TYPE_BITMASK;
1105                 break;
1106         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1107         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1108                 *type = V4L2_CTRL_TYPE_INTEGER;
1109                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1110                 break;
1111         case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1112                 *type = V4L2_CTRL_TYPE_INTEGER64;
1113                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1114                 *min = *def = 0;
1115                 *max = 0x1ffffffffLL;
1116                 *step = 1;
1117                 break;
1118         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1119                 *type = V4L2_CTRL_TYPE_INTEGER64;
1120                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1121                 *min = *def = 0;
1122                 *max = 0x7fffffffffffffffLL;
1123                 *step = 1;
1124                 break;
1125         case V4L2_CID_PIXEL_RATE:
1126                 *type = V4L2_CTRL_TYPE_INTEGER64;
1127                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1128                 break;
1129         case V4L2_CID_DETECT_MD_REGION_GRID:
1130                 *type = V4L2_CTRL_TYPE_U8;
1131                 break;
1132         case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
1133                 *type = V4L2_CTRL_TYPE_U16;
1134                 break;
1135         case V4L2_CID_RDS_TX_ALT_FREQS:
1136                 *type = V4L2_CTRL_TYPE_U32;
1137                 break;
1138         case V4L2_CID_MPEG_VIDEO_H264_SPS:
1139                 *type = V4L2_CTRL_TYPE_H264_SPS;
1140                 break;
1141         case V4L2_CID_MPEG_VIDEO_H264_PPS:
1142                 *type = V4L2_CTRL_TYPE_H264_PPS;
1143                 break;
1144         case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX:
1145                 *type = V4L2_CTRL_TYPE_H264_SCALING_MATRIX;
1146                 break;
1147         case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAM:
1148                 *type = V4L2_CTRL_TYPE_H264_SLICE_PARAM;
1149                 break;
1150         case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAM:
1151                 *type = V4L2_CTRL_TYPE_H264_DECODE_PARAM;
1152                 break;
1153         case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HDR:
1154                 *type = V4L2_CTRL_TYPE_VP8_FRAME_HDR;
1155                 break;
1156         default:
1157                 *type = V4L2_CTRL_TYPE_INTEGER;
1158                 break;
1159         }
1160         switch (id) {
1161         case V4L2_CID_MPEG_AUDIO_ENCODING:
1162         case V4L2_CID_MPEG_AUDIO_MODE:
1163         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1164         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1165         case V4L2_CID_MPEG_STREAM_TYPE:
1166                 *flags |= V4L2_CTRL_FLAG_UPDATE;
1167                 break;
1168         case V4L2_CID_AUDIO_VOLUME:
1169         case V4L2_CID_AUDIO_BALANCE:
1170         case V4L2_CID_AUDIO_BASS:
1171         case V4L2_CID_AUDIO_TREBLE:
1172         case V4L2_CID_BRIGHTNESS:
1173         case V4L2_CID_CONTRAST:
1174         case V4L2_CID_SATURATION:
1175         case V4L2_CID_HUE:
1176         case V4L2_CID_RED_BALANCE:
1177         case V4L2_CID_BLUE_BALANCE:
1178         case V4L2_CID_GAMMA:
1179         case V4L2_CID_SHARPNESS:
1180         case V4L2_CID_CHROMA_GAIN:
1181         case V4L2_CID_RDS_TX_DEVIATION:
1182         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1183         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1184         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1185         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1186         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1187         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1188         case V4L2_CID_PILOT_TONE_DEVIATION:
1189         case V4L2_CID_PILOT_TONE_FREQUENCY:
1190         case V4L2_CID_TUNE_POWER_LEVEL:
1191         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1192         case V4L2_CID_RF_TUNER_RF_GAIN:
1193         case V4L2_CID_RF_TUNER_LNA_GAIN:
1194         case V4L2_CID_RF_TUNER_MIXER_GAIN:
1195         case V4L2_CID_RF_TUNER_IF_GAIN:
1196         case V4L2_CID_RF_TUNER_BANDWIDTH:
1197         case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
1198                 *flags |= V4L2_CTRL_FLAG_SLIDER;
1199                 break;
1200         case V4L2_CID_PAN_RELATIVE:
1201         case V4L2_CID_TILT_RELATIVE:
1202         case V4L2_CID_FOCUS_RELATIVE:
1203         case V4L2_CID_IRIS_RELATIVE:
1204         case V4L2_CID_ZOOM_RELATIVE:
1205                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1206                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1207                 break;
1208         case V4L2_CID_FLASH_STROBE_STATUS:
1209         case V4L2_CID_AUTO_FOCUS_STATUS:
1210         case V4L2_CID_FLASH_READY:
1211         case V4L2_CID_DV_TX_HOTPLUG:
1212         case V4L2_CID_DV_TX_RXSENSE:
1213         case V4L2_CID_DV_TX_EDID_PRESENT:
1214         case V4L2_CID_DV_RX_POWER_PRESENT:
1215         case V4L2_CID_RDS_RX_PTY:
1216         case V4L2_CID_RDS_RX_PS_NAME:
1217         case V4L2_CID_RDS_RX_RADIO_TEXT:
1218         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1219         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1220         case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1221                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1222                 break;
1223         case V4L2_CID_RF_TUNER_PLL_LOCK:
1224                 *flags |= V4L2_CTRL_FLAG_VOLATILE;
1225                 break;
1226         }
1227 }
1228 EXPORT_SYMBOL(v4l2_ctrl_fill);
1229
1230 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1231 {
1232         memset(ev->reserved, 0, sizeof(ev->reserved));
1233         ev->type = V4L2_EVENT_CTRL;
1234         ev->id = ctrl->id;
1235         ev->u.ctrl.changes = changes;
1236         ev->u.ctrl.type = ctrl->type;
1237         ev->u.ctrl.flags = ctrl->flags;
1238         if (ctrl->is_ptr)
1239                 ev->u.ctrl.value64 = 0;
1240         else
1241                 ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
1242         ev->u.ctrl.minimum = ctrl->minimum;
1243         ev->u.ctrl.maximum = ctrl->maximum;
1244         if (ctrl->type == V4L2_CTRL_TYPE_MENU
1245             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1246                 ev->u.ctrl.step = 1;
1247         else
1248                 ev->u.ctrl.step = ctrl->step;
1249         ev->u.ctrl.default_value = ctrl->default_value;
1250 }
1251
1252 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1253 {
1254         struct v4l2_event ev;
1255         struct v4l2_subscribed_event *sev;
1256
1257         if (list_empty(&ctrl->ev_subs))
1258                 return;
1259         fill_event(&ev, ctrl, changes);
1260
1261         list_for_each_entry(sev, &ctrl->ev_subs, node)
1262                 if (sev->fh != fh ||
1263                     (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1264                         v4l2_event_queue_fh(sev->fh, &ev);
1265 }
1266
1267 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
1268                       union v4l2_ctrl_ptr ptr1,
1269                       union v4l2_ctrl_ptr ptr2)
1270 {
1271         switch (ctrl->type) {
1272         case V4L2_CTRL_TYPE_BUTTON:
1273                 return false;
1274         case V4L2_CTRL_TYPE_STRING:
1275                 idx *= ctrl->elem_size;
1276                 /* strings are always 0-terminated */
1277                 return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
1278         case V4L2_CTRL_TYPE_INTEGER64:
1279                 return ptr1.p_s64[idx] == ptr2.p_s64[idx];
1280         case V4L2_CTRL_TYPE_U8:
1281                 return ptr1.p_u8[idx] == ptr2.p_u8[idx];
1282         case V4L2_CTRL_TYPE_U16:
1283                 return ptr1.p_u16[idx] == ptr2.p_u16[idx];
1284         case V4L2_CTRL_TYPE_U32:
1285                 return ptr1.p_u32[idx] == ptr2.p_u32[idx];
1286         default:
1287                 if (ctrl->is_int)
1288                         return ptr1.p_s32[idx] == ptr2.p_s32[idx];
1289                 idx *= ctrl->elem_size;
1290                 return !memcmp(ptr1.p + idx, ptr2.p + idx, ctrl->elem_size);
1291         }
1292 }
1293
1294 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
1295                      union v4l2_ctrl_ptr ptr)
1296 {
1297         switch (ctrl->type) {
1298         case V4L2_CTRL_TYPE_STRING:
1299                 idx *= ctrl->elem_size;
1300                 memset(ptr.p_char + idx, ' ', ctrl->minimum);
1301                 ptr.p_char[idx + ctrl->minimum] = '\0';
1302                 break;
1303         case V4L2_CTRL_TYPE_INTEGER64:
1304                 ptr.p_s64[idx] = ctrl->default_value;
1305                 break;
1306         case V4L2_CTRL_TYPE_INTEGER:
1307         case V4L2_CTRL_TYPE_INTEGER_MENU:
1308         case V4L2_CTRL_TYPE_MENU:
1309         case V4L2_CTRL_TYPE_BITMASK:
1310         case V4L2_CTRL_TYPE_BOOLEAN:
1311                 ptr.p_s32[idx] = ctrl->default_value;
1312                 break;
1313         case V4L2_CTRL_TYPE_U8:
1314                 ptr.p_u8[idx] = ctrl->default_value;
1315                 break;
1316         case V4L2_CTRL_TYPE_U16:
1317                 ptr.p_u16[idx] = ctrl->default_value;
1318                 break;
1319         case V4L2_CTRL_TYPE_U32:
1320                 ptr.p_u32[idx] = ctrl->default_value;
1321                 break;
1322         default:
1323                 idx *= ctrl->elem_size;
1324                 memset(ptr.p + idx, 0, ctrl->elem_size);
1325                 break;
1326         }
1327 }
1328
1329 static void std_log(const struct v4l2_ctrl *ctrl)
1330 {
1331         union v4l2_ctrl_ptr ptr = ctrl->p_cur;
1332
1333         if (ctrl->is_array) {
1334                 unsigned i;
1335
1336                 for (i = 0; i < ctrl->nr_of_dims; i++)
1337                         pr_cont("[%u]", ctrl->dims[i]);
1338                 pr_cont(" ");
1339         }
1340
1341         switch (ctrl->type) {
1342         case V4L2_CTRL_TYPE_INTEGER:
1343                 pr_cont("%d", *ptr.p_s32);
1344                 break;
1345         case V4L2_CTRL_TYPE_BOOLEAN:
1346                 pr_cont("%s", *ptr.p_s32 ? "true" : "false");
1347                 break;
1348         case V4L2_CTRL_TYPE_MENU:
1349                 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
1350                 break;
1351         case V4L2_CTRL_TYPE_INTEGER_MENU:
1352                 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
1353                 break;
1354         case V4L2_CTRL_TYPE_BITMASK:
1355                 pr_cont("0x%08x", *ptr.p_s32);
1356                 break;
1357         case V4L2_CTRL_TYPE_INTEGER64:
1358                 pr_cont("%lld", *ptr.p_s64);
1359                 break;
1360         case V4L2_CTRL_TYPE_STRING:
1361                 pr_cont("%s", ptr.p_char);
1362                 break;
1363         case V4L2_CTRL_TYPE_U8:
1364                 pr_cont("%u", (unsigned)*ptr.p_u8);
1365                 break;
1366         case V4L2_CTRL_TYPE_U16:
1367                 pr_cont("%u", (unsigned)*ptr.p_u16);
1368                 break;
1369         case V4L2_CTRL_TYPE_U32:
1370                 pr_cont("%u", (unsigned)*ptr.p_u32);
1371                 break;
1372         default:
1373                 pr_cont("unknown type %d", ctrl->type);
1374                 break;
1375         }
1376 }
1377
1378 /*
1379  * Round towards the closest legal value. Be careful when we are
1380  * close to the maximum range of the control type to prevent
1381  * wrap-arounds.
1382  */
1383 #define ROUND_TO_RANGE(val, offset_type, ctrl)                  \
1384 ({                                                              \
1385         offset_type offset;                                     \
1386         if ((ctrl)->maximum >= 0 &&                             \
1387             val >= (ctrl)->maximum - (s32)((ctrl)->step / 2))   \
1388                 val = (ctrl)->maximum;                          \
1389         else                                                    \
1390                 val += (s32)((ctrl)->step / 2);                 \
1391         val = clamp_t(typeof(val), val,                         \
1392                       (ctrl)->minimum, (ctrl)->maximum);        \
1393         offset = (val) - (ctrl)->minimum;                       \
1394         offset = (ctrl)->step * (offset / (u32)(ctrl)->step);   \
1395         val = (ctrl)->minimum + offset;                         \
1396         0;                                                      \
1397 })
1398
1399 /* Validate a new control */
1400 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
1401                         union v4l2_ctrl_ptr ptr)
1402 {
1403         size_t len;
1404         u64 offset;
1405         s64 val;
1406
1407         switch (ctrl->type) {
1408         case V4L2_CTRL_TYPE_INTEGER:
1409                 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
1410         case V4L2_CTRL_TYPE_INTEGER64:
1411                 /*
1412                  * We can't use the ROUND_TO_RANGE define here due to
1413                  * the u64 divide that needs special care.
1414                  */
1415                 val = ptr.p_s64[idx];
1416                 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
1417                         val = ctrl->maximum;
1418                 else
1419                         val += (s64)(ctrl->step / 2);
1420                 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
1421                 offset = val - ctrl->minimum;
1422                 do_div(offset, ctrl->step);
1423                 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
1424                 return 0;
1425         case V4L2_CTRL_TYPE_U8:
1426                 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
1427         case V4L2_CTRL_TYPE_U16:
1428                 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
1429         case V4L2_CTRL_TYPE_U32:
1430                 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
1431
1432         case V4L2_CTRL_TYPE_BOOLEAN:
1433                 ptr.p_s32[idx] = !!ptr.p_s32[idx];
1434                 return 0;
1435
1436         case V4L2_CTRL_TYPE_MENU:
1437         case V4L2_CTRL_TYPE_INTEGER_MENU:
1438                 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
1439                         return -ERANGE;
1440                 if (ctrl->menu_skip_mask & (1 << ptr.p_s32[idx]))
1441                         return -EINVAL;
1442                 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1443                     ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
1444                         return -EINVAL;
1445                 return 0;
1446
1447         case V4L2_CTRL_TYPE_BITMASK:
1448                 ptr.p_s32[idx] &= ctrl->maximum;
1449                 return 0;
1450
1451         case V4L2_CTRL_TYPE_BUTTON:
1452         case V4L2_CTRL_TYPE_CTRL_CLASS:
1453                 ptr.p_s32[idx] = 0;
1454                 return 0;
1455
1456         case V4L2_CTRL_TYPE_STRING:
1457                 idx *= ctrl->elem_size;
1458                 len = strlen(ptr.p_char + idx);
1459                 if (len < ctrl->minimum)
1460                         return -ERANGE;
1461                 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
1462                         return -ERANGE;
1463                 return 0;
1464
1465         /* FIXME:just return 0 for now */
1466         case V4L2_CTRL_TYPE_PRIVATE:
1467                 return 0;
1468
1469         case V4L2_CTRL_TYPE_H264_SPS:
1470         case V4L2_CTRL_TYPE_H264_PPS:
1471         case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
1472         case V4L2_CTRL_TYPE_H264_SLICE_PARAM:
1473         case V4L2_CTRL_TYPE_H264_DECODE_PARAM:
1474         case V4L2_CTRL_TYPE_VP8_FRAME_HDR:
1475                 return 0;
1476
1477         default:
1478                 return -EINVAL;
1479         }
1480 }
1481
1482 static const struct v4l2_ctrl_type_ops std_type_ops = {
1483         .equal = std_equal,
1484         .init = std_init,
1485         .log = std_log,
1486         .validate = std_validate,
1487 };
1488
1489 /* Helper function: copy the given control value back to the caller */
1490 static int ptr_to_user(struct v4l2_ext_control *c,
1491                        struct v4l2_ctrl *ctrl,
1492                        union v4l2_ctrl_ptr ptr)
1493 {
1494         u32 len;
1495
1496         if (ctrl->is_ptr && !ctrl->is_string)
1497                 return copy_to_user(c->ptr, ptr.p, c->size) ?
1498                        -EFAULT : 0;
1499
1500         switch (ctrl->type) {
1501         case V4L2_CTRL_TYPE_STRING:
1502                 len = strlen(ptr.p_char);
1503                 if (c->size < len + 1) {
1504                         c->size = ctrl->elem_size;
1505                         return -ENOSPC;
1506                 }
1507                 return copy_to_user(c->string, ptr.p_char, len + 1) ?
1508                        -EFAULT : 0;
1509         case V4L2_CTRL_TYPE_INTEGER64:
1510                 c->value64 = *ptr.p_s64;
1511                 break;
1512         default:
1513                 c->value = *ptr.p_s32;
1514                 break;
1515         }
1516         return 0;
1517 }
1518
1519 /* Helper function: copy the current control value back to the caller */
1520 static int cur_to_user(struct v4l2_ext_control *c,
1521                        struct v4l2_ctrl *ctrl)
1522 {
1523         return ptr_to_user(c, ctrl, ctrl->p_cur);
1524 }
1525
1526 /* Helper function: copy the store's control value back to the caller */
1527 static int store_to_user(struct v4l2_ext_control *c,
1528                        struct v4l2_ctrl *ctrl, unsigned store)
1529 {
1530         if (store == 0)
1531                 return ptr_to_user(c, ctrl, ctrl->p_new);
1532         return ptr_to_user(c, ctrl, ctrl->p_stores[store - 1]);
1533 }
1534
1535 /* Helper function: copy the new control value back to the caller */
1536 static int new_to_user(struct v4l2_ext_control *c,
1537                        struct v4l2_ctrl *ctrl)
1538 {
1539         return ptr_to_user(c, ctrl, ctrl->p_new);
1540 }
1541
1542 /* Helper function: copy the caller-provider value to the given control value */
1543 static int user_to_ptr(struct v4l2_ext_control *c,
1544                        struct v4l2_ctrl *ctrl,
1545                        union v4l2_ctrl_ptr ptr)
1546 {
1547         int ret;
1548         u32 size;
1549
1550         ctrl->is_new = 1;
1551         if (ctrl->is_ptr && !ctrl->is_string) {
1552                 unsigned idx;
1553
1554                 ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0;
1555                 if (ret || !ctrl->is_array)
1556                         return ret;
1557                 for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++)
1558                         ctrl->type_ops->init(ctrl, idx, ptr);
1559                 return 0;
1560         }
1561
1562         switch (ctrl->type) {
1563         case V4L2_CTRL_TYPE_INTEGER64:
1564                 *ptr.p_s64 = c->value64;
1565                 break;
1566         case V4L2_CTRL_TYPE_STRING:
1567                 size = c->size;
1568                 if (size == 0)
1569                         return -ERANGE;
1570                 if (size > ctrl->maximum + 1)
1571                         size = ctrl->maximum + 1;
1572                 ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0;
1573                 if (!ret) {
1574                         char last = ptr.p_char[size - 1];
1575
1576                         ptr.p_char[size - 1] = 0;
1577                         /* If the string was longer than ctrl->maximum,
1578                            then return an error. */
1579                         if (strlen(ptr.p_char) == ctrl->maximum && last)
1580                                 return -ERANGE;
1581                 }
1582                 return ret;
1583         default:
1584                 *ptr.p_s32 = c->value;
1585                 break;
1586         }
1587         return 0;
1588 }
1589
1590 /* Helper function: copy the caller-provider value as the new control value */
1591 static int user_to_new(struct v4l2_ext_control *c,
1592                        struct v4l2_ctrl *ctrl)
1593 {
1594         return user_to_ptr(c, ctrl, ctrl->p_new);
1595 }
1596
1597 /* Copy the one value to another. */
1598 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
1599                        union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
1600 {
1601         if (ctrl == NULL)
1602                 return;
1603         memcpy(to.p, from.p, ctrl->elems * ctrl->elem_size);
1604 }
1605
1606 /* Copy the new value to the current value. */
1607 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1608 {
1609         bool changed;
1610
1611         if (ctrl == NULL)
1612                 return;
1613
1614         /* has_changed is set by cluster_changed */
1615         changed = ctrl->has_changed;
1616         if (changed)
1617                 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
1618
1619         if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1620                 /* Note: CH_FLAGS is only set for auto clusters. */
1621                 ctrl->flags &=
1622                         ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1623                 if (!is_cur_manual(ctrl->cluster[0])) {
1624                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1625                         if (ctrl->cluster[0]->has_volatiles)
1626                                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1627                 }
1628                 fh = NULL;
1629         }
1630         if (changed || ch_flags) {
1631                 /* If a control was changed that was not one of the controls
1632                    modified by the application, then send the event to all. */
1633                 if (!ctrl->is_new)
1634                         fh = NULL;
1635                 send_event(fh, ctrl,
1636                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1637                 if (ctrl->call_notify && changed && ctrl->handler->notify)
1638                         ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1639         }
1640 }
1641
1642 /* Helper function: copy the new control value to the store */
1643 static void new_to_store(struct v4l2_ctrl *ctrl)
1644 {
1645         /* has_changed is set by cluster_changed */
1646         if (ctrl && ctrl->has_changed)
1647                 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_stores[ctrl->store - 1]);
1648 }
1649
1650 /* Copy the current value to the new value */
1651 static void cur_to_new(struct v4l2_ctrl *ctrl)
1652 {
1653         if (ctrl == NULL)
1654                 return;
1655         ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1656 }
1657
1658 static void store_to_new(struct v4l2_ctrl *ctrl, unsigned store)
1659 {
1660         if (ctrl == NULL)
1661                 return;
1662         if (store)
1663                 ptr_to_ptr(ctrl, ctrl->p_stores[store - 1], ctrl->p_new);
1664         else
1665                 ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1666         ctrl->is_new = true;
1667 }
1668
1669 /* Return non-zero if one or more of the controls in the cluster has a new
1670    value that differs from the current value. */
1671 static int cluster_changed(struct v4l2_ctrl *master)
1672 {
1673         bool changed = false;
1674         unsigned idx;
1675         int i;
1676
1677         for (i = 0; i < master->ncontrols; i++) {
1678                 struct v4l2_ctrl *ctrl = master->cluster[i];
1679                 union v4l2_ctrl_ptr ptr;
1680                 bool ctrl_changed = false;
1681
1682                 if (ctrl == NULL)
1683                         continue;
1684
1685                 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE)
1686                         changed = ctrl_changed = true;
1687
1688                 /*
1689                  * Set has_changed to false to avoid generating
1690                  * the event V4L2_EVENT_CTRL_CH_VALUE
1691                  */
1692                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
1693                         ctrl->has_changed = false;
1694                         continue;
1695                 }
1696
1697                 if (ctrl->store)
1698                         ptr = ctrl->p_stores[ctrl->store - 1];
1699                 else
1700                         ptr = ctrl->p_cur;
1701
1702                 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1703                         ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1704                                 ptr, ctrl->p_new);
1705                 ctrl->has_changed = ctrl_changed;
1706                 changed |= ctrl->has_changed;
1707         }
1708         return changed;
1709 }
1710
1711 /* Control range checking */
1712 static int check_range(enum v4l2_ctrl_type type,
1713                 s64 min, s64 max, u64 step, s64 def)
1714 {
1715         switch (type) {
1716         case V4L2_CTRL_TYPE_BOOLEAN:
1717                 if (step != 1 || max > 1 || min < 0)
1718                         return -ERANGE;
1719                 /* fall through */
1720         case V4L2_CTRL_TYPE_U8:
1721         case V4L2_CTRL_TYPE_U16:
1722         case V4L2_CTRL_TYPE_U32:
1723         case V4L2_CTRL_TYPE_INTEGER:
1724         case V4L2_CTRL_TYPE_INTEGER64:
1725                 if (step == 0 || min > max || def < min || def > max)
1726                         return -ERANGE;
1727                 return 0;
1728         case V4L2_CTRL_TYPE_BITMASK:
1729                 if (step || min || !max || (def & ~max))
1730                         return -ERANGE;
1731                 return 0;
1732         case V4L2_CTRL_TYPE_MENU:
1733         case V4L2_CTRL_TYPE_INTEGER_MENU:
1734                 if (min > max || def < min || def > max)
1735                         return -ERANGE;
1736                 /* Note: step == menu_skip_mask for menu controls.
1737                    So here we check if the default value is masked out. */
1738                 if (step && ((1 << def) & step))
1739                         return -EINVAL;
1740                 return 0;
1741         case V4L2_CTRL_TYPE_STRING:
1742                 if (min > max || min < 0 || step < 1 || def)
1743                         return -ERANGE;
1744                 return 0;
1745         default:
1746                 return 0;
1747         }
1748 }
1749
1750 /* Validate a new control */
1751 static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
1752 {
1753         unsigned idx;
1754         int err = 0;
1755
1756         for (idx = 0; !err && idx < ctrl->elems; idx++)
1757                 err = ctrl->type_ops->validate(ctrl, idx, p_new);
1758         return err;
1759 }
1760
1761 static inline u32 node2id(struct list_head *node)
1762 {
1763         return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1764 }
1765
1766 /* Set the handler's error code if it wasn't set earlier already */
1767 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1768 {
1769         if (hdl->error == 0)
1770                 hdl->error = err;
1771         return err;
1772 }
1773
1774 /* Initialize the handler */
1775 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1776                                  unsigned nr_of_controls_hint,
1777                                  struct lock_class_key *key, const char *name)
1778 {
1779         hdl->lock = &hdl->_lock;
1780         mutex_init(hdl->lock);
1781         lockdep_set_class_and_name(hdl->lock, key, name);
1782         INIT_LIST_HEAD(&hdl->ctrls);
1783         INIT_LIST_HEAD(&hdl->ctrl_refs);
1784         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1785         hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1786                                GFP_KERNEL);
1787         hdl->error = hdl->buckets ? 0 : -ENOMEM;
1788         return hdl->error;
1789 }
1790 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1791
1792 /* Free all controls and control refs */
1793 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1794 {
1795         struct v4l2_ctrl_ref *ref, *next_ref;
1796         struct v4l2_ctrl *ctrl, *next_ctrl;
1797         struct v4l2_subscribed_event *sev, *next_sev;
1798
1799         if (hdl == NULL || hdl->buckets == NULL)
1800                 return;
1801
1802         mutex_lock(hdl->lock);
1803         /* Free all nodes */
1804         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1805                 list_del(&ref->node);
1806                 kfree(ref);
1807         }
1808         /* Free all controls owned by the handler */
1809         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1810                 list_del(&ctrl->node);
1811                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1812                         list_del(&sev->node);
1813                 if (ctrl->p_stores) {
1814                         unsigned s;
1815
1816                         for (s = 0; s < ctrl->nr_of_stores; s++)
1817                                 kfree(ctrl->p_stores[s].p);
1818                 }
1819                 kfree(ctrl->p_stores);
1820                 kfree(ctrl);
1821         }
1822         kfree(hdl->buckets);
1823         hdl->buckets = NULL;
1824         hdl->cached = NULL;
1825         hdl->error = 0;
1826         mutex_unlock(hdl->lock);
1827 }
1828 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1829
1830 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1831    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1832    with applications that do not use the NEXT_CTRL flag.
1833
1834    We just find the n-th private user control. It's O(N), but that should not
1835    be an issue in this particular case. */
1836 static struct v4l2_ctrl_ref *find_private_ref(
1837                 struct v4l2_ctrl_handler *hdl, u32 id)
1838 {
1839         struct v4l2_ctrl_ref *ref;
1840
1841         id -= V4L2_CID_PRIVATE_BASE;
1842         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1843                 /* Search for private user controls that are compatible with
1844                    VIDIOC_G/S_CTRL. */
1845                 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1846                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1847                         if (!ref->ctrl->is_int)
1848                                 continue;
1849                         if (id == 0)
1850                                 return ref;
1851                         id--;
1852                 }
1853         }
1854         return NULL;
1855 }
1856
1857 /* Find a control with the given ID. */
1858 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1859 {
1860         struct v4l2_ctrl_ref *ref;
1861         int bucket;
1862
1863         id &= V4L2_CTRL_ID_MASK;
1864
1865         /* Old-style private controls need special handling */
1866         if (id >= V4L2_CID_PRIVATE_BASE)
1867                 return find_private_ref(hdl, id);
1868         bucket = id % hdl->nr_of_buckets;
1869
1870         /* Simple optimization: cache the last control found */
1871         if (hdl->cached && hdl->cached->ctrl->id == id)
1872                 return hdl->cached;
1873
1874         /* Not in cache, search the hash */
1875         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1876         while (ref && ref->ctrl->id != id)
1877                 ref = ref->next;
1878
1879         if (ref)
1880                 hdl->cached = ref; /* cache it! */
1881         return ref;
1882 }
1883
1884 /* Find a control with the given ID. Take the handler's lock first. */
1885 static struct v4l2_ctrl_ref *find_ref_lock(
1886                 struct v4l2_ctrl_handler *hdl, u32 id)
1887 {
1888         struct v4l2_ctrl_ref *ref = NULL;
1889
1890         if (hdl) {
1891                 mutex_lock(hdl->lock);
1892                 ref = find_ref(hdl, id);
1893                 mutex_unlock(hdl->lock);
1894         }
1895         return ref;
1896 }
1897
1898 /* Find a control with the given ID. */
1899 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1900 {
1901         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1902
1903         return ref ? ref->ctrl : NULL;
1904 }
1905 EXPORT_SYMBOL(v4l2_ctrl_find);
1906
1907 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1908 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1909                            struct v4l2_ctrl *ctrl)
1910 {
1911         struct v4l2_ctrl_ref *ref;
1912         struct v4l2_ctrl_ref *new_ref;
1913         u32 id = ctrl->id;
1914         u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
1915         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
1916
1917         /*
1918          * Automatically add the control class if it is not yet present and
1919          * the new control is not a compound control.
1920          */
1921         if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
1922             id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1923                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1924                         return hdl->error;
1925
1926         if (hdl->error)
1927                 return hdl->error;
1928
1929         new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1930         if (!new_ref)
1931                 return handler_set_err(hdl, -ENOMEM);
1932         new_ref->ctrl = ctrl;
1933         if (ctrl->handler == hdl) {
1934                 /* By default each control starts in a cluster of its own.
1935                    new_ref->ctrl is basically a cluster array with one
1936                    element, so that's perfect to use as the cluster pointer.
1937                    But only do this for the handler that owns the control. */
1938                 ctrl->cluster = &new_ref->ctrl;
1939                 ctrl->ncontrols = 1;
1940         }
1941
1942         INIT_LIST_HEAD(&new_ref->node);
1943
1944         mutex_lock(hdl->lock);
1945
1946         /* Add immediately at the end of the list if the list is empty, or if
1947            the last element in the list has a lower ID.
1948            This ensures that when elements are added in ascending order the
1949            insertion is an O(1) operation. */
1950         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1951                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1952                 goto insert_in_hash;
1953         }
1954
1955         /* Find insert position in sorted list */
1956         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1957                 if (ref->ctrl->id < id)
1958                         continue;
1959                 /* Don't add duplicates */
1960                 if (ref->ctrl->id == id) {
1961                         kfree(new_ref);
1962                         goto unlock;
1963                 }
1964                 list_add(&new_ref->node, ref->node.prev);
1965                 break;
1966         }
1967
1968 insert_in_hash:
1969         /* Insert the control node in the hash */
1970         new_ref->next = hdl->buckets[bucket];
1971         hdl->buckets[bucket] = new_ref;
1972
1973 unlock:
1974         mutex_unlock(hdl->lock);
1975         return 0;
1976 }
1977
1978 /* Add a new control */
1979 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1980                         const struct v4l2_ctrl_ops *ops,
1981                         const struct v4l2_ctrl_type_ops *type_ops,
1982                         u32 id, const char *name, enum v4l2_ctrl_type type,
1983                         s64 min, s64 max, u64 step, s64 def,
1984                         const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
1985                         u32 flags, const char * const *qmenu,
1986                         const s64 *qmenu_int, void *priv)
1987 {
1988         struct v4l2_ctrl *ctrl;
1989         unsigned sz_extra;
1990         unsigned nr_of_dims = 0;
1991         unsigned elems = 1;
1992         bool is_array;
1993         unsigned tot_ctrl_size;
1994         unsigned idx;
1995         void *data;
1996         int err;
1997
1998         if (hdl->error)
1999                 return NULL;
2000
2001         while (dims && dims[nr_of_dims]) {
2002                 elems *= dims[nr_of_dims];
2003                 nr_of_dims++;
2004                 if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
2005                         break;
2006         }
2007         is_array = nr_of_dims > 0;
2008
2009         /* Prefill elem_size for all types handled by std_type_ops */
2010         switch (type) {
2011         case V4L2_CTRL_TYPE_INTEGER64:
2012                 elem_size = sizeof(s64);
2013                 break;
2014         case V4L2_CTRL_TYPE_STRING:
2015                 elem_size = max + 1;
2016                 break;
2017         case V4L2_CTRL_TYPE_U8:
2018                 elem_size = sizeof(u8);
2019                 break;
2020         case V4L2_CTRL_TYPE_U16:
2021                 elem_size = sizeof(u16);
2022                 break;
2023         case V4L2_CTRL_TYPE_U32:
2024                 elem_size = sizeof(u32);
2025                 break;
2026         case V4L2_CTRL_TYPE_H264_SPS:
2027                 elem_size = sizeof(struct v4l2_ctrl_h264_sps);
2028                 break;
2029         case V4L2_CTRL_TYPE_H264_PPS:
2030                 elem_size = sizeof(struct v4l2_ctrl_h264_pps);
2031                 break;
2032         case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
2033                 elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix);
2034                 break;
2035         case V4L2_CTRL_TYPE_H264_SLICE_PARAM:
2036                 elem_size = sizeof(struct v4l2_ctrl_h264_slice_param);
2037                 break;
2038         case V4L2_CTRL_TYPE_H264_DECODE_PARAM:
2039                 elem_size = sizeof(struct v4l2_ctrl_h264_decode_param);
2040                 break;
2041         case V4L2_CTRL_TYPE_VP8_FRAME_HDR:
2042                 elem_size = sizeof(struct v4l2_ctrl_vp8_frame_hdr);
2043                 break;
2044         default:
2045                 if (type < V4L2_CTRL_COMPOUND_TYPES)
2046                         elem_size = sizeof(s32);
2047                 break;
2048         }
2049         tot_ctrl_size = elem_size * elems;
2050
2051         /* Sanity checks */
2052         if (id == 0 || name == NULL || !elem_size ||
2053             id >= V4L2_CID_PRIVATE_BASE ||
2054             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
2055             (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
2056                 handler_set_err(hdl, -ERANGE);
2057                 return NULL;
2058         }
2059         err = check_range(type, min, max, step, def);
2060         if (err) {
2061                 handler_set_err(hdl, err);
2062                 return NULL;
2063         }
2064         if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
2065                 handler_set_err(hdl, -ERANGE);
2066                 return NULL;
2067         }
2068         if ((is_array || (flags & V4L2_CTRL_FLAG_CAN_STORE)) &&
2069             (type == V4L2_CTRL_TYPE_BUTTON ||
2070              type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
2071                 handler_set_err(hdl, -EINVAL);
2072                 return NULL;
2073         }
2074
2075         sz_extra = 0;
2076         if (type == V4L2_CTRL_TYPE_BUTTON)
2077                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
2078                         V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
2079         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
2080                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
2081         else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
2082                  type == V4L2_CTRL_TYPE_STRING ||
2083                  type >= V4L2_CTRL_COMPOUND_TYPES ||
2084                  is_array)
2085                 sz_extra += 2 * tot_ctrl_size;
2086
2087         ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
2088         if (ctrl == NULL) {
2089                 handler_set_err(hdl, -ENOMEM);
2090                 return NULL;
2091         }
2092
2093         INIT_LIST_HEAD(&ctrl->node);
2094         INIT_LIST_HEAD(&ctrl->ev_subs);
2095         ctrl->handler = hdl;
2096         ctrl->ops = ops;
2097         ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
2098         ctrl->id = id;
2099         ctrl->name = name;
2100         ctrl->type = type;
2101         ctrl->flags = flags;
2102         ctrl->minimum = min;
2103         ctrl->maximum = max;
2104         ctrl->step = step;
2105         ctrl->default_value = def;
2106         ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
2107         ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
2108         ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
2109         ctrl->is_array = is_array;
2110         ctrl->elems = elems;
2111         ctrl->nr_of_dims = nr_of_dims;
2112         if (nr_of_dims)
2113                 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
2114         ctrl->elem_size = elem_size;
2115         if (type == V4L2_CTRL_TYPE_MENU)
2116                 ctrl->qmenu = qmenu;
2117         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2118                 ctrl->qmenu_int = qmenu_int;
2119         ctrl->priv = priv;
2120         ctrl->cur.val = ctrl->val = def;
2121         data = &ctrl[1];
2122
2123         if (!ctrl->is_int) {
2124                 ctrl->p_new.p = data;
2125                 ctrl->p_cur.p = data + tot_ctrl_size;
2126         } else {
2127                 ctrl->p_new.p = &ctrl->val;
2128                 ctrl->p_cur.p = &ctrl->cur.val;
2129         }
2130         for (idx = 0; idx < elems; idx++) {
2131                 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
2132                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2133         }
2134
2135         if (handler_new_ref(hdl, ctrl)) {
2136                 kfree(ctrl);
2137                 return NULL;
2138         }
2139         mutex_lock(hdl->lock);
2140         list_add_tail(&ctrl->node, &hdl->ctrls);
2141         mutex_unlock(hdl->lock);
2142         return ctrl;
2143 }
2144
2145 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
2146                         const struct v4l2_ctrl_config *cfg, void *priv)
2147 {
2148         bool is_menu;
2149         struct v4l2_ctrl *ctrl;
2150         const char *name = cfg->name;
2151         const char * const *qmenu = cfg->qmenu;
2152         const s64 *qmenu_int = cfg->qmenu_int;
2153         enum v4l2_ctrl_type type = cfg->type;
2154         u32 flags = cfg->flags;
2155         s64 min = cfg->min;
2156         s64 max = cfg->max;
2157         u64 step = cfg->step;
2158         s64 def = cfg->def;
2159
2160         if (name == NULL)
2161                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
2162                                                                 &def, &flags);
2163
2164         is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
2165                    cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
2166         if (is_menu)
2167                 WARN_ON(step);
2168         else
2169                 WARN_ON(cfg->menu_skip_mask);
2170         if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
2171                 qmenu = v4l2_ctrl_get_menu(cfg->id);
2172         else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
2173                  qmenu_int == NULL) {
2174                 handler_set_err(hdl, -EINVAL);
2175                 return NULL;
2176         }
2177
2178         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
2179                         type, min, max,
2180                         is_menu ? cfg->menu_skip_mask : step, def,
2181                         cfg->dims, cfg->elem_size,
2182                         flags, qmenu, qmenu_int, priv);
2183         if (ctrl) {
2184                 ctrl->is_private = cfg->is_private;
2185                 v4l2_ctrl_set_max_stores(ctrl, cfg->max_stores);
2186         }
2187         return ctrl;
2188 }
2189 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
2190
2191 /* Helper function for standard non-menu controls */
2192 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
2193                         const struct v4l2_ctrl_ops *ops,
2194                         u32 id, s64 min, s64 max, u64 step, s64 def)
2195 {
2196         const char *name;
2197         enum v4l2_ctrl_type type;
2198         u32 flags;
2199
2200         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2201         if (type == V4L2_CTRL_TYPE_MENU ||
2202             type == V4L2_CTRL_TYPE_INTEGER_MENU ||
2203             type >= V4L2_CTRL_COMPOUND_TYPES) {
2204                 handler_set_err(hdl, -EINVAL);
2205                 return NULL;
2206         }
2207         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2208                              min, max, step, def, NULL, 0,
2209                              flags, NULL, NULL, NULL);
2210 }
2211 EXPORT_SYMBOL(v4l2_ctrl_new_std);
2212
2213 /* Helper function for standard menu controls */
2214 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
2215                         const struct v4l2_ctrl_ops *ops,
2216                         u32 id, u8 _max, u64 mask, u8 _def)
2217 {
2218         const char * const *qmenu = NULL;
2219         const s64 *qmenu_int = NULL;
2220         unsigned int qmenu_int_len = 0;
2221         const char *name;
2222         enum v4l2_ctrl_type type;
2223         s64 min;
2224         s64 max = _max;
2225         s64 def = _def;
2226         u64 step;
2227         u32 flags;
2228
2229         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2230
2231         if (type == V4L2_CTRL_TYPE_MENU)
2232                 qmenu = v4l2_ctrl_get_menu(id);
2233         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2234                 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
2235
2236         if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
2237                 handler_set_err(hdl, -EINVAL);
2238                 return NULL;
2239         }
2240         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2241                              0, max, mask, def, NULL, 0,
2242                              flags, qmenu, qmenu_int, NULL);
2243 }
2244 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
2245
2246 /* Helper function for standard menu controls with driver defined menu */
2247 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
2248                         const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
2249                         u64 mask, u8 _def, const char * const *qmenu)
2250 {
2251         enum v4l2_ctrl_type type;
2252         const char *name;
2253         u32 flags;
2254         u64 step;
2255         s64 min;
2256         s64 max = _max;
2257         s64 def = _def;
2258
2259         /* v4l2_ctrl_new_std_menu_items() should only be called for
2260          * standard controls without a standard menu.
2261          */
2262         if (v4l2_ctrl_get_menu(id)) {
2263                 handler_set_err(hdl, -EINVAL);
2264                 return NULL;
2265         }
2266
2267         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2268         if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
2269                 handler_set_err(hdl, -EINVAL);
2270                 return NULL;
2271         }
2272         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2273                              0, max, mask, def, NULL, 0,
2274                              flags, qmenu, NULL, NULL);
2275
2276 }
2277 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
2278
2279 /* Helper function for standard integer menu controls */
2280 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
2281                         const struct v4l2_ctrl_ops *ops,
2282                         u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
2283 {
2284         const char *name;
2285         enum v4l2_ctrl_type type;
2286         s64 min;
2287         u64 step;
2288         s64 max = _max;
2289         s64 def = _def;
2290         u32 flags;
2291
2292         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2293         if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
2294                 handler_set_err(hdl, -EINVAL);
2295                 return NULL;
2296         }
2297         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2298                              0, max, 0, def, NULL, 0,
2299                              flags, NULL, qmenu_int, NULL);
2300 }
2301 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
2302
2303 /* Add a control from another handler to this handler */
2304 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
2305                                           struct v4l2_ctrl *ctrl)
2306 {
2307         if (hdl == NULL || hdl->error)
2308                 return NULL;
2309         if (ctrl == NULL) {
2310                 handler_set_err(hdl, -EINVAL);
2311                 return NULL;
2312         }
2313         if (ctrl->handler == hdl)
2314                 return ctrl;
2315         return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
2316 }
2317 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
2318
2319 /* Add the controls from another handler to our own. */
2320 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
2321                           struct v4l2_ctrl_handler *add,
2322                           bool (*filter)(const struct v4l2_ctrl *ctrl))
2323 {
2324         struct v4l2_ctrl_ref *ref;
2325         int ret = 0;
2326
2327         /* Do nothing if either handler is NULL or if they are the same */
2328         if (!hdl || !add || hdl == add)
2329                 return 0;
2330         if (hdl->error)
2331                 return hdl->error;
2332         mutex_lock(add->lock);
2333         list_for_each_entry(ref, &add->ctrl_refs, node) {
2334                 struct v4l2_ctrl *ctrl = ref->ctrl;
2335
2336                 /* Skip handler-private controls. */
2337                 if (ctrl->is_private)
2338                         continue;
2339                 /* And control classes */
2340                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2341                         continue;
2342                 /* Filter any unwanted controls */
2343                 if (filter && !filter(ctrl))
2344                         continue;
2345                 ret = handler_new_ref(hdl, ctrl);
2346                 if (ret)
2347                         break;
2348         }
2349         mutex_unlock(add->lock);
2350         return ret;
2351 }
2352 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
2353
2354 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
2355 {
2356         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
2357                 return true;
2358         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
2359                 return true;
2360         switch (ctrl->id) {
2361         case V4L2_CID_AUDIO_MUTE:
2362         case V4L2_CID_AUDIO_VOLUME:
2363         case V4L2_CID_AUDIO_BALANCE:
2364         case V4L2_CID_AUDIO_BASS:
2365         case V4L2_CID_AUDIO_TREBLE:
2366         case V4L2_CID_AUDIO_LOUDNESS:
2367                 return true;
2368         default:
2369                 break;
2370         }
2371         return false;
2372 }
2373 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
2374
2375 /* Cluster controls */
2376 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
2377 {
2378         bool has_volatiles = false;
2379         int i;
2380
2381         /* The first control is the master control and it must not be NULL */
2382         if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
2383                 return;
2384
2385         for (i = 0; i < ncontrols; i++) {
2386                 if (controls[i]) {
2387                         controls[i]->cluster = controls;
2388                         controls[i]->ncontrols = ncontrols;
2389                         if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
2390                                 has_volatiles = true;
2391                 }
2392         }
2393         controls[0]->has_volatiles = has_volatiles;
2394 }
2395 EXPORT_SYMBOL(v4l2_ctrl_cluster);
2396
2397 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
2398                             u8 manual_val, bool set_volatile)
2399 {
2400         struct v4l2_ctrl *master = controls[0];
2401         u32 flag = 0;
2402         int i;
2403
2404         v4l2_ctrl_cluster(ncontrols, controls);
2405         WARN_ON(ncontrols <= 1);
2406         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
2407         WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
2408         master->is_auto = true;
2409         master->has_volatiles = set_volatile;
2410         master->manual_mode_value = manual_val;
2411         master->flags |= V4L2_CTRL_FLAG_UPDATE;
2412
2413         if (!is_cur_manual(master))
2414                 flag = V4L2_CTRL_FLAG_INACTIVE |
2415                         (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
2416
2417         for (i = 1; i < ncontrols; i++)
2418                 if (controls[i])
2419                         controls[i]->flags |= flag;
2420 }
2421 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
2422
2423 /* Activate/deactivate a control. */
2424 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
2425 {
2426         /* invert since the actual flag is called 'inactive' */
2427         bool inactive = !active;
2428         bool old;
2429
2430         if (ctrl == NULL)
2431                 return;
2432
2433         if (inactive)
2434                 /* set V4L2_CTRL_FLAG_INACTIVE */
2435                 old = test_and_set_bit(4, &ctrl->flags);
2436         else
2437                 /* clear V4L2_CTRL_FLAG_INACTIVE */
2438                 old = test_and_clear_bit(4, &ctrl->flags);
2439         if (old != inactive)
2440                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2441 }
2442 EXPORT_SYMBOL(v4l2_ctrl_activate);
2443
2444 /* Grab/ungrab a control.
2445    Typically used when streaming starts and you want to grab controls,
2446    preventing the user from changing them.
2447
2448    Just call this and the framework will block any attempts to change
2449    these controls. */
2450 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
2451 {
2452         bool old;
2453
2454         if (ctrl == NULL)
2455                 return;
2456
2457         v4l2_ctrl_lock(ctrl);
2458         if (grabbed)
2459                 /* set V4L2_CTRL_FLAG_GRABBED */
2460                 old = test_and_set_bit(1, &ctrl->flags);
2461         else
2462                 /* clear V4L2_CTRL_FLAG_GRABBED */
2463                 old = test_and_clear_bit(1, &ctrl->flags);
2464         if (old != grabbed)
2465                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2466         v4l2_ctrl_unlock(ctrl);
2467 }
2468 EXPORT_SYMBOL(v4l2_ctrl_grab);
2469
2470 /* Log the control name and value */
2471 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2472                      const char *prefix, const char *colon)
2473 {
2474         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2475                 return;
2476         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2477                 return;
2478
2479         pr_info("%s%s%s: ", prefix, colon, ctrl->name);
2480
2481         ctrl->type_ops->log(ctrl);
2482
2483         if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2484                            V4L2_CTRL_FLAG_GRABBED |
2485                            V4L2_CTRL_FLAG_VOLATILE)) {
2486                 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2487                         pr_cont(" inactive");
2488                 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2489                         pr_cont(" grabbed");
2490                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2491                         pr_cont(" volatile");
2492         }
2493         pr_cont("\n");
2494 }
2495
2496 /* Log all controls owned by the handler */
2497 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2498                                   const char *prefix)
2499 {
2500         struct v4l2_ctrl *ctrl;
2501         const char *colon = "";
2502         int len;
2503
2504         if (hdl == NULL)
2505                 return;
2506         if (prefix == NULL)
2507                 prefix = "";
2508         len = strlen(prefix);
2509         if (len && prefix[len - 1] != ' ')
2510                 colon = ": ";
2511         mutex_lock(hdl->lock);
2512         list_for_each_entry(ctrl, &hdl->ctrls, node)
2513                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2514                         log_ctrl(ctrl, prefix, colon);
2515         mutex_unlock(hdl->lock);
2516 }
2517 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2518
2519 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2520 {
2521         v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2522         return 0;
2523 }
2524 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2525
2526 /* Call s_ctrl for all controls owned by the handler */
2527 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2528 {
2529         struct v4l2_ctrl *ctrl;
2530         int ret = 0;
2531
2532         if (hdl == NULL)
2533                 return 0;
2534         mutex_lock(hdl->lock);
2535         list_for_each_entry(ctrl, &hdl->ctrls, node)
2536                 ctrl->done = false;
2537
2538         list_for_each_entry(ctrl, &hdl->ctrls, node) {
2539                 struct v4l2_ctrl *master = ctrl->cluster[0];
2540                 int i;
2541
2542                 /* Skip if this control was already handled by a cluster. */
2543                 /* Skip button controls and read-only controls. */
2544                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2545                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2546                         continue;
2547
2548                 for (i = 0; i < master->ncontrols; i++) {
2549                         if (master->cluster[i]) {
2550                                 cur_to_new(master->cluster[i]);
2551                                 master->cluster[i]->is_new = 1;
2552                                 master->cluster[i]->done = true;
2553                                 master->cluster[i]->store = 0;
2554                         }
2555                 }
2556                 ret = call_op(master, s_ctrl);
2557                 if (ret)
2558                         break;
2559         }
2560         mutex_unlock(hdl->lock);
2561         return ret;
2562 }
2563 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2564
2565 /* Implement VIDIOC_QUERY_EXT_CTRL */
2566 int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
2567 {
2568         const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
2569         u32 id = qc->id & V4L2_CTRL_ID_MASK;
2570         struct v4l2_ctrl_ref *ref;
2571         struct v4l2_ctrl *ctrl;
2572
2573         if (hdl == NULL)
2574                 return -EINVAL;
2575
2576         mutex_lock(hdl->lock);
2577
2578         /* Try to find it */
2579         ref = find_ref(hdl, id);
2580
2581         if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
2582                 bool is_compound;
2583                 /* Match any control that is not hidden */
2584                 unsigned mask = 1;
2585                 bool match = false;
2586
2587                 if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
2588                         /* Match any hidden control */
2589                         match = true;
2590                 } else if ((qc->id & next_flags) == next_flags) {
2591                         /* Match any control, compound or not */
2592                         mask = 0;
2593                 }
2594
2595                 /* Find the next control with ID > qc->id */
2596
2597                 /* Did we reach the end of the control list? */
2598                 if (id >= node2id(hdl->ctrl_refs.prev)) {
2599                         ref = NULL; /* Yes, so there is no next control */
2600                 } else if (ref) {
2601                         /* We found a control with the given ID, so just get
2602                            the next valid one in the list. */
2603                         list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
2604                                 is_compound = ref->ctrl->is_array ||
2605                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2606                                 if (id < ref->ctrl->id &&
2607                                     (is_compound & mask) == match)
2608                                         break;
2609                         }
2610                         if (&ref->node == &hdl->ctrl_refs)
2611                                 ref = NULL;
2612                 } else {
2613                         /* No control with the given ID exists, so start
2614                            searching for the next largest ID. We know there
2615                            is one, otherwise the first 'if' above would have
2616                            been true. */
2617                         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2618                                 is_compound = ref->ctrl->is_array ||
2619                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2620                                 if (id < ref->ctrl->id &&
2621                                     (is_compound & mask) == match)
2622                                         break;
2623                         }
2624                         if (&ref->node == &hdl->ctrl_refs)
2625                                 ref = NULL;
2626                 }
2627         }
2628         mutex_unlock(hdl->lock);
2629
2630         if (!ref)
2631                 return -EINVAL;
2632
2633         ctrl = ref->ctrl;
2634         memset(qc, 0, sizeof(*qc));
2635         if (id >= V4L2_CID_PRIVATE_BASE)
2636                 qc->id = id;
2637         else
2638                 qc->id = ctrl->id;
2639         strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2640         qc->flags = ctrl->flags;
2641         if (ctrl->max_stores)
2642                 qc->flags |= V4L2_CTRL_FLAG_CAN_STORE;
2643         qc->type = ctrl->type;
2644         if (ctrl->is_ptr)
2645                 qc->flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD;
2646         qc->elem_size = ctrl->elem_size;
2647         qc->elems = ctrl->elems;
2648         qc->nr_of_dims = ctrl->nr_of_dims;
2649         memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
2650         qc->minimum = ctrl->minimum;
2651         qc->maximum = ctrl->maximum;
2652         qc->default_value = ctrl->default_value;
2653         if (ctrl->type == V4L2_CTRL_TYPE_MENU
2654             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2655                 qc->step = 1;
2656         else
2657                 qc->step = ctrl->step;
2658         return 0;
2659 }
2660 EXPORT_SYMBOL(v4l2_query_ext_ctrl);
2661
2662 /* Implement VIDIOC_QUERYCTRL */
2663 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2664 {
2665         struct v4l2_query_ext_ctrl qec = { qc->id };
2666         int rc;
2667
2668         rc = v4l2_query_ext_ctrl(hdl, &qec);
2669         if (rc)
2670                 return rc;
2671
2672         qc->id = qec.id;
2673         qc->type = qec.type;
2674         qc->flags = qec.flags;
2675         strlcpy(qc->name, qec.name, sizeof(qc->name));
2676         switch (qc->type) {
2677         case V4L2_CTRL_TYPE_INTEGER:
2678         case V4L2_CTRL_TYPE_BOOLEAN:
2679         case V4L2_CTRL_TYPE_MENU:
2680         case V4L2_CTRL_TYPE_INTEGER_MENU:
2681         case V4L2_CTRL_TYPE_STRING:
2682         case V4L2_CTRL_TYPE_BITMASK:
2683                 qc->minimum = qec.minimum;
2684                 qc->maximum = qec.maximum;
2685                 qc->step = qec.step;
2686                 qc->default_value = qec.default_value;
2687                 break;
2688         default:
2689                 qc->minimum = 0;
2690                 qc->maximum = 0;
2691                 qc->step = 0;
2692                 qc->default_value = 0;
2693                 break;
2694         }
2695         return 0;
2696 }
2697 EXPORT_SYMBOL(v4l2_queryctrl);
2698
2699 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
2700 {
2701         if (qc->id & (V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND))
2702                 return -EINVAL;
2703         return v4l2_queryctrl(sd->ctrl_handler, qc);
2704 }
2705 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
2706
2707 /* Implement VIDIOC_QUERYMENU */
2708 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2709 {
2710         struct v4l2_ctrl *ctrl;
2711         u32 i = qm->index;
2712
2713         ctrl = v4l2_ctrl_find(hdl, qm->id);
2714         if (!ctrl)
2715                 return -EINVAL;
2716
2717         qm->reserved = 0;
2718         /* Sanity checks */
2719         switch (ctrl->type) {
2720         case V4L2_CTRL_TYPE_MENU:
2721                 if (ctrl->qmenu == NULL)
2722                         return -EINVAL;
2723                 break;
2724         case V4L2_CTRL_TYPE_INTEGER_MENU:
2725                 if (ctrl->qmenu_int == NULL)
2726                         return -EINVAL;
2727                 break;
2728         default:
2729                 return -EINVAL;
2730         }
2731
2732         if (i < ctrl->minimum || i > ctrl->maximum)
2733                 return -EINVAL;
2734
2735         /* Use mask to see if this menu item should be skipped */
2736         if (ctrl->menu_skip_mask & (1 << i))
2737                 return -EINVAL;
2738         /* Empty menu items should also be skipped */
2739         if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2740                 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2741                         return -EINVAL;
2742                 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2743         } else {
2744                 qm->value = ctrl->qmenu_int[i];
2745         }
2746         return 0;
2747 }
2748 EXPORT_SYMBOL(v4l2_querymenu);
2749
2750 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2751 {
2752         return v4l2_querymenu(sd->ctrl_handler, qm);
2753 }
2754 EXPORT_SYMBOL(v4l2_subdev_querymenu);
2755
2756
2757
2758 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2759
2760    It is not a fully atomic operation, just best-effort only. After all, if
2761    multiple controls have to be set through multiple i2c writes (for example)
2762    then some initial writes may succeed while others fail. Thus leaving the
2763    system in an inconsistent state. The question is how much effort you are
2764    willing to spend on trying to make something atomic that really isn't.
2765
2766    From the point of view of an application the main requirement is that
2767    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2768    error should be returned without actually affecting any controls.
2769
2770    If all the values are correct, then it is acceptable to just give up
2771    in case of low-level errors.
2772
2773    It is important though that the application can tell when only a partial
2774    configuration was done. The way we do that is through the error_idx field
2775    of struct v4l2_ext_controls: if that is equal to the count field then no
2776    controls were affected. Otherwise all controls before that index were
2777    successful in performing their 'get' or 'set' operation, the control at
2778    the given index failed, and you don't know what happened with the controls
2779    after the failed one. Since if they were part of a control cluster they
2780    could have been successfully processed (if a cluster member was encountered
2781    at index < error_idx), they could have failed (if a cluster member was at
2782    error_idx), or they may not have been processed yet (if the first cluster
2783    member appeared after error_idx).
2784
2785    It is all fairly theoretical, though. In practice all you can do is to
2786    bail out. If error_idx == count, then it is an application bug. If
2787    error_idx < count then it is only an application bug if the error code was
2788    EBUSY. That usually means that something started streaming just when you
2789    tried to set the controls. In all other cases it is a driver/hardware
2790    problem and all you can do is to retry or bail out.
2791
2792    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2793    never modifies controls the error_idx is just set to whatever control
2794    has an invalid value.
2795  */
2796
2797 /* Prepare for the extended g/s/try functions.
2798    Find the controls in the control array and do some basic checks. */
2799 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2800                              struct v4l2_ext_controls *cs,
2801                              struct v4l2_ctrl_helper *helpers,
2802                              bool get)
2803 {
2804         u32 which = V4L2_CTRL_ID2WHICH(cs->which);
2805         unsigned store = cs->config_store & 0xffff;
2806         struct v4l2_ctrl_helper *h;
2807         bool have_clusters = false;
2808         u32 i;
2809
2810         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2811                 struct v4l2_ext_control *c = &cs->controls[i];
2812                 struct v4l2_ctrl_ref *ref;
2813                 struct v4l2_ctrl *ctrl;
2814                 u32 id = c->id & V4L2_CTRL_ID_MASK;
2815
2816                 cs->error_idx = i;
2817
2818                 if (which && V4L2_CTRL_ID2WHICH(id) != cs->which)
2819                         return -EINVAL;
2820
2821                 /* Old-style private controls are not allowed for
2822                    extended controls */
2823                 if (id >= V4L2_CID_PRIVATE_BASE)
2824                         return -EINVAL;
2825                 ref = find_ref_lock(hdl, id);
2826                 if (ref == NULL)
2827                         return -EINVAL;
2828                 ctrl = ref->ctrl;
2829                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2830                         return -EINVAL;
2831                 if (store > ctrl->max_stores)
2832                         return -EINVAL;
2833
2834                 if (ctrl->cluster[0]->ncontrols > 1)
2835                         have_clusters = true;
2836                 if (ctrl->cluster[0] != ctrl)
2837                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2838                 if (ctrl->is_ptr && !ctrl->is_string) {
2839                         unsigned tot_size = ctrl->elems * ctrl->elem_size;
2840
2841                         if (c->size < tot_size) {
2842                                 if (get) {
2843                                         c->size = tot_size;
2844                                         return -ENOSPC;
2845                                 }
2846                                 return -EFAULT;
2847                         }
2848                         c->size = tot_size;
2849                 }
2850                 /* Store the ref to the master control of the cluster */
2851                 h->mref = ref;
2852                 h->ctrl = ctrl;
2853                 /* Initially set next to 0, meaning that there is no other
2854                    control in this helper array belonging to the same
2855                    cluster */
2856                 h->next = 0;
2857         }
2858
2859         /* We are done if there were no controls that belong to a multi-
2860            control cluster. */
2861         if (!have_clusters)
2862                 return 0;
2863
2864         /* The code below figures out in O(n) time which controls in the list
2865            belong to the same cluster. */
2866
2867         /* This has to be done with the handler lock taken. */
2868         mutex_lock(hdl->lock);
2869
2870         /* First zero the helper field in the master control references */
2871         for (i = 0; i < cs->count; i++)
2872                 helpers[i].mref->helper = NULL;
2873         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2874                 struct v4l2_ctrl_ref *mref = h->mref;
2875
2876                 /* If the mref->helper is set, then it points to an earlier
2877                    helper that belongs to the same cluster. */
2878                 if (mref->helper) {
2879                         /* Set the next field of mref->helper to the current
2880                            index: this means that that earlier helper now
2881                            points to the next helper in the same cluster. */
2882                         mref->helper->next = i;
2883                         /* mref should be set only for the first helper in the
2884                            cluster, clear the others. */
2885                         h->mref = NULL;
2886                 }
2887                 /* Point the mref helper to the current helper struct. */
2888                 mref->helper = h;
2889         }
2890         mutex_unlock(hdl->lock);
2891         return 0;
2892 }
2893
2894 /* Handles the corner case where cs->count == 0. It checks whether the
2895    specified control class exists. If that class ID is 0, then it checks
2896    whether there are any controls at all. */
2897 static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
2898 {
2899         if (!which)
2900                 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2901         return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
2902 }
2903
2904 static int extend_store(struct v4l2_ctrl *ctrl, unsigned stores)
2905 {
2906         unsigned s, idx;
2907         union v4l2_ctrl_ptr *p;
2908
2909         p = kcalloc(stores, sizeof(union v4l2_ctrl_ptr), GFP_KERNEL);
2910         if (p == NULL)
2911                 return -ENOMEM;
2912         for (s = ctrl->nr_of_stores; s < stores; s++) {
2913                 p[s].p = kcalloc(ctrl->elems, ctrl->elem_size, GFP_KERNEL);
2914                 if (p[s].p == NULL) {
2915                         while (s > ctrl->nr_of_stores)
2916                                 kfree(p[--s].p);
2917                         kfree(p);
2918                         return -ENOMEM;
2919                 }
2920                 for (idx = 0; idx < ctrl->elems; idx++)
2921                         ctrl->type_ops->init(ctrl, idx, p[s]);
2922         }
2923         if (ctrl->p_stores)
2924                 memcpy(p, ctrl->p_stores, ctrl->nr_of_stores * sizeof(union v4l2_ctrl_ptr));
2925         kfree(ctrl->p_stores);
2926         ctrl->p_stores = p;
2927         ctrl->nr_of_stores = stores;
2928         return 0;
2929 }
2930
2931
2932 /* Get extended controls. Allocates the helpers array if needed. */
2933 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2934 {
2935         struct v4l2_ctrl_helper helper[4];
2936         struct v4l2_ctrl_helper *helpers = helper;
2937         unsigned store = 0;
2938         int ret;
2939         int i, j;
2940
2941         cs->error_idx = cs->count;
2942         if (V4L2_CTRL_ID2WHICH(cs->which))
2943                 cs->which = V4L2_CTRL_ID2WHICH(cs->which);
2944         else
2945                 store = cs->config_store;
2946
2947         if (hdl == NULL)
2948                 return -EINVAL;
2949
2950         if (cs->count == 0)
2951                 return class_check(hdl, cs->which);
2952
2953         if (cs->count > ARRAY_SIZE(helper)) {
2954                 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2955                                         GFP_KERNEL);
2956                 if (helpers == NULL)
2957                         return -ENOMEM;
2958         }
2959
2960         ret = prepare_ext_ctrls(hdl, cs, helpers, true);
2961         cs->error_idx = cs->count;
2962
2963         for (i = 0; !ret && i < cs->count; i++)
2964                 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2965                         ret = -EACCES;
2966
2967         for (i = 0; !ret && i < cs->count; i++) {
2968                 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2969                                     struct v4l2_ctrl *ctrl) = cur_to_user;
2970                 struct v4l2_ctrl *master;
2971
2972                 if (helpers[i].mref == NULL)
2973                         continue;
2974
2975                 master = helpers[i].mref->ctrl;
2976                 cs->error_idx = i;
2977
2978                 v4l2_ctrl_lock(master);
2979
2980                 /* g_volatile_ctrl will update the new control values */
2981                 if (store == 0 &&
2982                     ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2983                      (master->has_volatiles && !is_cur_manual(master)))) {
2984                         for (j = 0; j < master->ncontrols; j++)
2985                                 cur_to_new(master->cluster[j]);
2986                         ret = call_op(master, g_volatile_ctrl);
2987                         ctrl_to_user = new_to_user;
2988                 }
2989                 for (j = 0; j < master->ncontrols; j++)
2990                         if (!ret && master->cluster[j] &&
2991                             store > master->cluster[j]->nr_of_stores)
2992                                 ret = extend_store(master->cluster[j], store);
2993
2994                 /* If OK, then copy the current (for non-volatile controls)
2995                    or the new (for volatile controls) control values to the
2996                    caller */
2997                 if (!ret) {
2998                         u32 idx = i;
2999
3000                         do {
3001                                 if (store)
3002                                         ret = store_to_user(cs->controls + idx,
3003                                                    helpers[idx].ctrl, store);
3004                                 else
3005                                         ret = ctrl_to_user(cs->controls + idx,
3006                                                    helpers[idx].ctrl);
3007                                 idx = helpers[idx].next;
3008                         } while (!ret && idx);
3009                 }
3010                 v4l2_ctrl_unlock(master);
3011         }
3012
3013         if (cs->count > ARRAY_SIZE(helper))
3014                 kfree(helpers);
3015         return ret;
3016 }
3017 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
3018
3019 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
3020 {
3021         return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
3022 }
3023 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
3024
3025 /* Helper function to get a single control */
3026 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
3027 {
3028         struct v4l2_ctrl *master = ctrl->cluster[0];
3029         int ret = 0;
3030         int i;
3031
3032         /* Compound controls are not supported. The new_to_user() and
3033          * cur_to_user() calls below would need to be modified not to access
3034          * userspace memory when called from get_ctrl().
3035          */
3036         if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64)
3037                 return -EINVAL;
3038
3039         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
3040                 return -EACCES;
3041
3042         v4l2_ctrl_lock(master);
3043         /* g_volatile_ctrl will update the current control values */
3044         if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
3045                 for (i = 0; i < master->ncontrols; i++)
3046                         cur_to_new(master->cluster[i]);
3047                 ret = call_op(master, g_volatile_ctrl);
3048                 new_to_user(c, ctrl);
3049         } else {
3050                 cur_to_user(c, ctrl);
3051         }
3052         v4l2_ctrl_unlock(master);
3053         return ret;
3054 }
3055
3056 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
3057 {
3058         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3059         struct v4l2_ext_control c;
3060         int ret;
3061
3062         if (ctrl == NULL || !ctrl->is_int)
3063                 return -EINVAL;
3064         ret = get_ctrl(ctrl, &c);
3065         control->value = c.value;
3066         return ret;
3067 }
3068 EXPORT_SYMBOL(v4l2_g_ctrl);
3069
3070 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
3071 {
3072         return v4l2_g_ctrl(sd->ctrl_handler, control);
3073 }
3074 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
3075
3076 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
3077 {
3078         struct v4l2_ext_control c;
3079
3080         /* It's a driver bug if this happens. */
3081         WARN_ON(!ctrl->is_int);
3082         c.value = 0;
3083         get_ctrl(ctrl, &c);
3084         return c.value;
3085 }
3086 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
3087
3088 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
3089 {
3090         struct v4l2_ext_control c;
3091
3092         /* It's a driver bug if this happens. */
3093         WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
3094         c.value64 = 0;
3095         get_ctrl(ctrl, &c);
3096         return c.value64;
3097 }
3098 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
3099
3100 /* Core function that calls try/s_ctrl and ensures that the new value is
3101    copied to the current value on a set.
3102    Must be called with ctrl->handler->lock held. */
3103 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
3104                               u16 store, bool set, u32 ch_flags)
3105 {
3106         bool update_flag;
3107         int ret;
3108         int i;
3109
3110         /* Go through the cluster and either validate the new value or
3111            (if no new value was set), copy the current value to the new
3112            value, ensuring a consistent view for the control ops when
3113            called. */
3114         for (i = 0; i < master->ncontrols; i++) {
3115                 struct v4l2_ctrl *ctrl = master->cluster[i];
3116
3117                 if (ctrl == NULL)
3118                         continue;
3119
3120                 if (store > ctrl->max_stores)
3121                         return -EINVAL;
3122                 if (store > ctrl->nr_of_stores) {
3123                         ret = extend_store(ctrl, store);
3124                         if (ret)
3125                                 return ret;
3126                 }
3127                 ctrl->store = store;
3128                 if (!ctrl->is_new) {
3129                         cur_to_new(ctrl);
3130                         continue;
3131                 }
3132                 /* Check again: it may have changed since the
3133                    previous check in try_or_set_ext_ctrls(). */
3134                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3135                         return -EBUSY;
3136         }
3137
3138         ret = call_op(master, try_ctrl);
3139
3140         /* Don't set if there is no change */
3141         if (ret || !set || !cluster_changed(master))
3142                 return ret;
3143         ret = call_op(master, s_ctrl);
3144         if (ret)
3145                 return ret;
3146
3147         /* If OK, then make the new values permanent. */
3148         update_flag = is_cur_manual(master) != is_new_manual(master);
3149         for (i = 0; i < master->ncontrols; i++) {
3150                 if (store)
3151                         new_to_store(master->cluster[i]);
3152                 else
3153                         new_to_cur(fh, master->cluster[i], ch_flags |
3154                                 ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
3155         }
3156         return 0;
3157 }
3158
3159 /* Validate controls. */
3160 static int validate_ctrls(struct v4l2_ext_controls *cs,
3161                           struct v4l2_ctrl_helper *helpers, bool set)
3162 {
3163         unsigned i;
3164         int ret = 0;
3165
3166         cs->error_idx = cs->count;
3167         for (i = 0; i < cs->count; i++) {
3168                 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
3169                 union v4l2_ctrl_ptr p_new;
3170
3171                 cs->error_idx = i;
3172
3173                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3174                         return -EACCES;
3175                 /* This test is also done in try_set_control_cluster() which
3176                    is called in atomic context, so that has the final say,
3177                    but it makes sense to do an up-front check as well. Once
3178                    an error occurs in try_set_control_cluster() some other
3179                    controls may have been set already and we want to do a
3180                    best-effort to avoid that. */
3181                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3182                         return -EBUSY;
3183                 /*
3184                  * Skip validation for now if the payload needs to be copied
3185                  * from userspace into kernelspace. We'll validate those later.
3186                  */
3187                 if (ctrl->is_ptr)
3188                         continue;
3189                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3190                         p_new.p_s64 = &cs->controls[i].value64;
3191                 else
3192                         p_new.p_s32 = &cs->controls[i].value;
3193                 ret = validate_new(ctrl, p_new);
3194                 if (ret)
3195                         return ret;
3196         }
3197         return 0;
3198 }
3199
3200 /* Obtain the current volatile values of an autocluster and mark them
3201    as new. */
3202 static void update_from_auto_cluster(struct v4l2_ctrl *master)
3203 {
3204         int i;
3205
3206         for (i = 0; i < master->ncontrols; i++) {
3207                 if (master->cluster[i] == NULL)
3208                         continue;
3209                 cur_to_new(master->cluster[i]);
3210                 master->cluster[i]->store = 0;
3211         }
3212         if (!call_op(master, g_volatile_ctrl))
3213                 for (i = 1; i < master->ncontrols; i++)
3214                         if (master->cluster[i])
3215                                 master->cluster[i]->is_new = 1;
3216 }
3217
3218 /* Try or try-and-set controls */
3219 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3220                              struct v4l2_ext_controls *cs,
3221                              bool set)
3222 {
3223         struct v4l2_ctrl_helper helper[4];
3224         struct v4l2_ctrl_helper *helpers = helper;
3225         unsigned store = 0;
3226         unsigned i, j;
3227         int ret;
3228
3229         cs->error_idx = cs->count;
3230         if (V4L2_CTRL_ID2WHICH(cs->which))
3231                 cs->which = V4L2_CTRL_ID2WHICH(cs->which);
3232         else
3233                 store = cs->config_store;
3234
3235         if (hdl == NULL)
3236                 return -EINVAL;
3237
3238         if (cs->count == 0)
3239                 return class_check(hdl, cs->which);
3240
3241         if (cs->count > ARRAY_SIZE(helper)) {
3242                 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
3243                                         GFP_KERNEL);
3244                 if (!helpers)
3245                         return -ENOMEM;
3246         }
3247         ret = prepare_ext_ctrls(hdl, cs, helpers, false);
3248         if (!ret)
3249                 ret = validate_ctrls(cs, helpers, set);
3250         if (ret && set)
3251                 cs->error_idx = cs->count;
3252         for (i = 0; !ret && i < cs->count; i++) {
3253                 struct v4l2_ctrl *master;
3254                 u32 idx = i;
3255
3256                 if (helpers[i].mref == NULL)
3257                         continue;
3258
3259                 cs->error_idx = i;
3260                 master = helpers[i].mref->ctrl;
3261                 v4l2_ctrl_lock(master);
3262
3263                 /* Reset the 'is_new' flags of the cluster */
3264                 for (j = 0; j < master->ncontrols; j++)
3265                         if (master->cluster[j])
3266                                 master->cluster[j]->is_new = 0;
3267
3268                 /* For volatile autoclusters that are currently in auto mode
3269                    we need to discover if it will be set to manual mode.
3270                    If so, then we have to copy the current volatile values
3271                    first since those will become the new manual values (which
3272                    may be overwritten by explicit new values from this set
3273                    of controls). */
3274                 if (!store && master->is_auto && master->has_volatiles &&
3275                                                 !is_cur_manual(master)) {
3276                         /* Pick an initial non-manual value */
3277                         s32 new_auto_val = master->manual_mode_value + 1;
3278                         u32 tmp_idx = idx;
3279
3280                         do {
3281                                 /* Check if the auto control is part of the
3282                                    list, and remember the new value. */
3283                                 if (helpers[tmp_idx].ctrl == master)
3284                                         new_auto_val = cs->controls[tmp_idx].value;
3285                                 tmp_idx = helpers[tmp_idx].next;
3286                         } while (tmp_idx);
3287                         /* If the new value == the manual value, then copy
3288                            the current volatile values. */
3289                         if (new_auto_val == master->manual_mode_value)
3290                                 update_from_auto_cluster(master);
3291                 }
3292
3293                 /* Copy the new caller-supplied control values.
3294                    user_to_new() sets 'is_new' to 1. */
3295                 do {
3296                         struct v4l2_ctrl *ctrl = helpers[idx].ctrl;
3297
3298                         ret = user_to_new(cs->controls + idx, ctrl);
3299                         if (!ret && ctrl->is_ptr)
3300                                 ret = validate_new(ctrl, ctrl->p_new);
3301                         idx = helpers[idx].next;
3302                 } while (!ret && idx);
3303
3304                 if (!ret)
3305                         ret = try_or_set_cluster(fh, master, store, set, 0);
3306
3307                 /* Copy the new values back to userspace. */
3308                 if (!ret) {
3309                         idx = i;
3310                         do {
3311                                 ret = store_to_user(cs->controls + idx,
3312                                                 helpers[idx].ctrl, store);
3313                                 idx = helpers[idx].next;
3314                         } while (!ret && idx);
3315                 }
3316                 v4l2_ctrl_unlock(master);
3317         }
3318
3319         if (cs->count > ARRAY_SIZE(helper))
3320                 kfree(helpers);
3321         return ret;
3322 }
3323
3324 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
3325 {
3326         return try_set_ext_ctrls(NULL, hdl, cs, false);
3327 }
3328 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
3329
3330 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3331                                         struct v4l2_ext_controls *cs)
3332 {
3333         return try_set_ext_ctrls(fh, hdl, cs, true);
3334 }
3335 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
3336
3337 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
3338 {
3339         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
3340 }
3341 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
3342
3343 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
3344 {
3345         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
3346 }
3347 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
3348
3349 /* Helper function for VIDIOC_S_CTRL compatibility */
3350 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
3351 {
3352         struct v4l2_ctrl *master = ctrl->cluster[0];
3353         int ret;
3354         int i;
3355
3356         /* Reset the 'is_new' flags of the cluster */
3357         for (i = 0; i < master->ncontrols; i++) {
3358                 if (master->cluster[i] == NULL)
3359                         continue;
3360                 master->cluster[i]->is_new = 0;
3361                 master->cluster[i]->store = 0;
3362         }
3363
3364         ret = validate_new(ctrl, ctrl->p_new);
3365         if (ret)
3366                 return ret;
3367
3368         /* For autoclusters with volatiles that are switched from auto to
3369            manual mode we have to update the current volatile values since
3370            those will become the initial manual values after such a switch. */
3371         if (master->is_auto && master->has_volatiles && ctrl == master &&
3372             !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
3373                 update_from_auto_cluster(master);
3374
3375         ctrl->is_new = 1;
3376         return try_or_set_cluster(fh, master, 0, true, ch_flags);
3377 }
3378
3379 /* Helper function for VIDIOC_S_CTRL compatibility */
3380 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
3381                          struct v4l2_ext_control *c)
3382 {
3383         int ret;
3384
3385         v4l2_ctrl_lock(ctrl);
3386         user_to_new(c, ctrl);
3387         ret = set_ctrl(fh, ctrl, 0);
3388         if (!ret)
3389                 cur_to_user(c, ctrl);
3390         v4l2_ctrl_unlock(ctrl);
3391         return ret;
3392 }
3393
3394 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3395                                         struct v4l2_control *control)
3396 {
3397         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3398         struct v4l2_ext_control c = { control->id };
3399         int ret;
3400
3401         if (ctrl == NULL || !ctrl->is_int)
3402                 return -EINVAL;
3403
3404         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3405                 return -EACCES;
3406
3407         c.value = control->value;
3408         ret = set_ctrl_lock(fh, ctrl, &c);
3409         control->value = c.value;
3410         return ret;
3411 }
3412 EXPORT_SYMBOL(v4l2_s_ctrl);
3413
3414 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
3415 {
3416         return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
3417 }
3418 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
3419
3420 int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
3421 {
3422         lockdep_assert_held(ctrl->handler->lock);
3423
3424         /* It's a driver bug if this happens. */
3425         WARN_ON(!ctrl->is_int);
3426         ctrl->val = val;
3427         return set_ctrl(NULL, ctrl, 0);
3428 }
3429 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
3430
3431 int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
3432 {
3433         lockdep_assert_held(ctrl->handler->lock);
3434
3435         /* It's a driver bug if this happens. */
3436         WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
3437         *ctrl->p_new.p_s64 = val;
3438         return set_ctrl(NULL, ctrl, 0);
3439 }
3440 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
3441
3442 int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
3443 {
3444         lockdep_assert_held(ctrl->handler->lock);
3445
3446         /* It's a driver bug if this happens. */
3447         WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING);
3448         strlcpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
3449         return set_ctrl(NULL, ctrl, 0);
3450 }
3451 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
3452
3453 int v4l2_ctrl_apply_store(struct v4l2_ctrl_handler *hdl, unsigned store)
3454 {
3455         struct v4l2_ctrl_ref *ref;
3456         bool found_store = false;
3457         unsigned i;
3458
3459         if (hdl == NULL || store == 0)
3460                 return -EINVAL;
3461
3462         mutex_lock(hdl->lock);
3463
3464         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
3465                 struct v4l2_ctrl *master;
3466
3467                 if (store > ref->ctrl->nr_of_stores)
3468                         continue;
3469                 found_store = true;
3470                 master = ref->ctrl->cluster[0];
3471                 if (ref->ctrl != master)
3472                         continue;
3473                 if (master->handler != hdl)
3474                         v4l2_ctrl_lock(master);
3475                 for (i = 0; i < master->ncontrols; i++)
3476                         store_to_new(master->cluster[i], store);
3477
3478                 /* For volatile autoclusters that are currently in auto mode
3479                    we need to discover if it will be set to manual mode.
3480                    If so, then we have to copy the current volatile values
3481                    first since those will become the new manual values (which
3482                    may be overwritten by explicit new values from this set
3483                    of controls). */
3484                 if (master->is_auto && master->has_volatiles &&
3485                                                 !is_cur_manual(master)) {
3486                         s32 new_auto_val = *master->p_stores[store - 1].p_s32;
3487
3488                         /* If the new value == the manual value, then copy
3489                            the current volatile values. */
3490                         if (new_auto_val == master->manual_mode_value)
3491                                 update_from_auto_cluster(master);
3492                 }
3493
3494                 try_or_set_cluster(NULL, master, 0, true, 0);
3495                 if (master->handler != hdl)
3496                         v4l2_ctrl_unlock(master);
3497         }
3498         mutex_unlock(hdl->lock);
3499         return found_store ? 0 : -EINVAL;
3500 }
3501 EXPORT_SYMBOL(v4l2_ctrl_apply_store);
3502
3503 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
3504 {
3505         if (ctrl == NULL)
3506                 return;
3507         if (notify == NULL) {
3508                 ctrl->call_notify = 0;
3509                 return;
3510         }
3511         if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
3512                 return;
3513         ctrl->handler->notify = notify;
3514         ctrl->handler->notify_priv = priv;
3515         ctrl->call_notify = 1;
3516 }
3517 EXPORT_SYMBOL(v4l2_ctrl_notify);
3518
3519 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
3520                         s64 min, s64 max, u64 step, s64 def)
3521 {
3522         bool value_changed;
3523         bool range_changed = false;
3524         int ret;
3525
3526         lockdep_assert_held(ctrl->handler->lock);
3527
3528         switch (ctrl->type) {
3529         case V4L2_CTRL_TYPE_INTEGER:
3530         case V4L2_CTRL_TYPE_INTEGER64:
3531         case V4L2_CTRL_TYPE_BOOLEAN:
3532         case V4L2_CTRL_TYPE_MENU:
3533         case V4L2_CTRL_TYPE_INTEGER_MENU:
3534         case V4L2_CTRL_TYPE_BITMASK:
3535         case V4L2_CTRL_TYPE_U8:
3536         case V4L2_CTRL_TYPE_U16:
3537         case V4L2_CTRL_TYPE_U32:
3538                 if (ctrl->is_array)
3539                         return -EINVAL;
3540                 ret = check_range(ctrl->type, min, max, step, def);
3541                 if (ret)
3542                         return ret;
3543                 break;
3544         default:
3545                 return -EINVAL;
3546         }
3547         if ((ctrl->minimum != min) || (ctrl->maximum != max) ||
3548                 (ctrl->step != step) || ctrl->default_value != def) {
3549                 range_changed = true;
3550                 ctrl->minimum = min;
3551                 ctrl->maximum = max;
3552                 ctrl->step = step;
3553                 ctrl->default_value = def;
3554         }
3555         cur_to_new(ctrl);
3556         if (validate_new(ctrl, ctrl->p_new)) {
3557                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3558                         *ctrl->p_new.p_s64 = def;
3559                 else
3560                         *ctrl->p_new.p_s32 = def;
3561         }
3562
3563         if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3564                 value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
3565         else
3566                 value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
3567         if (value_changed)
3568                 ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
3569         else if (range_changed)
3570                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
3571         return ret;
3572 }
3573 EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
3574
3575 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
3576 {
3577         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3578
3579         if (ctrl == NULL)
3580                 return -EINVAL;
3581
3582         v4l2_ctrl_lock(ctrl);
3583         list_add_tail(&sev->node, &ctrl->ev_subs);
3584         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
3585             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
3586                 struct v4l2_event ev;
3587                 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
3588
3589                 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
3590                         changes |= V4L2_EVENT_CTRL_CH_VALUE;
3591                 fill_event(&ev, ctrl, changes);
3592                 /* Mark the queue as active, allowing this initial
3593                    event to be accepted. */
3594                 sev->elems = elems;
3595                 v4l2_event_queue_fh(sev->fh, &ev);
3596         }
3597         v4l2_ctrl_unlock(ctrl);
3598         return 0;
3599 }
3600
3601 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
3602 {
3603         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3604
3605         v4l2_ctrl_lock(ctrl);
3606         list_del(&sev->node);
3607         v4l2_ctrl_unlock(ctrl);
3608 }
3609
3610 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
3611 {
3612         u32 old_changes = old->u.ctrl.changes;
3613
3614         old->u.ctrl = new->u.ctrl;
3615         old->u.ctrl.changes |= old_changes;
3616 }
3617 EXPORT_SYMBOL(v4l2_ctrl_replace);
3618
3619 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
3620 {
3621         new->u.ctrl.changes |= old->u.ctrl.changes;
3622 }
3623 EXPORT_SYMBOL(v4l2_ctrl_merge);
3624
3625 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
3626         .add = v4l2_ctrl_add_event,
3627         .del = v4l2_ctrl_del_event,
3628         .replace = v4l2_ctrl_replace,
3629         .merge = v4l2_ctrl_merge,
3630 };
3631 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
3632
3633 int v4l2_ctrl_log_status(struct file *file, void *fh)
3634 {
3635         struct video_device *vfd = video_devdata(file);
3636         struct v4l2_fh *vfh = file->private_data;
3637
3638         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
3639                 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
3640                         vfd->v4l2_dev->name);
3641         return 0;
3642 }
3643 EXPORT_SYMBOL(v4l2_ctrl_log_status);
3644
3645 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
3646                                 const struct v4l2_event_subscription *sub)
3647 {
3648         if (sub->type == V4L2_EVENT_CTRL)
3649                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
3650         return -EINVAL;
3651 }
3652 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
3653
3654 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
3655                                      struct v4l2_event_subscription *sub)
3656 {
3657         if (!sd->ctrl_handler)
3658                 return -EINVAL;
3659         return v4l2_ctrl_subscribe_event(fh, sub);
3660 }
3661 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
3662
3663 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
3664 {
3665         struct v4l2_fh *fh = file->private_data;
3666
3667         if (v4l2_event_pending(fh))
3668                 return POLLPRI;
3669         poll_wait(file, &fh->wait, wait);
3670         return 0;
3671 }
3672 EXPORT_SYMBOL(v4l2_ctrl_poll);