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 ref corresponding to the v4l2_ext_control ID field. */
  41         struct v4l2_ctrl_ref *ref;
  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         case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS:            return "MPEG-2 Slice Parameters";
 848         case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION:            return "MPEG-2 Quantization Matrices";
 849
 850         /* VPX controls */
 851         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:            return "VPX Number of Partitions";
 852         case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4:           return "VPX Intra Mode Decision Disable";
 853         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:            return "VPX No. of Refs for P Frame";
 854         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL:              return "VPX Loop Filter Level Range";
 855         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS:          return "VPX Deblocking Effect Control";
 856         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD:   return "VPX Golden Frame Refresh Period";
 857         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:          return "VPX Golden Frame Indicator";
 858         case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:                    return "VPX Minimum QP Value";
 859         case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:                    return "VPX Maximum QP Value";
 860         case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP:                return "VPX I-Frame QP Value";
 861         case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP:                return "VPX P-Frame QP Value";
 862         case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:                   return "VP8 Profile";
 863         case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:                   return "VP9 Profile";
 864
 865         /* HEVC controls */
 866         case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP:               return "HEVC I-Frame QP Value";
 867         case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP:               return "HEVC P-Frame QP Value";
 868         case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP:               return "HEVC B-Frame QP Value";
 869         case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP:                   return "HEVC Minimum QP Value";
 870         case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP:                   return "HEVC Maximum QP Value";
 871         case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:                  return "HEVC Profile";
 872         case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:                    return "HEVC Level";
 873         case V4L2_CID_MPEG_VIDEO_HEVC_TIER:                     return "HEVC Tier";
 874         case V4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTION:    return "HEVC Frame Rate Resolution";
 875         case V4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTH:      return "HEVC Maximum Coding Unit Depth";
 876         case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:             return "HEVC Refresh Type";
 877         case V4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PRED:         return "HEVC Constant Intra Prediction";
 878         case V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU:              return "HEVC Lossless Encoding";
 879         case V4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONT:                return "HEVC Wavefront";
 880         case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:         return "HEVC Loop Filter";
 881         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP:                  return "HEVC QP Values";
 882         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:         return "HEVC Hierarchical Coding Type";
 883         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER:        return "HEVC Hierarchical Coding Layer";
 884         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP:        return "HEVC Hierarchical Layer 0 QP";
 885         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP:        return "HEVC Hierarchical Layer 1 QP";
 886         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP:        return "HEVC Hierarchical Layer 2 QP";
 887         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP:        return "HEVC Hierarchical Layer 3 QP";
 888         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP:        return "HEVC Hierarchical Layer 4 QP";
 889         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP:        return "HEVC Hierarchical Layer 5 QP";
 890         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP:        return "HEVC Hierarchical Layer 6 QP";
 891         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR:        return "HEVC Hierarchical Lay 0 BitRate";
 892         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR:        return "HEVC Hierarchical Lay 1 BitRate";
 893         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR:        return "HEVC Hierarchical Lay 2 BitRate";
 894         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR:        return "HEVC Hierarchical Lay 3 BitRate";
 895         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR:        return "HEVC Hierarchical Lay 4 BitRate";
 896         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR:        return "HEVC Hierarchical Lay 5 BitRate";
 897         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BR:        return "HEVC Hierarchical Lay 6 BitRate";
 898         case V4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PB:               return "HEVC General PB";
 899         case V4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_ID:              return "HEVC Temporal ID";
 900         case V4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHING:         return "HEVC Strong Intra Smoothing";
 901         case V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLIT:           return "HEVC Intra PU Split";
 902         case V4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTION:           return "HEVC TMV Prediction";
 903         case V4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1:  return "HEVC Max Num of Candidate MVs";
 904         case V4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODE:        return "HEVC ENC Without Startcode";
 905         case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIOD:           return "HEVC Num of I-Frame b/w 2 IDR";
 906         case V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2:      return "HEVC Loop Filter Beta Offset";
 907         case V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2:        return "HEVC Loop Filter TC Offset";
 908         case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:     return "HEVC Size of Length Field";
 909         case V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES:        return "Reference Frames for a P-Frame";
 910         case V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR:         return "Prepend SPS and PPS to IDR";
 911
 912         /* CAMERA controls */
 913         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 914         case V4L2_CID_CAMERA_CLASS:             return "Camera Controls";
 915         case V4L2_CID_EXPOSURE_AUTO:            return "Auto Exposure";
 916         case V4L2_CID_EXPOSURE_ABSOLUTE:        return "Exposure Time, Absolute";
 917         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:   return "Exposure, Dynamic Framerate";
 918         case V4L2_CID_PAN_RELATIVE:             return "Pan, Relative";
 919         case V4L2_CID_TILT_RELATIVE:            return "Tilt, Relative";
 920         case V4L2_CID_PAN_RESET:                return "Pan, Reset";
 921         case V4L2_CID_TILT_RESET:               return "Tilt, Reset";
 922         case V4L2_CID_PAN_ABSOLUTE:             return "Pan, Absolute";
 923         case V4L2_CID_TILT_ABSOLUTE:            return "Tilt, Absolute";
 924         case V4L2_CID_FOCUS_ABSOLUTE:           return "Focus, Absolute";
 925         case V4L2_CID_FOCUS_RELATIVE:           return "Focus, Relative";
 926         case V4L2_CID_FOCUS_AUTO:               return "Focus, Automatic Continuous";
 927         case V4L2_CID_ZOOM_ABSOLUTE:            return "Zoom, Absolute";
 928         case V4L2_CID_ZOOM_RELATIVE:            return "Zoom, Relative";
 929         case V4L2_CID_ZOOM_CONTINUOUS:          return "Zoom, Continuous";
 930         case V4L2_CID_PRIVACY:                  return "Privacy";
 931         case V4L2_CID_IRIS_ABSOLUTE:            return "Iris, Absolute";
 932         case V4L2_CID_IRIS_RELATIVE:            return "Iris, Relative";
 933         case V4L2_CID_AUTO_EXPOSURE_BIAS:       return "Auto Exposure, Bias";
 934         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
 935         case V4L2_CID_WIDE_DYNAMIC_RANGE:       return "Wide Dynamic Range";
 936         case V4L2_CID_IMAGE_STABILIZATION:      return "Image Stabilization";
 937         case V4L2_CID_ISO_SENSITIVITY:          return "ISO Sensitivity";
 938         case V4L2_CID_ISO_SENSITIVITY_AUTO:     return "ISO Sensitivity, Auto";
 939         case V4L2_CID_EXPOSURE_METERING:        return "Exposure, Metering Mode";
 940         case V4L2_CID_SCENE_MODE:               return "Scene Mode";
 941         case V4L2_CID_3A_LOCK:                  return "3A Lock";
 942         case V4L2_CID_AUTO_FOCUS_START:         return "Auto Focus, Start";
 943         case V4L2_CID_AUTO_FOCUS_STOP:          return "Auto Focus, Stop";
 944         case V4L2_CID_AUTO_FOCUS_STATUS:        return "Auto Focus, Status";
 945         case V4L2_CID_AUTO_FOCUS_RANGE:         return "Auto Focus, Range";
 946         case V4L2_CID_PAN_SPEED:                return "Pan, Speed";
 947         case V4L2_CID_TILT_SPEED:               return "Tilt, Speed";
 948
 949         /* FM Radio Modulator controls */
 950         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 951         case V4L2_CID_FM_TX_CLASS:              return "FM Radio Modulator Controls";
 952         case V4L2_CID_RDS_TX_DEVIATION:         return "RDS Signal Deviation";
 953         case V4L2_CID_RDS_TX_PI:                return "RDS Program ID";
 954         case V4L2_CID_RDS_TX_PTY:               return "RDS Program Type";
 955         case V4L2_CID_RDS_TX_PS_NAME:           return "RDS PS Name";
 956         case V4L2_CID_RDS_TX_RADIO_TEXT:        return "RDS Radio Text";
 957         case V4L2_CID_RDS_TX_MONO_STEREO:       return "RDS Stereo";
 958         case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:   return "RDS Artificial Head";
 959         case V4L2_CID_RDS_TX_COMPRESSED:        return "RDS Compressed";
 960         case V4L2_CID_RDS_TX_DYNAMIC_PTY:       return "RDS Dynamic PTY";
 961         case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
 962         case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:   return "RDS Traffic Program";
 963         case V4L2_CID_RDS_TX_MUSIC_SPEECH:      return "RDS Music";
 964         case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:  return "RDS Enable Alt Frequencies";
 965         case V4L2_CID_RDS_TX_ALT_FREQS:         return "RDS Alternate Frequencies";
 966         case V4L2_CID_AUDIO_LIMITER_ENABLED:    return "Audio Limiter Feature Enabled";
 967         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
 968         case V4L2_CID_AUDIO_LIMITER_DEVIATION:  return "Audio Limiter Deviation";
 969         case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
 970         case V4L2_CID_AUDIO_COMPRESSION_GAIN:   return "Audio Compression Gain";
 971         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
 972         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
 973         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
 974         case V4L2_CID_PILOT_TONE_ENABLED:       return "Pilot Tone Feature Enabled";
 975         case V4L2_CID_PILOT_TONE_DEVIATION:     return "Pilot Tone Deviation";
 976         case V4L2_CID_PILOT_TONE_FREQUENCY:     return "Pilot Tone Frequency";
 977         case V4L2_CID_TUNE_PREEMPHASIS:         return "Pre-Emphasis";
 978         case V4L2_CID_TUNE_POWER_LEVEL:         return "Tune Power Level";
 979         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:   return "Tune Antenna Capacitor";
 980
 981         /* Flash controls */
 982         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 983         case V4L2_CID_FLASH_CLASS:              return "Flash Controls";
 984         case V4L2_CID_FLASH_LED_MODE:           return "LED Mode";
 985         case V4L2_CID_FLASH_STROBE_SOURCE:      return "Strobe Source";
 986         case V4L2_CID_FLASH_STROBE:             return "Strobe";
 987         case V4L2_CID_FLASH_STROBE_STOP:        return "Stop Strobe";
 988         case V4L2_CID_FLASH_STROBE_STATUS:      return "Strobe Status";
 989         case V4L2_CID_FLASH_TIMEOUT:            return "Strobe Timeout";
 990         case V4L2_CID_FLASH_INTENSITY:          return "Intensity, Flash Mode";
 991         case V4L2_CID_FLASH_TORCH_INTENSITY:    return "Intensity, Torch Mode";
 992         case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
 993         case V4L2_CID_FLASH_FAULT:              return "Faults";
 994         case V4L2_CID_FLASH_CHARGE:             return "Charge";
 995         case V4L2_CID_FLASH_READY:              return "Ready to Strobe";
 996
 997         /* JPEG encoder controls */
 998         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 999         case V4L2_CID_JPEG_CLASS:               return "JPEG Compression Controls";
