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