1000         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:  return "Chroma Subsampling";
1001         case V4L2_CID_JPEG_RESTART_INTERVAL:    return "Restart Interval";
1002         case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
1003         case V4L2_CID_JPEG_ACTIVE_MARKER:       return "Active Markers";
1004
1005         /* Image source controls */
1006         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1007         case V4L2_CID_IMAGE_SOURCE_CLASS:       return "Image Source Controls";
1008         case V4L2_CID_VBLANK:                   return "Vertical Blanking";
1009         case V4L2_CID_HBLANK:                   return "Horizontal Blanking";
1010         case V4L2_CID_ANALOGUE_GAIN:            return "Analogue Gain";
1011         case V4L2_CID_TEST_PATTERN_RED:         return "Red Pixel Value";
1012         case V4L2_CID_TEST_PATTERN_GREENR:      return "Green (Red) Pixel Value";
1013         case V4L2_CID_TEST_PATTERN_BLUE:        return "Blue Pixel Value";
1014         case V4L2_CID_TEST_PATTERN_GREENB:      return "Green (Blue) Pixel Value";
1015
1016         /* Image processing controls */
1017         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1018         case V4L2_CID_IMAGE_PROC_CLASS:         return "Image Processing Controls";
1019         case V4L2_CID_LINK_FREQ:                return "Link Frequency";
1020         case V4L2_CID_PIXEL_RATE:               return "Pixel Rate";
1021         case V4L2_CID_TEST_PATTERN:             return "Test Pattern";
1022         case V4L2_CID_DEINTERLACING_MODE:       return "Deinterlacing Mode";
1023         case V4L2_CID_DIGITAL_GAIN:             return "Digital Gain";
1024
1025         /* DV controls */
1026         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1027         case V4L2_CID_DV_CLASS:                 return "Digital Video Controls";
1028         case V4L2_CID_DV_TX_HOTPLUG:            return "Hotplug Present";
1029         case V4L2_CID_DV_TX_RXSENSE:            return "RxSense Present";
1030         case V4L2_CID_DV_TX_EDID_PRESENT:       return "EDID Present";
1031         case V4L2_CID_DV_TX_MODE:               return "Transmit Mode";
1032         case V4L2_CID_DV_TX_RGB_RANGE:          return "Tx RGB Quantization Range";
1033         case V4L2_CID_DV_TX_IT_CONTENT_TYPE:    return "Tx IT Content Type";
1034         case V4L2_CID_DV_RX_POWER_PRESENT:      return "Power Present";
1035         case V4L2_CID_DV_RX_RGB_RANGE:          return "Rx RGB Quantization Range";
1036         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:    return "Rx IT Content Type";
1037
1038         case V4L2_CID_FM_RX_CLASS:              return "FM Radio Receiver Controls";
1039         case V4L2_CID_TUNE_DEEMPHASIS:          return "De-Emphasis";
1040         case V4L2_CID_RDS_RECEPTION:            return "RDS Reception";
1041         case V4L2_CID_RF_TUNER_CLASS:           return "RF Tuner Controls";
1042         case V4L2_CID_RF_TUNER_RF_GAIN:         return "RF Gain";
1043         case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:   return "LNA Gain, Auto";
1044         case V4L2_CID_RF_TUNER_LNA_GAIN:        return "LNA Gain";
1045         case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO: return "Mixer Gain, Auto";
1046         case V4L2_CID_RF_TUNER_MIXER_GAIN:      return "Mixer Gain";
1047         case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:    return "IF Gain, Auto";
1048         case V4L2_CID_RF_TUNER_IF_GAIN:         return "IF Gain";
1049         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:  return "Bandwidth, Auto";
1050         case V4L2_CID_RF_TUNER_BANDWIDTH:       return "Bandwidth";
1051         case V4L2_CID_RF_TUNER_PLL_LOCK:        return "PLL Lock";
1052         case V4L2_CID_RDS_RX_PTY:               return "RDS Program Type";
1053         case V4L2_CID_RDS_RX_PS_NAME:           return "RDS PS Name";
1054         case V4L2_CID_RDS_RX_RADIO_TEXT:        return "RDS Radio Text";
1055         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
1056         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:   return "RDS Traffic Program";
1057         case V4L2_CID_RDS_RX_MUSIC_SPEECH:      return "RDS Music";
1058
1059         /* Detection controls */
1060         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1061         case V4L2_CID_DETECT_CLASS:             return "Detection Controls";
1062         case V4L2_CID_DETECT_MD_MODE:           return "Motion Detection Mode";
1063         case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: return "MD Global Threshold";
1064         case V4L2_CID_DETECT_MD_THRESHOLD_GRID: return "MD Threshold Grid";
1065         case V4L2_CID_DETECT_MD_REGION_GRID:    return "MD Region Grid";
1066         default:
1067                 return NULL;
1068         }
1069 }
1070 EXPORT_SYMBOL(v4l2_ctrl_get_name);
1071
1072 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
1073                     s64 *min, s64 *max, u64 *step, s64 *def, u32 *flags)
1074 {
1075         *name = v4l2_ctrl_get_name(id);
1076         *flags = 0;
1077
1078         switch (id) {
1079         case V4L2_CID_AUDIO_MUTE:
1080         case V4L2_CID_AUDIO_LOUDNESS:
1081         case V4L2_CID_AUTO_WHITE_BALANCE:
1082         case V4L2_CID_AUTOGAIN:
1083         case V4L2_CID_HFLIP:
1084         case V4L2_CID_VFLIP:
1085         case V4L2_CID_HUE_AUTO:
1086         case V4L2_CID_CHROMA_AGC:
1087         case V4L2_CID_COLOR_KILLER:
1088         case V4L2_CID_AUTOBRIGHTNESS:
1089         case V4L2_CID_MPEG_AUDIO_MUTE:
1090         case V4L2_CID_MPEG_VIDEO_MUTE:
1091         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1092         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1093         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
1094         case V4L2_CID_FOCUS_AUTO:
1095         case V4L2_CID_PRIVACY:
1096         case V4L2_CID_AUDIO_LIMITER_ENABLED:
1097         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1098         case V4L2_CID_PILOT_TONE_ENABLED:
1099         case V4L2_CID_ILLUMINATORS_1:
1100         case V4L2_CID_ILLUMINATORS_2:
1101         case V4L2_CID_FLASH_STROBE_STATUS:
1102         case V4L2_CID_FLASH_CHARGE:
1103         case V4L2_CID_FLASH_READY:
1104         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
1105         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
1106         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1107         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1108         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1109         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
1110         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
1111         case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
1112         case V4L2_CID_WIDE_DYNAMIC_RANGE:
1113         case V4L2_CID_IMAGE_STABILIZATION:
1114         case V4L2_CID_RDS_RECEPTION:
1115         case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
1116         case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
1117         case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:
1118         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1119         case V4L2_CID_RF_TUNER_PLL_LOCK:
1120         case V4L2_CID_RDS_TX_MONO_STEREO:
1121         case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
1122         case V4L2_CID_RDS_TX_COMPRESSED:
1123         case V4L2_CID_RDS_TX_DYNAMIC_PTY:
1124         case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
1125         case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
1126         case V4L2_CID_RDS_TX_MUSIC_SPEECH:
1127         case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
1128         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1129         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1130         case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1131                 *type = V4L2_CTRL_TYPE_BOOLEAN;
1132                 *min = 0;
1133                 *max = *step = 1;
1134                 break;
1135         case V4L2_CID_ROTATE:
1136                 *type = V4L2_CTRL_TYPE_INTEGER;
1137                 *flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
1138                 break;
1139         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
1140         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
1141                 *type = V4L2_CTRL_TYPE_INTEGER;
1142                 break;
1143         case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
1144         case V4L2_CID_PAN_RESET:
1145         case V4L2_CID_TILT_RESET:
1146         case V4L2_CID_FLASH_STROBE:
1147         case V4L2_CID_FLASH_STROBE_STOP:
1148         case V4L2_CID_AUTO_FOCUS_START:
1149         case V4L2_CID_AUTO_FOCUS_STOP:
1150                 *type = V4L2_CTRL_TYPE_BUTTON;
1151                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1152                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1153                 *min = *max = *step = *def = 0;
1154                 break;
1155         case V4L2_CID_POWER_LINE_FREQUENCY:
1156         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1157         case V4L2_CID_MPEG_AUDIO_ENCODING:
1158         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1159         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1160         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1161         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
1162         case V4L2_CID_MPEG_AUDIO_MODE:
1163         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1164         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1165         case V4L2_CID_MPEG_AUDIO_CRC:
1166         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
1167         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
1168         case V4L2_CID_MPEG_VIDEO_ENCODING:
1169         case V4L2_CID_MPEG_VIDEO_ASPECT:
1170         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1171         case V4L2_CID_MPEG_STREAM_TYPE:
1172         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1173         case V4L2_CID_EXPOSURE_AUTO:
1174         case V4L2_CID_AUTO_FOCUS_RANGE:
1175         case V4L2_CID_COLORFX:
1176         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1177         case V4L2_CID_TUNE_PREEMPHASIS:
1178         case V4L2_CID_FLASH_LED_MODE:
1179         case V4L2_CID_FLASH_STROBE_SOURCE:
1180         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1181         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1182         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1183         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1184         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1185         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1186         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1187         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1188         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1189         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1190         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1191         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1192         case V4L2_CID_ISO_SENSITIVITY_AUTO:
1193         case V4L2_CID_EXPOSURE_METERING:
1194         case V4L2_CID_SCENE_MODE:
1195         case V4L2_CID_DV_TX_MODE:
1196         case V4L2_CID_DV_TX_RGB_RANGE:
1197         case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
1198         case V4L2_CID_DV_RX_RGB_RANGE:
1199         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1200         case V4L2_CID_TEST_PATTERN:
1201         case V4L2_CID_DEINTERLACING_MODE:
1202         case V4L2_CID_TUNE_DEEMPHASIS:
1203         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1204         case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
1205         case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
1206         case V4L2_CID_DETECT_MD_MODE:
1207         case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
1208         case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
1209         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
1210         case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
1211         case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
1212         case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
1213         case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
1214                 *type = V4L2_CTRL_TYPE_MENU;
1215                 break;
1216         case V4L2_CID_LINK_FREQ:
1217                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1218                 break;
1219         case V4L2_CID_RDS_TX_PS_NAME:
1220         case V4L2_CID_RDS_TX_RADIO_TEXT:
1221         case V4L2_CID_RDS_RX_PS_NAME:
1222         case V4L2_CID_RDS_RX_RADIO_TEXT:
1223                 *type = V4L2_CTRL_TYPE_STRING;
1224                 break;
1225         case V4L2_CID_ISO_SENSITIVITY:
1226         case V4L2_CID_AUTO_EXPOSURE_BIAS:
1227         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1228         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1229                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1230                 break;
1231         case V4L2_CID_USER_CLASS:
1232         case V4L2_CID_CAMERA_CLASS:
1233         case V4L2_CID_MPEG_CLASS:
1234         case V4L2_CID_FM_TX_CLASS:
1235         case V4L2_CID_FLASH_CLASS:
1236         case V4L2_CID_JPEG_CLASS:
1237         case V4L2_CID_IMAGE_SOURCE_CLASS:
1238         case V4L2_CID_IMAGE_PROC_CLASS:
1239         case V4L2_CID_DV_CLASS:
1240         case V4L2_CID_FM_RX_CLASS:
1241         case V4L2_CID_RF_TUNER_CLASS:
1242         case V4L2_CID_DETECT_CLASS:
1243                 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
1244                 /* You can neither read not write these */
1245                 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1246                 *min = *max = *step = *def = 0;
1247                 break;
1248         case V4L2_CID_BG_COLOR:
1249                 *type = V4L2_CTRL_TYPE_INTEGER;
1250                 *step = 1;
1251                 *min = 0;
1252                 /* Max is calculated as RGB888 that is 2^24 */
1253                 *max = 0xFFFFFF;
1254                 break;
1255         case V4L2_CID_FLASH_FAULT:
1256         case V4L2_CID_JPEG_ACTIVE_MARKER:
1257         case V4L2_CID_3A_LOCK:
1258         case V4L2_CID_AUTO_FOCUS_STATUS:
1259         case V4L2_CID_DV_TX_HOTPLUG:
1260         case V4L2_CID_DV_TX_RXSENSE:
1261         case V4L2_CID_DV_TX_EDID_PRESENT:
1262         case V4L2_CID_DV_RX_POWER_PRESENT:
1263                 *type = V4L2_CTRL_TYPE_BITMASK;
1264                 break;
1265         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1266         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1267                 *type = V4L2_CTRL_TYPE_INTEGER;
1268                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1269                 break;
1270         case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1271                 *type = V4L2_CTRL_TYPE_INTEGER64;
1272                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1273                 *min = *def = 0;
1274                 *max = 0x1ffffffffLL;
1275                 *step = 1;
1276                 break;
1277         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1278                 *type = V4L2_CTRL_TYPE_INTEGER64;
1279                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1280                 *min = *def = 0;
1281                 *max = 0x7fffffffffffffffLL;
1282                 *step = 1;
1283                 break;
1284         case V4L2_CID_PIXEL_RATE:
1285                 *type = V4L2_CTRL_TYPE_INTEGER64;
1286                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1287                 break;
1288         case V4L2_CID_DETECT_MD_REGION_GRID:
1289                 *type = V4L2_CTRL_TYPE_U8;
1290                 break;
1291         case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
1292                 *type = V4L2_CTRL_TYPE_U16;
1293                 break;
1294         case V4L2_CID_RDS_TX_ALT_FREQS:
1295                 *type = V4L2_CTRL_TYPE_U32;
1296                 break;
1297         case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS:
1298                 *type = V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS;
1299                 break;
1300         case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION:
1301                 *type = V4L2_CTRL_TYPE_MPEG2_QUANTIZATION;
1302                 break;
1303         default:
1304                 *type = V4L2_CTRL_TYPE_INTEGER;
1305                 break;
1306         }
1307         switch (id) {
1308         case V4L2_CID_MPEG_AUDIO_ENCODING:
1309         case V4L2_CID_MPEG_AUDIO_MODE:
1310         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1311         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1312         case V4L2_CID_MPEG_STREAM_TYPE:
1313                 *flags |= V4L2_CTRL_FLAG_UPDATE;
1314                 break;
1315         case V4L2_CID_AUDIO_VOLUME:
1316         case V4L2_CID_AUDIO_BALANCE:
1317         case V4L2_CID_AUDIO_BASS:
1318         case V4L2_CID_AUDIO_TREBLE:
1319         case V4L2_CID_BRIGHTNESS:
1320         case V4L2_CID_CONTRAST:
1321         case V4L2_CID_SATURATION:
1322         case V4L2_CID_HUE:
1323         case V4L2_CID_RED_BALANCE:
1324         case V4L2_CID_BLUE_BALANCE:
1325         case V4L2_CID_GAMMA:
1326         case V4L2_CID_SHARPNESS:
1327         case V4L2_CID_CHROMA_GAIN:
1328         case V4L2_CID_RDS_TX_DEVIATION:
1329         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1330         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1331         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1332         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1333         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1334         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1335         case V4L2_CID_PILOT_TONE_DEVIATION:
1336         case V4L2_CID_PILOT_TONE_FREQUENCY:
1337         case V4L2_CID_TUNE_POWER_LEVEL:
1338         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1339         case V4L2_CID_RF_TUNER_RF_GAIN:
1340         case V4L2_CID_RF_TUNER_LNA_GAIN:
1341         case V4L2_CID_RF_TUNER_MIXER_GAIN:
1342         case V4L2_CID_RF_TUNER_IF_GAIN:
1343         case V4L2_CID_RF_TUNER_BANDWIDTH:
1344         case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
1345                 *flags |= V4L2_CTRL_FLAG_SLIDER;
1346                 break;
1347         case V4L2_CID_PAN_RELATIVE:
1348         case V4L2_CID_TILT_RELATIVE:
1349         case V4L2_CID_FOCUS_RELATIVE:
1350         case V4L2_CID_IRIS_RELATIVE:
1351         case V4L2_CID_ZOOM_RELATIVE:
1352                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1353                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1354                 break;
1355         case V4L2_CID_FLASH_STROBE_STATUS:
1356         case V4L2_CID_AUTO_FOCUS_STATUS:
1357         case V4L2_CID_FLASH_READY:
1358         case V4L2_CID_DV_TX_HOTPLUG:
1359         case V4L2_CID_DV_TX_RXSENSE:
1360         case V4L2_CID_DV_TX_EDID_PRESENT:
1361         case V4L2_CID_DV_RX_POWER_PRESENT:
1362         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1363         case V4L2_CID_RDS_RX_PTY:
1364         case V4L2_CID_RDS_RX_PS_NAME:
1365         case V4L2_CID_RDS_RX_RADIO_TEXT:
1366         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1367         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1368         case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1369                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1370                 break;
1371         case V4L2_CID_RF_TUNER_PLL_LOCK:
1372                 *flags |= V4L2_CTRL_FLAG_VOLATILE;
1373                 break;
1374         }
1375 }
1376 EXPORT_SYMBOL(v4l2_ctrl_fill);
1377
1378 static u32 user_flags(const struct v4l2_ctrl *ctrl)
1379 {
1380         u32 flags = ctrl->flags;
1381
1382         if (ctrl->is_ptr)
1383                 flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD;
1384
1385         return flags;
1386 }
1387
1388 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1389 {
1390         memset(ev->reserved, 0, sizeof(ev->reserved));
1391         ev->type = V4L2_EVENT_CTRL;
1392         ev->id = ctrl->id;
1393         ev->u.ctrl.changes = changes;
1394         ev->u.ctrl.type = ctrl->type;
1395         ev->u.ctrl.flags = user_flags(ctrl);
1396         if (ctrl->is_ptr)
1397                 ev->u.ctrl.value64 = 0;
1398         else
1399                 ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
1400         ev->u.ctrl.minimum = ctrl->minimum;
1401         ev->u.ctrl.maximum = ctrl->maximum;
1402         if (ctrl->type == V4L2_CTRL_TYPE_MENU
1403             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1404                 ev->u.ctrl.step = 1;
1405         else
1406                 ev->u.ctrl.step = ctrl->step;
1407         ev->u.ctrl.default_value = ctrl->default_value;
1408 }
1409
1410 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1411 {
1412         struct v4l2_event ev;
1413         struct v4l2_subscribed_event *sev;
1414
1415         if (list_empty(&ctrl->ev_subs))
1416                 return;
1417         fill_event(&ev, ctrl, changes);
1418
1419         list_for_each_entry(sev, &ctrl->ev_subs, node)
1420                 if (sev->fh != fh ||
1421                     (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1422                         v4l2_event_queue_fh(sev->fh, &ev);
1423 }
1424
1425 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
1426                       union v4l2_ctrl_ptr ptr1,
1427                       union v4l2_ctrl_ptr ptr2)
1428 {
1429         switch (ctrl->type) {
1430         case V4L2_CTRL_TYPE_BUTTON:
1431                 return false;
1432         case V4L2_CTRL_TYPE_STRING:
1433                 idx *= ctrl->elem_size;
1434                 /* strings are always 0-terminated */
1435                 return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
1436         case V4L2_CTRL_TYPE_INTEGER64:
1437                 return ptr1.p_s64[idx] == ptr2.p_s64[idx];
1438         case V4L2_CTRL_TYPE_U8:
1439                 return ptr1.p_u8[idx] == ptr2.p_u8[idx];
1440         case V4L2_CTRL_TYPE_U16:
1441                 return ptr1.p_u16[idx] == ptr2.p_u16[idx];
1442         case V4L2_CTRL_TYPE_U32:
1443                 return ptr1.p_u32[idx] == ptr2.p_u32[idx];
1444         default:
1445                 if (ctrl->is_int)
1446                         return ptr1.p_s32[idx] == ptr2.p_s32[idx];
1447                 idx *= ctrl->elem_size;
1448                 return !memcmp(ptr1.p + idx, ptr2.p + idx, ctrl->elem_size);
1449         }
1450 }
1451
1452 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
1453                      union v4l2_ctrl_ptr ptr)
1454 {
1455         switch (ctrl->type) {
1456         case V4L2_CTRL_TYPE_STRING:
1457                 idx *= ctrl->elem_size;
1458                 memset(ptr.p_char + idx, ' ', ctrl->minimum);
1459                 ptr.p_char[idx + ctrl->minimum] = '\0';
1460                 break;
1461         case V4L2_CTRL_TYPE_INTEGER64:
1462                 ptr.p_s64[idx] = ctrl->default_value;
1463                 break;
1464         case V4L2_CTRL_TYPE_INTEGER:
1465         case V4L2_CTRL_TYPE_INTEGER_MENU:
1466         case V4L2_CTRL_TYPE_MENU:
1467         case V4L2_CTRL_TYPE_BITMASK:
1468         case V4L2_CTRL_TYPE_BOOLEAN:
1469                 ptr.p_s32[idx] = ctrl->default_value;
1470                 break;
1471         case V4L2_CTRL_TYPE_U8:
1472                 ptr.p_u8[idx] = ctrl->default_value;
1473                 break;
1474         case V4L2_CTRL_TYPE_U16:
1475                 ptr.p_u16[idx] = ctrl->default_value;
1476                 break;
1477         case V4L2_CTRL_TYPE_U32:
1478                 ptr.p_u32[idx] = ctrl->default_value;
1479                 break;
1480         default:
1481                 idx *= ctrl->elem_size;
1482                 memset(ptr.p + idx, 0, ctrl->elem_size);
1483                 break;
1484         }
1485 }
1486
1487 static void std_log(const struct v4l2_ctrl *ctrl)
1488 {
1489         union v4l2_ctrl_ptr ptr = ctrl->p_cur;
1490
1491         if (ctrl->is_array) {
1492                 unsigned i;
1493
1494                 for (i = 0; i < ctrl->nr_of_dims; i++)
1495                         pr_cont("[%u]", ctrl->dims[i]);
1496                 pr_cont(" ");
1497         }
1498
1499         switch (ctrl->type) {
1500         case V4L2_CTRL_TYPE_INTEGER:
1501                 pr_cont("%d", *ptr.p_s32);
1502                 break;
1503         case V4L2_CTRL_TYPE_BOOLEAN:
1504                 pr_cont("%s", *ptr.p_s32 ? "true" : "false");
1505                 break;
1506         case V4L2_CTRL_TYPE_MENU:
1507                 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
1508                 break;
1509         case V4L2_CTRL_TYPE_INTEGER_MENU:
1510                 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
1511                 break;
1512         case V4L2_CTRL_TYPE_BITMASK:
1513                 pr_cont("0x%08x", *ptr.p_s32);
1514                 break;
1515         case V4L2_CTRL_TYPE_INTEGER64:
1516                 pr_cont("%lld", *ptr.p_s64);
1517                 break;
1518         case V4L2_CTRL_TYPE_STRING:
1519                 pr_cont("%s", ptr.p_char);
1520                 break;
1521         case V4L2_CTRL_TYPE_U8:
1522                 pr_cont("%u", (unsigned)*ptr.p_u8);
1523                 break;
1524         case V4L2_CTRL_TYPE_U16:
1525                 pr_cont("%u", (unsigned)*ptr.p_u16);
1526                 break;
1527         case V4L2_CTRL_TYPE_U32:
1528                 pr_cont("%u", (unsigned)*ptr.p_u32);
1529                 break;
1530         default:
1531                 pr_cont("unknown type %d", ctrl->type);
1532                 break;
1533         }
1534 }
1535
1536 /*
1537  * Round towards the closest legal value. Be careful when we are
1538  * close to the maximum range of the control type to prevent
1539  * wrap-arounds.
1540  */
1541 #define ROUND_TO_RANGE(val, offset_type, ctrl)                  \
1542 ({                                                              \
1543         offset_type offset;                                     \
1544         if ((ctrl)->maximum >= 0 &&                             \
1545             val >= (ctrl)->maximum - (s32)((ctrl)->step / 2))   \
1546                 val = (ctrl)->maximum;                          \
1547         else                                                    \
1548                 val += (s32)((ctrl)->step / 2);                 \
1549         val = clamp_t(typeof(val), val,                         \
1550                       (ctrl)->minimum, (ctrl)->maximum);        \
1551         offset = (val) - (ctrl)->minimum;                       \
1552         offset = (ctrl)->step * (offset / (u32)(ctrl)->step);   \
1553         val = (ctrl)->minimum + offset;                         \
1554         0;                                                      \
1555 })
1556
1557 /* Validate a new control */
1558 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
1559                         union v4l2_ctrl_ptr ptr)
1560 {
1561         struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
1562         size_t len;
1563         u64 offset;
1564         s64 val;
1565
1566         switch (ctrl->type) {
1567         case V4L2_CTRL_TYPE_INTEGER:
1568                 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
1569         case V4L2_CTRL_TYPE_INTEGER64:
1570                 /*
1571                  * We can't use the ROUND_TO_RANGE define here due to
1572                  * the u64 divide that needs special care.
1573                  */
1574                 val = ptr.p_s64[idx];
1575                 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
1576                         val = ctrl->maximum;
1577                 else
1578                         val += (s64)(ctrl->step / 2);
1579                 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
1580                 offset = val - ctrl->minimum;
1581                 do_div(offset, ctrl->step);
1582                 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
1583                 return 0;
1584         case V4L2_CTRL_TYPE_U8:
1585                 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
1586         case V4L2_CTRL_TYPE_U16:
1587                 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
1588         case V4L2_CTRL_TYPE_U32:
1589                 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
1590
1591         case V4L2_CTRL_TYPE_BOOLEAN:
1592                 ptr.p_s32[idx] = !!ptr.p_s32[idx];
1593                 return 0;
1594
1595         case V4L2_CTRL_TYPE_MENU:
1596         case V4L2_CTRL_TYPE_INTEGER_MENU:
1597                 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
1598                         return -ERANGE;
1599                 if (ctrl->menu_skip_mask & (1 << ptr.p_s32[idx]))
1600                         return -EINVAL;
1601                 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1602                     ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
1603                         return -EINVAL;
1604                 return 0;
1605
1606         case V4L2_CTRL_TYPE_BITMASK:
1607                 ptr.p_s32[idx] &= ctrl->maximum;
1608                 return 0;
1609
1610         case V4L2_CTRL_TYPE_BUTTON:
1611         case V4L2_CTRL_TYPE_CTRL_CLASS:
1612                 ptr.p_s32[idx] = 0;
1613                 return 0;
1614
1615         case V4L2_CTRL_TYPE_STRING:
1616                 idx *= ctrl->elem_size;
1617                 len = strlen(ptr.p_char + idx);
1618                 if (len < ctrl->minimum)
1619                         return -ERANGE;
1620                 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
1621                         return -ERANGE;
1622                 return 0;
1623
1624         case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
1625                 p_mpeg2_slice_params = ptr.p;
1626
1627                 switch (p_mpeg2_slice_params->sequence.chroma_format) {
1628                 case 1: /* 4:2:0 */
1629                 case 2: /* 4:2:2 */
1630                 case 3: /* 4:4:4 */
1631                         break;
1632                 default:
1633                         return -EINVAL;
1634                 }
1635
1636                 switch (p_mpeg2_slice_params->picture.intra_dc_precision) {
1637                 case 0: /* 8 bits */
1638                 case 1: /* 9 bits */
1639                 case 11: /* 11 bits */
1640                         break;
1641                 default:
1642                         return -EINVAL;
1643                 }
1644
1645                 switch (p_mpeg2_slice_params->picture.picture_structure) {
1646                 case 1: /* interlaced top field */
1647                 case 2: /* interlaced bottom field */
1648                 case 3: /* progressive */
1649                         break;
1650                 default:
1651                         return -EINVAL;
1652                 }
1653
1654                 switch (p_mpeg2_slice_params->picture.picture_coding_type) {
1655                 case V4L2_MPEG2_PICTURE_CODING_TYPE_I:
1656                 case V4L2_MPEG2_PICTURE_CODING_TYPE_P:
1657                 case V4L2_MPEG2_PICTURE_CODING_TYPE_B:
1658                         break;
1659                 default:
1660                         return -EINVAL;
1661                 }
1662
1663                 if (p_mpeg2_slice_params->backward_ref_index >= VIDEO_MAX_FRAME ||
1664                     p_mpeg2_slice_params->forward_ref_index >= VIDEO_MAX_FRAME)
1665                         return -EINVAL;
1666
1667                 if (p_mpeg2_slice_params->pad ||
1668                     p_mpeg2_slice_params->picture.pad ||
1669                     p_mpeg2_slice_params->sequence.pad)
1670                         return -EINVAL;
1671
1672                 return 0;
1673
1674         case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION:
1675                 return 0;
1676
1677         default:
1678                 return -EINVAL;
1679         }
1680 }
1681
1682 static const struct v4l2_ctrl_type_ops std_type_ops = {
1683         .equal = std_equal,
1684         .init = std_init,
1685         .log = std_log,
1686         .validate = std_validate,
1687 };
1688
1689 /* Helper function: copy the given control value back to the caller */
1690 static int ptr_to_user(struct v4l2_ext_control *c,
1691                        struct v4l2_ctrl *ctrl,
1692                        union v4l2_ctrl_ptr ptr)
1693 {
1694         u32 len;
1695
1696         if (ctrl->is_ptr && !ctrl->is_string)
1697                 return copy_to_user(c->ptr, ptr.p, c->size) ?
1698                        -EFAULT : 0;
1699
1700         switch (ctrl->type) {
1701         case V4L2_CTRL_TYPE_STRING:
1702                 len = strlen(ptr.p_char);
1703                 if (c->size < len + 1) {
1704                         c->size = ctrl->elem_size;
1705                         return -ENOSPC;
1706                 }
1707                 return copy_to_user(c->string, ptr.p_char, len + 1) ?
1708                        -EFAULT : 0;
1709         case V4L2_CTRL_TYPE_INTEGER64:
1710                 c->value64 = *ptr.p_s64;
1711                 break;
1712         default:
1713                 c->value = *ptr.p_s32;
1714                 break;
1715         }
1716         return 0;
1717 }
1718
1719 /* Helper function: copy the current control value back to the caller */
1720 static int cur_to_user(struct v4l2_ext_control *c,
1721                        struct v4l2_ctrl *ctrl)
1722 {
1723         return ptr_to_user(c, ctrl, ctrl->p_cur);
1724 }
1725
1726 /* Helper function: copy the new control value back to the caller */
1727 static int new_to_user(struct v4l2_ext_control *c,
1728                        struct v4l2_ctrl *ctrl)
1729 {
1730         return ptr_to_user(c, ctrl, ctrl->p_new);
1731 }
1732
1733 /* Helper function: copy the request value back to the caller */
1734 static int req_to_user(struct v4l2_ext_control *c,
1735                        struct v4l2_ctrl_ref *ref)
1736 {
1737         return ptr_to_user(c, ref->ctrl, ref->p_req);
1738 }
1739
1740 /* Helper function: copy the initial control value back to the caller */
1741 static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
1742 {
1743         int idx;
1744
1745         for (idx = 0; idx < ctrl->elems; idx++)
1746                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
1747
1748         return ptr_to_user(c, ctrl, ctrl->p_new);
1749 }
1750
1751 /* Helper function: copy the caller-provider value to the given control value */
1752 static int user_to_ptr(struct v4l2_ext_control *c,
1753                        struct v4l2_ctrl *ctrl,
1754                        union v4l2_ctrl_ptr ptr)
1755 {
1756         int ret;
1757         u32 size;
1758
1759         ctrl->is_new = 1;
1760         if (ctrl->is_ptr && !ctrl->is_string) {
1761                 unsigned idx;
1762
1763                 ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0;
1764                 if (ret || !ctrl->is_array)
1765                         return ret;
1766                 for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++)
1767                         ctrl->type_ops->init(ctrl, idx, ptr);
1768                 return 0;
1769         }
1770
1771         switch (ctrl->type) {
1772         case V4L2_CTRL_TYPE_INTEGER64:
1773                 *ptr.p_s64 = c->value64;
1774                 break;
1775         case V4L2_CTRL_TYPE_STRING:
1776                 size = c->size;
1777                 if (size == 0)
1778                         return -ERANGE;
1779                 if (size > ctrl->maximum + 1)
1780                         size = ctrl->maximum + 1;
1781                 ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0;
1782                 if (!ret) {
1783                         char last = ptr.p_char[size - 1];
1784
1785                         ptr.p_char[size - 1] = 0;
1786                         /* If the string was longer than ctrl->maximum,
1787                            then return an error. */
1788                         if (strlen(ptr.p_char) == ctrl->maximum && last)
1789                                 return -ERANGE;
1790                 }
1791                 return ret;
1792         default:
1793                 *ptr.p_s32 = c->value;
1794                 break;
1795         }
1796         return 0;
1797 }
1798
1799 /* Helper function: copy the caller-provider value as the new control value */
1800 static int user_to_new(struct v4l2_ext_control *c,
1801                        struct v4l2_ctrl *ctrl)
1802 {
1803         return user_to_ptr(c, ctrl, ctrl->p_new);
1804 }
1805
1806 /* Copy the one value to another. */
1807 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
1808                        union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
1809 {
1810         if (ctrl == NULL)
1811                 return;
1812         memcpy(to.p, from.p, ctrl->elems * ctrl->elem_size);
1813 }
1814
1815 /* Copy the new value to the current value. */
1816 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1817 {
1818         bool changed;
1819
1820         if (ctrl == NULL)
1821                 return;
1822
1823         /* has_changed is set by cluster_changed */
1824         changed = ctrl->has_changed;
1825         if (changed)
1826                 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
1827
1828         if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1829                 /* Note: CH_FLAGS is only set for auto clusters. */
1830                 ctrl->flags &=
1831                         ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1832                 if (!is_cur_manual(ctrl->cluster[0])) {
1833                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1834                         if (ctrl->cluster[0]->has_volatiles)
1835                                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1836                 }
1837                 fh = NULL;
1838         }
1839         if (changed || ch_flags) {
1840                 /* If a control was changed that was not one of the controls
1841                    modified by the application, then send the event to all. */
1842                 if (!ctrl->is_new)
1843                         fh = NULL;
1844                 send_event(fh, ctrl,
1845                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1846                 if (ctrl->call_notify && changed && ctrl->handler->notify)
1847                         ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1848         }
1849 }
1850
1851 /* Copy the current value to the new value */
1852 static void cur_to_new(struct v4l2_ctrl *ctrl)
1853 {
1854         if (ctrl == NULL)
1855                 return;
1856         ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1857 }
1858
1859 /* Copy the new value to the request value */
1860 static void new_to_req(struct v4l2_ctrl_ref *ref)
1861 {
1862         if (!ref)
1863                 return;
1864         ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req);
1865         ref->req = ref;
1866 }
1867
1868 /* Copy the request value to the new value */
1869 static void req_to_new(struct v4l2_ctrl_ref *ref)
1870 {
1871         if (!ref)
1872                 return;
1873         if (ref->req)
1874                 ptr_to_ptr(ref->ctrl, ref->req->p_req, ref->ctrl->p_new);
1875         else
1876                 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new);
1877 }
1878
1879 /* Return non-zero if one or more of the controls in the cluster has a new
1880    value that differs from the current value. */
1881 static int cluster_changed(struct v4l2_ctrl *master)
1882 {
1883         bool changed = false;
1884         unsigned idx;
1885         int i;
1886
1887         for (i = 0; i < master->ncontrols; i++) {
1888                 struct v4l2_ctrl *ctrl = master->cluster[i];
1889                 bool ctrl_changed = false;
1890
1891                 if (ctrl == NULL)
1892                         continue;
1893
1894                 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE)
1895                         changed = ctrl_changed = true;
1896
1897                 /*
1898                  * Set has_changed to false to avoid generating
1899                  * the event V4L2_EVENT_CTRL_CH_VALUE
1900                  */
1901                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
1902                         ctrl->has_changed = false;
1903                         continue;
1904                 }
1905
1906                 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1907                         ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1908                                 ctrl->p_cur, ctrl->p_new);
1909                 ctrl->has_changed = ctrl_changed;
1910                 changed |= ctrl->has_changed;
1911         }
1912         return changed;
1913 }
1914
1915 /* Control range checking */
1916 static int check_range(enum v4l2_ctrl_type type,
1917                 s64 min, s64 max, u64 step, s64 def)
1918 {
1919         switch (type) {
1920         case V4L2_CTRL_TYPE_BOOLEAN:
1921                 if (step != 1 || max > 1 || min < 0)
1922                         return -ERANGE;
1923                 /* fall through */
1924         case V4L2_CTRL_TYPE_U8:
1925         case V4L2_CTRL_TYPE_U16:
1926         case V4L2_CTRL_TYPE_U32:
1927         case V4L2_CTRL_TYPE_INTEGER:
1928         case V4L2_CTRL_TYPE_INTEGER64:
1929                 if (step == 0 || min > max || def < min || def > max)
1930                         return -ERANGE;
1931                 return 0;
1932         case V4L2_CTRL_TYPE_BITMASK:
1933                 if (step || min || !max || (def & ~max))
1934                         return -ERANGE;
1935                 return 0;
1936         case V4L2_CTRL_TYPE_MENU:
1937         case V4L2_CTRL_TYPE_INTEGER_MENU:
1938                 if (min > max || def < min || def > max)
1939                         return -ERANGE;
1940                 /* Note: step == menu_skip_mask for menu controls.
1941                    So here we check if the default value is masked out. */
1942                 if (step && ((1 << def) & step))
1943                         return -EINVAL;
1944                 return 0;
1945         case V4L2_CTRL_TYPE_STRING:
1946                 if (min > max || min < 0 || step < 1 || def)
1947                         return -ERANGE;
1948                 return 0;
1949         default:
1950                 return 0;
1951         }
1952 }
1953
1954 /* Validate a new control */
1955 static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
1956 {
1957         unsigned idx;
1958         int err = 0;
1959
1960         for (idx = 0; !err && idx < ctrl->elems; idx++)
1961                 err = ctrl->type_ops->validate(ctrl, idx, p_new);
1962         return err;
1963 }
1964
1965 static inline u32 node2id(struct list_head *node)
1966 {
1967         return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1968 }
1969
1970 /* Set the handler's error code if it wasn't set earlier already */
1971 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1972 {
1973         if (hdl->error == 0)
1974                 hdl->error = err;
1975         return err;
1976 }
1977
1978 /* Initialize the handler */
1979 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1980                                  unsigned nr_of_controls_hint,
1981                                  struct lock_class_key *key, const char *name)
1982 {
1983         mutex_init(&hdl->_lock);
1984         hdl->lock = &hdl->_lock;
1985         lockdep_set_class_and_name(hdl->lock, key, name);
1986         INIT_LIST_HEAD(&hdl->ctrls);
1987         INIT_LIST_HEAD(&hdl->ctrl_refs);
1988         INIT_LIST_HEAD(&hdl->requests);
1989         INIT_LIST_HEAD(&hdl->requests_queued);
1990         hdl->request_is_queued = false;
1991         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1992         hdl->buckets = kvmalloc_array(hdl->nr_of_buckets,
1993                                       sizeof(hdl->buckets[0]),
1994                                       GFP_KERNEL | __GFP_ZERO);
1995         hdl->error = hdl->buckets ? 0 : -ENOMEM;
1996         media_request_object_init(&hdl->req_obj);
1997         return hdl->error;
1998 }
1999 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
2000
2001 /* Free all controls and control refs */
2002 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
2003 {
2004         struct v4l2_ctrl_ref *ref, *next_ref;
2005         struct v4l2_ctrl *ctrl, *next_ctrl;
2006         struct v4l2_subscribed_event *sev, *next_sev;
2007
2008         if (hdl == NULL || hdl->buckets == NULL)
2009                 return;
2010
2011         if (!hdl->req_obj.req && !list_empty(&hdl->requests)) {
2012                 struct v4l2_ctrl_handler *req, *next_req;
2013
2014                 list_for_each_entry_safe(req, next_req, &hdl->requests, requests) {
2015                         media_request_object_unbind(&req->req_obj);
2016                         media_request_object_put(&req->req_obj);
2017                 }
2018         }
2019         mutex_lock(hdl->lock);
2020         /* Free all nodes */
2021         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
2022                 list_del(&ref->node);
2023                 kfree(ref);
2024         }
2025         /* Free all controls owned by the handler */
2026         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
2027                 list_del(&ctrl->node);
2028                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
2029                         list_del(&sev->node);
2030                 kvfree(ctrl);
2031         }
2032         kvfree(hdl->buckets);
2033         hdl->buckets = NULL;
2034         hdl->cached = NULL;
2035         hdl->error = 0;
2036         mutex_unlock(hdl->lock);
2037         mutex_destroy(&hdl->_lock);
2038 }
2039 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
2040
2041 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
2042    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
2043    with applications that do not use the NEXT_CTRL flag.
2044
2045    We just find the n-th private user control. It's O(N), but that should not
2046    be an issue in this particular case. */
2047 static struct v4l2_ctrl_ref *find_private_ref(
2048                 struct v4l2_ctrl_handler *hdl, u32 id)
2049 {
2050         struct v4l2_ctrl_ref *ref;
2051
2052         id -= V4L2_CID_PRIVATE_BASE;
2053         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2054                 /* Search for private user controls that are compatible with
2055                    VIDIOC_G/S_CTRL. */
2056                 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
2057                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
2058                         if (!ref->ctrl->is_int)
2059                                 continue;
2060                         if (id == 0)
2061                                 return ref;
2062                         id--;
2063                 }
2064         }
2065         return NULL;
2066 }
2067
2068 /* Find a control with the given ID. */
2069 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
2070 {
2071         struct v4l2_ctrl_ref *ref;
2072         int bucket;
2073
2074         id &= V4L2_CTRL_ID_MASK;
2075
2076         /* Old-style private controls need special handling */
2077         if (id >= V4L2_CID_PRIVATE_BASE)
2078                 return find_private_ref(hdl, id);
2079         bucket = id % hdl->nr_of_buckets;
2080
2081         /* Simple optimization: cache the last control found */
2082         if (hdl->cached && hdl->cached->ctrl->id == id)
2083                 return hdl->cached;
2084
2085         /* Not in cache, search the hash */
2086         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
2087         while (ref && ref->ctrl->id != id)
2088                 ref = ref->next;
2089
2090         if (ref)
2091                 hdl->cached = ref; /* cache it! */
2092         return ref;
2093 }
2094
2095 /* Find a control with the given ID. Take the handler's lock first. */
2096 static struct v4l2_ctrl_ref *find_ref_lock(
2097                 struct v4l2_ctrl_handler *hdl, u32 id)
2098 {
2099         struct v4l2_ctrl_ref *ref = NULL;
2100
2101         if (hdl) {
2102                 mutex_lock(hdl->lock);
2103                 ref = find_ref(hdl, id);
2104                 mutex_unlock(hdl->lock);
2105         }
2106         return ref;
2107 }
2108
2109 /* Find a control with the given ID. */
2110 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
2111 {
2112         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
2113
2114         return ref ? ref->ctrl : NULL;
2115 }
2116 EXPORT_SYMBOL(v4l2_ctrl_find);
2117
2118 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
2119 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
2120                            struct v4l2_ctrl *ctrl,
2121                            struct v4l2_ctrl_ref **ctrl_ref,
2122                            bool from_other_dev, bool allocate_req)
2123 {
2124         struct v4l2_ctrl_ref *ref;
2125         struct v4l2_ctrl_ref *new_ref;
2126         u32 id = ctrl->id;
2127         u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
2128         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
2129         unsigned int size_extra_req = 0;
2130
2131         if (ctrl_ref)
2132                 *ctrl_ref = NULL;
2133
2134         /*
2135          * Automatically add the control class if it is not yet present and
2136          * the new control is not a compound control.
2137          */
2138         if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
2139             id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
2140                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
2141                         return hdl->error;
2142
2143         if (hdl->error)
2144                 return hdl->error;
2145
2146         if (allocate_req)
2147                 size_extra_req = ctrl->elems * ctrl->elem_size;
2148         new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL);
2149         if (!new_ref)
2150                 return handler_set_err(hdl, -ENOMEM);
2151         new_ref->ctrl = ctrl;
2152         new_ref->from_other_dev = from_other_dev;
2153         if (size_extra_req)
2154                 new_ref->p_req.p = &new_ref[1];
2155
2156         if (ctrl->handler == hdl) {
2157                 /* By default each control starts in a cluster of its own.
2158                    new_ref->ctrl is basically a cluster array with one
2159                    element, so that's perfect to use as the cluster pointer.
2160                    But only do this for the handler that owns the control. */
2161                 ctrl->cluster = &new_ref->ctrl;
2162                 ctrl->ncontrols = 1;
2163         }
2164
2165         INIT_LIST_HEAD(&new_ref->node);
2166
2167         mutex_lock(hdl->lock);
2168
2169         /* Add immediately at the end of the list if the list is empty, or if
2170            the last element in the list has a lower ID.
2171            This ensures that when elements are added in ascending order the
2172            insertion is an O(1) operation. */
2173         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
2174                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
2175                 goto insert_in_hash;
2176         }
2177
2178         /* Find insert position in sorted list */
2179         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2180                 if (ref->ctrl->id < id)
2181                         continue;
2182                 /* Don't add duplicates */
2183                 if (ref->ctrl->id == id) {
2184                         kfree(new_ref);
2185                         goto unlock;
2186                 }
2187                 list_add(&new_ref->node, ref->node.prev);
2188                 break;
2189         }
2190
2191 insert_in_hash:
2192         /* Insert the control node in the hash */
2193         new_ref->next = hdl->buckets[bucket];
2194         hdl->buckets[bucket] = new_ref;
2195         if (ctrl_ref)
2196                 *ctrl_ref = new_ref;
2197
2198 unlock:
2199         mutex_unlock(hdl->lock);
2200         return 0;
2201 }
2202
2203 /* Add a new control */
2204 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
2205                         const struct v4l2_ctrl_ops *ops,
2206                         const struct v4l2_ctrl_type_ops *type_ops,
2207                         u32 id, const char *name, enum v4l2_ctrl_type type,
2208                         s64 min, s64 max, u64 step, s64 def,
2209                         const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
2210                         u32 flags, const char * const *qmenu,
2211                         const s64 *qmenu_int, void *priv)
2212 {
2213         struct v4l2_ctrl *ctrl;
2214         unsigned sz_extra;
2215         unsigned nr_of_dims = 0;
2216         unsigned elems = 1;
2217         bool is_array;
2218         unsigned tot_ctrl_size;
2219         unsigned idx;
2220         void *data;
2221         int err;
2222
2223         if (hdl->error)
2224                 return NULL;
2225
2226         while (dims && dims[nr_of_dims]) {
2227                 elems *= dims[nr_of_dims];
2228                 nr_of_dims++;
2229                 if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
2230                         break;
2231         }
2232         is_array = nr_of_dims > 0;
2233
2234         /* Prefill elem_size for all types handled by std_type_ops */
2235         switch (type) {
2236         case V4L2_CTRL_TYPE_INTEGER64:
2237                 elem_size = sizeof(s64);
2238                 break;
2239         case V4L2_CTRL_TYPE_STRING:
2240                 elem_size = max + 1;
2241                 break;
2242         case V4L2_CTRL_TYPE_U8:
2243                 elem_size = sizeof(u8);
2244                 break;
2245         case V4L2_CTRL_TYPE_U16:
2246                 elem_size = sizeof(u16);
2247                 break;
2248         case V4L2_CTRL_TYPE_U32:
2249                 elem_size = sizeof(u32);
2250                 break;
2251         case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
2252                 elem_size = sizeof(struct v4l2_ctrl_mpeg2_slice_params);
2253                 break;
2254         case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION:
2255                 elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantization);
2256                 break;
2257         default:
2258                 if (type < V4L2_CTRL_COMPOUND_TYPES)
2259                         elem_size = sizeof(s32);
2260                 break;
2261         }
2262         tot_ctrl_size = elem_size * elems;
2263
2264         /* Sanity checks */
2265         if (id == 0 || name == NULL || !elem_size ||
2266             id >= V4L2_CID_PRIVATE_BASE ||
2267             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
2268             (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
2269                 handler_set_err(hdl, -ERANGE);
2270                 return NULL;
2271         }
2272         err = check_range(type, min, max, step, def);
2273         if (err) {
2274                 handler_set_err(hdl, err);
2275                 return NULL;
2276         }
2277         if (is_array &&
2278             (type == V4L2_CTRL_TYPE_BUTTON ||
2279              type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
2280                 handler_set_err(hdl, -EINVAL);
2281                 return NULL;
2282         }
2283
2284         sz_extra = 0;
2285         if (type == V4L2_CTRL_TYPE_BUTTON)
2286                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
2287                         V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
2288         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
2289                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
2290         else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
2291                  type == V4L2_CTRL_TYPE_STRING ||
2292                  type >= V4L2_CTRL_COMPOUND_TYPES ||
2293                  is_array)
2294                 sz_extra += 2 * tot_ctrl_size;
2295
2296         ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
2297         if (ctrl == NULL) {
2298                 handler_set_err(hdl, -ENOMEM);
2299                 return NULL;
2300         }
2301
2302         INIT_LIST_HEAD(&ctrl->node);
2303         INIT_LIST_HEAD(&ctrl->ev_subs);
2304         ctrl->handler = hdl;
2305         ctrl->ops = ops;
2306         ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
2307         ctrl->id = id;
2308         ctrl->name = name;
2309         ctrl->type = type;
2310         ctrl->flags = flags;
2311         ctrl->minimum = min;
2312         ctrl->maximum = max;
2313         ctrl->step = step;
2314         ctrl->default_value = def;
2315         ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
2316         ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
2317         ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
2318         ctrl->is_array = is_array;
2319         ctrl->elems = elems;
2320         ctrl->nr_of_dims = nr_of_dims;
2321         if (nr_of_dims)
2322                 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
2323         ctrl->elem_size = elem_size;
2324         if (type == V4L2_CTRL_TYPE_MENU)
2325                 ctrl->qmenu = qmenu;
2326         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2327                 ctrl->qmenu_int = qmenu_int;
2328         ctrl->priv = priv;
2329         ctrl->cur.val = ctrl->val = def;
2330         data = &ctrl[1];
2331
2332         if (!ctrl->is_int) {
2333                 ctrl->p_new.p = data;
2334                 ctrl->p_cur.p = data + tot_ctrl_size;
2335         } else {
2336                 ctrl->p_new.p = &ctrl->val;
2337                 ctrl->p_cur.p = &ctrl->cur.val;
2338         }
2339         for (idx = 0; idx < elems; idx++) {
2340                 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
2341                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2342         }
2343
2344         if (handler_new_ref(hdl, ctrl, NULL, false, false)) {
2345                 kvfree(ctrl);
2346                 return NULL;
2347         }
2348         mutex_lock(hdl->lock);
2349         list_add_tail(&ctrl->node, &hdl->ctrls);
2350         mutex_unlock(hdl->lock);
2351         return ctrl;
2352 }
2353
2354 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
2355                         const struct v4l2_ctrl_config *cfg, void *priv)
2356 {
2357         bool is_menu;
2358         struct v4l2_ctrl *ctrl;
2359         const char *name = cfg->name;
2360         const char * const *qmenu = cfg->qmenu;
2361         const s64 *qmenu_int = cfg->qmenu_int;
2362         enum v4l2_ctrl_type type = cfg->type;
2363         u32 flags = cfg->flags;
2364         s64 min = cfg->min;
2365         s64 max = cfg->max;
2366         u64 step = cfg->step;
2367         s64 def = cfg->def;
2368
2369         if (name == NULL)
2370                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
2371                                                                 &def, &flags);
2372
2373         is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
2374                    cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
2375         if (is_menu)
2376                 WARN_ON(step);
2377         else
2378                 WARN_ON(cfg->menu_skip_mask);
2379         if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
2380                 qmenu = v4l2_ctrl_get_menu(cfg->id);
2381         else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
2382                  qmenu_int == NULL) {
2383                 handler_set_err(hdl, -EINVAL);
2384                 return NULL;
2385         }
2386
2387         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
2388                         type, min, max,
2389                         is_menu ? cfg->menu_skip_mask : step, def,
2390                         cfg->dims, cfg->elem_size,
2391                         flags, qmenu, qmenu_int, priv);
2392         if (ctrl)
2393                 ctrl->is_private = cfg->is_private;
2394         return ctrl;
2395 }
2396 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
2397
2398 /* Helper function for standard non-menu controls */
2399 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
2400                         const struct v4l2_ctrl_ops *ops,
2401                         u32 id, s64 min, s64 max, u64 step, s64 def)
2402 {
2403         const char *name;
2404         enum v4l2_ctrl_type type;
2405         u32 flags;
2406
2407         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2408         if (type == V4L2_CTRL_TYPE_MENU ||
2409             type == V4L2_CTRL_TYPE_INTEGER_MENU ||
2410             type >= V4L2_CTRL_COMPOUND_TYPES) {
2411                 handler_set_err(hdl, -EINVAL);
2412                 return NULL;
2413         }
2414         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2415                              min, max, step, def, NULL, 0,
2416                              flags, NULL, NULL, NULL);
2417 }
2418 EXPORT_SYMBOL(v4l2_ctrl_new_std);
2419
2420 /* Helper function for standard menu controls */
2421 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
2422                         const struct v4l2_ctrl_ops *ops,
2423                         u32 id, u8 _max, u64 mask, u8 _def)
2424 {
2425         const char * const *qmenu = NULL;
2426         const s64 *qmenu_int = NULL;
2427         unsigned int qmenu_int_len = 0;
2428         const char *name;
2429         enum v4l2_ctrl_type type;
2430         s64 min;
2431         s64 max = _max;
2432         s64 def = _def;
2433         u64 step;
2434         u32 flags;
2435
2436         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2437
2438         if (type == V4L2_CTRL_TYPE_MENU)
2439                 qmenu = v4l2_ctrl_get_menu(id);
2440         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2441                 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
2442
2443         if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
2444                 handler_set_err(hdl, -EINVAL);
2445                 return NULL;
2446         }
2447         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2448                              0, max, mask, def, NULL, 0,
2449                              flags, qmenu, qmenu_int, NULL);
2450 }
2451 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
2452
2453 /* Helper function for standard menu controls with driver defined menu */
2454 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
2455                         const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
2456                         u64 mask, u8 _def, const char * const *qmenu)
2457 {
2458         enum v4l2_ctrl_type type;
2459         const char *name;
2460         u32 flags;
2461         u64 step;
2462         s64 min;
2463         s64 max = _max;
2464         s64 def = _def;
2465
2466         /* v4l2_ctrl_new_std_menu_items() should only be called for
2467          * standard controls without a standard menu.
2468          */
2469         if (v4l2_ctrl_get_menu(id)) {
2470                 handler_set_err(hdl, -EINVAL);
2471                 return NULL;
2472         }
2473
2474         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2475         if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
2476                 handler_set_err(hdl, -EINVAL);
2477                 return NULL;
2478         }
2479         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2480                              0, max, mask, def, NULL, 0,
2481                              flags, qmenu, NULL, NULL);
2482
2483 }
2484 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
2485
2486 /* Helper function for standard integer menu controls */
2487 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
2488                         const struct v4l2_ctrl_ops *ops,
2489                         u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
2490 {
2491         const char *name;
2492         enum v4l2_ctrl_type type;
2493         s64 min;
2494         u64 step;
2495         s64 max = _max;
2496         s64 def = _def;
2497         u32 flags;
2498
2499         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2500         if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
2501                 handler_set_err(hdl, -EINVAL);
2502                 return NULL;
2503         }
2504         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2505                              0, max, 0, def, NULL, 0,
2506                              flags, NULL, qmenu_int, NULL);
2507 }
2508 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
2509
2510 /* Add the controls from another handler to our own. */
2511 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
2512                           struct v4l2_ctrl_handler *add,
2513                           bool (*filter)(const struct v4l2_ctrl *ctrl),
2514                           bool from_other_dev)
2515 {
2516         struct v4l2_ctrl_ref *ref;
2517         int ret = 0;
2518
2519         /* Do nothing if either handler is NULL or if they are the same */
2520         if (!hdl || !add || hdl == add)
2521                 return 0;
2522         if (hdl->error)
2523                 return hdl->error;
2524         mutex_lock(add->lock);
2525         list_for_each_entry(ref, &add->ctrl_refs, node) {
2526                 struct v4l2_ctrl *ctrl = ref->ctrl;
2527
2528                 /* Skip handler-private controls. */
2529                 if (ctrl->is_private)
2530                         continue;
2531                 /* And control classes */
2532                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2533                         continue;
2534                 /* Filter any unwanted controls */
2535                 if (filter && !filter(ctrl))
2536                         continue;
2537                 ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false);
2538                 if (ret)
2539                         break;
2540         }
2541         mutex_unlock(add->lock);
2542         return ret;
2543 }
2544 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
2545
2546 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
2547 {
2548         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
2549                 return true;
2550         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
2551                 return true;
2552         switch (ctrl->id) {
2553         case V4L2_CID_AUDIO_MUTE:
2554         case V4L2_CID_AUDIO_VOLUME:
2555         case V4L2_CID_AUDIO_BALANCE:
2556         case V4L2_CID_AUDIO_BASS:
2557         case V4L2_CID_AUDIO_TREBLE:
2558         case V4L2_CID_AUDIO_LOUDNESS:
2559                 return true;
2560         default:
2561                 break;
2562         }
2563         return false;
2564 }
2565 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
2566
2567 /* Cluster controls */
2568 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
2569 {
2570         bool has_volatiles = false;
2571         int i;
2572
2573         /* The first control is the master control and it must not be NULL */
2574         if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
2575                 return;
2576
2577         for (i = 0; i < ncontrols; i++) {
2578                 if (controls[i]) {
2579                         controls[i]->cluster = controls;
2580                         controls[i]->ncontrols = ncontrols;
2581                         if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
2582                                 has_volatiles = true;
2583                 }
2584         }
2585         controls[0]->has_volatiles = has_volatiles;
2586 }
2587 EXPORT_SYMBOL(v4l2_ctrl_cluster);
2588
2589 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
2590                             u8 manual_val, bool set_volatile)
2591 {
2592         struct v4l2_ctrl *master = controls[0];
2593         u32 flag = 0;
2594         int i;
2595
2596         v4l2_ctrl_cluster(ncontrols, controls);
2597         WARN_ON(ncontrols <= 1);
2598         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
2599         WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
2600         master->is_auto = true;
2601         master->has_volatiles = set_volatile;
2602         master->manual_mode_value = manual_val;
2603         master->flags |= V4L2_CTRL_FLAG_UPDATE;
2604
2605         if (!is_cur_manual(master))
2606                 flag = V4L2_CTRL_FLAG_INACTIVE |
2607                         (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
2608
2609         for (i = 1; i < ncontrols; i++)
2610                 if (controls[i])
2611                         controls[i]->flags |= flag;
2612 }
2613 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
2614
2615 /* Activate/deactivate a control. */
2616 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
2617 {
2618         /* invert since the actual flag is called 'inactive' */
2619         bool inactive = !active;
2620         bool old;
2621
2622         if (ctrl == NULL)
2623                 return;
2624
2625         if (inactive)
2626                 /* set V4L2_CTRL_FLAG_INACTIVE */
2627                 old = test_and_set_bit(4, &ctrl->flags);
2628         else
2629                 /* clear V4L2_CTRL_FLAG_INACTIVE */
2630                 old = test_and_clear_bit(4, &ctrl->flags);
2631         if (old != inactive)
2632                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2633 }
2634 EXPORT_SYMBOL(v4l2_ctrl_activate);
2635
2636 void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
2637 {
2638         bool old;
2639
2640         if (ctrl == NULL)
2641                 return;
2642
2643         lockdep_assert_held(ctrl->handler->lock);
2644
2645         if (grabbed)
2646                 /* set V4L2_CTRL_FLAG_GRABBED */
2647                 old = test_and_set_bit(1, &ctrl->flags);
2648         else
2649                 /* clear V4L2_CTRL_FLAG_GRABBED */
2650                 old = test_and_clear_bit(1, &ctrl->flags);
2651         if (old != grabbed)
2652                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2653 }
2654 EXPORT_SYMBOL(__v4l2_ctrl_grab);
2655
2656 /* Log the control name and value */
2657 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2658                      const char *prefix, const char *colon)
2659 {
2660         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2661                 return;
2662         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2663                 return;
2664
2665         pr_info("%s%s%s: ", prefix, colon, ctrl->name);
2666
2667         ctrl->type_ops->log(ctrl);
2668
2669         if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2670                            V4L2_CTRL_FLAG_GRABBED |
2671                            V4L2_CTRL_FLAG_VOLATILE)) {
2672                 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2673                         pr_cont(" inactive");
2674                 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2675                         pr_cont(" grabbed");
2676                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2677                         pr_cont(" volatile");
2678         }
2679         pr_cont("\n");
2680 }
2681
2682 /* Log all controls owned by the handler */
2683 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2684                                   const char *prefix)
2685 {
2686         struct v4l2_ctrl *ctrl;
2687         const char *colon = "";
2688         int len;
2689
2690         if (hdl == NULL)
2691                 return;
2692         if (prefix == NULL)
2693                 prefix = "";
2694         len = strlen(prefix);
2695         if (len && prefix[len - 1] != ' ')
2696                 colon = ": ";
2697         mutex_lock(hdl->lock);
2698         list_for_each_entry(ctrl, &hdl->ctrls, node)
2699                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2700                         log_ctrl(ctrl, prefix, colon);
2701         mutex_unlock(hdl->lock);
2702 }
2703 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2704
2705 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2706 {
2707         v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2708         return 0;
2709 }
2710 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2711
2712 /* Call s_ctrl for all controls owned by the handler */
2713 int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2714 {
2715         struct v4l2_ctrl *ctrl;
2716         int ret = 0;
2717
2718         if (hdl == NULL)
2719                 return 0;
2720
2721         lockdep_assert_held(hdl->lock);
2722
2723         list_for_each_entry(ctrl, &hdl->ctrls, node)
2724                 ctrl->done = false;
2725
2726         list_for_each_entry(ctrl, &hdl->ctrls, node) {
2727                 struct v4l2_ctrl *master = ctrl->cluster[0];
2728                 int i;
2729
2730                 /* Skip if this control was already handled by a cluster. */
2731                 /* Skip button controls and read-only controls. */
2732                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2733                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2734                         continue;
2735
2736                 for (i = 0; i < master->ncontrols; i++) {
2737                         if (master->cluster[i]) {
2738                                 cur_to_new(master->cluster[i]);
2739                                 master->cluster[i]->is_new = 1;
2740                                 master->cluster[i]->done = true;
2741                         }
2742                 }
2743                 ret = call_op(master, s_ctrl);
2744                 if (ret)
2745                         break;
2746         }
2747
2748         return ret;
2749 }
2750 EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup);
2751
2752 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2753 {
2754         int ret;
2755
2756         if (hdl == NULL)
2757                 return 0;
2758
2759         mutex_lock(hdl->lock);
2760         ret = __v4l2_ctrl_handler_setup(hdl);
2761         mutex_unlock(hdl->lock);
2762
2763         return ret;
2764 }
2765 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2766
2767 /* Implement VIDIOC_QUERY_EXT_CTRL */
2768 int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
2769 {
2770         const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
2771         u32 id = qc->id & V4L2_CTRL_ID_MASK;
2772         struct v4l2_ctrl_ref *ref;
2773         struct v4l2_ctrl *ctrl;
2774
2775         if (hdl == NULL)
2776                 return -EINVAL;
2777
2778         mutex_lock(hdl->lock);
2779
2780         /* Try to find it */
2781         ref = find_ref(hdl, id);
2782
2783         if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
2784                 bool is_compound;
2785                 /* Match any control that is not hidden */
2786                 unsigned mask = 1;
2787                 bool match = false;
2788
2789                 if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
2790                         /* Match any hidden control */
2791                         match = true;
2792                 } else if ((qc->id & next_flags) == next_flags) {
2793                         /* Match any control, compound or not */
2794                         mask = 0;
2795                 }
2796
2797                 /* Find the next control with ID > qc->id */
2798
2799                 /* Did we reach the end of the control list? */
2800                 if (id >= node2id(hdl->ctrl_refs.prev)) {
2801                         ref = NULL; /* Yes, so there is no next control */
2802                 } else if (ref) {
2803                         /* We found a control with the given ID, so just get
2804                            the next valid one in the list. */
2805                         list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
2806                                 is_compound = ref->ctrl->is_array ||
2807                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2808                                 if (id < ref->ctrl->id &&
2809                                     (is_compound & mask) == match)
2810                                         break;
2811                         }
2812                         if (&ref->node == &hdl->ctrl_refs)
2813                                 ref = NULL;
2814                 } else {
2815                         /* No control with the given ID exists, so start
2816                            searching for the next largest ID. We know there
2817                            is one, otherwise the first 'if' above would have
2818                            been true. */
2819                         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2820                                 is_compound = ref->ctrl->is_array ||
2821                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2822                                 if (id < ref->ctrl->id &&
2823                                     (is_compound & mask) == match)
2824                                         break;
2825                         }
2826                         if (&ref->node == &hdl->ctrl_refs)
2827                                 ref = NULL;
2828                 }
2829         }
2830         mutex_unlock(hdl->lock);
2831
2832         if (!ref)
2833                 return -EINVAL;
2834
2835         ctrl = ref->ctrl;
2836         memset(qc, 0, sizeof(*qc));
2837         if (id >= V4L2_CID_PRIVATE_BASE)
2838                 qc->id = id;
2839         else
2840                 qc->id = ctrl->id;
2841         strscpy(qc->name, ctrl->name, sizeof(qc->name));
2842         qc->flags = user_flags(ctrl);
2843         qc->type = ctrl->type;
2844         qc->elem_size = ctrl->elem_size;
2845         qc->elems = ctrl->elems;
2846         qc->nr_of_dims = ctrl->nr_of_dims;
2847         memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
2848         qc->minimum = ctrl->minimum;
2849         qc->maximum = ctrl->maximum;
2850         qc->default_value = ctrl->default_value;
2851         if (ctrl->type == V4L2_CTRL_TYPE_MENU
2852             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2853                 qc->step = 1;
2854         else
2855                 qc->step = ctrl->step;
2856         return 0;
2857 }
2858 EXPORT_SYMBOL(v4l2_query_ext_ctrl);
2859
2860 /* Implement VIDIOC_QUERYCTRL */
2861 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2862 {
2863         struct v4l2_query_ext_ctrl qec = { qc->id };
2864         int rc;
2865
2866         rc = v4l2_query_ext_ctrl(hdl, &qec);
2867         if (rc)
2868                 return rc;
2869
2870         qc->id = qec.id;
2871         qc->type = qec.type;
2872         qc->flags = qec.flags;
2873         strscpy(qc->name, qec.name, sizeof(qc->name));
2874         switch (qc->type) {
2875         case V4L2_CTRL_TYPE_INTEGER:
2876         case V4L2_CTRL_TYPE_BOOLEAN:
2877         case V4L2_CTRL_TYPE_MENU:
2878         case V4L2_CTRL_TYPE_INTEGER_MENU:
2879         case V4L2_CTRL_TYPE_STRING:
2880         case V4L2_CTRL_TYPE_BITMASK:
2881                 qc->minimum = qec.minimum;
2882                 qc->maximum = qec.maximum;
2883                 qc->step = qec.step;
2884                 qc->default_value = qec.default_value;
2885                 break;
2886         default:
2887                 qc->minimum = 0;
2888                 qc->maximum = 0;
2889                 qc->step = 0;
2890                 qc->default_value = 0;
2891                 break;
2892         }
2893         return 0;
2894 }
2895 EXPORT_SYMBOL(v4l2_queryctrl);
2896
2897 /* Implement VIDIOC_QUERYMENU */
2898 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2899 {
2900         struct v4l2_ctrl *ctrl;
2901         u32 i = qm->index;
2902
2903         ctrl = v4l2_ctrl_find(hdl, qm->id);
2904         if (!ctrl)
2905                 return -EINVAL;
2906
2907         qm->reserved = 0;
2908         /* Sanity checks */
2909         switch (ctrl->type) {
2910         case V4L2_CTRL_TYPE_MENU:
2911                 if (ctrl->qmenu == NULL)
2912                         return -EINVAL;
2913                 break;
2914         case V4L2_CTRL_TYPE_INTEGER_MENU:
2915                 if (ctrl->qmenu_int == NULL)
2916                         return -EINVAL;
2917                 break;
2918         default:
2919                 return -EINVAL;
2920         }
2921
2922         if (i < ctrl->minimum || i > ctrl->maximum)
2923                 return -EINVAL;
2924
2925         /* Use mask to see if this menu item should be skipped */
2926         if (ctrl->menu_skip_mask & (1 << i))
2927                 return -EINVAL;
2928         /* Empty menu items should also be skipped */
2929         if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2930                 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2931                         return -EINVAL;
2932                 strscpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2933         } else {
2934                 qm->value = ctrl->qmenu_int[i];
2935         }
2936         return 0;
2937 }
2938 EXPORT_SYMBOL(v4l2_querymenu);
2939
2940 static int v4l2_ctrl_request_clone(struct v4l2_ctrl_handler *hdl,
2941                                    const struct v4l2_ctrl_handler *from)
2942 {
2943         struct v4l2_ctrl_ref *ref;
2944         int err = 0;
2945
2946         if (WARN_ON(!hdl || hdl == from))
2947                 return -EINVAL;
2948
2949         if (hdl->error)
2950                 return hdl->error;
2951
2952         WARN_ON(hdl->lock != &hdl->_lock);
2953
2954         mutex_lock(from->lock);
2955         list_for_each_entry(ref, &from->ctrl_refs, node) {
2956                 struct v4l2_ctrl *ctrl = ref->ctrl;
2957                 struct v4l2_ctrl_ref *new_ref;
2958
2959                 /* Skip refs inherited from other devices */
2960                 if (ref->from_other_dev)
2961                         continue;
2962                 /* And buttons */
2963                 if (ctrl->type == V4L2_CTRL_TYPE_BUTTON)
2964                         continue;
2965                 err = handler_new_ref(hdl, ctrl, &new_ref, false, true);
2966                 if (err)
2967                         break;
2968         }
2969         mutex_unlock(from->lock);
2970         return err;
2971 }
2972
2973 static void v4l2_ctrl_request_queue(struct media_request_object *obj)
2974 {
2975         struct v4l2_ctrl_handler *hdl =
2976                 container_of(obj, struct v4l2_ctrl_handler, req_obj);
2977         struct v4l2_ctrl_handler *main_hdl = obj->priv;
2978         struct v4l2_ctrl_handler *prev_hdl = NULL;
2979         struct v4l2_ctrl_ref *ref_ctrl, *ref_ctrl_prev = NULL;
2980
2981         if (list_empty(&main_hdl->requests_queued))
2982                 goto queue;
2983
2984         prev_hdl = list_last_entry(&main_hdl->requests_queued,
2985                                    struct v4l2_ctrl_handler, requests_queued);
2986         /*
2987          * Note: prev_hdl and hdl must contain the same list of control
2988          * references, so if any differences are detected then that is a
2989          * driver bug and the WARN_ON is triggered.
2990          */
2991         mutex_lock(prev_hdl->lock);
2992         ref_ctrl_prev = list_first_entry(&prev_hdl->ctrl_refs,
2993                                          struct v4l2_ctrl_ref, node);
2994         list_for_each_entry(ref_ctrl, &hdl->ctrl_refs, node) {
2995                 if (ref_ctrl->req)
2996                         continue;
2997                 while (ref_ctrl_prev->ctrl->id < ref_ctrl->ctrl->id) {
2998                         /* Should never happen, but just in case... */
2999                         if (list_is_last(&ref_ctrl_prev->node,
3000                                          &prev_hdl->ctrl_refs))
3001                                 break;
3002                         ref_ctrl_prev = list_next_entry(ref_ctrl_prev, node);
3003                 }
3004                 if (WARN_ON(ref_ctrl_prev->ctrl->id != ref_ctrl->ctrl->id))
3005                         break;
3006                 ref_ctrl->req = ref_ctrl_prev->req;
3007         }
3008         mutex_unlock(prev_hdl->lock);
3009 queue:
3010         list_add_tail(&hdl->requests_queued, &main_hdl->requests_queued);
3011         hdl->request_is_queued = true;
3012 }
3013
3014 static void v4l2_ctrl_request_unbind(struct media_request_object *obj)
3015 {
3016         struct v4l2_ctrl_handler *hdl =
3017                 container_of(obj, struct v4l2_ctrl_handler, req_obj);
3018
3019         list_del_init(&hdl->requests);
3020         if (hdl->request_is_queued) {
3021                 list_del_init(&hdl->requests_queued);
3022                 hdl->request_is_queued = false;
3023         }
3024 }
3025
3026 static void v4l2_ctrl_request_release(struct media_request_object *obj)
3027 {
3028         struct v4l2_ctrl_handler *hdl =
3029                 container_of(obj, struct v4l2_ctrl_handler, req_obj);
3030
3031         v4l2_ctrl_handler_free(hdl);
3032         kfree(hdl);
3033 }
3034
3035 static const struct media_request_object_ops req_ops = {
3036         .queue = v4l2_ctrl_request_queue,
3037         .unbind = v4l2_ctrl_request_unbind,
3038         .release = v4l2_ctrl_request_release,
3039 };
3040
3041 struct v4l2_ctrl_handler *v4l2_ctrl_request_hdl_find(struct media_request *req,
3042                                         struct v4l2_ctrl_handler *parent)
3043 {
3044         struct media_request_object *obj;
3045
3046         if (WARN_ON(req->state != MEDIA_REQUEST_STATE_VALIDATING &&
3047                     req->state != MEDIA_REQUEST_STATE_QUEUED))
3048                 return NULL;
3049
3050         obj = media_request_object_find(req, &req_ops, parent);
3051         if (obj)
3052                 return container_of(obj, struct v4l2_ctrl_handler, req_obj);
3053         return NULL;
3054 }
3055 EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_find);
3056
3057 struct v4l2_ctrl *
3058 v4l2_ctrl_request_hdl_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
3059 {
3060         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
3061
3062         return (ref && ref->req == ref) ? ref->ctrl : NULL;
3063 }
3064 EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_ctrl_find);
3065
3066 static int v4l2_ctrl_request_bind(struct media_request *req,
3067                            struct v4l2_ctrl_handler *hdl,
3068                            struct v4l2_ctrl_handler *from)
3069 {
3070         int ret;
3071
3072         ret = v4l2_ctrl_request_clone(hdl, from);
3073
3074         if (!ret) {
3075                 ret = media_request_object_bind(req, &req_ops,
3076                                                 from, false, &hdl->req_obj);
3077                 if (!ret)
3078                         list_add_tail(&hdl->requests, &from->requests);
3079         }
3080         return ret;
3081 }
3082
3083 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
3084
3085    It is not a fully atomic operation, just best-effort only. After all, if
3086    multiple controls have to be set through multiple i2c writes (for example)
3087    then some initial writes may succeed while others fail. Thus leaving the
3088    system in an inconsistent state. The question is how much effort you are
3089    willing to spend on trying to make something atomic that really isn't.
3090
3091    From the point of view of an application the main requirement is that
3092    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
3093    error should be returned without actually affecting any controls.
3094
3095    If all the values are correct, then it is acceptable to just give up
3096    in case of low-level errors.
3097
3098    It is important though that the application can tell when only a partial
3099    configuration was done. The way we do that is through the error_idx field
3100    of struct v4l2_ext_controls: if that is equal to the count field then no
3101    controls were affected. Otherwise all controls before that index were
3102    successful in performing their 'get' or 'set' operation, the control at
3103    the given index failed, and you don't know what happened with the controls
3104    after the failed one. Since if they were part of a control cluster they
3105    could have been successfully processed (if a cluster member was encountered
3106    at index < error_idx), they could have failed (if a cluster member was at
3107    error_idx), or they may not have been processed yet (if the first cluster
3108    member appeared after error_idx).
3109
3110    It is all fairly theoretical, though. In practice all you can do is to
3111    bail out. If error_idx == count, then it is an application bug. If
3112    error_idx < count then it is only an application bug if the error code was
3113    EBUSY. That usually means that something started streaming just when you
3114    tried to set the controls. In all other cases it is a driver/hardware
3115    problem and all you can do is to retry or bail out.
3116
3117    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
3118    never modifies controls the error_idx is just set to whatever control
3119    has an invalid value.
3120  */
3121
3122 /* Prepare for the extended g/s/try functions.
3123    Find the controls in the control array and do some basic checks. */
3124 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
3125                              struct v4l2_ext_controls *cs,
3126                              struct v4l2_ctrl_helper *helpers,
3127                              bool get)
3128 {
3129         struct v4l2_ctrl_helper *h;
3130         bool have_clusters = false;
3131         u32 i;
3132
3133         for (i = 0, h = helpers; i < cs->count; i++, h++) {
3134                 struct v4l2_ext_control *c = &cs->controls[i];
3135                 struct v4l2_ctrl_ref *ref;
3136                 struct v4l2_ctrl *ctrl;
3137                 u32 id = c->id & V4L2_CTRL_ID_MASK;
3138
3139                 cs->error_idx = i;
3140
3141                 if (cs->which &&
3142                     cs->which != V4L2_CTRL_WHICH_DEF_VAL &&
3143                     cs->which != V4L2_CTRL_WHICH_REQUEST_VAL &&
3144                     V4L2_CTRL_ID2WHICH(id) != cs->which)
3145                         return -EINVAL;
3146
3147                 /* Old-style private controls are not allowed for
3148                    extended controls */
3149                 if (id >= V4L2_CID_PRIVATE_BASE)
3150                         return -EINVAL;
3151                 ref = find_ref_lock(hdl, id);
3152                 if (ref == NULL)
3153                         return -EINVAL;
3154                 h->ref = ref;
3155                 ctrl = ref->ctrl;
3156                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
3157                         return -EINVAL;
3158
3159                 if (ctrl->cluster[0]->ncontrols > 1)
3160                         have_clusters = true;
3161                 if (ctrl->cluster[0] != ctrl)
3162                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
3163                 if (ctrl->is_ptr && !ctrl->is_string) {
3164                         unsigned tot_size = ctrl->elems * ctrl->elem_size;
3165
3166                         if (c->size < tot_size) {
3167                                 if (get) {
3168                                         c->size = tot_size;
3169                                         return -ENOSPC;
3170                                 }
3171                                 return -EFAULT;
3172                         }
3173                         c->size = tot_size;
3174                 }
3175                 /* Store the ref to the master control of the cluster */
3176                 h->mref = ref;
3177                 /* Initially set next to 0, meaning that there is no other
3178                    control in this helper array belonging to the same
3179                    cluster */
3180                 h->next = 0;
3181         }
3182
3183         /* We are done if there were no controls that belong to a multi-
3184            control cluster. */
3185         if (!have_clusters)
3186                 return 0;
3187
3188         /* The code below figures out in O(n) time which controls in the list
3189            belong to the same cluster. */
3190
3191         /* This has to be done with the handler lock taken. */
3192         mutex_lock(hdl->lock);
3193
3194         /* First zero the helper field in the master control references */
3195         for (i = 0; i < cs->count; i++)
3196                 helpers[i].mref->helper = NULL;
3197         for (i = 0, h = helpers; i < cs->count; i++, h++) {
3198                 struct v4l2_ctrl_ref *mref = h->mref;
3199
3200                 /* If the mref->helper is set, then it points to an earlier
3201                    helper that belongs to the same cluster. */
3202                 if (mref->helper) {
3203                         /* Set the next field of mref->helper to the current
3204                            index: this means that that earlier helper now
3205                            points to the next helper in the same cluster. */
3206                         mref->helper->next = i;
3207                         /* mref should be set only for the first helper in the
3208                            cluster, clear the others. */
3209                         h->mref = NULL;
3210                 }
3211                 /* Point the mref helper to the current helper struct. */
3212                 mref->helper = h;
3213         }
3214         mutex_unlock(hdl->lock);
3215         return 0;
3216 }
3217
3218 /* Handles the corner case where cs->count == 0. It checks whether the
3219    specified control class exists. If that class ID is 0, then it checks
3220    whether there are any controls at all. */
3221 static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
3222 {
3223         if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL ||
3224             which == V4L2_CTRL_WHICH_REQUEST_VAL)
3225                 return 0;
3226         return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
3227 }
3228
3229 /* Get extended controls. Allocates the helpers array if needed. */
3230 static int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
3231                                    struct v4l2_ext_controls *cs)
3232 {
3233         struct v4l2_ctrl_helper helper[4];
3234         struct v4l2_ctrl_helper *helpers = helper;
3235         int ret;
3236         int i, j;
3237         bool def_value;
3238
3239         def_value = (cs->which == V4L2_CTRL_WHICH_DEF_VAL);
3240
3241         cs->error_idx = cs->count;
3242         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
3243
3244         if (hdl == NULL)
3245                 return -EINVAL;
3246
3247         if (cs->count == 0)
3248                 return class_check(hdl, cs->which);
3249
3250         if (cs->count > ARRAY_SIZE(helper)) {
3251                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
3252                                          GFP_KERNEL);
3253                 if (helpers == NULL)
3254                         return -ENOMEM;
3255         }
3256
3257         ret = prepare_ext_ctrls(hdl, cs, helpers, true);
3258         cs->error_idx = cs->count;
3259
3260         for (i = 0; !ret && i < cs->count; i++)
3261                 if (helpers[i].ref->ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
3262                         ret = -EACCES;
3263
3264         for (i = 0; !ret && i < cs->count; i++) {
3265                 int (*ctrl_to_user)(struct v4l2_ext_control *c,
3266                                     struct v4l2_ctrl *ctrl);
3267                 struct v4l2_ctrl *master;
3268
3269                 ctrl_to_user = def_value ? def_to_user : cur_to_user;
3270
3271                 if (helpers[i].mref == NULL)
3272                         continue;
3273
3274                 master = helpers[i].mref->ctrl;
3275                 cs->error_idx = i;
3276
3277                 v4l2_ctrl_lock(master);
3278
3279                 /* g_volatile_ctrl will update the new control values */
3280                 if (!def_value &&
3281                     ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
3282                     (master->has_volatiles && !is_cur_manual(master)))) {
3283                         for (j = 0; j < master->ncontrols; j++)
3284                                 cur_to_new(master->cluster[j]);
3285                         ret = call_op(master, g_volatile_ctrl);
3286                         ctrl_to_user = new_to_user;
3287                 }
3288                 /* If OK, then copy the current (for non-volatile controls)
3289                    or the new (for volatile controls) control values to the
3290                    caller */
3291                 if (!ret) {
3292                         u32 idx = i;
3293
3294                         do {
3295                                 if (helpers[idx].ref->req)
3296                                         ret = req_to_user(cs->controls + idx,
3297                                                 helpers[idx].ref->req);
3298                                 else
3299                                         ret = ctrl_to_user(cs->controls + idx,
3300                                                 helpers[idx].ref->ctrl);
3301                                 idx = helpers[idx].next;
3302                         } while (!ret && idx);
3303                 }
3304                 v4l2_ctrl_unlock(master);
3305         }
3306
3307         if (cs->count > ARRAY_SIZE(helper))
3308                 kvfree(helpers);
3309         return ret;
3310 }
3311
3312 static struct media_request_object *
3313 v4l2_ctrls_find_req_obj(struct v4l2_ctrl_handler *hdl,
3314                         struct media_request *req, bool set)
3315 {
3316         struct media_request_object *obj;
3317         struct v4l2_ctrl_handler *new_hdl;
3318         int ret;
3319
3320         if (IS_ERR(req))
3321                 return ERR_CAST(req);
3322
3323         if (set && WARN_ON(req->state != MEDIA_REQUEST_STATE_UPDATING))
3324                 return ERR_PTR(-EBUSY);
3325
3326         obj = media_request_object_find(req, &req_ops, hdl);
3327         if (obj)
3328                 return obj;
3329         if (!set)
3330                 return ERR_PTR(-ENOENT);
3331
3332         new_hdl = kzalloc(sizeof(*new_hdl), GFP_KERNEL);
3333         if (!new_hdl)
3334                 return ERR_PTR(-ENOMEM);
3335
3336         obj = &new_hdl->req_obj;
3337         ret = v4l2_ctrl_handler_init(new_hdl, (hdl->nr_of_buckets - 1) * 8);
3338         if (!ret)
3339                 ret = v4l2_ctrl_request_bind(req, new_hdl, hdl);
3340         if (ret) {
3341                 kfree(new_hdl);
3342
3343                 return ERR_PTR(ret);
3344         }
3345
3346         media_request_object_get(obj);
3347         return obj;
3348 }
3349
3350 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct media_device *mdev,
3351                      struct v4l2_ext_controls *cs)
3352 {
3353         struct media_request_object *obj = NULL;
3354         struct media_request *req = NULL;
3355         int ret;
3356
3357         if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) {
3358                 if (!mdev || cs->request_fd < 0)
3359                         return -EINVAL;
3360
3361                 req = media_request_get_by_fd(mdev, cs->request_fd);
3362                 if (IS_ERR(req))
3363                         return PTR_ERR(req);
3364
3365                 if (req->state != MEDIA_REQUEST_STATE_COMPLETE) {
3366                         media_request_put(req);
3367                         return -EACCES;
3368                 }
3369
3370                 ret = media_request_lock_for_access(req);
3371                 if (ret) {
3372                         media_request_put(req);
3373                         return ret;
3374                 }
3375
3376                 obj = v4l2_ctrls_find_req_obj(hdl, req, false);
3377                 if (IS_ERR(obj)) {
3378                         media_request_unlock_for_access(req);
3379                         media_request_put(req);
3380                         return PTR_ERR(obj);
3381                 }
3382
3383                 hdl = container_of(obj, struct v4l2_ctrl_handler,
3384                                    req_obj);
3385         }
3386
3387         ret = v4l2_g_ext_ctrls_common(hdl, cs);
3388
3389         if (obj) {
3390                 media_request_unlock_for_access(req);
3391                 media_request_object_put(obj);
3392                 media_request_put(req);
3393         }
3394         return ret;
3395 }
3396 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
3397
3398 /* Helper function to get a single control */
3399 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
3400 {
3401         struct v4l2_ctrl *master = ctrl->cluster[0];
3402         int ret = 0;
3403         int i;
3404
3405         /* Compound controls are not supported. The new_to_user() and
3406          * cur_to_user() calls below would need to be modified not to access
3407          * userspace memory when called from get_ctrl().
3408          */
3409         if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64)
3410                 return -EINVAL;
3411
3412         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
3413                 return -EACCES;
3414
3415         v4l2_ctrl_lock(master);
3416         /* g_volatile_ctrl will update the current control values */
3417         if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
3418                 for (i = 0; i < master->ncontrols; i++)
3419                         cur_to_new(master->cluster[i]);
3420                 ret = call_op(master, g_volatile_ctrl);
3421                 new_to_user(c, ctrl);
3422         } else {
3423                 cur_to_user(c, ctrl);
3424         }
3425         v4l2_ctrl_unlock(master);
3426         return ret;
3427 }
3428
3429 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
3430 {
3431         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3432         struct v4l2_ext_control c;
3433         int ret;
3434
3435         if (ctrl == NULL || !ctrl->is_int)
3436                 return -EINVAL;
3437         ret = get_ctrl(ctrl, &c);
3438         control->value = c.value;
3439         return ret;
3440 }
3441 EXPORT_SYMBOL(v4l2_g_ctrl);
3442
3443 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
3444 {
3445         struct v4l2_ext_control c;
3446
3447         /* It's a driver bug if this happens. */
3448         WARN_ON(!ctrl->is_int);
3449         c.value = 0;
3450         get_ctrl(ctrl, &c);
3451         return c.value;
3452 }
3453 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
3454
3455 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
3456 {
3457         struct v4l2_ext_control c;
3458
3459         /* It's a driver bug if this happens. */
3460         WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
3461         c.value64 = 0;
3462         get_ctrl(ctrl, &c);
3463         return c.value64;
3464 }
3465 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
3466
3467
3468 /* Core function that calls try/s_ctrl and ensures that the new value is
3469    copied to the current value on a set.
3470    Must be called with ctrl->handler->lock held. */
3471 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
3472                               bool set, u32 ch_flags)
3473 {
3474         bool update_flag;
3475         int ret;
3476         int i;
3477
3478         /* Go through the cluster and either validate the new value or
3479            (if no new value was set), copy the current value to the new
3480            value, ensuring a consistent view for the control ops when
3481            called. */
3482         for (i = 0; i < master->ncontrols; i++) {
3483                 struct v4l2_ctrl *ctrl = master->cluster[i];
3484
3485                 if (ctrl == NULL)
3486                         continue;
3487
3488                 if (!ctrl->is_new) {
3489                         cur_to_new(ctrl);
3490                         continue;
3491                 }
3492                 /* Check again: it may have changed since the
3493                    previous check in try_or_set_ext_ctrls(). */
3494                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3495                         return -EBUSY;
3496         }
3497
3498         ret = call_op(master, try_ctrl);
3499
3500         /* Don't set if there is no change */
3501         if (ret || !set || !cluster_changed(master))
3502                 return ret;
3503         ret = call_op(master, s_ctrl);
3504         if (ret)
3505                 return ret;
3506
3507         /* If OK, then make the new values permanent. */
3508         update_flag = is_cur_manual(master) != is_new_manual(master);
3509
3510         for (i = 0; i < master->ncontrols; i++) {
3511                 /*
3512                  * If we switch from auto to manual mode, and this cluster
3513                  * contains volatile controls, then all non-master controls
3514                  * have to be marked as changed. The 'new' value contains
3515                  * the volatile value (obtained by update_from_auto_cluster),
3516                  * which now has to become the current value.
3517                  */
3518                 if (i && update_flag && is_new_manual(master) &&
3519                     master->has_volatiles && master->cluster[i])
3520                         master->cluster[i]->has_changed = true;
3521
3522                 new_to_cur(fh, master->cluster[i], ch_flags |
3523                         ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
3524         }
3525         return 0;
3526 }
3527
3528 /* Validate controls. */
3529 static int validate_ctrls(struct v4l2_ext_controls *cs,
3530                           struct v4l2_ctrl_helper *helpers, bool set)
3531 {
3532         unsigned i;
3533         int ret = 0;
3534
3535         cs->error_idx = cs->count;
3536         for (i = 0; i < cs->count; i++) {
3537                 struct v4l2_ctrl *ctrl = helpers[i].ref->ctrl;
3538                 union v4l2_ctrl_ptr p_new;
3539
3540                 cs->error_idx = i;
3541
3542                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3543                         return -EACCES;
3544                 /* This test is also done in try_set_control_cluster() which
3545                    is called in atomic context, so that has the final say,
3546                    but it makes sense to do an up-front check as well. Once
3547                    an error occurs in try_set_control_cluster() some other
3548                    controls may have been set already and we want to do a
3549                    best-effort to avoid that. */
3550                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3551                         return -EBUSY;
3552                 /*
3553                  * Skip validation for now if the payload needs to be copied
3554                  * from userspace into kernelspace. We'll validate those later.
3555                  */
3556                 if (ctrl->is_ptr)
3557                         continue;
3558                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3559                         p_new.p_s64 = &cs->controls[i].value64;
3560                 else
3561                         p_new.p_s32 = &cs->controls[i].value;
3562                 ret = validate_new(ctrl, p_new);
3563                 if (ret)
3564                         return ret;
3565         }
3566         return 0;
3567 }
3568
3569 /* Obtain the current volatile values of an autocluster and mark them
3570    as new. */
3571 static void update_from_auto_cluster(struct v4l2_ctrl *master)
3572 {
3573         int i;
3574
3575         for (i = 1; i < master->ncontrols; i++)
3576                 cur_to_new(master->cluster[i]);
3577         if (!call_op(master, g_volatile_ctrl))
3578                 for (i = 1; i < master->ncontrols; i++)
3579                         if (master->cluster[i])
3580                                 master->cluster[i]->is_new = 1;
3581 }
3582
3583 /* Try or try-and-set controls */
3584 static int try_set_ext_ctrls_common(struct v4l2_fh *fh,
3585                                     struct v4l2_ctrl_handler *hdl,
3586                                     struct v4l2_ext_controls *cs, bool set)
3587 {
3588         struct v4l2_ctrl_helper helper[4];
3589         struct v4l2_ctrl_helper *helpers = helper;
3590         unsigned i, j;
3591         int ret;
3592
3593         cs->error_idx = cs->count;
3594
3595         /* Default value cannot be changed */
3596         if (cs->which == V4L2_CTRL_WHICH_DEF_VAL)
3597                 return -EINVAL;
3598
3599         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
3600
3601         if (hdl == NULL)
3602                 return -EINVAL;
3603
3604         if (cs->count == 0)
3605                 return class_check(hdl, cs->which);
3606
3607         if (cs->count > ARRAY_SIZE(helper)) {
3608                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
3609                                          GFP_KERNEL);
3610                 if (!helpers)
3611                         return -ENOMEM;
3612         }
3613         ret = prepare_ext_ctrls(hdl, cs, helpers, false);
3614         if (!ret)
3615                 ret = validate_ctrls(cs, helpers, set);
3616         if (ret && set)
3617                 cs->error_idx = cs->count;
3618         for (i = 0; !ret && i < cs->count; i++) {
3619                 struct v4l2_ctrl *master;
3620                 u32 idx = i;
3621
3622                 if (helpers[i].mref == NULL)
3623                         continue;
3624
3625                 cs->error_idx = i;
3626                 master = helpers[i].mref->ctrl;
3627                 v4l2_ctrl_lock(master);
3628
3629                 /* Reset the 'is_new' flags of the cluster */
3630                 for (j = 0; j < master->ncontrols; j++)
3631                         if (master->cluster[j])
3632                                 master->cluster[j]->is_new = 0;
3633
3634                 /* For volatile autoclusters that are currently in auto mode
3635                    we need to discover if it will be set to manual mode.
3636                    If so, then we have to copy the current volatile values
3637                    first since those will become the new manual values (which
3638                    may be overwritten by explicit new values from this set
3639                    of controls). */
3640                 if (master->is_auto && master->has_volatiles &&
3641                                                 !is_cur_manual(master)) {
3642                         /* Pick an initial non-manual value */
3643                         s32 new_auto_val = master->manual_mode_value + 1;
3644                         u32 tmp_idx = idx;
3645
3646                         do {
3647                                 /* Check if the auto control is part of the
3648                                    list, and remember the new value. */
3649                                 if (helpers[tmp_idx].ref->ctrl == master)
3650                                         new_auto_val = cs->controls[tmp_idx].value;
3651                                 tmp_idx = helpers[tmp_idx].next;
3652                         } while (tmp_idx);
3653                         /* If the new value == the manual value, then copy
3654                            the current volatile values. */
3655                         if (new_auto_val == master->manual_mode_value)
3656                                 update_from_auto_cluster(master);
3657                 }
3658
3659                 /* Copy the new caller-supplied control values.
3660                    user_to_new() sets 'is_new' to 1. */
3661                 do {
3662                         struct v4l2_ctrl *ctrl = helpers[idx].ref->ctrl;
3663
3664                         ret = user_to_new(cs->controls + idx, ctrl);
3665                         if (!ret && ctrl->is_ptr)
3666                                 ret = validate_new(ctrl, ctrl->p_new);
3667                         idx = helpers[idx].next;
3668                 } while (!ret && idx);
3669
3670                 if (!ret)
3671                         ret = try_or_set_cluster(fh, master,
3672                                                  !hdl->req_obj.req && set, 0);
3673                 if (!ret && hdl->req_obj.req && set) {
3674                         for (j = 0; j < master->ncontrols; j++) {
3675                                 struct v4l2_ctrl_ref *ref =
3676                                         find_ref(hdl, master->cluster[j]->id);
3677
3678                                 new_to_req(ref);
3679                         }
3680                 }
3681
3682                 /* Copy the new values back to userspace. */
3683                 if (!ret) {
3684                         idx = i;
3685                         do {
3686                                 ret = new_to_user(cs->controls + idx,
3687                                                 helpers[idx].ref->ctrl);
3688                                 idx = helpers[idx].next;
3689                         } while (!ret && idx);
3690                 }
3691                 v4l2_ctrl_unlock(master);
3692         }
3693
3694         if (cs->count > ARRAY_SIZE(helper))
3695                 kvfree(helpers);
3696         return ret;
3697 }
3698
3699 static int try_set_ext_ctrls(struct v4l2_fh *fh,
3700                              struct v4l2_ctrl_handler *hdl, struct media_device *mdev,
3701                              struct v4l2_ext_controls *cs, bool set)
3702 {
3703         struct media_request_object *obj = NULL;
3704         struct media_request *req = NULL;
3705         int ret;
3706
3707         if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) {
3708                 if (!mdev || cs->request_fd < 0)
3709                         return -EINVAL;
3710
3711                 req = media_request_get_by_fd(mdev, cs->request_fd);
3712                 if (IS_ERR(req))
3713                         return PTR_ERR(req);
3714
3715                 ret = media_request_lock_for_update(req);
3716                 if (ret) {
3717                         media_request_put(req);
3718                         return ret;
3719                 }
3720
3721                 obj = v4l2_ctrls_find_req_obj(hdl, req, set);
3722                 if (IS_ERR(obj)) {
3723                         media_request_unlock_for_update(req);
3724                         media_request_put(req);
3725                         return PTR_ERR(obj);
3726                 }
3727                 hdl = container_of(obj, struct v4l2_ctrl_handler,
3728                                    req_obj);
3729         }
3730
3731         ret = try_set_ext_ctrls_common(fh, hdl, cs, set);
3732
3733         if (obj) {
3734                 media_request_unlock_for_update(req);
3735                 media_request_object_put(obj);
3736                 media_request_put(req);
3737         }
3738
3739         return ret;
3740 }
3741
3742 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct media_device *mdev,
3743                        struct v4l2_ext_controls *cs)
3744 {
3745         return try_set_ext_ctrls(NULL, hdl, mdev, cs, false);
3746 }
3747 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
3748
3749 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3750                      struct media_device *mdev, struct v4l2_ext_controls *cs)
3751 {
3752         return try_set_ext_ctrls(fh, hdl, mdev, cs, true);
3753 }
3754 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
3755
3756 /* Helper function for VIDIOC_S_CTRL compatibility */
3757 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
3758 {
3759         struct v4l2_ctrl *master = ctrl->cluster[0];
3760         int ret;
3761         int i;
3762
3763         /* Reset the 'is_new' flags of the cluster */
3764         for (i = 0; i < master->ncontrols; i++)
3765                 if (master->cluster[i])
3766                         master->cluster[i]->is_new = 0;
3767
3768         ret = validate_new(ctrl, ctrl->p_new);
3769         if (ret)
3770                 return ret;
3771
3772         /* For autoclusters with volatiles that are switched from auto to
3773            manual mode we have to update the current volatile values since
3774            those will become the initial manual values after such a switch. */
3775         if (master->is_auto && master->has_volatiles && ctrl == master &&
3776             !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
3777                 update_from_auto_cluster(master);
3778
3779         ctrl->is_new = 1;
3780         return try_or_set_cluster(fh, master, true, ch_flags);
3781 }
3782
3783 /* Helper function for VIDIOC_S_CTRL compatibility */
3784 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
3785                          struct v4l2_ext_control *c)
3786 {
3787         int ret;
3788
3789         v4l2_ctrl_lock(ctrl);
3790         user_to_new(c, ctrl);
3791         ret = set_ctrl(fh, ctrl, 0);
3792         if (!ret)
3793                 cur_to_user(c, ctrl);
3794         v4l2_ctrl_unlock(ctrl);
3795         return ret;
3796 }
3797
3798 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3799                                         struct v4l2_control *control)
3800 {
3801         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3802         struct v4l2_ext_control c = { control->id };
3803         int ret;
3804
3805         if (ctrl == NULL || !ctrl->is_int)
3806                 return -EINVAL;
3807
3808         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3809                 return -EACCES;
3810
3811         c.value = control->value;
3812         ret = set_ctrl_lock(fh, ctrl, &c);
3813         control->value = c.value;
3814         return ret;
3815 }
3816 EXPORT_SYMBOL(v4l2_s_ctrl);
3817
3818 int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
3819 {
3820         lockdep_assert_held(ctrl->handler->lock);
3821
3822         /* It's a driver bug if this happens. */
3823         WARN_ON(!ctrl->is_int);
3824         ctrl->val = val;
3825         return set_ctrl(NULL, ctrl, 0);
3826 }
3827 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
3828
3829 int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
3830 {
3831         lockdep_assert_held(ctrl->handler->lock);
3832
3833         /* It's a driver bug if this happens. */
3834         WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
3835         *ctrl->p_new.p_s64 = val;
3836         return set_ctrl(NULL, ctrl, 0);
3837 }
3838 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
3839
3840 int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
3841 {
3842         lockdep_assert_held(ctrl->handler->lock);
3843
3844         /* It's a driver bug if this happens. */
3845         WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING);
3846         strscpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
3847         return set_ctrl(NULL, ctrl, 0);
3848 }
3849 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
3850
3851 void v4l2_ctrl_request_complete(struct media_request *req,
3852                                 struct v4l2_ctrl_handler *main_hdl)
3853 {
3854         struct media_request_object *obj;
3855         struct v4l2_ctrl_handler *hdl;
3856         struct v4l2_ctrl_ref *ref;
3857
3858         if (!req || !main_hdl)
3859                 return;
3860
3861         /*
3862          * Note that it is valid if nothing was found. It means
3863          * that this request doesn't have any controls and so just
3864          * wants to leave the controls unchanged.
3865          */
3866         obj = media_request_object_find(req, &req_ops, main_hdl);
3867         if (!obj)
3868                 return;
3869         hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
3870
3871         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
3872                 struct v4l2_ctrl *ctrl = ref->ctrl;
3873                 struct v4l2_ctrl *master = ctrl->cluster[0];
3874                 unsigned int i;
3875
3876                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
3877                         ref->req = ref;
3878
3879                         v4l2_ctrl_lock(master);
3880                         /* g_volatile_ctrl will update the current control values */
3881                         for (i = 0; i < master->ncontrols; i++)
3882                                 cur_to_new(master->cluster[i]);
3883                         call_op(master, g_volatile_ctrl);
3884                         new_to_req(ref);
3885                         v4l2_ctrl_unlock(master);
3886                         continue;
3887                 }
3888                 if (ref->req == ref)
3889                         continue;
3890
3891                 v4l2_ctrl_lock(ctrl);
3892                 if (ref->req)
3893                         ptr_to_ptr(ctrl, ref->req->p_req, ref->p_req);
3894                 else
3895                         ptr_to_ptr(ctrl, ctrl->p_cur, ref->p_req);
3896                 v4l2_ctrl_unlock(ctrl);
3897         }
3898
3899         WARN_ON(!hdl->request_is_queued);
3900         list_del_init(&hdl->requests_queued);
3901         hdl->request_is_queued = false;
3902         media_request_object_complete(obj);
3903         media_request_object_put(obj);
3904 }
3905 EXPORT_SYMBOL(v4l2_ctrl_request_complete);
3906
3907 void v4l2_ctrl_request_setup(struct media_request *req,
3908                              struct v4l2_ctrl_handler *main_hdl)
3909 {
3910         struct media_request_object *obj;
3911         struct v4l2_ctrl_handler *hdl;
3912         struct v4l2_ctrl_ref *ref;
3913
3914         if (!req || !main_hdl)
3915                 return;
3916
3917         if (WARN_ON(req->state != MEDIA_REQUEST_STATE_QUEUED))
3918                 return;
3919
3920         /*
3921          * Note that it is valid if nothing was found. It means
3922          * that this request doesn't have any controls and so just
3923          * wants to leave the controls unchanged.
3924          */
3925         obj = media_request_object_find(req, &req_ops, main_hdl);
3926         if (!obj)
3927                 return;
3928         if (obj->completed) {
3929                 media_request_object_put(obj);
3930                 return;
3931         }
3932         hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
3933
3934         list_for_each_entry(ref, &hdl->ctrl_refs, node)
3935                 ref->req_done = false;
3936
3937         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
3938                 struct v4l2_ctrl *ctrl = ref->ctrl;
3939                 struct v4l2_ctrl *master = ctrl->cluster[0];
3940                 bool have_new_data = false;
3941                 int i;
3942
3943                 /*
3944                  * Skip if this control was already handled by a cluster.
3945                  * Skip button controls and read-only controls.
3946                  */
3947                 if (ref->req_done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
3948                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
3949                         continue;
3950
3951                 v4l2_ctrl_lock(master);
3952                 for (i = 0; i < master->ncontrols; i++) {
3953                         if (master->cluster[i]) {
3954                                 struct v4l2_ctrl_ref *r =
3955                                         find_ref(hdl, master->cluster[i]->id);
3956
3957                                 if (r->req && r == r->req) {
3958                                         have_new_data = true;
3959                                         break;
3960                                 }
3961                         }
3962                 }
3963                 if (!have_new_data) {
3964                         v4l2_ctrl_unlock(master);
3965                         continue;
3966                 }
3967
3968                 for (i = 0; i < master->ncontrols; i++) {
3969                         if (master->cluster[i]) {
3970                                 struct v4l2_ctrl_ref *r =
3971                                         find_ref(hdl, master->cluster[i]->id);
3972
3973                                 req_to_new(r);
3974                                 master->cluster[i]->is_new = 1;
3975                                 r->req_done = true;
3976                         }
3977                 }
3978                 /*
3979                  * For volatile autoclusters that are currently in auto mode
3980                  * we need to discover if it will be set to manual mode.
3981                  * If so, then we have to copy the current volatile values
3982                  * first since those will become the new manual values (which
3983                  * may be overwritten by explicit new values from this set
3984                  * of controls).
3985                  */
3986                 if (master->is_auto && master->has_volatiles &&
3987                     !is_cur_manual(master)) {
3988                         s32 new_auto_val = *master->p_new.p_s32;
3989
3990                         /*
3991                          * If the new value == the manual value, then copy
3992                          * the current volatile values.
3993                          */
3994                         if (new_auto_val == master->manual_mode_value)
3995                                 update_from_auto_cluster(master);
3996                 }
3997
3998                 try_or_set_cluster(NULL, master, true, 0);
3999
4000                 v4l2_ctrl_unlock(master);
4001         }
4002
4003         media_request_object_put(obj);
4004 }
4005 EXPORT_SYMBOL(v4l2_ctrl_request_setup);
4006
4007 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
4008 {
4009         if (ctrl == NULL)
4010                 return;
4011         if (notify == NULL) {
4012                 ctrl->call_notify = 0;
4013                 return;
4014         }
4015         if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
4016                 return;
4017         ctrl->handler->notify = notify;
4018         ctrl->handler->notify_priv = priv;
4019         ctrl->call_notify = 1;
4020 }
4021 EXPORT_SYMBOL(v4l2_ctrl_notify);
4022
4023 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
4024                         s64 min, s64 max, u64 step, s64 def)
4025 {
4026         bool value_changed;
4027         bool range_changed = false;
4028         int ret;
4029
4030         lockdep_assert_held(ctrl->handler->lock);
4031
4032         switch (ctrl->type) {
4033         case V4L2_CTRL_TYPE_INTEGER:
4034         case V4L2_CTRL_TYPE_INTEGER64:
4035         case V4L2_CTRL_TYPE_BOOLEAN:
4036         case V4L2_CTRL_TYPE_MENU:
4037         case V4L2_CTRL_TYPE_INTEGER_MENU:
4038         case V4L2_CTRL_TYPE_BITMASK:
4039         case V4L2_CTRL_TYPE_U8:
4040         case V4L2_CTRL_TYPE_U16:
4041         case V4L2_CTRL_TYPE_U32:
4042                 if (ctrl->is_array)
4043                         return -EINVAL;
4044                 ret = check_range(ctrl->type, min, max, step, def);
4045                 if (ret)
4046                         return ret;
4047                 break;
4048         default:
4049                 return -EINVAL;
4050         }
4051         if ((ctrl->minimum != min) || (ctrl->maximum != max) ||
4052                 (ctrl->step != step) || ctrl->default_value != def) {
4053                 range_changed = true;
4054                 ctrl->minimum = min;
4055                 ctrl->maximum = max;
4056                 ctrl->step = step;
4057                 ctrl->default_value = def;
4058         }
4059         cur_to_new(ctrl);
4060         if (validate_new(ctrl, ctrl->p_new)) {
4061                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4062                         *ctrl->p_new.p_s64 = def;
4063                 else
4064                         *ctrl->p_new.p_s32 = def;
4065         }
4066
4067         if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4068                 value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
4069         else
4070                 value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
4071         if (value_changed)
4072                 ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
4073         else if (range_changed)
4074                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
4075         return ret;
4076 }
4077 EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
4078
4079 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
4080 {
4081         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
4082
4083         if (ctrl == NULL)
4084                 return -EINVAL;
4085
4086         v4l2_ctrl_lock(ctrl);
4087         list_add_tail(&sev->node, &ctrl->ev_subs);
4088         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
4089             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
4090                 struct v4l2_event ev;
4091                 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
4092
4093                 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
4094                         changes |= V4L2_EVENT_CTRL_CH_VALUE;
4095                 fill_event(&ev, ctrl, changes);
4096                 /* Mark the queue as active, allowing this initial
4097                    event to be accepted. */
4098                 sev->elems = elems;
4099                 v4l2_event_queue_fh(sev->fh, &ev);
4100         }
4101         v4l2_ctrl_unlock(ctrl);
4102         return 0;
4103 }
4104
4105 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
4106 {
4107         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
4108
4109         if (ctrl == NULL)
4110                 return;
4111
4112         v4l2_ctrl_lock(ctrl);
4113         list_del(&sev->node);
4114         v4l2_ctrl_unlock(ctrl);
4115 }
4116
4117 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
4118 {
4119         u32 old_changes = old->u.ctrl.changes;
4120
4121         old->u.ctrl = new->u.ctrl;
4122         old->u.ctrl.changes |= old_changes;
4123 }
4124 EXPORT_SYMBOL(v4l2_ctrl_replace);
4125
4126 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
4127 {
4128         new->u.ctrl.changes |= old->u.ctrl.changes;
4129 }
4130 EXPORT_SYMBOL(v4l2_ctrl_merge);
4131
4132 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
4133         .add = v4l2_ctrl_add_event,
4134         .del = v4l2_ctrl_del_event,
4135         .replace = v4l2_ctrl_replace,
4136         .merge = v4l2_ctrl_merge,
4137 };
4138 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
4139
4140 int v4l2_ctrl_log_status(struct file *file, void *fh)
4141 {
4142         struct video_device *vfd = video_devdata(file);
4143         struct v4l2_fh *vfh = file->private_data;
4144
4145         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
4146                 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
4147                         vfd->v4l2_dev->name);
4148         return 0;
4149 }
4150 EXPORT_SYMBOL(v4l2_ctrl_log_status);
4151
4152 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
4153                                 const struct v4l2_event_subscription *sub)
4154 {
4155         if (sub->type == V4L2_EVENT_CTRL)
4156                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
4157         return -EINVAL;
4158 }
4159 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
4160
4161 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
4162                                      struct v4l2_event_subscription *sub)
4163 {
4164         if (!sd->ctrl_handler)
4165                 return -EINVAL;
4166         return v4l2_ctrl_subscribe_event(fh, sub);
4167 }
4168 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
4169
4170 __poll_t v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
4171 {
4172         struct v4l2_fh *fh = file->private_data;
4173
4174         if (v4l2_event_pending(fh))
4175                 return EPOLLPRI;
4176         poll_wait(file, &fh->wait, wait);
4177         return 0;
4178 }
4179 EXPORT_SYMBOL(v4l2_ctrl_poll);