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

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3     V4L2 controls framework implementation.
   4
   5     Copyright (C) 2010  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7  */
   8
   9 #define pr_fmt(fmt) "v4l2-ctrls: " fmt
  10
  11 #include <linux/ctype.h>
  12 #include <linux/export.h>
  13 #include <linux/mm.h>
  14 #include <linux/slab.h>
  15 #include <media/v4l2-ctrls.h>
  16 #include <media/v4l2-dev.h>
  17 #include <media/v4l2-device.h>
  18 #include <media/v4l2-event.h>
  19 #include <media/v4l2-fwnode.h>
  20 #include <media/v4l2-ioctl.h>
  21
  22 #define dprintk(vdev, fmt, arg...) do {                                 \
  23         if (!WARN_ON(!(vdev)) && ((vdev)->dev_debug & V4L2_DEV_DEBUG_CTRL)) \
  24                 printk(KERN_DEBUG pr_fmt("%s: %s: " fmt),               \
  25                        __func__, video_device_node_name(vdev), ##arg);  \
  26 } while (0)
  27
  28 #define has_op(master, op) \
  29         (master->ops && master->ops->op)
  30 #define call_op(master, op) \
  31         (has_op(master, op) ? master->ops->op(master) : 0)
  32
  33 static const union v4l2_ctrl_ptr ptr_null;
  34
  35 /* Internal temporary helper struct, one for each v4l2_ext_control */
  36 struct v4l2_ctrl_helper {
  37         /* Pointer to the control reference of the master control */
  38         struct v4l2_ctrl_ref *mref;
  39         /* The control ref corresponding to the v4l2_ext_control ID field. */
  40         struct v4l2_ctrl_ref *ref;
  41         /* v4l2_ext_control index of the next control belonging to the
  42            same cluster, or 0 if there isn't any. */
  43         u32 next;
  44 };
  45
  46 /* Small helper function to determine if the autocluster is set to manual
  47    mode. */
  48 static bool is_cur_manual(const struct v4l2_ctrl *master)
  49 {
  50         return master->is_auto && master->cur.val == master->manual_mode_value;
  51 }
  52
  53 /* Same as above, but this checks the against the new value instead of the
  54    current value. */
  55 static bool is_new_manual(const struct v4l2_ctrl *master)
  56 {
  57         return master->is_auto && master->val == master->manual_mode_value;
  58 }
  59
  60 /* Returns NULL or a character pointer array containing the menu for
  61    the given control ID. The pointer array ends with a NULL pointer.
  62    An empty string signifies a menu entry that is invalid. This allows
  63    drivers to disable certain options if it is not supported. */
  64 const char * const *v4l2_ctrl_get_menu(u32 id)
  65 {
  66         static const char * const mpeg_audio_sampling_freq[] = {
  67                 "44.1 kHz",
  68                 "48 kHz",
  69                 "32 kHz",
  70                 NULL
  71         };
  72         static const char * const mpeg_audio_encoding[] = {
  73                 "MPEG-1/2 Layer I",
  74                 "MPEG-1/2 Layer II",
  75                 "MPEG-1/2 Layer III",
  76                 "MPEG-2/4 AAC",
  77                 "AC-3",
  78                 NULL
  79         };
  80         static const char * const mpeg_audio_l1_bitrate[] = {
  81                 "32 kbps",
  82                 "64 kbps",
  83                 "96 kbps",
  84                 "128 kbps",
  85                 "160 kbps",
  86                 "192 kbps",
  87                 "224 kbps",
  88                 "256 kbps",
  89                 "288 kbps",
  90                 "320 kbps",
  91                 "352 kbps",
  92                 "384 kbps",
  93                 "416 kbps",
  94                 "448 kbps",
  95                 NULL
  96         };
  97         static const char * const mpeg_audio_l2_bitrate[] = {
  98                 "32 kbps",
  99                 "48 kbps",
 100                 "56 kbps",
 101                 "64 kbps",
 102                 "80 kbps",
 103                 "96 kbps",
 104                 "112 kbps",
 105                 "128 kbps",
 106                 "160 kbps",
 107                 "192 kbps",
 108                 "224 kbps",
 109                 "256 kbps",
 110                 "320 kbps",
 111                 "384 kbps",
 112                 NULL
 113         };
 114         static const char * const mpeg_audio_l3_bitrate[] = {
 115                 "32 kbps",
 116                 "40 kbps",
 117                 "48 kbps",
 118                 "56 kbps",
 119                 "64 kbps",
 120                 "80 kbps",
 121                 "96 kbps",
 122                 "112 kbps",
 123                 "128 kbps",
 124                 "160 kbps",
 125                 "192 kbps",
 126                 "224 kbps",
 127                 "256 kbps",
 128                 "320 kbps",
 129                 NULL
 130         };
 131         static const char * const mpeg_audio_ac3_bitrate[] = {
 132                 "32 kbps",
 133                 "40 kbps",
 134                 "48 kbps",
 135                 "56 kbps",
 136                 "64 kbps",
 137                 "80 kbps",
 138                 "96 kbps",
 139                 "112 kbps",
 140                 "128 kbps",
 141                 "160 kbps",
 142                 "192 kbps",
 143                 "224 kbps",
 144                 "256 kbps",
 145                 "320 kbps",
 146                 "384 kbps",
 147                 "448 kbps",
 148                 "512 kbps",
 149                 "576 kbps",
 150                 "640 kbps",
 151                 NULL
 152         };
 153         static const char * const mpeg_audio_mode[] = {
 154                 "Stereo",
 155                 "Joint Stereo",
 156                 "Dual",
 157                 "Mono",
 158                 NULL
 159         };
 160         static const char * const mpeg_audio_mode_extension[] = {
 161                 "Bound 4",
 162                 "Bound 8",
 163                 "Bound 12",
 164                 "Bound 16",
 165                 NULL
 166         };
 167         static const char * const mpeg_audio_emphasis[] = {
 168                 "No Emphasis",
 169                 "50/15 us",
 170                 "CCITT J17",
 171                 NULL
 172         };
 173         static const char * const mpeg_audio_crc[] = {
 174                 "No CRC",
 175                 "16-bit CRC",
 176                 NULL
 177         };
 178         static const char * const mpeg_audio_dec_playback[] = {
 179                 "Auto",
 180                 "Stereo",
 181                 "Left",
 182                 "Right",
 183                 "Mono",
 184                 "Swapped Stereo",
 185                 NULL
 186         };
 187         static const char * const mpeg_video_encoding[] = {
 188                 "MPEG-1",
 189                 "MPEG-2",
 190                 "MPEG-4 AVC",
 191                 NULL
 192         };
 193         static const char * const mpeg_video_aspect[] = {
 194                 "1x1",
 195                 "4x3",
 196                 "16x9",
 197                 "2.21x1",
 198                 NULL
 199         };
 200         static const char * const mpeg_video_bitrate_mode[] = {
 201                 "Variable Bitrate",
 202                 "Constant Bitrate",
 203                 "Constant Quality",
 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                 "5.2",
 342                 "6.0",
 343                 "6.1",
 344                 "6.2",
 345                 NULL,
 346         };
 347         static const char * const h264_loop_filter[] = {
 348                 "Enabled",
 349                 "Disabled",
 350                 "Disabled at Slice Boundary",
 351                 NULL,
 352         };
 353         static const char * const h264_profile[] = {
 354                 "Baseline",
 355                 "Constrained Baseline",
 356                 "Main",
 357                 "Extended",
 358                 "High",
 359                 "High 10",
 360                 "High 422",
 361                 "High 444 Predictive",
 362                 "High 10 Intra",
 363                 "High 422 Intra",
 364                 "High 444 Intra",
 365                 "CAVLC 444 Intra",
 366                 "Scalable Baseline",
 367                 "Scalable High",
 368                 "Scalable High Intra",
 369                 "Stereo High",
 370                 "Multiview High",
 371                 "Constrained High",
 372                 NULL,
 373         };
 374         static const char * const vui_sar_idc[] = {
 375                 "Unspecified",
 376                 "1:1",
 377                 "12:11",
 378                 "10:11",
 379                 "16:11",
 380                 "40:33",
 381                 "24:11",
 382                 "20:11",
 383                 "32:11",
 384                 "80:33",
 385                 "18:11",
 386                 "15:11",
 387                 "64:33",
 388                 "160:99",
 389                 "4:3",
 390                 "3:2",
 391                 "2:1",
 392                 "Extended SAR",
 393                 NULL,
 394         };
 395         static const char * const h264_fp_arrangement_type[] = {
 396                 "Checkerboard",
 397                 "Column",
 398                 "Row",
 399                 "Side by Side",
 400                 "Top Bottom",
 401                 "Temporal",
 402                 NULL,
 403         };
 404         static const char * const h264_fmo_map_type[] = {
 405                 "Interleaved Slices",
 406                 "Scattered Slices",
 407                 "Foreground with Leftover",
 408                 "Box Out",
 409                 "Raster Scan",
 410                 "Wipe Scan",
 411                 "Explicit",
 412                 NULL,
 413         };
 414         static const char * const h264_decode_mode[] = {
 415                 "Slice-Based",
 416                 "Frame-Based",
 417                 NULL,
 418         };
 419         static const char * const h264_start_code[] = {
 420                 "No Start Code",
 421                 "Annex B Start Code",
 422                 NULL,
 423         };
 424         static const char * const mpeg_mpeg2_level[] = {
 425                 "Low",
 426                 "Main",
 427                 "High 1440",
 428                 "High",
 429                 NULL,
 430         };
 431         static const char * const mpeg2_profile[] = {
 432                 "Simple",
 433                 "Main",
 434                 "SNR Scalable",
 435                 "Spatially Scalable",
 436                 "High",
 437                 NULL,
 438         };
 439         static const char * const mpeg_mpeg4_level[] = {
 440                 "0",
 441                 "0b",
 442                 "1",
 443                 "2",
 444                 "3",
 445                 "3b",
 446                 "4",
 447                 "5",
 448                 NULL,
 449         };
 450         static const char * const mpeg4_profile[] = {
 451                 "Simple",
 452                 "Advanced Simple",
 453                 "Core",
 454                 "Simple Scalable",
 455                 "Advanced Coding Efficiency",
 456                 NULL,
 457         };
 458
 459         static const char * const vpx_golden_frame_sel[] = {
 460                 "Use Previous Frame",
 461                 "Use Previous Specific Frame",
 462                 NULL,
 463         };
 464         static const char * const vp8_profile[] = {
 465                 "0",
 466                 "1",
 467                 "2",
 468                 "3",
 469                 NULL,
 470         };
 471         static const char * const vp9_profile[] = {
 472                 "0",
 473                 "1",
 474                 "2",
 475                 "3",
 476                 NULL,
 477         };
 478         static const char * const vp9_level[] = {
 479                 "1",
 480                 "1.1",
 481                 "2",
 482                 "2.1",
 483                 "3",
 484                 "3.1",
 485                 "4",
 486                 "4.1",
 487                 "5",
 488                 "5.1",
 489                 "5.2",
 490                 "6",
 491                 "6.1",
 492                 "6.2",
 493                 NULL,
 494         };
 495
 496         static const char * const flash_led_mode[] = {
 497                 "Off",
 498                 "Flash",
 499                 "Torch",
 500                 NULL,
 501         };
 502         static const char * const flash_strobe_source[] = {
 503                 "Software",
 504                 "External",
 505                 NULL,
 506         };
 507
 508         static const char * const jpeg_chroma_subsampling[] = {
 509                 "4:4:4",
 510                 "4:2:2",
 511                 "4:2:0",
 512                 "4:1:1",
 513                 "4:1:0",
 514                 "Gray",
 515                 NULL,
 516         };
 517         static const char * const dv_tx_mode[] = {
 518                 "DVI-D",
 519                 "HDMI",
 520                 NULL,
 521         };
 522         static const char * const dv_rgb_range[] = {
 523                 "Automatic",
 524                 "RGB Limited Range (16-235)",
 525                 "RGB Full Range (0-255)",
 526                 NULL,
 527         };
 528         static const char * const dv_it_content_type[] = {
 529                 "Graphics",
 530                 "Photo",
 531                 "Cinema",
 532                 "Game",
 533                 "No IT Content",
 534                 NULL,
 535         };
 536         static const char * const detect_md_mode[] = {
 537                 "Disabled",
 538                 "Global",
 539                 "Threshold Grid",
 540                 "Region Grid",
 541                 NULL,
 542         };
 543
 544         static const char * const hevc_profile[] = {
 545                 "Main",
 546                 "Main Still Picture",
 547                 "Main 10",
 548                 NULL,
 549         };
 550         static const char * const hevc_level[] = {
 551                 "1",
 552                 "2",
 553                 "2.1",
 554                 "3",
 555                 "3.1",
 556                 "4",
 557                 "4.1",
 558                 "5",
 559                 "5.1",
 560                 "5.2",
 561                 "6",
 562                 "6.1",
 563                 "6.2",
 564                 NULL,
 565         };
 566         static const char * const hevc_hierarchial_coding_type[] = {
 567                 "B",
 568                 "P",
 569                 NULL,
 570         };
 571         static const char * const hevc_refresh_type[] = {
 572                 "None",
 573                 "CRA",
 574                 "IDR",
 575                 NULL,
 576         };
 577         static const char * const hevc_size_of_length_field[] = {
 578                 "0",
 579                 "1",
 580                 "2",
 581                 "4",
 582                 NULL,
 583         };
 584         static const char * const hevc_tier[] = {
 585                 "Main",
 586                 "High",
 587                 NULL,
 588         };
 589         static const char * const hevc_loop_filter_mode[] = {
 590                 "Disabled",
 591                 "Enabled",
 592                 "Disabled at slice boundary",
 593                 "NULL",
 594         };
 595         static const char * const hevc_decode_mode[] = {
 596                 "Slice-Based",
 597                 "Frame-Based",
 598                 NULL,
 599         };
 600         static const char * const hevc_start_code[] = {
 601                 "No Start Code",
 602                 "Annex B Start Code",
 603                 NULL,
 604         };
 605         static const char * const camera_orientation[] = {
 606                 "Front",
 607                 "Back",
 608                 "External",
 609                 NULL,
 610         };
 611         static const char * const mpeg_video_frame_skip[] = {
 612                 "Disabled",
 613                 "Level Limit",
 614                 "VBV/CPB Limit",
 615                 NULL,
 616         };
 617
 618         switch (id) {
 619         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 620                 return mpeg_audio_sampling_freq;
 621         case V4L2_CID_MPEG_AUDIO_ENCODING:
 622                 return mpeg_audio_encoding;
 623         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 624                 return mpeg_audio_l1_bitrate;
 625         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 626                 return mpeg_audio_l2_bitrate;
 627         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 628                 return mpeg_audio_l3_bitrate;
 629         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 630                 return mpeg_audio_ac3_bitrate;
 631         case V4L2_CID_MPEG_AUDIO_MODE:
 632                 return mpeg_audio_mode;
 633         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 634                 return mpeg_audio_mode_extension;
 635         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 636                 return mpeg_audio_emphasis;
 637         case V4L2_CID_MPEG_AUDIO_CRC:
 638                 return mpeg_audio_crc;
 639         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
 640         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
 641                 return mpeg_audio_dec_playback;
 642         case V4L2_CID_MPEG_VIDEO_ENCODING:
 643                 return mpeg_video_encoding;
 644         case V4L2_CID_MPEG_VIDEO_ASPECT:
 645                 return mpeg_video_aspect;
 646         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 647                 return mpeg_video_bitrate_mode;
 648         case V4L2_CID_MPEG_STREAM_TYPE:
 649                 return mpeg_stream_type;
 650         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 651                 return mpeg_stream_vbi_fmt;
 652         case V4L2_CID_POWER_LINE_FREQUENCY:
 653                 return camera_power_line_frequency;
 654         case V4L2_CID_EXPOSURE_AUTO:
 655                 return camera_exposure_auto;
 656         case V4L2_CID_EXPOSURE_METERING:
 657                 return camera_exposure_metering;
 658         case V4L2_CID_AUTO_FOCUS_RANGE:
 659                 return camera_auto_focus_range;
 660         case V4L2_CID_COLORFX:
 661                 return colorfx;
 662         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
 663                 return auto_n_preset_white_balance;
 664         case V4L2_CID_ISO_SENSITIVITY_AUTO:
 665                 return camera_iso_sensitivity_auto;
 666         case V4L2_CID_SCENE_MODE:
 667                 return scene_mode;
 668         case V4L2_CID_TUNE_PREEMPHASIS:
 669                 return tune_emphasis;
 670         case V4L2_CID_TUNE_DEEMPHASIS:
 671                 return tune_emphasis;
 672         case V4L2_CID_FLASH_LED_MODE:
 673                 return flash_led_mode;
 674         case V4L2_CID_FLASH_STROBE_SOURCE:
 675                 return flash_strobe_source;
 676         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
 677                 return header_mode;
 678         case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
 679                 return mpeg_video_frame_skip;
 680         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
 681                 return multi_slice;
 682         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
 683                 return entropy_mode;
 684         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
 685                 return mpeg_h264_level;
 686         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
 687                 return h264_loop_filter;
 688         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
 689                 return h264_profile;
 690         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
 691                 return vui_sar_idc;
 692         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
 693                 return h264_fp_arrangement_type;
 694         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
 695                 return h264_fmo_map_type;
 696         case V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE:
 697                 return h264_decode_mode;
 698         case V4L2_CID_MPEG_VIDEO_H264_START_CODE:
 699                 return h264_start_code;
 700         case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:
 701                 return mpeg_mpeg2_level;
 702         case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:
 703                 return mpeg2_profile;
 704         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
 705                 return mpeg_mpeg4_level;
 706         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
 707                 return mpeg4_profile;
 708         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
 709                 return vpx_golden_frame_sel;
 710         case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
 711                 return vp8_profile;
 712         case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
 713                 return vp9_profile;
 714         case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:
 715                 return vp9_level;
 716         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
 717                 return jpeg_chroma_subsampling;
 718         case V4L2_CID_DV_TX_MODE:
 719                 return dv_tx_mode;
 720         case V4L2_CID_DV_TX_RGB_RANGE:
 721         case V4L2_CID_DV_RX_RGB_RANGE:
 722                 return dv_rgb_range;
 723         case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
 724         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
 725                 return dv_it_content_type;
 726         case V4L2_CID_DETECT_MD_MODE:
 727                 return detect_md_mode;
 728         case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
 729                 return hevc_profile;
 730         case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
 731                 return hevc_level;
 732         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
 733                 return hevc_hierarchial_coding_type;
 734         case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
 735                 return hevc_refresh_type;
 736         case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
 737                 return hevc_size_of_length_field;
 738         case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
 739                 return hevc_tier;
 740         case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
 741                 return hevc_loop_filter_mode;
 742         case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:
 743                 return hevc_decode_mode;
 744         case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:
 745                 return hevc_start_code;
 746         case V4L2_CID_CAMERA_ORIENTATION:
 747                 return camera_orientation;
 748         default:
 749                 return NULL;
 750         }
 751 }
 752 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
 753
 754 #define __v4l2_qmenu_int_len(arr, len) ({ *(len) = ARRAY_SIZE(arr); arr; })
 755 /*
 756  * Returns NULL or an s64 type array containing the menu for given
 757  * control ID. The total number of the menu items is returned in @len.
 758  */
 759 const s64 *v4l2_ctrl_get_int_menu(u32 id, u32 *len)
 760 {
 761         static const s64 qmenu_int_vpx_num_partitions[] = {
 762                 1, 2, 4, 8,
 763         };
 764
 765         static const s64 qmenu_int_vpx_num_ref_frames[] = {
 766                 1, 2, 3,
 767         };
 768
 769         switch (id) {
 770         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
 771                 return __v4l2_qmenu_int_len(qmenu_int_vpx_num_partitions, len);
 772         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
 773                 return __v4l2_qmenu_int_len(qmenu_int_vpx_num_ref_frames, len);
 774         default:
 775                 *len = 0;
 776                 return NULL;
 777         }
 778 }
 779 EXPORT_SYMBOL(v4l2_ctrl_get_int_menu);
 780
 781 /* Return the control name. */
 782 const char *v4l2_ctrl_get_name(u32 id)
 783 {
 784         switch (id) {
 785         /* USER controls */
 786         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
 787         case V4L2_CID_USER_CLASS:               return "User Controls";
 788         case V4L2_CID_BRIGHTNESS:               return "Brightness";
 789         case V4L2_CID_CONTRAST:                 return "Contrast";
 790         case V4L2_CID_SATURATION:               return "Saturation";
 791         case V4L2_CID_HUE:                      return "Hue";
 792         case V4L2_CID_AUDIO_VOLUME:             return "Volume";
 793         case V4L2_CID_AUDIO_BALANCE:            return "Balance";
 794         case V4L2_CID_AUDIO_BASS:               return "Bass";
 795         case V4L2_CID_AUDIO_TREBLE:             return "Treble";
 796         case V4L2_CID_AUDIO_MUTE:               return "Mute";
 797         case V4L2_CID_AUDIO_LOUDNESS:           return "Loudness";
 798         case V4L2_CID_BLACK_LEVEL:              return "Black Level";
 799         case V4L2_CID_AUTO_WHITE_BALANCE:       return "White Balance, Automatic";
 800         case V4L2_CID_DO_WHITE_BALANCE:         return "Do White Balance";
 801         case V4L2_CID_RED_BALANCE:              return "Red Balance";
 802         case V4L2_CID_BLUE_BALANCE:             return "Blue Balance";
 803         case V4L2_CID_GAMMA:                    return "Gamma";
 804         case V4L2_CID_EXPOSURE:                 return "Exposure";
 805         case V4L2_CID_AUTOGAIN:                 return "Gain, Automatic";
 806         case V4L2_CID_GAIN:                     return "Gain";
 807         case V4L2_CID_HFLIP:                    return "Horizontal Flip";
 808         case V4L2_CID_VFLIP:                    return "Vertical Flip";
 809         case V4L2_CID_POWER_LINE_FREQUENCY:     return "Power Line Frequency";
 810         case V4L2_CID_HUE_AUTO:                 return "Hue, Automatic";
 811         case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
 812         case V4L2_CID_SHARPNESS:                return "Sharpness";
 813         case V4L2_CID_BACKLIGHT_COMPENSATION:   return "Backlight Compensation";
 814         case V4L2_CID_CHROMA_AGC:               return "Chroma AGC";
 815         case V4L2_CID_COLOR_KILLER:             return "Color Killer";
 816         case V4L2_CID_COLORFX:                  return "Color Effects";
 817         case V4L2_CID_AUTOBRIGHTNESS:           return "Brightness, Automatic";
 818         case V4L2_CID_BAND_STOP_FILTER:         return "Band-Stop Filter";
 819         case V4L2_CID_ROTATE:                   return "Rotate";
 820         case V4L2_CID_BG_COLOR:                 return "Background Color";
 821         case V4L2_CID_CHROMA_GAIN:              return "Chroma Gain";
 822         case V4L2_CID_ILLUMINATORS_1:           return "Illuminator 1";
 823         case V4L2_CID_ILLUMINATORS_2:           return "Illuminator 2";
 824         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:  return "Min Number of Capture Buffers";
 825         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:   return "Min Number of Output Buffers";
 826         case V4L2_CID_ALPHA_COMPONENT:          return "Alpha Component";
 827         case V4L2_CID_COLORFX_CBCR:             return "Color Effects, CbCr";
 828
 829         /* Codec controls */
 830         /* The MPEG controls are applicable to all codec controls
 831          * and the 'MPEG' part of the define is historical */
 832         /* Keep the order of the 'case's the same as in videodev2.h! */
 833         case V4L2_CID_MPEG_CLASS:               return "Codec Controls";
 834         case V4L2_CID_MPEG_STREAM_TYPE:         return "Stream Type";
 835         case V4L2_CID_MPEG_STREAM_PID_PMT:      return "Stream PMT Program ID";
 836         case V4L2_CID_MPEG_STREAM_PID_AUDIO:    return "Stream Audio Program ID";
 837         case V4L2_CID_MPEG_STREAM_PID_VIDEO:    return "Stream Video Program ID";
 838         case V4L2_CID_MPEG_STREAM_PID_PCR:      return "Stream PCR Program ID";
 839         case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
 840         case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
 841         case V4L2_CID_MPEG_STREAM_VBI_FMT:      return "Stream VBI Format";
 842         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
 843         case V4L2_CID_MPEG_AUDIO_ENCODING:      return "Audio Encoding";
 844         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    return "Audio Layer I Bitrate";
 845         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    return "Audio Layer II Bitrate";
 846         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    return "Audio Layer III Bitrate";
 847         case V4L2_CID_MPEG_AUDIO_MODE:          return "Audio Stereo Mode";
 848         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
 849         case V4L2_CID_MPEG_AUDIO_EMPHASIS:      return "Audio Emphasis";
 850         case V4L2_CID_MPEG_AUDIO_CRC:           return "Audio CRC";
 851         case V4L2_CID_MPEG_AUDIO_MUTE:          return "Audio Mute";
 852         case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:   return "Audio AAC Bitrate";
 853         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:   return "Audio AC-3 Bitrate";
 854         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:  return "Audio Playback";
 855         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
 856         case V4L2_CID_MPEG_VIDEO_ENCODING:      return "Video Encoding";
 857         case V4L2_CID_MPEG_VIDEO_ASPECT:        return "Video Aspect";
 858         case V4L2_CID_MPEG_VIDEO_B_FRAMES:      return "Video B Frames";
 859         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      return "Video GOP Size";
 860         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   return "Video GOP Closure";
 861         case V4L2_CID_MPEG_VIDEO_PULLDOWN:      return "Video Pulldown";
 862         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  return "Video Bitrate Mode";
 863         case V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY:      return "Constant Quality";
 864         case V4L2_CID_MPEG_VIDEO_BITRATE:       return "Video Bitrate";
 865         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  return "Video Peak Bitrate";
 866         case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
 867         case V4L2_CID_MPEG_VIDEO_MUTE:          return "Video Mute";
 868         case V4L2_CID_MPEG_VIDEO_MUTE_YUV:      return "Video Mute YUV";
 869         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:       return "Decoder Slice Interface";
 870         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:  return "MPEG4 Loop Filter Enable";
 871         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:       return "Number of Intra Refresh MBs";
 872         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:               return "Frame Level Rate Control Enable";
 873         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:                  return "H264 MB Level Rate Control";
 874         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:                   return "Sequence Header Mode";
 875         case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC:                   return "Max Number of Reference Pics";
 876         case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:               return "Frame Skip Mode";
 877         case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:               return "H263 I-Frame QP Value";
 878         case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:               return "H263 P-Frame QP Value";
 879         case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:               return "H263 B-Frame QP Value";
 880         case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:                   return "H263 Minimum QP Value";
 881         case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:                   return "H263 Maximum QP Value";
 882         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:               return "H264 I-Frame QP Value";
 883         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:               return "H264 P-Frame QP Value";
 884         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:               return "H264 B-Frame QP Value";
 885         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:                   return "H264 Maximum QP Value";
 886         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:                   return "H264 Minimum QP Value";
 887         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:            return "H264 8x8 Transform Enable";
 888         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:                 return "H264 CPB Buffer Size";
 889         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:             return "H264 Entropy Mode";
 890         case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:                 return "H264 I-Frame Period";
 891         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:                    return "H264 Level";
 892         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:        return "H264 Loop Filter Alpha Offset";
 893         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:         return "H264 Loop Filter Beta Offset";
 894         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:         return "H264 Loop Filter Mode";
 895         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:                  return "H264 Profile";
 896         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:       return "Vertical Size of SAR";
 897         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:        return "Horizontal Size of SAR";
 898         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:           return "Aspect Ratio VUI Enable";
 899         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:              return "VUI Aspect Ratio IDC";
 900         case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING:        return "H264 Enable Frame Packing SEI";
 901         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0:   return "H264 Set Curr. Frame as Frame0";
 902         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:  return "H264 FP Arrangement Type";
 903         case V4L2_CID_MPEG_VIDEO_H264_FMO:                      return "H264 Flexible MB Ordering";
 904         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:             return "H264 Map Type for FMO";
 905         case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP:          return "H264 FMO Number of Slice Groups";
 906         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION:     return "H264 FMO Direction of Change";
 907         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE:          return "H264 FMO Size of 1st Slice Grp";
 908         case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH:           return "H264 FMO No. of Consecutive MBs";
 909         case V4L2_CID_MPEG_VIDEO_H264_ASO:                      return "H264 Arbitrary Slice Ordering";
 910         case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER:          return "H264 ASO Slice Order";
 911         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING:      return "Enable H264 Hierarchical Coding";
 912         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type";
 913         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
 914         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
 915                                                                 return "H264 Set QP Value for HC Layers";
 916         case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION:
 917                                                                 return "H264 Constrained Intra Pred";
 918         case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET:   return "H264 Chroma QP Index Offset";
 919         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP:           return "H264 I-Frame Minimum QP Value";
 920         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP:           return "H264 I-Frame Maximum QP Value";
 921         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP:           return "H264 P-Frame Minimum QP Value";
 922         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP:           return "H264 P-Frame Maximum QP Value";
 923         case V4L2_CID_MPEG_VIDEO_H264_SPS:                      return "H264 Sequence Parameter Set";
 924         case V4L2_CID_MPEG_VIDEO_H264_PPS:                      return "H264 Picture Parameter Set";
 925         case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX:           return "H264 Scaling Matrix";
 926         case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS:             return "H264 Slice Parameters";
 927         case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS:            return "H264 Decode Parameters";
 928         case V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE:              return "H264 Decode Mode";
 929         case V4L2_CID_MPEG_VIDEO_H264_START_CODE:               return "H264 Start Code";
 930         case V4L2_CID_MPEG_VIDEO_H264_PRED_WEIGHTS:             return "H264 Prediction Weight Table";
 931         case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:                   return "MPEG2 Level";
 932         case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:                 return "MPEG2 Profile";
 933         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:              return "MPEG4 I-Frame QP Value";
 934         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:              return "MPEG4 P-Frame QP Value";
 935         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:              return "MPEG4 B-Frame QP Value";
 936         case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:                  return "MPEG4 Minimum QP Value";
 937         case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:                  return "MPEG4 Maximum QP Value";
 938         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:                   return "MPEG4 Level";
 939         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:                 return "MPEG4 Profile";
 940         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:                    return "Quarter Pixel Search Enable";
 941         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:         return "Maximum Bytes in a Slice";
 942         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:            return "Number of MBs in a Slice";
 943         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:              return "Slice Partitioning Method";
 944         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:                      return "VBV Buffer Size";
 945         case V4L2_CID_MPEG_VIDEO_DEC_PTS:                       return "Video Decoder PTS";
 946         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:                     return "Video Decoder Frame Count";
 947         case V4L2_CID_MPEG_VIDEO_VBV_DELAY:                     return "Initial Delay for VBV Control";
 948         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:             return "Horizontal MV Search Range";
 949         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:             return "Vertical MV Search Range";
 950         case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:             return "Repeat Sequence Header";
 951         case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:               return "Force Key Frame";
 952         case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS:            return "MPEG-2 Slice Parameters";
 953         case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION:            return "MPEG-2 Quantization Matrices";
 954         case V4L2_CID_MPEG_VIDEO_FWHT_PARAMS:                   return "FWHT Stateless Parameters";
 955         case V4L2_CID_FWHT_I_FRAME_QP:                          return "FWHT I-Frame QP Value";
 956         case V4L2_CID_FWHT_P_FRAME_QP:                          return "FWHT P-Frame QP Value";
 957
 958         /* VPX controls */
 959         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:            return "VPX Number of Partitions";
 960         case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4:           return "VPX Intra Mode Decision Disable";
 961         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:            return "VPX No. of Refs for P Frame";
 962         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL:              return "VPX Loop Filter Level Range";
 963         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS:          return "VPX Deblocking Effect Control";
 964         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD:   return "VPX Golden Frame Refresh Period";
 965         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:          return "VPX Golden Frame Indicator";
 966         case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:                    return "VPX Minimum QP Value";
 967         case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:                    return "VPX Maximum QP Value";
 968         case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP:                return "VPX I-Frame QP Value";
 969         case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP:                return "VPX P-Frame QP Value";
 970         case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:                   return "VP8 Profile";
 971         case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:                   return "VP9 Profile";
 972         case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:                     return "VP9 Level";
 973         case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER:              return "VP8 Frame Header";
 974
 975         /* HEVC controls */
 976         case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP:               return "HEVC I-Frame QP Value";
 977         case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP:               return "HEVC P-Frame QP Value";
 978         case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP:               return "HEVC B-Frame QP Value";
 979         case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP:                   return "HEVC Minimum QP Value";
 980         case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP:                   return "HEVC Maximum QP Value";
 981         case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:                  return "HEVC Profile";
 982         case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:                    return "HEVC Level";
 983         case V4L2_CID_MPEG_VIDEO_HEVC_TIER:                     return "HEVC Tier";
 984         case V4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTION:    return "HEVC Frame Rate Resolution";
 985         case V4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTH:      return "HEVC Maximum Coding Unit Depth";
 986         case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:             return "HEVC Refresh Type";
 987         case V4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PRED:         return "HEVC Constant Intra Prediction";
 988         case V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU:              return "HEVC Lossless Encoding";
 989         case V4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONT:                return "HEVC Wavefront";
 990         case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:         return "HEVC Loop Filter";
 991         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP:                  return "HEVC QP Values";
 992         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:         return "HEVC Hierarchical Coding Type";
 993         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER:        return "HEVC Hierarchical Coding Layer";
 994         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP:        return "HEVC Hierarchical Layer 0 QP";
 995         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP:        return "HEVC Hierarchical Layer 1 QP";
 996         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP:        return "HEVC Hierarchical Layer 2 QP";
 997         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP:        return "HEVC Hierarchical Layer 3 QP";
 998         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP:        return "HEVC Hierarchical Layer 4 QP";
 999         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP:        return "HEVC Hierarchical Layer 5 QP";
1000         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP:        return "HEVC Hierarchical Layer 6 QP";
1001         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR:        return "HEVC Hierarchical Lay 0 BitRate";
1002         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR:        return "HEVC Hierarchical Lay 1 BitRate";
1003         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR:        return "HEVC Hierarchical Lay 2 BitRate";
1004         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR:        return "HEVC Hierarchical Lay 3 BitRate";
1005         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR:        return "HEVC Hierarchical Lay 4 BitRate";
1006         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR:        return "HEVC Hierarchical Lay 5 BitRate";
1007         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BR:        return "HEVC Hierarchical Lay 6 BitRate";
1008         case V4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PB:               return "HEVC General PB";
1009         case V4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_ID:              return "HEVC Temporal ID";
1010         case V4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHING:         return "HEVC Strong Intra Smoothing";
1011         case V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLIT:           return "HEVC Intra PU Split";
1012         case V4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTION:           return "HEVC TMV Prediction";
1013         case V4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1:  return "HEVC Max Num of Candidate MVs";
1014         case V4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODE:        return "HEVC ENC Without Startcode";
1015         case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIOD:           return "HEVC Num of I-Frame b/w 2 IDR";
1016         case V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2:      return "HEVC Loop Filter Beta Offset";
1017         case V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2:        return "HEVC Loop Filter TC Offset";
1018         case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:     return "HEVC Size of Length Field";
1019         case V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES:        return "Reference Frames for a P-Frame";
1020         case V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR:         return "Prepend SPS and PPS to IDR";
1021         case V4L2_CID_MPEG_VIDEO_HEVC_SPS:                      return "HEVC Sequence Parameter Set";
1022         case V4L2_CID_MPEG_VIDEO_HEVC_PPS:                      return "HEVC Picture Parameter Set";
1023         case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS:             return "HEVC Slice Parameters";
1024         case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:              return "HEVC Decode Mode";
1025         case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:               return "HEVC Start Code";
1026
1027         /* CAMERA controls */
1028         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1029         case V4L2_CID_CAMERA_CLASS:             return "Camera Controls";
1030         case V4L2_CID_EXPOSURE_AUTO:            return "Auto Exposure";
1031         case V4L2_CID_EXPOSURE_ABSOLUTE:        return "Exposure Time, Absolute";
1032         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:   return "Exposure, Dynamic Framerate";
1033         case V4L2_CID_PAN_RELATIVE:             return "Pan, Relative";
1034         case V4L2_CID_TILT_RELATIVE:            return "Tilt, Relative";
1035         case V4L2_CID_PAN_RESET:                return "Pan, Reset";
1036         case V4L2_CID_TILT_RESET:               return "Tilt, Reset";
1037         case V4L2_CID_PAN_ABSOLUTE:             return "Pan, Absolute";
1038         case V4L2_CID_TILT_ABSOLUTE:            return "Tilt, Absolute";
1039         case V4L2_CID_FOCUS_ABSOLUTE:           return "Focus, Absolute";
1040         case V4L2_CID_FOCUS_RELATIVE:           return "Focus, Relative";
1041         case V4L2_CID_FOCUS_AUTO:               return "Focus, Automatic Continuous";
1042         case V4L2_CID_ZOOM_ABSOLUTE:            return "Zoom, Absolute";
1043         case V4L2_CID_ZOOM_RELATIVE:            return "Zoom, Relative";
1044         case V4L2_CID_ZOOM_CONTINUOUS:          return "Zoom, Continuous";
1045         case V4L2_CID_PRIVACY:                  return "Privacy";
1046         case V4L2_CID_IRIS_ABSOLUTE:            return "Iris, Absolute";
1047         case V4L2_CID_IRIS_RELATIVE:            return "Iris, Relative";
1048         case V4L2_CID_AUTO_EXPOSURE_BIAS:       return "Auto Exposure, Bias";
1049         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
1050         case V4L2_CID_WIDE_DYNAMIC_RANGE:       return "Wide Dynamic Range";
1051         case V4L2_CID_IMAGE_STABILIZATION:      return "Image Stabilization";
1052         case V4L2_CID_ISO_SENSITIVITY:          return "ISO Sensitivity";
1053         case V4L2_CID_ISO_SENSITIVITY_AUTO:     return "ISO Sensitivity, Auto";
1054         case V4L2_CID_EXPOSURE_METERING:        return "Exposure, Metering Mode";
1055         case V4L2_CID_SCENE_MODE:               return "Scene Mode";
1056         case V4L2_CID_3A_LOCK:                  return "3A Lock";
1057         case V4L2_CID_AUTO_FOCUS_START:         return "Auto Focus, Start";
1058         case V4L2_CID_AUTO_FOCUS_STOP:          return "Auto Focus, Stop";
1059         case V4L2_CID_AUTO_FOCUS_STATUS:        return "Auto Focus, Status";
1060         case V4L2_CID_AUTO_FOCUS_RANGE:         return "Auto Focus, Range";
1061         case V4L2_CID_PAN_SPEED:                return "Pan, Speed";
1062         case V4L2_CID_TILT_SPEED:               return "Tilt, Speed";
1063         case V4L2_CID_UNIT_CELL_SIZE:           return "Unit Cell Size";
1064         case V4L2_CID_CAMERA_ORIENTATION:       return "Camera Orientation";
1065         case V4L2_CID_CAMERA_SENSOR_ROTATION:   return "Camera Sensor Rotation";
1066
1067         /* FM Radio Modulator controls */
1068         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1069         case V4L2_CID_FM_TX_CLASS:              return "FM Radio Modulator Controls";
1070         case V4L2_CID_RDS_TX_DEVIATION:         return "RDS Signal Deviation";
1071         case V4L2_CID_RDS_TX_PI:                return "RDS Program ID";
1072         case V4L2_CID_RDS_TX_PTY:               return "RDS Program Type";
1073         case V4L2_CID_RDS_TX_PS_NAME:           return "RDS PS Name";
1074         case V4L2_CID_RDS_TX_RADIO_TEXT:        return "RDS Radio Text";
1075         case V4L2_CID_RDS_TX_MONO_STEREO:       return "RDS Stereo";
1076         case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:   return "RDS Artificial Head";
1077         case V4L2_CID_RDS_TX_COMPRESSED:        return "RDS Compressed";
1078         case V4L2_CID_RDS_TX_DYNAMIC_PTY:       return "RDS Dynamic PTY";
1079         case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
1080         case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:   return "RDS Traffic Program";
1081         case V4L2_CID_RDS_TX_MUSIC_SPEECH:      return "RDS Music";
1082         case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:  return "RDS Enable Alt Frequencies";
1083         case V4L2_CID_RDS_TX_ALT_FREQS:         return "RDS Alternate Frequencies";
1084         case V4L2_CID_AUDIO_LIMITER_ENABLED:    return "Audio Limiter Feature Enabled";
1085         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
1086         case V4L2_CID_AUDIO_LIMITER_DEVIATION:  return "Audio Limiter Deviation";
1087         case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
1088         case V4L2_CID_AUDIO_COMPRESSION_GAIN:   return "Audio Compression Gain";
1089         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
1090         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
1091         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
1092         case V4L2_CID_PILOT_TONE_ENABLED:       return "Pilot Tone Feature Enabled";
1093         case V4L2_CID_PILOT_TONE_DEVIATION:     return "Pilot Tone Deviation";
1094         case V4L2_CID_PILOT_TONE_FREQUENCY:     return "Pilot Tone Frequency";
1095         case V4L2_CID_TUNE_PREEMPHASIS:         return "Pre-Emphasis";
1096         case V4L2_CID_TUNE_POWER_LEVEL:         return "Tune Power Level";
1097         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:   return "Tune Antenna Capacitor";
1098
1099         /* Flash controls */
1100         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1101         case V4L2_CID_FLASH_CLASS:              return "Flash Controls";
1102         case V4L2_CID_FLASH_LED_MODE:           return "LED Mode";
1103         case V4L2_CID_FLASH_STROBE_SOURCE:      return "Strobe Source";
1104         case V4L2_CID_FLASH_STROBE:             return "Strobe";
1105         case V4L2_CID_FLASH_STROBE_STOP:        return "Stop Strobe";
1106         case V4L2_CID_FLASH_STROBE_STATUS:      return "Strobe Status";
1107         case V4L2_CID_FLASH_TIMEOUT:            return "Strobe Timeout";
1108         case V4L2_CID_FLASH_INTENSITY:          return "Intensity, Flash Mode";
1109         case V4L2_CID_FLASH_TORCH_INTENSITY:    return "Intensity, Torch Mode";
1110         case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
1111         case V4L2_CID_FLASH_FAULT:              return "Faults";
1112         case V4L2_CID_FLASH_CHARGE:             return "Charge";
1113         case V4L2_CID_FLASH_READY:              return "Ready to Strobe";
1114
1115         /* JPEG encoder controls */
1116         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1117         case V4L2_CID_JPEG_CLASS:               return "JPEG Compression Controls";
1118         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:  return "Chroma Subsampling";
1119         case V4L2_CID_JPEG_RESTART_INTERVAL:    return "Restart Interval";
1120         case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
1121         case V4L2_CID_JPEG_ACTIVE_MARKER:       return "Active Markers";
1122
1123         /* Image source controls */
1124         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1125         case V4L2_CID_IMAGE_SOURCE_CLASS:       return "Image Source Controls";
1126         case V4L2_CID_VBLANK:                   return "Vertical Blanking";
1127         case V4L2_CID_HBLANK:                   return "Horizontal Blanking";
1128         case V4L2_CID_ANALOGUE_GAIN:            return "Analogue Gain";
1129         case V4L2_CID_TEST_PATTERN_RED:         return "Red Pixel Value";
1130         case V4L2_CID_TEST_PATTERN_GREENR:      return "Green (Red) Pixel Value";
1131         case V4L2_CID_TEST_PATTERN_BLUE:        return "Blue Pixel Value";
1132         case V4L2_CID_TEST_PATTERN_GREENB:      return "Green (Blue) Pixel Value";
1133
1134         /* Image processing controls */
1135         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1136         case V4L2_CID_IMAGE_PROC_CLASS:         return "Image Processing Controls";
1137         case V4L2_CID_LINK_FREQ:                return "Link Frequency";
1138         case V4L2_CID_PIXEL_RATE:               return "Pixel Rate";
1139         case V4L2_CID_TEST_PATTERN:             return "Test Pattern";
1140         case V4L2_CID_DEINTERLACING_MODE:       return "Deinterlacing Mode";
1141         case V4L2_CID_DIGITAL_GAIN:             return "Digital Gain";
1142
1143         /* DV controls */
1144         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1145         case V4L2_CID_DV_CLASS:                 return "Digital Video Controls";
1146         case V4L2_CID_DV_TX_HOTPLUG:            return "Hotplug Present";
1147         case V4L2_CID_DV_TX_RXSENSE:            return "RxSense Present";
1148         case V4L2_CID_DV_TX_EDID_PRESENT:       return "EDID Present";
1149         case V4L2_CID_DV_TX_MODE:               return "Transmit Mode";
1150         case V4L2_CID_DV_TX_RGB_RANGE:          return "Tx RGB Quantization Range";
1151         case V4L2_CID_DV_TX_IT_CONTENT_TYPE:    return "Tx IT Content Type";
1152         case V4L2_CID_DV_RX_POWER_PRESENT:      return "Power Present";
1153         case V4L2_CID_DV_RX_RGB_RANGE:          return "Rx RGB Quantization Range";
1154         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:    return "Rx IT Content Type";
1155
1156         case V4L2_CID_FM_RX_CLASS:              return "FM Radio Receiver Controls";
1157         case V4L2_CID_TUNE_DEEMPHASIS:          return "De-Emphasis";
1158         case V4L2_CID_RDS_RECEPTION:            return "RDS Reception";
1159         case V4L2_CID_RF_TUNER_CLASS:           return "RF Tuner Controls";
1160         case V4L2_CID_RF_TUNER_RF_GAIN:         return "RF Gain";
1161         case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:   return "LNA Gain, Auto";
1162         case V4L2_CID_RF_TUNER_LNA_GAIN:        return "LNA Gain";
1163         case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO: return "Mixer Gain, Auto";
1164         case V4L2_CID_RF_TUNER_MIXER_GAIN:      return "Mixer Gain";
1165         case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:    return "IF Gain, Auto";
1166         case V4L2_CID_RF_TUNER_IF_GAIN:         return "IF Gain";
1167         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:  return "Bandwidth, Auto";
1168         case V4L2_CID_RF_TUNER_BANDWIDTH:       return "Bandwidth";
1169         case V4L2_CID_RF_TUNER_PLL_LOCK:        return "PLL Lock";
1170         case V4L2_CID_RDS_RX_PTY:               return "RDS Program Type";
1171         case V4L2_CID_RDS_RX_PS_NAME:           return "RDS PS Name";
1172         case V4L2_CID_RDS_RX_RADIO_TEXT:        return "RDS Radio Text";
1173         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
1174         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:   return "RDS Traffic Program";
1175         case V4L2_CID_RDS_RX_MUSIC_SPEECH:      return "RDS Music";
1176
1177         /* Detection controls */
1178         /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1179         case V4L2_CID_DETECT_CLASS:             return "Detection Controls";
1180         case V4L2_CID_DETECT_MD_MODE:           return "Motion Detection Mode";
1181         case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: return "MD Global Threshold";
1182         case V4L2_CID_DETECT_MD_THRESHOLD_GRID: return "MD Threshold Grid";
1183         case V4L2_CID_DETECT_MD_REGION_GRID:    return "MD Region Grid";
1184         default:
1185                 return NULL;
1186         }
1187 }
1188 EXPORT_SYMBOL(v4l2_ctrl_get_name);
1189
1190 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
1191                     s64 *min, s64 *max, u64 *step, s64 *def, u32 *flags)
1192 {
1193         *name = v4l2_ctrl_get_name(id);
1194         *flags = 0;
1195
1196         switch (id) {
1197         case V4L2_CID_AUDIO_MUTE:
1198         case V4L2_CID_AUDIO_LOUDNESS:
1199         case V4L2_CID_AUTO_WHITE_BALANCE:
1200         case V4L2_CID_AUTOGAIN:
1201         case V4L2_CID_HFLIP:
1202         case V4L2_CID_VFLIP:
1203         case V4L2_CID_HUE_AUTO:
1204         case V4L2_CID_CHROMA_AGC:
1205         case V4L2_CID_COLOR_KILLER:
1206         case V4L2_CID_AUTOBRIGHTNESS:
1207         case V4L2_CID_MPEG_AUDIO_MUTE:
1208         case V4L2_CID_MPEG_VIDEO_MUTE:
1209         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1210         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1211         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
1212         case V4L2_CID_FOCUS_AUTO:
1213         case V4L2_CID_PRIVACY:
1214         case V4L2_CID_AUDIO_LIMITER_ENABLED:
1215         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1216         case V4L2_CID_PILOT_TONE_ENABLED:
1217         case V4L2_CID_ILLUMINATORS_1:
1218         case V4L2_CID_ILLUMINATORS_2:
1219         case V4L2_CID_FLASH_STROBE_STATUS:
1220         case V4L2_CID_FLASH_CHARGE:
1221         case V4L2_CID_FLASH_READY:
1222         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
1223         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
1224         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1225         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1226         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1227         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
1228         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
1229         case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
1230         case V4L2_CID_WIDE_DYNAMIC_RANGE:
1231         case V4L2_CID_IMAGE_STABILIZATION:
1232         case V4L2_CID_RDS_RECEPTION:
1233         case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
1234         case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
1235         case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:
1236         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1237         case V4L2_CID_RF_TUNER_PLL_LOCK:
1238         case V4L2_CID_RDS_TX_MONO_STEREO:
1239         case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
1240         case V4L2_CID_RDS_TX_COMPRESSED:
1241         case V4L2_CID_RDS_TX_DYNAMIC_PTY:
1242         case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
1243         case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
1244         case V4L2_CID_RDS_TX_MUSIC_SPEECH:
1245         case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
1246         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1247         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1248         case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1249                 *type = V4L2_CTRL_TYPE_BOOLEAN;
1250                 *min = 0;
1251                 *max = *step = 1;
1252                 break;
1253         case V4L2_CID_ROTATE:
1254                 *type = V4L2_CTRL_TYPE_INTEGER;
1255                 *flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
1256                 break;
1257         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
1258         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
1259                 *type = V4L2_CTRL_TYPE_INTEGER;
1260                 break;
1261         case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
1262         case V4L2_CID_PAN_RESET:
1263         case V4L2_CID_TILT_RESET:
1264         case V4L2_CID_FLASH_STROBE:
1265         case V4L2_CID_FLASH_STROBE_STOP:
1266         case V4L2_CID_AUTO_FOCUS_START:
1267         case V4L2_CID_AUTO_FOCUS_STOP:
1268         case V4L2_CID_DO_WHITE_BALANCE:
1269                 *type = V4L2_CTRL_TYPE_BUTTON;
1270                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1271                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1272                 *min = *max = *step = *def = 0;
1273                 break;
1274         case V4L2_CID_POWER_LINE_FREQUENCY:
1275         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1276         case V4L2_CID_MPEG_AUDIO_ENCODING:
1277         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1278         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1279         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1280         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
1281         case V4L2_CID_MPEG_AUDIO_MODE:
1282         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1283         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1284         case V4L2_CID_MPEG_AUDIO_CRC:
1285         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
1286         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
1287         case V4L2_CID_MPEG_VIDEO_ENCODING:
1288         case V4L2_CID_MPEG_VIDEO_ASPECT:
1289         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1290         case V4L2_CID_MPEG_STREAM_TYPE:
1291         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1292         case V4L2_CID_EXPOSURE_AUTO:
1293         case V4L2_CID_AUTO_FOCUS_RANGE:
1294         case V4L2_CID_COLORFX:
1295         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1296         case V4L2_CID_TUNE_PREEMPHASIS:
1297         case V4L2_CID_FLASH_LED_MODE:
1298         case V4L2_CID_FLASH_STROBE_SOURCE:
1299         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1300         case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
1301         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1302         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1303         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1304         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1305         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1306         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1307         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1308         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1309         case V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE:
1310         case V4L2_CID_MPEG_VIDEO_H264_START_CODE:
1311         case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:
1312         case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:
1313         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1314         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1315         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1316         case V4L2_CID_ISO_SENSITIVITY_AUTO:
1317         case V4L2_CID_EXPOSURE_METERING:
1318         case V4L2_CID_SCENE_MODE:
1319         case V4L2_CID_DV_TX_MODE:
1320         case V4L2_CID_DV_TX_RGB_RANGE:
1321         case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
1322         case V4L2_CID_DV_RX_RGB_RANGE:
1323         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1324         case V4L2_CID_TEST_PATTERN:
1325         case V4L2_CID_DEINTERLACING_MODE:
1326         case V4L2_CID_TUNE_DEEMPHASIS:
1327         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1328         case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
1329         case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
1330         case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:
1331         case V4L2_CID_DETECT_MD_MODE:
1332         case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
1333         case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
1334         case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
1335         case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
1336         case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
1337         case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
1338         case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
1339         case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:
1340         case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:
1341         case V4L2_CID_CAMERA_ORIENTATION:
1342                 *type = V4L2_CTRL_TYPE_MENU;
1343                 break;
1344         case V4L2_CID_LINK_FREQ:
1345                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1346                 break;
1347         case V4L2_CID_RDS_TX_PS_NAME:
1348         case V4L2_CID_RDS_TX_RADIO_TEXT:
1349         case V4L2_CID_RDS_RX_PS_NAME:
1350         case V4L2_CID_RDS_RX_RADIO_TEXT:
1351                 *type = V4L2_CTRL_TYPE_STRING;
1352                 break;
1353         case V4L2_CID_ISO_SENSITIVITY:
1354         case V4L2_CID_AUTO_EXPOSURE_BIAS:
1355         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1356         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1357                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1358                 break;
1359         case V4L2_CID_USER_CLASS:
1360         case V4L2_CID_CAMERA_CLASS:
1361         case V4L2_CID_MPEG_CLASS:
1362         case V4L2_CID_FM_TX_CLASS:
1363         case V4L2_CID_FLASH_CLASS:
1364         case V4L2_CID_JPEG_CLASS:
1365         case V4L2_CID_IMAGE_SOURCE_CLASS:
1366         case V4L2_CID_IMAGE_PROC_CLASS:
1367         case V4L2_CID_DV_CLASS:
1368         case V4L2_CID_FM_RX_CLASS:
1369         case V4L2_CID_RF_TUNER_CLASS:
1370         case V4L2_CID_DETECT_CLASS:
1371                 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
1372                 /* You can neither read not write these */
1373                 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1374                 *min = *max = *step = *def = 0;
1375                 break;
1376         case V4L2_CID_BG_COLOR:
1377                 *type = V4L2_CTRL_TYPE_INTEGER;
1378                 *step = 1;
1379                 *min = 0;
1380                 /* Max is calculated as RGB888 that is 2^24 */
1381                 *max = 0xFFFFFF;
1382                 break;
1383         case V4L2_CID_FLASH_FAULT:
1384         case V4L2_CID_JPEG_ACTIVE_MARKER:
1385         case V4L2_CID_3A_LOCK:
1386         case V4L2_CID_AUTO_FOCUS_STATUS:
1387         case V4L2_CID_DV_TX_HOTPLUG:
1388         case V4L2_CID_DV_TX_RXSENSE:
1389         case V4L2_CID_DV_TX_EDID_PRESENT:
1390         case V4L2_CID_DV_RX_POWER_PRESENT:
1391                 *type = V4L2_CTRL_TYPE_BITMASK;
1392                 break;
1393         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1394         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1395                 *type = V4L2_CTRL_TYPE_INTEGER;
1396                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1397                 break;
1398         case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1399                 *type = V4L2_CTRL_TYPE_INTEGER64;
1400                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1401                 *min = *def = 0;
1402                 *max = 0x1ffffffffLL;
1403                 *step = 1;
1404                 break;
1405         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1406                 *type = V4L2_CTRL_TYPE_INTEGER64;
1407                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1408                 *min = *def = 0;
1409                 *max = 0x7fffffffffffffffLL;
1410                 *step = 1;
1411                 break;
1412         case V4L2_CID_PIXEL_RATE:
1413                 *type = V4L2_CTRL_TYPE_INTEGER64;
1414                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1415                 break;
1416         case V4L2_CID_DETECT_MD_REGION_GRID:
1417                 *type = V4L2_CTRL_TYPE_U8;
1418                 break;
1419         case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
1420                 *type = V4L2_CTRL_TYPE_U16;
1421                 break;
1422         case V4L2_CID_RDS_TX_ALT_FREQS:
1423                 *type = V4L2_CTRL_TYPE_U32;
1424                 break;
1425         case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS:
1426                 *type = V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS;
1427                 break;
1428         case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION:
1429                 *type = V4L2_CTRL_TYPE_MPEG2_QUANTIZATION;
1430                 break;
1431         case V4L2_CID_MPEG_VIDEO_FWHT_PARAMS:
1432                 *type = V4L2_CTRL_TYPE_FWHT_PARAMS;
1433                 break;
1434         case V4L2_CID_MPEG_VIDEO_H264_SPS:
1435                 *type = V4L2_CTRL_TYPE_H264_SPS;
1436                 break;
1437         case V4L2_CID_MPEG_VIDEO_H264_PPS:
1438                 *type = V4L2_CTRL_TYPE_H264_PPS;
1439                 break;
1440         case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX:
1441                 *type = V4L2_CTRL_TYPE_H264_SCALING_MATRIX;
1442                 break;
1443         case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS:
1444                 *type = V4L2_CTRL_TYPE_H264_SLICE_PARAMS;
1445                 break;
1446         case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS:
1447                 *type = V4L2_CTRL_TYPE_H264_DECODE_PARAMS;
1448                 break;
1449         case V4L2_CID_MPEG_VIDEO_H264_PRED_WEIGHTS:
1450                 *type = V4L2_CTRL_TYPE_H264_PRED_WEIGHTS;
1451                 break;
1452         case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER:
1453                 *type = V4L2_CTRL_TYPE_VP8_FRAME_HEADER;
1454                 break;
1455         case V4L2_CID_MPEG_VIDEO_HEVC_SPS:
1456                 *type = V4L2_CTRL_TYPE_HEVC_SPS;
1457                 break;
1458         case V4L2_CID_MPEG_VIDEO_HEVC_PPS:
1459                 *type = V4L2_CTRL_TYPE_HEVC_PPS;
1460                 break;
1461         case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS:
1462                 *type = V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS;
1463                 break;
1464         case V4L2_CID_UNIT_CELL_SIZE:
1465                 *type = V4L2_CTRL_TYPE_AREA;
1466                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1467                 break;
1468         default:
1469                 *type = V4L2_CTRL_TYPE_INTEGER;
1470                 break;
1471         }
1472         switch (id) {
1473         case V4L2_CID_MPEG_AUDIO_ENCODING:
1474         case V4L2_CID_MPEG_AUDIO_MODE:
1475         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1476         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1477         case V4L2_CID_MPEG_STREAM_TYPE:
1478                 *flags |= V4L2_CTRL_FLAG_UPDATE;
1479                 break;
1480         case V4L2_CID_AUDIO_VOLUME:
1481         case V4L2_CID_AUDIO_BALANCE:
1482         case V4L2_CID_AUDIO_BASS:
1483         case V4L2_CID_AUDIO_TREBLE:
1484         case V4L2_CID_BRIGHTNESS:
1485         case V4L2_CID_CONTRAST:
1486         case V4L2_CID_SATURATION:
1487         case V4L2_CID_HUE:
1488         case V4L2_CID_RED_BALANCE:
1489         case V4L2_CID_BLUE_BALANCE:
1490         case V4L2_CID_GAMMA:
1491         case V4L2_CID_SHARPNESS:
1492         case V4L2_CID_CHROMA_GAIN:
1493         case V4L2_CID_RDS_TX_DEVIATION:
1494         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1495         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1496         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1497         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1498         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1499         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1500         case V4L2_CID_PILOT_TONE_DEVIATION:
1501         case V4L2_CID_PILOT_TONE_FREQUENCY:
1502         case V4L2_CID_TUNE_POWER_LEVEL:
1503         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1504         case V4L2_CID_RF_TUNER_RF_GAIN:
1505         case V4L2_CID_RF_TUNER_LNA_GAIN:
1506         case V4L2_CID_RF_TUNER_MIXER_GAIN:
1507         case V4L2_CID_RF_TUNER_IF_GAIN:
1508         case V4L2_CID_RF_TUNER_BANDWIDTH:
1509         case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
1510                 *flags |= V4L2_CTRL_FLAG_SLIDER;
1511                 break;
1512         case V4L2_CID_PAN_RELATIVE:
1513         case V4L2_CID_TILT_RELATIVE:
1514         case V4L2_CID_FOCUS_RELATIVE:
1515         case V4L2_CID_IRIS_RELATIVE:
1516         case V4L2_CID_ZOOM_RELATIVE:
1517                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1518                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1519                 break;
1520         case V4L2_CID_FLASH_STROBE_STATUS:
1521         case V4L2_CID_AUTO_FOCUS_STATUS:
1522         case V4L2_CID_FLASH_READY:
1523         case V4L2_CID_DV_TX_HOTPLUG:
1524         case V4L2_CID_DV_TX_RXSENSE:
1525         case V4L2_CID_DV_TX_EDID_PRESENT:
1526         case V4L2_CID_DV_RX_POWER_PRESENT:
1527         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1528         case V4L2_CID_RDS_RX_PTY:
1529         case V4L2_CID_RDS_RX_PS_NAME:
1530         case V4L2_CID_RDS_RX_RADIO_TEXT:
1531         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1532         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1533         case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1534         case V4L2_CID_CAMERA_ORIENTATION:
1535         case V4L2_CID_CAMERA_SENSOR_ROTATION:
1536                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1537                 break;
1538         case V4L2_CID_RF_TUNER_PLL_LOCK:
1539                 *flags |= V4L2_CTRL_FLAG_VOLATILE;
1540                 break;
1541         }
1542 }
1543 EXPORT_SYMBOL(v4l2_ctrl_fill);
1544
1545 static u32 user_flags(const struct v4l2_ctrl *ctrl)
1546 {
1547         u32 flags = ctrl->flags;
1548
1549         if (ctrl->is_ptr)
1550                 flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD;
1551
1552         return flags;
1553 }
1554
1555 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1556 {
1557         memset(ev, 0, sizeof(*ev));
1558         ev->type = V4L2_EVENT_CTRL;
1559         ev->id = ctrl->id;
1560         ev->u.ctrl.changes = changes;
1561         ev->u.ctrl.type = ctrl->type;
1562         ev->u.ctrl.flags = user_flags(ctrl);
1563         if (ctrl->is_ptr)
1564                 ev->u.ctrl.value64 = 0;
1565         else
1566                 ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
1567         ev->u.ctrl.minimum = ctrl->minimum;
1568         ev->u.ctrl.maximum = ctrl->maximum;
1569         if (ctrl->type == V4L2_CTRL_TYPE_MENU
1570             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1571                 ev->u.ctrl.step = 1;
1572         else
1573                 ev->u.ctrl.step = ctrl->step;
1574         ev->u.ctrl.default_value = ctrl->default_value;
1575 }
1576
1577 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1578 {
1579         struct v4l2_event ev;
1580         struct v4l2_subscribed_event *sev;
1581
1582         if (list_empty(&ctrl->ev_subs))
1583                 return;
1584         fill_event(&ev, ctrl, changes);
1585
1586         list_for_each_entry(sev, &ctrl->ev_subs, node)
1587                 if (sev->fh != fh ||
1588                     (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1589                         v4l2_event_queue_fh(sev->fh, &ev);
1590 }
1591
1592 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
1593                       union v4l2_ctrl_ptr ptr1,
1594                       union v4l2_ctrl_ptr ptr2)
1595 {
1596         switch (ctrl->type) {
1597         case V4L2_CTRL_TYPE_BUTTON:
1598                 return false;
1599         case V4L2_CTRL_TYPE_STRING:
1600                 idx *= ctrl->elem_size;
1601                 /* strings are always 0-terminated */
1602                 return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
1603         case V4L2_CTRL_TYPE_INTEGER64:
1604                 return ptr1.p_s64[idx] == ptr2.p_s64[idx];
1605         case V4L2_CTRL_TYPE_U8:
1606                 return ptr1.p_u8[idx] == ptr2.p_u8[idx];
1607         case V4L2_CTRL_TYPE_U16:
1608                 return ptr1.p_u16[idx] == ptr2.p_u16[idx];
1609         case V4L2_CTRL_TYPE_U32:
1610                 return ptr1.p_u32[idx] == ptr2.p_u32[idx];
1611         default:
1612                 if (ctrl->is_int)
1613                         return ptr1.p_s32[idx] == ptr2.p_s32[idx];
1614                 idx *= ctrl->elem_size;
1615                 return !memcmp(ptr1.p_const + idx, ptr2.p_const + idx,
1616                                ctrl->elem_size);
1617         }
1618 }
1619
1620 static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
1621                               union v4l2_ctrl_ptr ptr)
1622 {
1623         struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
1624         struct v4l2_ctrl_vp8_frame_header *p_vp8_frame_header;
1625         void *p = ptr.p + idx * ctrl->elem_size;
1626
1627         if (ctrl->p_def.p_const)
1628                 memcpy(p, ctrl->p_def.p_const, ctrl->elem_size);
1629         else
1630                 memset(p, 0, ctrl->elem_size);
1631
1632         /*
1633          * The cast is needed to get rid of a gcc warning complaining that
1634          * V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS is not part of the
1635          * v4l2_ctrl_type enum.
1636          */
1637         switch ((u32)ctrl->type) {
1638         case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
1639                 p_mpeg2_slice_params = p;
1640                 /* 4:2:0 */
1641                 p_mpeg2_slice_params->sequence.chroma_format = 1;
1642                 /* interlaced top field */
1643                 p_mpeg2_slice_params->picture.picture_structure = 1;
1644                 p_mpeg2_slice_params->picture.picture_coding_type =
1645                                         V4L2_MPEG2_PICTURE_CODING_TYPE_I;
1646                 break;
1647         case V4L2_CTRL_TYPE_VP8_FRAME_HEADER:
1648                 p_vp8_frame_header = p;
1649                 p_vp8_frame_header->num_dct_parts = 1;
1650                 break;
1651         }
1652 }
1653
1654 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
1655                      union v4l2_ctrl_ptr ptr)
1656 {
1657         switch (ctrl->type) {
1658         case V4L2_CTRL_TYPE_STRING:
1659                 idx *= ctrl->elem_size;
1660                 memset(ptr.p_char + idx, ' ', ctrl->minimum);
1661                 ptr.p_char[idx + ctrl->minimum] = '\0';
1662                 break;
1663         case V4L2_CTRL_TYPE_INTEGER64:
1664                 ptr.p_s64[idx] = ctrl->default_value;
1665                 break;
1666         case V4L2_CTRL_TYPE_INTEGER:
1667         case V4L2_CTRL_TYPE_INTEGER_MENU:
1668         case V4L2_CTRL_TYPE_MENU:
1669         case V4L2_CTRL_TYPE_BITMASK:
1670         case V4L2_CTRL_TYPE_BOOLEAN:
1671                 ptr.p_s32[idx] = ctrl->default_value;
1672                 break;
1673         case V4L2_CTRL_TYPE_BUTTON:
1674         case V4L2_CTRL_TYPE_CTRL_CLASS:
1675                 ptr.p_s32[idx] = 0;
1676                 break;
1677         case V4L2_CTRL_TYPE_U8:
1678                 ptr.p_u8[idx] = ctrl->default_value;
1679                 break;
1680         case V4L2_CTRL_TYPE_U16:
1681                 ptr.p_u16[idx] = ctrl->default_value;
1682                 break;
1683         case V4L2_CTRL_TYPE_U32:
1684                 ptr.p_u32[idx] = ctrl->default_value;
1685                 break;
1686         default:
1687                 std_init_compound(ctrl, idx, ptr);
1688                 break;
1689         }
1690 }
1691
1692 static void std_log(const struct v4l2_ctrl *ctrl)
1693 {
1694         union v4l2_ctrl_ptr ptr = ctrl->p_cur;
1695
1696         if (ctrl->is_array) {
1697                 unsigned i;
1698
1699                 for (i = 0; i < ctrl->nr_of_dims; i++)
1700                         pr_cont("[%u]", ctrl->dims[i]);
1701                 pr_cont(" ");
1702         }
1703
1704         switch (ctrl->type) {
1705         case V4L2_CTRL_TYPE_INTEGER:
1706                 pr_cont("%d", *ptr.p_s32);
1707                 break;
1708         case V4L2_CTRL_TYPE_BOOLEAN:
1709                 pr_cont("%s", *ptr.p_s32 ? "true" : "false");
1710                 break;
1711         case V4L2_CTRL_TYPE_MENU:
1712                 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
1713                 break;
1714         case V4L2_CTRL_TYPE_INTEGER_MENU:
1715                 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
1716                 break;
1717         case V4L2_CTRL_TYPE_BITMASK:
1718                 pr_cont("0x%08x", *ptr.p_s32);
1719                 break;
1720         case V4L2_CTRL_TYPE_INTEGER64:
1721                 pr_cont("%lld", *ptr.p_s64);
1722                 break;
1723         case V4L2_CTRL_TYPE_STRING:
1724                 pr_cont("%s", ptr.p_char);
1725                 break;
1726         case V4L2_CTRL_TYPE_U8:
1727                 pr_cont("%u", (unsigned)*ptr.p_u8);
1728                 break;
1729         case V4L2_CTRL_TYPE_U16:
1730                 pr_cont("%u", (unsigned)*ptr.p_u16);
1731                 break;
1732         case V4L2_CTRL_TYPE_U32:
1733                 pr_cont("%u", (unsigned)*ptr.p_u32);
1734                 break;
1735         default:
1736                 pr_cont("unknown type %d", ctrl->type);
1737                 break;
1738         }
1739 }
1740
1741 /*
1742  * Round towards the closest legal value. Be careful when we are
1743  * close to the maximum range of the control type to prevent
1744  * wrap-arounds.
1745  */
1746 #define ROUND_TO_RANGE(val, offset_type, ctrl)                  \
1747 ({                                                              \
1748         offset_type offset;                                     \
1749         if ((ctrl)->maximum >= 0 &&                             \
1750             val >= (ctrl)->maximum - (s32)((ctrl)->step / 2))   \
1751                 val = (ctrl)->maximum;                          \
1752         else                                                    \
1753                 val += (s32)((ctrl)->step / 2);                 \
1754         val = clamp_t(typeof(val), val,                         \
1755                       (ctrl)->minimum, (ctrl)->maximum);        \
1756         offset = (val) - (ctrl)->minimum;                       \
1757         offset = (ctrl)->step * (offset / (u32)(ctrl)->step);   \
1758         val = (ctrl)->minimum + offset;                         \
1759         0;                                                      \
1760 })
1761
1762 /* Validate a new control */
1763
1764 #define zero_padding(s) \
1765         memset(&(s).padding, 0, sizeof((s).padding))
1766 #define zero_reserved(s) \
1767         memset(&(s).reserved, 0, sizeof((s).reserved))
1768
1769 /*
1770  * Compound controls validation requires setting unused fields/flags to zero
1771  * in order to properly detect unchanged controls with std_equal's memcmp.
1772  */
1773 static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
1774                                  union v4l2_ctrl_ptr ptr)
1775 {
1776         struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
1777         struct v4l2_ctrl_vp8_frame_header *p_vp8_frame_header;
1778         struct v4l2_ctrl_h264_slice_params *p_h264_slice_params;
1779         struct v4l2_ctrl_h264_decode_params *p_h264_dec_params;
1780         struct v4l2_ctrl_hevc_sps *p_hevc_sps;
1781         struct v4l2_ctrl_hevc_pps *p_hevc_pps;
1782         struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
1783         struct v4l2_area *area;
1784         void *p = ptr.p + idx * ctrl->elem_size;
1785         unsigned int i;
1786
1787         switch ((u32)ctrl->type) {
1788         case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
1789                 p_mpeg2_slice_params = p;
1790
1791                 switch (p_mpeg2_slice_params->sequence.chroma_format) {
1792                 case 1: /* 4:2:0 */
1793                 case 2: /* 4:2:2 */
1794                 case 3: /* 4:4:4 */
1795                         break;
1796                 default:
1797                         return -EINVAL;
1798                 }
1799
1800                 switch (p_mpeg2_slice_params->picture.intra_dc_precision) {
1801                 case 0: /* 8 bits */
1802                 case 1: /* 9 bits */
1803                 case 2: /* 10 bits */
1804                 case 3: /* 11 bits */
1805                         break;
1806                 default:
1807                         return -EINVAL;
1808                 }
1809
1810                 switch (p_mpeg2_slice_params->picture.picture_structure) {
1811                 case 1: /* interlaced top field */
1812                 case 2: /* interlaced bottom field */
1813                 case 3: /* progressive */
1814                         break;
1815                 default:
1816                         return -EINVAL;
1817                 }
1818
1819                 switch (p_mpeg2_slice_params->picture.picture_coding_type) {
1820                 case V4L2_MPEG2_PICTURE_CODING_TYPE_I:
1821                 case V4L2_MPEG2_PICTURE_CODING_TYPE_P:
1822                 case V4L2_MPEG2_PICTURE_CODING_TYPE_B:
1823                         break;
1824                 default:
1825                         return -EINVAL;
1826                 }
1827
1828                 break;
1829
1830         case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION:
1831                 break;
1832
1833         case V4L2_CTRL_TYPE_FWHT_PARAMS:
1834                 break;
1835
1836         case V4L2_CTRL_TYPE_H264_SPS:
1837         case V4L2_CTRL_TYPE_H264_PPS:
1838         case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
1839         case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
1840                 break;
1841
1842         case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
1843                 p_h264_slice_params = p;
1844
1845                 zero_reserved(*p_h264_slice_params);
1846                 break;
1847
1848         case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
1849                 p_h264_dec_params = p;
1850
1851                 for (i = 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) {
1852                         struct v4l2_h264_dpb_entry *dpb_entry =
1853                                 &p_h264_dec_params->dpb[i];
1854
1855                         zero_reserved(*dpb_entry);
1856                 }
1857                 zero_reserved(*p_h264_dec_params);
1858                 break;
1859
1860         case V4L2_CTRL_TYPE_VP8_FRAME_HEADER:
1861                 p_vp8_frame_header = p;
1862
1863                 switch (p_vp8_frame_header->num_dct_parts) {
1864                 case 1:
1865                 case 2:
1866                 case 4:
1867                 case 8:
1868                         break;
1869                 default:
1870                         return -EINVAL;
1871                 }
1872                 zero_padding(p_vp8_frame_header->segment_header);
1873                 zero_padding(p_vp8_frame_header->lf_header);
1874                 zero_padding(p_vp8_frame_header->quant_header);
1875                 zero_padding(p_vp8_frame_header->entropy_header);
1876                 zero_padding(p_vp8_frame_header->coder_state);
1877                 break;
1878
1879         case V4L2_CTRL_TYPE_HEVC_SPS:
1880                 p_hevc_sps = p;
1881
1882                 if (!(p_hevc_sps->flags & V4L2_HEVC_SPS_FLAG_PCM_ENABLED)) {
1883                         p_hevc_sps->pcm_sample_bit_depth_luma_minus1 = 0;
1884                         p_hevc_sps->pcm_sample_bit_depth_chroma_minus1 = 0;
1885                         p_hevc_sps->log2_min_pcm_luma_coding_block_size_minus3 = 0;
1886                         p_hevc_sps->log2_diff_max_min_pcm_luma_coding_block_size = 0;
1887                 }
1888
1889                 if (!(p_hevc_sps->flags &
1890                       V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT))
1891                         p_hevc_sps->num_long_term_ref_pics_sps = 0;
1892                 break;
1893
1894         case V4L2_CTRL_TYPE_HEVC_PPS:
1895                 p_hevc_pps = p;
1896
1897                 if (!(p_hevc_pps->flags &
1898                       V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED))
1899                         p_hevc_pps->diff_cu_qp_delta_depth = 0;
1900
1901                 if (!(p_hevc_pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED)) {
1902                         p_hevc_pps->num_tile_columns_minus1 = 0;
1903                         p_hevc_pps->num_tile_rows_minus1 = 0;
1904                         memset(&p_hevc_pps->column_width_minus1, 0,
1905                                sizeof(p_hevc_pps->column_width_minus1));
1906                         memset(&p_hevc_pps->row_height_minus1, 0,
1907                                sizeof(p_hevc_pps->row_height_minus1));
1908
1909                         p_hevc_pps->flags &=
1910                                 ~V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED;
1911                 }
1912
1913                 if (p_hevc_pps->flags &
1914                     V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER) {
1915                         p_hevc_pps->pps_beta_offset_div2 = 0;
1916                         p_hevc_pps->pps_tc_offset_div2 = 0;
1917                 }
1918
1919                 zero_padding(*p_hevc_pps);
1920                 break;
1921
1922         case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
1923                 p_hevc_slice_params = p;
1924
1925                 if (p_hevc_slice_params->num_active_dpb_entries >
1926                     V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
1927                         return -EINVAL;
1928
1929                 zero_padding(p_hevc_slice_params->pred_weight_table);
1930
1931                 for (i = 0; i < p_hevc_slice_params->num_active_dpb_entries;
1932                      i++) {
1933                         struct v4l2_hevc_dpb_entry *dpb_entry =
1934                                 &p_hevc_slice_params->dpb[i];
1935
1936                         zero_padding(*dpb_entry);
1937                 }
1938
1939                 zero_padding(*p_hevc_slice_params);
1940                 break;
1941
1942         case V4L2_CTRL_TYPE_AREA:
1943                 area = p;
1944                 if (!area->width || !area->height)
1945                         return -EINVAL;
1946                 break;
1947
1948         default:
1949                 return -EINVAL;
1950         }
1951
1952         return 0;
1953 }
1954
1955 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
1956                         union v4l2_ctrl_ptr ptr)
1957 {
1958         size_t len;
1959         u64 offset;
1960         s64 val;
1961
1962         switch ((u32)ctrl->type) {
1963         case V4L2_CTRL_TYPE_INTEGER:
1964                 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
1965         case V4L2_CTRL_TYPE_INTEGER64:
1966                 /*
1967                  * We can't use the ROUND_TO_RANGE define here due to
1968                  * the u64 divide that needs special care.
1969                  */
1970                 val = ptr.p_s64[idx];
1971                 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
1972                         val = ctrl->maximum;
1973                 else
1974                         val += (s64)(ctrl->step / 2);
1975                 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
1976                 offset = val - ctrl->minimum;
1977                 do_div(offset, ctrl->step);
1978                 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
1979                 return 0;
1980         case V4L2_CTRL_TYPE_U8:
1981                 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
1982         case V4L2_CTRL_TYPE_U16:
1983                 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
1984         case V4L2_CTRL_TYPE_U32:
1985                 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
1986
1987         case V4L2_CTRL_TYPE_BOOLEAN:
1988                 ptr.p_s32[idx] = !!ptr.p_s32[idx];
1989                 return 0;
1990
1991         case V4L2_CTRL_TYPE_MENU:
1992         case V4L2_CTRL_TYPE_INTEGER_MENU:
1993                 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
1994                         return -ERANGE;
1995                 if (ctrl->menu_skip_mask & (1ULL << ptr.p_s32[idx]))
1996                         return -EINVAL;
1997                 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1998                     ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
1999                         return -EINVAL;
2000                 return 0;
2001
2002         case V4L2_CTRL_TYPE_BITMASK:
2003                 ptr.p_s32[idx] &= ctrl->maximum;
2004                 return 0;
2005
2006         case V4L2_CTRL_TYPE_BUTTON:
2007         case V4L2_CTRL_TYPE_CTRL_CLASS:
2008                 ptr.p_s32[idx] = 0;
2009                 return 0;
2010
2011         case V4L2_CTRL_TYPE_STRING:
2012                 idx *= ctrl->elem_size;
2013                 len = strlen(ptr.p_char + idx);
2014                 if (len < ctrl->minimum)
2015                         return -ERANGE;
2016                 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
2017                         return -ERANGE;
2018                 return 0;
2019
2020         default:
2021                 return std_validate_compound(ctrl, idx, ptr);
2022         }
2023 }
2024
2025 static const struct v4l2_ctrl_type_ops std_type_ops = {
2026         .equal = std_equal,
2027         .init = std_init,
2028         .log = std_log,
2029         .validate = std_validate,
2030 };
2031
2032 /* Helper function: copy the given control value back to the caller */
2033 static int ptr_to_user(struct v4l2_ext_control *c,
2034                        struct v4l2_ctrl *ctrl,
2035                        union v4l2_ctrl_ptr ptr)
2036 {
2037         u32 len;
2038
2039         if (ctrl->is_ptr && !ctrl->is_string)
2040                 return copy_to_user(c->ptr, ptr.p_const, c->size) ?
2041                        -EFAULT : 0;
2042
2043         switch (ctrl->type) {
2044         case V4L2_CTRL_TYPE_STRING:
2045                 len = strlen(ptr.p_char);
2046                 if (c->size < len + 1) {
2047                         c->size = ctrl->elem_size;
2048                         return -ENOSPC;
2049                 }
2050                 return copy_to_user(c->string, ptr.p_char, len + 1) ?
2051                        -EFAULT : 0;
2052         case V4L2_CTRL_TYPE_INTEGER64:
2053                 c->value64 = *ptr.p_s64;
2054                 break;
2055         default:
2056                 c->value = *ptr.p_s32;
2057                 break;
2058         }
2059         return 0;
2060 }
2061
2062 /* Helper function: copy the current control value back to the caller */
2063 static int cur_to_user(struct v4l2_ext_control *c,
2064                        struct v4l2_ctrl *ctrl)
2065 {
2066         return ptr_to_user(c, ctrl, ctrl->p_cur);
2067 }
2068
2069 /* Helper function: copy the new control value back to the caller */
2070 static int new_to_user(struct v4l2_ext_control *c,
2071                        struct v4l2_ctrl *ctrl)
2072 {
2073         return ptr_to_user(c, ctrl, ctrl->p_new);
2074 }
2075
2076 /* Helper function: copy the request value back to the caller */
2077 static int req_to_user(struct v4l2_ext_control *c,
2078                        struct v4l2_ctrl_ref *ref)
2079 {
2080         return ptr_to_user(c, ref->ctrl, ref->p_req);
2081 }
2082
2083 /* Helper function: copy the initial control value back to the caller */
2084 static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
2085 {
2086         int idx;
2087
2088         for (idx = 0; idx < ctrl->elems; idx++)
2089                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2090
2091         return ptr_to_user(c, ctrl, ctrl->p_new);
2092 }
2093
2094 /* Helper function: copy the caller-provider value to the given control value */
2095 static int user_to_ptr(struct v4l2_ext_control *c,
2096                        struct v4l2_ctrl *ctrl,
2097                        union v4l2_ctrl_ptr ptr)
2098 {
2099         int ret;
2100         u32 size;
2101
2102         ctrl->is_new = 1;
2103         if (ctrl->is_ptr && !ctrl->is_string) {
2104                 unsigned idx;
2105
2106                 ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0;
2107                 if (ret || !ctrl->is_array)
2108                         return ret;
2109                 for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++)
2110                         ctrl->type_ops->init(ctrl, idx, ptr);
2111                 return 0;
2112         }
2113
2114         switch (ctrl->type) {
2115         case V4L2_CTRL_TYPE_INTEGER64:
2116                 *ptr.p_s64 = c->value64;
2117                 break;
2118         case V4L2_CTRL_TYPE_STRING:
2119                 size = c->size;
2120                 if (size == 0)
2121                         return -ERANGE;
2122                 if (size > ctrl->maximum + 1)
2123                         size = ctrl->maximum + 1;
2124                 ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0;
2125                 if (!ret) {
2126                         char last = ptr.p_char[size - 1];
2127
2128                         ptr.p_char[size - 1] = 0;
2129                         /* If the string was longer than ctrl->maximum,
2130                            then return an error. */
2131                         if (strlen(ptr.p_char) == ctrl->maximum && last)
2132                                 return -ERANGE;
2133                 }
2134                 return ret;
2135         default:
2136                 *ptr.p_s32 = c->value;
2137                 break;
2138         }
2139         return 0;
2140 }
2141
2142 /* Helper function: copy the caller-provider value as the new control value */
2143 static int user_to_new(struct v4l2_ext_control *c,
2144                        struct v4l2_ctrl *ctrl)
2145 {
2146         return user_to_ptr(c, ctrl, ctrl->p_new);
2147 }
2148
2149 /* Copy the one value to another. */
2150 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
2151                        union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
2152 {
2153         if (ctrl == NULL)
2154                 return;
2155         memcpy(to.p, from.p_const, ctrl->elems * ctrl->elem_size);
2156 }
2157
2158 /* Copy the new value to the current value. */
2159 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
2160 {
2161         bool changed;
2162
2163         if (ctrl == NULL)
2164                 return;
2165
2166         /* has_changed is set by cluster_changed */
2167         changed = ctrl->has_changed;
2168         if (changed)
2169                 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
2170
2171         if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
2172                 /* Note: CH_FLAGS is only set for auto clusters. */
2173                 ctrl->flags &=
2174                         ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
2175                 if (!is_cur_manual(ctrl->cluster[0])) {
2176                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
2177                         if (ctrl->cluster[0]->has_volatiles)
2178                                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
2179                 }
2180                 fh = NULL;
2181         }
2182         if (changed || ch_flags) {
2183                 /* If a control was changed that was not one of the controls
2184                    modified by the application, then send the event to all. */
2185                 if (!ctrl->is_new)
2186                         fh = NULL;
2187                 send_event(fh, ctrl,
2188                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
2189                 if (ctrl->call_notify && changed && ctrl->handler->notify)
2190                         ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
2191         }
2192 }
2193
2194 /* Copy the current value to the new value */
2195 static void cur_to_new(struct v4l2_ctrl *ctrl)
2196 {
2197         if (ctrl == NULL)
2198                 return;
2199         ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
2200 }
2201
2202 /* Copy the new value to the request value */
2203 static void new_to_req(struct v4l2_ctrl_ref *ref)
2204 {
2205         if (!ref)
2206                 return;
2207         ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req);
2208         ref->req = ref;
2209 }
2210
2211 /* Copy the request value to the new value */
2212 static void req_to_new(struct v4l2_ctrl_ref *ref)
2213 {
2214         if (!ref)
2215                 return;
2216         if (ref->req)
2217                 ptr_to_ptr(ref->ctrl, ref->req->p_req, ref->ctrl->p_new);
2218         else
2219                 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new);
2220 }
2221
2222 /* Return non-zero if one or more of the controls in the cluster has a new
2223    value that differs from the current value. */
2224 static int cluster_changed(struct v4l2_ctrl *master)
2225 {
2226         bool changed = false;
2227         unsigned idx;
2228         int i;
2229
2230         for (i = 0; i < master->ncontrols; i++) {
2231                 struct v4l2_ctrl *ctrl = master->cluster[i];
2232                 bool ctrl_changed = false;
2233
2234                 if (ctrl == NULL)
2235                         continue;
2236
2237                 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE)
2238                         changed = ctrl_changed = true;
2239
2240                 /*
2241                  * Set has_changed to false to avoid generating
2242                  * the event V4L2_EVENT_CTRL_CH_VALUE
2243                  */
2244                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2245                         ctrl->has_changed = false;
2246                         continue;
2247                 }
2248
2249                 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
2250                         ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
2251                                 ctrl->p_cur, ctrl->p_new);
2252                 ctrl->has_changed = ctrl_changed;
2253                 changed |= ctrl->has_changed;
2254         }
2255         return changed;
2256 }
2257
2258 /* Control range checking */
2259 static int check_range(enum v4l2_ctrl_type type,
2260                 s64 min, s64 max, u64 step, s64 def)
2261 {
2262         switch (type) {
2263         case V4L2_CTRL_TYPE_BOOLEAN:
2264                 if (step != 1 || max > 1 || min < 0)
2265                         return -ERANGE;
2266                 fallthrough;
2267         case V4L2_CTRL_TYPE_U8:
2268         case V4L2_CTRL_TYPE_U16:
2269         case V4L2_CTRL_TYPE_U32:
2270         case V4L2_CTRL_TYPE_INTEGER:
2271         case V4L2_CTRL_TYPE_INTEGER64:
2272                 if (step == 0 || min > max || def < min || def > max)
2273                         return -ERANGE;
2274                 return 0;
2275         case V4L2_CTRL_TYPE_BITMASK:
2276                 if (step || min || !max || (def & ~max))
2277                         return -ERANGE;
2278                 return 0;
2279         case V4L2_CTRL_TYPE_MENU:
2280         case V4L2_CTRL_TYPE_INTEGER_MENU:
2281                 if (min > max || def < min || def > max)
2282                         return -ERANGE;
2283                 /* Note: step == menu_skip_mask for menu controls.
2284                    So here we check if the default value is masked out. */
2285                 if (step && ((1 << def) & step))
2286                         return -EINVAL;
2287                 return 0;
2288         case V4L2_CTRL_TYPE_STRING:
2289                 if (min > max || min < 0 || step < 1 || def)
2290                         return -ERANGE;
2291                 return 0;
2292         default:
2293                 return 0;
2294         }
2295 }
2296
2297 /* Validate a new control */
2298 static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
2299 {
2300         unsigned idx;
2301         int err = 0;
2302
2303         for (idx = 0; !err && idx < ctrl->elems; idx++)
2304                 err = ctrl->type_ops->validate(ctrl, idx, p_new);
2305         return err;
2306 }
2307
2308 static inline u32 node2id(struct list_head *node)
2309 {
2310         return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
2311 }
2312
2313 /* Set the handler's error code if it wasn't set earlier already */
2314 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
2315 {
2316         if (hdl->error == 0)
2317                 hdl->error = err;
2318         return err;
2319 }
2320
2321 /* Initialize the handler */
2322 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
2323                                  unsigned nr_of_controls_hint,
2324                                  struct lock_class_key *key, const char *name)
2325 {
2326         mutex_init(&hdl->_lock);
2327         hdl->lock = &hdl->_lock;
2328         lockdep_set_class_and_name(hdl->lock, key, name);
2329         INIT_LIST_HEAD(&hdl->ctrls);
2330         INIT_LIST_HEAD(&hdl->ctrl_refs);
2331         INIT_LIST_HEAD(&hdl->requests);
2332         INIT_LIST_HEAD(&hdl->requests_queued);
2333         hdl->request_is_queued = false;
2334         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
2335         hdl->buckets = kvmalloc_array(hdl->nr_of_buckets,
2336                                       sizeof(hdl->buckets[0]),
2337                                       GFP_KERNEL | __GFP_ZERO);
2338         hdl->error = hdl->buckets ? 0 : -ENOMEM;
2339         media_request_object_init(&hdl->req_obj);
2340         return hdl->error;
2341 }
2342 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
2343
2344 /* Free all controls and control refs */
2345 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
2346 {
2347         struct v4l2_ctrl_ref *ref, *next_ref;
2348         struct v4l2_ctrl *ctrl, *next_ctrl;
2349         struct v4l2_subscribed_event *sev, *next_sev;
2350
2351         if (hdl == NULL || hdl->buckets == NULL)
2352                 return;
2353
2354         if (!hdl->req_obj.req && !list_empty(&hdl->requests)) {
2355                 struct v4l2_ctrl_handler *req, *next_req;
2356
2357                 list_for_each_entry_safe(req, next_req, &hdl->requests, requests) {
2358                         media_request_object_unbind(&req->req_obj);
2359                         media_request_object_put(&req->req_obj);
2360                 }
2361         }
2362         mutex_lock(hdl->lock);
2363         /* Free all nodes */
2364         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
2365                 list_del(&ref->node);
2366                 kfree(ref);
2367         }
2368         /* Free all controls owned by the handler */
2369         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
2370                 list_del(&ctrl->node);
2371                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
2372                         list_del(&sev->node);
2373                 kvfree(ctrl);
2374         }
2375         kvfree(hdl->buckets);
2376         hdl->buckets = NULL;
2377         hdl->cached = NULL;
2378         hdl->error = 0;
2379         mutex_unlock(hdl->lock);
2380         mutex_destroy(&hdl->_lock);
2381 }
2382 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
2383
2384 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
2385    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
2386    with applications that do not use the NEXT_CTRL flag.
2387
2388    We just find the n-th private user control. It's O(N), but that should not
2389    be an issue in this particular case. */
2390 static struct v4l2_ctrl_ref *find_private_ref(
2391                 struct v4l2_ctrl_handler *hdl, u32 id)
2392 {
2393         struct v4l2_ctrl_ref *ref;
2394
2395         id -= V4L2_CID_PRIVATE_BASE;
2396         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2397                 /* Search for private user controls that are compatible with
2398                    VIDIOC_G/S_CTRL. */
2399                 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
2400                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
2401                         if (!ref->ctrl->is_int)
2402                                 continue;
2403                         if (id == 0)
2404                                 return ref;
2405                         id--;
2406                 }
2407         }
2408         return NULL;
2409 }
2410
2411 /* Find a control with the given ID. */
2412 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
2413 {
2414         struct v4l2_ctrl_ref *ref;
2415         int bucket;
2416
2417         id &= V4L2_CTRL_ID_MASK;
2418
2419         /* Old-style private controls need special handling */
2420         if (id >= V4L2_CID_PRIVATE_BASE)
2421                 return find_private_ref(hdl, id);
2422         bucket = id % hdl->nr_of_buckets;
2423
2424         /* Simple optimization: cache the last control found */
2425         if (hdl->cached && hdl->cached->ctrl->id == id)
2426                 return hdl->cached;
2427
2428         /* Not in cache, search the hash */
2429         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
2430         while (ref && ref->ctrl->id != id)
2431                 ref = ref->next;
2432
2433         if (ref)
2434                 hdl->cached = ref; /* cache it! */
2435         return ref;
2436 }
2437
2438 /* Find a control with the given ID. Take the handler's lock first. */
2439 static struct v4l2_ctrl_ref *find_ref_lock(
2440                 struct v4l2_ctrl_handler *hdl, u32 id)
2441 {
2442         struct v4l2_ctrl_ref *ref = NULL;
2443
2444         if (hdl) {
2445                 mutex_lock(hdl->lock);
2446                 ref = find_ref(hdl, id);
2447                 mutex_unlock(hdl->lock);
2448         }
2449         return ref;
2450 }
2451
2452 /* Find a control with the given ID. */
2453 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
2454 {
2455         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
2456
2457         return ref ? ref->ctrl : NULL;
2458 }
2459 EXPORT_SYMBOL(v4l2_ctrl_find);
2460
2461 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
2462 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
2463                            struct v4l2_ctrl *ctrl,
2464                            struct v4l2_ctrl_ref **ctrl_ref,
2465                            bool from_other_dev, bool allocate_req)
2466 {
2467         struct v4l2_ctrl_ref *ref;
2468         struct v4l2_ctrl_ref *new_ref;
2469         u32 id = ctrl->id;
2470         u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
2471         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
2472         unsigned int size_extra_req = 0;
2473
2474         if (ctrl_ref)
2475                 *ctrl_ref = NULL;
2476
2477         /*
2478          * Automatically add the control class if it is not yet present and
2479          * the new control is not a compound control.
2480          */
2481         if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
2482             id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
2483                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
2484                         return hdl->error;
2485
2486         if (hdl->error)
2487                 return hdl->error;
2488
2489         if (allocate_req)
2490                 size_extra_req = ctrl->elems * ctrl->elem_size;
2491         new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL);
2492         if (!new_ref)
2493                 return handler_set_err(hdl, -ENOMEM);
2494         new_ref->ctrl = ctrl;
2495         new_ref->from_other_dev = from_other_dev;
2496         if (size_extra_req)
2497                 new_ref->p_req.p = &new_ref[1];
2498
2499         INIT_LIST_HEAD(&new_ref->node);
2500
2501         mutex_lock(hdl->lock);
2502
2503         /* Add immediately at the end of the list if the list is empty, or if
2504            the last element in the list has a lower ID.
2505            This ensures that when elements are added in ascending order the
2506            insertion is an O(1) operation. */
2507         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
2508                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
2509                 goto insert_in_hash;
2510         }
2511
2512         /* Find insert position in sorted list */
2513         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2514                 if (ref->ctrl->id < id)
2515                         continue;
2516                 /* Don't add duplicates */
2517                 if (ref->ctrl->id == id) {
2518                         kfree(new_ref);
2519                         goto unlock;
2520                 }
2521                 list_add(&new_ref->node, ref->node.prev);
2522                 break;
2523         }
2524
2525 insert_in_hash:
2526         /* Insert the control node in the hash */
2527         new_ref->next = hdl->buckets[bucket];
2528         hdl->buckets[bucket] = new_ref;
2529         if (ctrl_ref)
2530                 *ctrl_ref = new_ref;
2531         if (ctrl->handler == hdl) {
2532                 /* By default each control starts in a cluster of its own.
2533                  * new_ref->ctrl is basically a cluster array with one
2534                  * element, so that's perfect to use as the cluster pointer.
2535                  * But only do this for the handler that owns the control.
2536                  */
2537                 ctrl->cluster = &new_ref->ctrl;
2538                 ctrl->ncontrols = 1;
2539         }
2540
2541 unlock:
2542         mutex_unlock(hdl->lock);
2543         return 0;
2544 }
2545
2546 /* Add a new control */
2547 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
2548                         const struct v4l2_ctrl_ops *ops,
2549                         const struct v4l2_ctrl_type_ops *type_ops,
2550                         u32 id, const char *name, enum v4l2_ctrl_type type,
2551                         s64 min, s64 max, u64 step, s64 def,
2552                         const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
2553                         u32 flags, const char * const *qmenu,
2554                         const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def,
2555                         void *priv)
2556 {
2557         struct v4l2_ctrl *ctrl;
2558         unsigned sz_extra;
2559         unsigned nr_of_dims = 0;
2560         unsigned elems = 1;
2561         bool is_array;
2562         unsigned tot_ctrl_size;
2563         unsigned idx;
2564         void *data;
2565         int err;
2566
2567         if (hdl->error)
2568                 return NULL;
2569
2570         while (dims && dims[nr_of_dims]) {
2571                 elems *= dims[nr_of_dims];
2572                 nr_of_dims++;
2573                 if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
2574                         break;
2575         }
2576         is_array = nr_of_dims > 0;
2577
2578         /* Prefill elem_size for all types handled by std_type_ops */
2579         switch ((u32)type) {
2580         case V4L2_CTRL_TYPE_INTEGER64:
2581                 elem_size = sizeof(s64);
2582                 break;
2583         case V4L2_CTRL_TYPE_STRING:
2584                 elem_size = max + 1;
2585                 break;
2586         case V4L2_CTRL_TYPE_U8:
2587                 elem_size = sizeof(u8);
2588                 break;
2589         case V4L2_CTRL_TYPE_U16:
2590                 elem_size = sizeof(u16);
2591                 break;
2592         case V4L2_CTRL_TYPE_U32:
2593                 elem_size = sizeof(u32);
2594                 break;
2595         case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
2596                 elem_size = sizeof(struct v4l2_ctrl_mpeg2_slice_params);
2597                 break;
2598         case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION:
2599                 elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantization);
2600                 break;
2601         case V4L2_CTRL_TYPE_FWHT_PARAMS:
2602                 elem_size = sizeof(struct v4l2_ctrl_fwht_params);
2603                 break;
2604         case V4L2_CTRL_TYPE_H264_SPS:
2605                 elem_size = sizeof(struct v4l2_ctrl_h264_sps);
2606                 break;
2607         case V4L2_CTRL_TYPE_H264_PPS:
2608                 elem_size = sizeof(struct v4l2_ctrl_h264_pps);
2609                 break;
2610         case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
2611                 elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix);
2612                 break;
2613         case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
2614                 elem_size = sizeof(struct v4l2_ctrl_h264_slice_params);
2615                 break;
2616         case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
2617                 elem_size = sizeof(struct v4l2_ctrl_h264_decode_params);
2618                 break;
2619         case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
2620                 elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights);
2621                 break;
2622         case V4L2_CTRL_TYPE_VP8_FRAME_HEADER:
2623                 elem_size = sizeof(struct v4l2_ctrl_vp8_frame_header);
2624                 break;
2625         case V4L2_CTRL_TYPE_HEVC_SPS:
2626                 elem_size = sizeof(struct v4l2_ctrl_hevc_sps);
2627                 break;
2628         case V4L2_CTRL_TYPE_HEVC_PPS:
2629                 elem_size = sizeof(struct v4l2_ctrl_hevc_pps);
2630                 break;
2631         case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
2632                 elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params);
2633                 break;
2634         case V4L2_CTRL_TYPE_AREA:
2635                 elem_size = sizeof(struct v4l2_area);
2636                 break;
2637         default:
2638                 if (type < V4L2_CTRL_COMPOUND_TYPES)
2639                         elem_size = sizeof(s32);
2640                 break;
2641         }
2642         tot_ctrl_size = elem_size * elems;
2643
2644         /* Sanity checks */
2645         if (id == 0 || name == NULL || !elem_size ||
2646             id >= V4L2_CID_PRIVATE_BASE ||
2647             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
2648             (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
2649                 handler_set_err(hdl, -ERANGE);
2650                 return NULL;
2651         }
2652         err = check_range(type, min, max, step, def);
2653         if (err) {
2654                 handler_set_err(hdl, err);
2655                 return NULL;
2656         }
2657         if (is_array &&
2658             (type == V4L2_CTRL_TYPE_BUTTON ||
2659              type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
2660                 handler_set_err(hdl, -EINVAL);
2661                 return NULL;
2662         }
2663
2664         sz_extra = 0;
2665         if (type == V4L2_CTRL_TYPE_BUTTON)
2666                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
2667                         V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
2668         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
2669                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
2670         else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
2671                  type == V4L2_CTRL_TYPE_STRING ||
2672                  type >= V4L2_CTRL_COMPOUND_TYPES ||
2673                  is_array)
2674                 sz_extra += 2 * tot_ctrl_size;
2675
2676         if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
2677                 sz_extra += elem_size;
2678
2679         ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
2680         if (ctrl == NULL) {
2681                 handler_set_err(hdl, -ENOMEM);
2682                 return NULL;
2683         }
2684
2685         INIT_LIST_HEAD(&ctrl->node);
2686         INIT_LIST_HEAD(&ctrl->ev_subs);
2687         ctrl->handler = hdl;
2688         ctrl->ops = ops;
2689         ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
2690         ctrl->id = id;
2691         ctrl->name = name;
2692         ctrl->type = type;
2693         ctrl->flags = flags;
2694         ctrl->minimum = min;
2695         ctrl->maximum = max;
2696         ctrl->step = step;
2697         ctrl->default_value = def;
2698         ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
2699         ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
2700         ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
2701         ctrl->is_array = is_array;
2702         ctrl->elems = elems;
2703         ctrl->nr_of_dims = nr_of_dims;
2704         if (nr_of_dims)
2705                 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
2706         ctrl->elem_size = elem_size;
2707         if (type == V4L2_CTRL_TYPE_MENU)
2708                 ctrl->qmenu = qmenu;
2709         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2710                 ctrl->qmenu_int = qmenu_int;
2711         ctrl->priv = priv;
2712         ctrl->cur.val = ctrl->val = def;
2713         data = &ctrl[1];
2714
2715         if (!ctrl->is_int) {
2716                 ctrl->p_new.p = data;
2717                 ctrl->p_cur.p = data + tot_ctrl_size;
2718         } else {
2719                 ctrl->p_new.p = &ctrl->val;
2720                 ctrl->p_cur.p = &ctrl->cur.val;
2721         }
2722
2723         if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) {
2724                 ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
2725                 memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
2726         }
2727
2728         for (idx = 0; idx < elems; idx++) {
2729                 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
2730                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2731         }
2732
2733         if (handler_new_ref(hdl, ctrl, NULL, false, false)) {
2734                 kvfree(ctrl);
2735                 return NULL;
2736         }
2737         mutex_lock(hdl->lock);
2738         list_add_tail(&ctrl->node, &hdl->ctrls);
2739         mutex_unlock(hdl->lock);
2740         return ctrl;
2741 }
2742
2743 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
2744                         const struct v4l2_ctrl_config *cfg, void *priv)
2745 {
2746         bool is_menu;
2747         struct v4l2_ctrl *ctrl;
2748         const char *name = cfg->name;
2749         const char * const *qmenu = cfg->qmenu;
2750         const s64 *qmenu_int = cfg->qmenu_int;
2751         enum v4l2_ctrl_type type = cfg->type;
2752         u32 flags = cfg->flags;
2753         s64 min = cfg->min;
2754         s64 max = cfg->max;
2755         u64 step = cfg->step;
2756         s64 def = cfg->def;
2757
2758         if (name == NULL)
2759                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
2760                                                                 &def, &flags);
2761
2762         is_menu = (type == V4L2_CTRL_TYPE_MENU ||
2763                    type == V4L2_CTRL_TYPE_INTEGER_MENU);
2764         if (is_menu)
2765                 WARN_ON(step);
2766         else
2767                 WARN_ON(cfg->menu_skip_mask);
2768         if (type == V4L2_CTRL_TYPE_MENU && !qmenu) {
2769                 qmenu = v4l2_ctrl_get_menu(cfg->id);
2770         } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) {
2771                 handler_set_err(hdl, -EINVAL);
2772                 return NULL;
2773         }
2774
2775         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
2776                         type, min, max,
2777                         is_menu ? cfg->menu_skip_mask : step, def,
2778                         cfg->dims, cfg->elem_size,
2779                         flags, qmenu, qmenu_int, cfg->p_def, priv);
2780         if (ctrl)
2781                 ctrl->is_private = cfg->is_private;
2782         return ctrl;
2783 }
2784 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
2785
2786 /* Helper function for standard non-menu controls */
2787 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
2788                         const struct v4l2_ctrl_ops *ops,
2789                         u32 id, s64 min, s64 max, u64 step, s64 def)
2790 {
2791         const char *name;
2792         enum v4l2_ctrl_type type;
2793         u32 flags;
2794
2795         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2796         if (type == V4L2_CTRL_TYPE_MENU ||
2797             type == V4L2_CTRL_TYPE_INTEGER_MENU ||
2798             type >= V4L2_CTRL_COMPOUND_TYPES) {
2799                 handler_set_err(hdl, -EINVAL);
2800                 return NULL;
2801         }
2802         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2803                              min, max, step, def, NULL, 0,
2804                              flags, NULL, NULL, ptr_null, NULL);
2805 }
2806 EXPORT_SYMBOL(v4l2_ctrl_new_std);
2807
2808 /* Helper function for standard menu controls */
2809 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
2810                         const struct v4l2_ctrl_ops *ops,
2811                         u32 id, u8 _max, u64 mask, u8 _def)
2812 {
2813         const char * const *qmenu = NULL;
2814         const s64 *qmenu_int = NULL;
2815         unsigned int qmenu_int_len = 0;
2816         const char *name;
2817         enum v4l2_ctrl_type type;
2818         s64 min;
2819         s64 max = _max;
2820         s64 def = _def;
2821         u64 step;
2822         u32 flags;
2823
2824         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2825
2826         if (type == V4L2_CTRL_TYPE_MENU)
2827                 qmenu = v4l2_ctrl_get_menu(id);
2828         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2829                 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
2830
2831         if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
2832                 handler_set_err(hdl, -EINVAL);
2833                 return NULL;
2834         }
2835         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2836                              0, max, mask, def, NULL, 0,
2837                              flags, qmenu, qmenu_int, ptr_null, NULL);
2838 }
2839 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
2840
2841 /* Helper function for standard menu controls with driver defined menu */
2842 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
2843                         const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
2844                         u64 mask, u8 _def, const char * const *qmenu)
2845 {
2846         enum v4l2_ctrl_type type;
2847         const char *name;
2848         u32 flags;
2849         u64 step;
2850         s64 min;
2851         s64 max = _max;
2852         s64 def = _def;
2853
2854         /* v4l2_ctrl_new_std_menu_items() should only be called for
2855          * standard controls without a standard menu.
2856          */
2857         if (v4l2_ctrl_get_menu(id)) {
2858                 handler_set_err(hdl, -EINVAL);
2859                 return NULL;
2860         }
2861
2862         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2863         if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
2864                 handler_set_err(hdl, -EINVAL);
2865                 return NULL;
2866         }
2867         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2868                              0, max, mask, def, NULL, 0,
2869                              flags, qmenu, NULL, ptr_null, NULL);
2870
2871 }
2872 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
2873
2874 /* Helper function for standard compound controls */
2875 struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
2876                                 const struct v4l2_ctrl_ops *ops, u32 id,
2877                                 const union v4l2_ctrl_ptr p_def)
2878 {
2879         const char *name;
2880         enum v4l2_ctrl_type type;
2881         u32 flags;
2882         s64 min, max, step, def;
2883
2884         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2885         if (type < V4L2_CTRL_COMPOUND_TYPES) {
2886                 handler_set_err(hdl, -EINVAL);
2887                 return NULL;
2888         }
2889         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2890                              min, max, step, def, NULL, 0,
2891                              flags, NULL, NULL, p_def, NULL);
2892 }
2893 EXPORT_SYMBOL(v4l2_ctrl_new_std_compound);
2894
2895 /* Helper function for standard integer menu controls */
2896 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
2897                         const struct v4l2_ctrl_ops *ops,
2898                         u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
2899 {
2900         const char *name;
2901         enum v4l2_ctrl_type type;
2902         s64 min;
2903         u64 step;
2904         s64 max = _max;
2905         s64 def = _def;
2906         u32 flags;
2907
2908         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2909         if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
2910                 handler_set_err(hdl, -EINVAL);
2911                 return NULL;
2912         }
2913         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2914                              0, max, 0, def, NULL, 0,
2915                              flags, NULL, qmenu_int, ptr_null, NULL);
2916 }
2917 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
2918
2919 /* Add the controls from another handler to our own. */
2920 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
2921                           struct v4l2_ctrl_handler *add,
2922                           bool (*filter)(const struct v4l2_ctrl *ctrl),
2923                           bool from_other_dev)
2924 {
2925         struct v4l2_ctrl_ref *ref;
2926         int ret = 0;
2927
2928         /* Do nothing if either handler is NULL or if they are the same */
2929         if (!hdl || !add || hdl == add)
2930                 return 0;
2931         if (hdl->error)
2932                 return hdl->error;
2933         mutex_lock(add->lock);
2934         list_for_each_entry(ref, &add->ctrl_refs, node) {
2935                 struct v4l2_ctrl *ctrl = ref->ctrl;
2936
2937                 /* Skip handler-private controls. */
2938                 if (ctrl->is_private)
2939                         continue;
2940                 /* And control classes */
2941                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2942                         continue;
2943                 /* Filter any unwanted controls */
2944                 if (filter && !filter(ctrl))
2945                         continue;
2946                 ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false);
2947                 if (ret)
2948                         break;
2949         }
2950         mutex_unlock(add->lock);
2951         return ret;
2952 }
2953 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
2954
2955 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
2956 {
2957         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
2958                 return true;
2959         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
2960                 return true;
2961         switch (ctrl->id) {
2962         case V4L2_CID_AUDIO_MUTE:
2963         case V4L2_CID_AUDIO_VOLUME:
2964         case V4L2_CID_AUDIO_BALANCE:
2965         case V4L2_CID_AUDIO_BASS:
2966         case V4L2_CID_AUDIO_TREBLE:
2967         case V4L2_CID_AUDIO_LOUDNESS:
2968                 return true;
2969         default:
2970                 break;
2971         }
2972         return false;
2973 }
2974 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
2975
2976 /* Cluster controls */
2977 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
2978 {
2979         bool has_volatiles = false;
2980         int i;
2981
2982         /* The first control is the master control and it must not be NULL */
2983         if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
2984                 return;
2985
2986         for (i = 0; i < ncontrols; i++) {
2987                 if (controls[i]) {
2988                         controls[i]->cluster = controls;
2989                         controls[i]->ncontrols = ncontrols;
2990                         if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
2991                                 has_volatiles = true;
2992                 }
2993         }
2994         controls[0]->has_volatiles = has_volatiles;
2995 }
2996 EXPORT_SYMBOL(v4l2_ctrl_cluster);
2997
2998 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
2999                             u8 manual_val, bool set_volatile)
3000 {
3001         struct v4l2_ctrl *master = controls[0];
3002         u32 flag = 0;
3003         int i;
3004
3005         v4l2_ctrl_cluster(ncontrols, controls);
3006         WARN_ON(ncontrols <= 1);
3007         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
3008         WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
3009         master->is_auto = true;
3010         master->has_volatiles = set_volatile;
3011         master->manual_mode_value = manual_val;
3012         master->flags |= V4L2_CTRL_FLAG_UPDATE;
3013
3014         if (!is_cur_manual(master))
3015                 flag = V4L2_CTRL_FLAG_INACTIVE |
3016                         (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
3017
3018         for (i = 1; i < ncontrols; i++)
3019                 if (controls[i])
3020                         controls[i]->flags |= flag;
3021 }
3022 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
3023
3024 /* Activate/deactivate a control. */
3025 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
3026 {
3027         /* invert since the actual flag is called 'inactive' */
3028         bool inactive = !active;
3029         bool old;
3030
3031         if (ctrl == NULL)
3032                 return;
3033
3034         if (inactive)
3035                 /* set V4L2_CTRL_FLAG_INACTIVE */
3036                 old = test_and_set_bit(4, &ctrl->flags);
3037         else
3038                 /* clear V4L2_CTRL_FLAG_INACTIVE */
3039                 old = test_and_clear_bit(4, &ctrl->flags);
3040         if (old != inactive)
3041                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
3042 }
3043 EXPORT_SYMBOL(v4l2_ctrl_activate);
3044
3045 void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
3046 {
3047         bool old;
3048
3049         if (ctrl == NULL)
3050                 return;
3051
3052         lockdep_assert_held(ctrl->handler->lock);
3053
3054         if (grabbed)
3055                 /* set V4L2_CTRL_FLAG_GRABBED */
3056                 old = test_and_set_bit(1, &ctrl->flags);
3057         else
3058                 /* clear V4L2_CTRL_FLAG_GRABBED */
3059                 old = test_and_clear_bit(1, &ctrl->flags);
3060         if (old != grabbed)
3061                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
3062 }
3063 EXPORT_SYMBOL(__v4l2_ctrl_grab);
3064
3065 /* Log the control name and value */
3066 static void log_ctrl(const struct v4l2_ctrl *ctrl,
3067                      const char *prefix, const char *colon)
3068 {
3069         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
3070                 return;
3071         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
3072                 return;
3073
3074         pr_info("%s%s%s: ", prefix, colon, ctrl->name);
3075
3076         ctrl->type_ops->log(ctrl);
3077
3078         if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
3079                            V4L2_CTRL_FLAG_GRABBED |
3080                            V4L2_CTRL_FLAG_VOLATILE)) {
3081                 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
3082                         pr_cont(" inactive");
3083                 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
3084                         pr_cont(" grabbed");
3085                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
3086                         pr_cont(" volatile");
3087         }
3088         pr_cont("\n");
3089 }
3090
3091 /* Log all controls owned by the handler */
3092 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
3093                                   const char *prefix)
3094 {
3095         struct v4l2_ctrl *ctrl;
3096         const char *colon = "";
3097         int len;
3098
3099         if (hdl == NULL)
3100                 return;
3101         if (prefix == NULL)
3102                 prefix = "";
3103         len = strlen(prefix);
3104         if (len && prefix[len - 1] != ' ')
3105                 colon = ": ";
3106         mutex_lock(hdl->lock);
3107         list_for_each_entry(ctrl, &hdl->ctrls, node)
3108                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
3109                         log_ctrl(ctrl, prefix, colon);
3110         mutex_unlock(hdl->lock);
3111 }
3112 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
3113
3114 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
3115 {
3116         v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
3117         return 0;
3118 }
3119 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
3120
3121 /* Call s_ctrl for all controls owned by the handler */
3122 int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
3123 {
3124         struct v4l2_ctrl *ctrl;
3125         int ret = 0;
3126
3127         if (hdl == NULL)
3128                 return 0;
3129
3130         lockdep_assert_held(hdl->lock);
3131
3132         list_for_each_entry(ctrl, &hdl->ctrls, node)
3133                 ctrl->done = false;
3134
3135         list_for_each_entry(ctrl, &hdl->ctrls, node) {
3136                 struct v4l2_ctrl *master = ctrl->cluster[0];
3137                 int i;
3138
3139                 /* Skip if this control was already handled by a cluster. */
3140                 /* Skip button controls and read-only controls. */
3141                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
3142                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
3143                         continue;
3144
3145                 for (i = 0; i < master->ncontrols; i++) {
3146                         if (master->cluster[i]) {
3147                                 cur_to_new(master->cluster[i]);
3148                                 master->cluster[i]->is_new = 1;
3149                                 master->cluster[i]->done = true;
3150                         }
3151                 }
3152                 ret = call_op(master, s_ctrl);
3153                 if (ret)
3154                         break;
3155         }
3156
3157         return ret;
3158 }
3159 EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup);
3160
3161 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
3162 {
3163         int ret;
3164
3165         if (hdl == NULL)
3166                 return 0;
3167
3168         mutex_lock(hdl->lock);
3169         ret = __v4l2_ctrl_handler_setup(hdl);
3170         mutex_unlock(hdl->lock);
3171
3172         return ret;
3173 }
3174 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
3175
3176 /* Implement VIDIOC_QUERY_EXT_CTRL */
3177 int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
3178 {
3179         const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
3180         u32 id = qc->id & V4L2_CTRL_ID_MASK;
3181         struct v4l2_ctrl_ref *ref;
3182         struct v4l2_ctrl *ctrl;
3183
3184         if (hdl == NULL)
3185                 return -EINVAL;
3186
3187         mutex_lock(hdl->lock);
3188
3189         /* Try to find it */
3190         ref = find_ref(hdl, id);
3191
3192         if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
3193                 bool is_compound;
3194                 /* Match any control that is not hidden */
3195                 unsigned mask = 1;
3196                 bool match = false;
3197
3198                 if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
3199                         /* Match any hidden control */
3200                         match = true;
3201                 } else if ((qc->id & next_flags) == next_flags) {
3202                         /* Match any control, compound or not */
3203                         mask = 0;
3204                 }
3205
3206                 /* Find the next control with ID > qc->id */
3207
3208                 /* Did we reach the end of the control list? */
3209                 if (id >= node2id(hdl->ctrl_refs.prev)) {
3210                         ref = NULL; /* Yes, so there is no next control */
3211                 } else if (ref) {
3212                         /* We found a control with the given ID, so just get
3213                            the next valid one in the list. */
3214                         list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
3215                                 is_compound = ref->ctrl->is_array ||
3216                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
3217                                 if (id < ref->ctrl->id &&
3218                                     (is_compound & mask) == match)
3219                                         break;
3220                         }
3221                         if (&ref->node == &hdl->ctrl_refs)
3222                                 ref = NULL;
3223                 } else {
3224                         /* No control with the given ID exists, so start
3225                            searching for the next largest ID. We know there
3226                            is one, otherwise the first 'if' above would have
3227                            been true. */
3228                         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
3229                                 is_compound = ref->ctrl->is_array ||
3230                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
3231                                 if (id < ref->ctrl->id &&
3232                                     (is_compound & mask) == match)
3233                                         break;
3234                         }
3235                         if (&ref->node == &hdl->ctrl_refs)
3236                                 ref = NULL;
3237                 }
3238         }
3239         mutex_unlock(hdl->lock);
3240
3241         if (!ref)
3242                 return -EINVAL;
3243
3244         ctrl = ref->ctrl;
3245         memset(qc, 0, sizeof(*qc));
3246         if (id >= V4L2_CID_PRIVATE_BASE)
3247                 qc->id = id;
3248         else
3249                 qc->id = ctrl->id;
3250         strscpy(qc->name, ctrl->name, sizeof(qc->name));
3251         qc->flags = user_flags(ctrl);
3252         qc->type = ctrl->type;
3253         qc->elem_size = ctrl->elem_size;
3254         qc->elems = ctrl->elems;
3255         qc->nr_of_dims = ctrl->nr_of_dims;
3256         memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
3257         qc->minimum = ctrl->minimum;
3258         qc->maximum = ctrl->maximum;
3259         qc->default_value = ctrl->default_value;
3260         if (ctrl->type == V4L2_CTRL_TYPE_MENU
3261             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
3262                 qc->step = 1;
3263         else
3264                 qc->step = ctrl->step;
3265         return 0;
3266 }
3267 EXPORT_SYMBOL(v4l2_query_ext_ctrl);
3268
3269 /* Implement VIDIOC_QUERYCTRL */
3270 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
3271 {
3272         struct v4l2_query_ext_ctrl qec = { qc->id };
3273         int rc;
3274
3275         rc = v4l2_query_ext_ctrl(hdl, &qec);
3276         if (rc)
3277                 return rc;
3278
3279         qc->id = qec.id;
3280         qc->type = qec.type;
3281         qc->flags = qec.flags;
3282         strscpy(qc->name, qec.name, sizeof(qc->name));
3283         switch (qc->type) {
3284         case V4L2_CTRL_TYPE_INTEGER:
3285         case V4L2_CTRL_TYPE_BOOLEAN:
3286         case V4L2_CTRL_TYPE_MENU:
3287         case V4L2_CTRL_TYPE_INTEGER_MENU:
3288         case V4L2_CTRL_TYPE_STRING:
3289         case V4L2_CTRL_TYPE_BITMASK:
3290                 qc->minimum = qec.minimum;
3291                 qc->maximum = qec.maximum;
3292                 qc->step = qec.step;
3293                 qc->default_value = qec.default_value;
3294                 break;
3295         default:
3296                 qc->minimum = 0;
3297                 qc->maximum = 0;
3298                 qc->step = 0;
3299                 qc->default_value = 0;
3300                 break;
3301         }
3302         return 0;
3303 }
3304 EXPORT_SYMBOL(v4l2_queryctrl);
3305
3306 /* Implement VIDIOC_QUERYMENU */
3307 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
3308 {
3309         struct v4l2_ctrl *ctrl;
3310         u32 i = qm->index;
3311
3312         ctrl = v4l2_ctrl_find(hdl, qm->id);
3313         if (!ctrl)
3314                 return -EINVAL;
3315
3316         qm->reserved = 0;
3317         /* Sanity checks */
3318         switch (ctrl->type) {
3319         case V4L2_CTRL_TYPE_MENU:
3320                 if (ctrl->qmenu == NULL)
3321                         return -EINVAL;
3322                 break;
3323         case V4L2_CTRL_TYPE_INTEGER_MENU:
3324                 if (ctrl->qmenu_int == NULL)
3325                         return -EINVAL;
3326                 break;
3327         default:
3328                 return -EINVAL;
3329         }
3330
3331         if (i < ctrl->minimum || i > ctrl->maximum)
3332                 return -EINVAL;
3333
3334         /* Use mask to see if this menu item should be skipped */
3335         if (ctrl->menu_skip_mask & (1ULL << i))
3336                 return -EINVAL;
3337         /* Empty menu items should also be skipped */
3338         if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
3339                 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
3340                         return -EINVAL;
3341                 strscpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
3342         } else {
3343                 qm->value = ctrl->qmenu_int[i];
3344         }
3345         return 0;
3346 }
3347 EXPORT_SYMBOL(v4l2_querymenu);
3348
3349 static int v4l2_ctrl_request_clone(struct v4l2_ctrl_handler *hdl,
3350                                    const struct v4l2_ctrl_handler *from)
3351 {
3352         struct v4l2_ctrl_ref *ref;
3353         int err = 0;
3354
3355         if (WARN_ON(!hdl || hdl == from))
3356                 return -EINVAL;
3357
3358         if (hdl->error)
3359                 return hdl->error;
3360
3361         WARN_ON(hdl->lock != &hdl->_lock);
3362
3363         mutex_lock(from->lock);
3364         list_for_each_entry(ref, &from->ctrl_refs, node) {
3365                 struct v4l2_ctrl *ctrl = ref->ctrl;
3366                 struct v4l2_ctrl_ref *new_ref;
3367
3368                 /* Skip refs inherited from other devices */
3369                 if (ref->from_other_dev)
3370                         continue;
3371                 err = handler_new_ref(hdl, ctrl, &new_ref, false, true);
3372                 if (err)
3373                         break;
3374         }
3375         mutex_unlock(from->lock);
3376         return err;
3377 }
3378
3379 static void v4l2_ctrl_request_queue(struct media_request_object *obj)
3380 {
3381         struct v4l2_ctrl_handler *hdl =
3382                 container_of(obj, struct v4l2_ctrl_handler, req_obj);
3383         struct v4l2_ctrl_handler *main_hdl = obj->priv;
3384         struct v4l2_ctrl_handler *prev_hdl = NULL;
3385         struct v4l2_ctrl_ref *ref_ctrl, *ref_ctrl_prev = NULL;
3386
3387         mutex_lock(main_hdl->lock);
3388         if (list_empty(&main_hdl->requests_queued))
3389                 goto queue;
3390
3391         prev_hdl = list_last_entry(&main_hdl->requests_queued,
3392                                    struct v4l2_ctrl_handler, requests_queued);
3393         /*
3394          * Note: prev_hdl and hdl must contain the same list of control
3395          * references, so if any differences are detected then that is a
3396          * driver bug and the WARN_ON is triggered.
3397          */
3398         mutex_lock(prev_hdl->lock);
3399         ref_ctrl_prev = list_first_entry(&prev_hdl->ctrl_refs,
3400                                          struct v4l2_ctrl_ref, node);
3401         list_for_each_entry(ref_ctrl, &hdl->ctrl_refs, node) {
3402                 if (ref_ctrl->req)
3403                         continue;
3404                 while (ref_ctrl_prev->ctrl->id < ref_ctrl->ctrl->id) {
3405                         /* Should never happen, but just in case... */
3406                         if (list_is_last(&ref_ctrl_prev->node,
3407                                          &prev_hdl->ctrl_refs))
3408                                 break;
3409                         ref_ctrl_prev = list_next_entry(ref_ctrl_prev, node);
3410                 }
3411                 if (WARN_ON(ref_ctrl_prev->ctrl->id != ref_ctrl->ctrl->id))
3412                         break;
3413                 ref_ctrl->req = ref_ctrl_prev->req;
3414         }
3415         mutex_unlock(prev_hdl->lock);
3416 queue:
3417         list_add_tail(&hdl->requests_queued, &main_hdl->requests_queued);
3418         hdl->request_is_queued = true;
3419         mutex_unlock(main_hdl->lock);
3420 }
3421
3422 static void v4l2_ctrl_request_unbind(struct media_request_object *obj)
3423 {
3424         struct v4l2_ctrl_handler *hdl =
3425                 container_of(obj, struct v4l2_ctrl_handler, req_obj);
3426         struct v4l2_ctrl_handler *main_hdl = obj->priv;
3427
3428         list_del_init(&hdl->requests);
3429         mutex_lock(main_hdl->lock);
3430         if (hdl->request_is_queued) {
3431                 list_del_init(&hdl->requests_queued);
3432                 hdl->request_is_queued = false;
3433         }
3434         mutex_unlock(main_hdl->lock);
3435 }
3436
3437 static void v4l2_ctrl_request_release(struct media_request_object *obj)
3438 {
3439         struct v4l2_ctrl_handler *hdl =
3440                 container_of(obj, struct v4l2_ctrl_handler, req_obj);
3441
3442         v4l2_ctrl_handler_free(hdl);
3443         kfree(hdl);
3444 }
3445
3446 static const struct media_request_object_ops req_ops = {
3447         .queue = v4l2_ctrl_request_queue,
3448         .unbind = v4l2_ctrl_request_unbind,
3449         .release = v4l2_ctrl_request_release,
3450 };
3451
3452 struct v4l2_ctrl_handler *v4l2_ctrl_request_hdl_find(struct media_request *req,
3453                                         struct v4l2_ctrl_handler *parent)
3454 {
3455         struct media_request_object *obj;
3456
3457         if (WARN_ON(req->state != MEDIA_REQUEST_STATE_VALIDATING &&
3458                     req->state != MEDIA_REQUEST_STATE_QUEUED))
3459                 return NULL;
3460
3461         obj = media_request_object_find(req, &req_ops, parent);
3462         if (obj)
3463                 return container_of(obj, struct v4l2_ctrl_handler, req_obj);
3464         return NULL;
3465 }
3466 EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_find);
3467
3468 struct v4l2_ctrl *
3469 v4l2_ctrl_request_hdl_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
3470 {
3471         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
3472
3473         return (ref && ref->req == ref) ? ref->ctrl : NULL;
3474 }
3475 EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_ctrl_find);
3476
3477 static int v4l2_ctrl_request_bind(struct media_request *req,
3478                            struct v4l2_ctrl_handler *hdl,
3479                            struct v4l2_ctrl_handler *from)
3480 {
3481         int ret;
3482
3483         ret = v4l2_ctrl_request_clone(hdl, from);
3484
3485         if (!ret) {
3486                 ret = media_request_object_bind(req, &req_ops,
3487                                                 from, false, &hdl->req_obj);
3488                 if (!ret)
3489                         list_add_tail(&hdl->requests, &from->requests);
3490         }
3491         return ret;
3492 }
3493
3494 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
3495
3496    It is not a fully atomic operation, just best-effort only. After all, if
3497    multiple controls have to be set through multiple i2c writes (for example)
3498    then some initial writes may succeed while others fail. Thus leaving the
3499    system in an inconsistent state. The question is how much effort you are
3500    willing to spend on trying to make something atomic that really isn't.
3501
3502    From the point of view of an application the main requirement is that
3503    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
3504    error should be returned without actually affecting any controls.
3505
3506    If all the values are correct, then it is acceptable to just give up
3507    in case of low-level errors.
3508
3509    It is important though that the application can tell when only a partial
3510    configuration was done. The way we do that is through the error_idx field
3511    of struct v4l2_ext_controls: if that is equal to the count field then no
3512    controls were affected. Otherwise all controls before that index were
3513    successful in performing their 'get' or 'set' operation, the control at
3514    the given index failed, and you don't know what happened with the controls
3515    after the failed one. Since if they were part of a control cluster they
3516    could have been successfully processed (if a cluster member was encountered
3517    at index < error_idx), they could have failed (if a cluster member was at
3518    error_idx), or they may not have been processed yet (if the first cluster
3519    member appeared after error_idx).
3520
3521    It is all fairly theoretical, though. In practice all you can do is to
3522    bail out. If error_idx == count, then it is an application bug. If
3523    error_idx < count then it is only an application bug if the error code was
3524    EBUSY. That usually means that something started streaming just when you
3525    tried to set the controls. In all other cases it is a driver/hardware
3526    problem and all you can do is to retry or bail out.
3527
3528    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
3529    never modifies controls the error_idx is just set to whatever control
3530    has an invalid value.
3531  */
3532
3533 /* Prepare for the extended g/s/try functions.
3534    Find the controls in the control array and do some basic checks. */
3535 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
3536                              struct v4l2_ext_controls *cs,
3537                              struct v4l2_ctrl_helper *helpers,
3538                              struct video_device *vdev,
3539                              bool get)
3540 {
3541         struct v4l2_ctrl_helper *h;
3542         bool have_clusters = false;
3543         u32 i;
3544
3545         for (i = 0, h = helpers; i < cs->count; i++, h++) {
3546                 struct v4l2_ext_control *c = &cs->controls[i];
3547                 struct v4l2_ctrl_ref *ref;
3548                 struct v4l2_ctrl *ctrl;
3549                 u32 id = c->id & V4L2_CTRL_ID_MASK;
3550
3551                 cs->error_idx = i;
3552
3553                 if (cs->which &&
3554                     cs->which != V4L2_CTRL_WHICH_DEF_VAL &&
3555                     cs->which != V4L2_CTRL_WHICH_REQUEST_VAL &&
3556                     V4L2_CTRL_ID2WHICH(id) != cs->which) {
3557                         dprintk(vdev,
3558                                 "invalid which 0x%x or control id 0x%x\n",
3559                                 cs->which, id);
3560                         return -EINVAL;
3561                 }
3562
3563                 /* Old-style private controls are not allowed for
3564                    extended controls */
3565                 if (id >= V4L2_CID_PRIVATE_BASE) {
3566                         dprintk(vdev,
3567                                 "old-style private controls not allowed\n");
3568                         return -EINVAL;
3569                 }
3570                 ref = find_ref_lock(hdl, id);
3571                 if (ref == NULL) {
3572                         dprintk(vdev, "cannot find control id 0x%x\n", id);
3573                         return -EINVAL;
3574                 }
3575                 h->ref = ref;
3576                 ctrl = ref->ctrl;
3577                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED) {
3578                         dprintk(vdev, "control id 0x%x is disabled\n", id);
3579                         return -EINVAL;
3580                 }
3581
3582                 if (ctrl->cluster[0]->ncontrols > 1)
3583                         have_clusters = true;
3584                 if (ctrl->cluster[0] != ctrl)
3585                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
3586                 if (ctrl->is_ptr && !ctrl->is_string) {
3587                         unsigned tot_size = ctrl->elems * ctrl->elem_size;
3588
3589                         if (c->size < tot_size) {
3590                                 /*
3591                                  * In the get case the application first
3592                                  * queries to obtain the size of the control.
3593                                  */
3594                                 if (get) {
3595                                         c->size = tot_size;
3596                                         return -ENOSPC;
3597                                 }
3598                                 dprintk(vdev,
3599                                         "pointer control id 0x%x size too small, %d bytes but %d bytes needed\n",
3600                                         id, c->size, tot_size);
3601                                 return -EFAULT;
3602                         }
3603                         c->size = tot_size;
3604                 }
3605                 /* Store the ref to the master control of the cluster */
3606                 h->mref = ref;
3607                 /* Initially set next to 0, meaning that there is no other
3608                    control in this helper array belonging to the same
3609                    cluster */
3610                 h->next = 0;
3611         }
3612
3613         /* We are done if there were no controls that belong to a multi-
3614            control cluster. */
3615         if (!have_clusters)
3616                 return 0;
3617
3618         /* The code below figures out in O(n) time which controls in the list
3619            belong to the same cluster. */
3620
3621         /* This has to be done with the handler lock taken. */
3622         mutex_lock(hdl->lock);
3623
3624         /* First zero the helper field in the master control references */
3625         for (i = 0; i < cs->count; i++)
3626                 helpers[i].mref->helper = NULL;
3627         for (i = 0, h = helpers; i < cs->count; i++, h++) {
3628                 struct v4l2_ctrl_ref *mref = h->mref;
3629
3630                 /* If the mref->helper is set, then it points to an earlier
3631                    helper that belongs to the same cluster. */
3632                 if (mref->helper) {
3633                         /* Set the next field of mref->helper to the current
3634                            index: this means that that earlier helper now
3635                            points to the next helper in the same cluster. */
3636                         mref->helper->next = i;
3637                         /* mref should be set only for the first helper in the
3638                            cluster, clear the others. */
3639                         h->mref = NULL;
3640                 }
3641                 /* Point the mref helper to the current helper struct. */
3642                 mref->helper = h;
3643         }
3644         mutex_unlock(hdl->lock);
3645         return 0;
3646 }
3647
3648 /* Handles the corner case where cs->count == 0. It checks whether the
3649    specified control class exists. If that class ID is 0, then it checks
3650    whether there are any controls at all. */
3651 static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
3652 {
3653         if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL ||
3654             which == V4L2_CTRL_WHICH_REQUEST_VAL)
3655                 return 0;
3656         return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
3657 }
3658
3659 /* Get extended controls. Allocates the helpers array if needed. */
3660 static int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
3661                                    struct v4l2_ext_controls *cs,
3662                                    struct video_device *vdev)
3663 {
3664         struct v4l2_ctrl_helper helper[4];
3665         struct v4l2_ctrl_helper *helpers = helper;
3666         int ret;
3667         int i, j;
3668         bool def_value;
3669
3670         def_value = (cs->which == V4L2_CTRL_WHICH_DEF_VAL);
3671
3672         cs->error_idx = cs->count;
3673         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
3674
3675         if (hdl == NULL)
3676                 return -EINVAL;
3677
3678         if (cs->count == 0)
3679                 return class_check(hdl, cs->which);
3680
3681         if (cs->count > ARRAY_SIZE(helper)) {
3682                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
3683                                          GFP_KERNEL);
3684                 if (helpers == NULL)
3685                         return -ENOMEM;
3686         }
3687
3688         ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, true);
3689         cs->error_idx = cs->count;
3690
3691         for (i = 0; !ret && i < cs->count; i++)
3692                 if (helpers[i].ref->ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
3693                         ret = -EACCES;
3694
3695         for (i = 0; !ret && i < cs->count; i++) {
3696                 int (*ctrl_to_user)(struct v4l2_ext_control *c,
3697                                     struct v4l2_ctrl *ctrl);
3698                 struct v4l2_ctrl *master;
3699
3700                 ctrl_to_user = def_value ? def_to_user : cur_to_user;
3701
3702                 if (helpers[i].mref == NULL)
3703                         continue;
3704
3705                 master = helpers[i].mref->ctrl;
3706                 cs->error_idx = i;
3707
3708                 v4l2_ctrl_lock(master);
3709
3710                 /* g_volatile_ctrl will update the new control values */
3711                 if (!def_value &&
3712                     ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
3713                     (master->has_volatiles && !is_cur_manual(master)))) {
3714                         for (j = 0; j < master->ncontrols; j++)
3715                                 cur_to_new(master->cluster[j]);
3716                         ret = call_op(master, g_volatile_ctrl);
3717                         ctrl_to_user = new_to_user;
3718                 }
3719                 /* If OK, then copy the current (for non-volatile controls)
3720                    or the new (for volatile controls) control values to the
3721                    caller */
3722                 if (!ret) {
3723                         u32 idx = i;
3724
3725                         do {
3726                                 if (helpers[idx].ref->req)
3727                                         ret = req_to_user(cs->controls + idx,
3728                                                 helpers[idx].ref->req);
3729                                 else
3730                                         ret = ctrl_to_user(cs->controls + idx,
3731                                                 helpers[idx].ref->ctrl);
3732                                 idx = helpers[idx].next;
3733                         } while (!ret && idx);
3734                 }
3735                 v4l2_ctrl_unlock(master);
3736         }
3737
3738         if (cs->count > ARRAY_SIZE(helper))
3739                 kvfree(helpers);
3740         return ret;
3741 }
3742
3743 static struct media_request_object *
3744 v4l2_ctrls_find_req_obj(struct v4l2_ctrl_handler *hdl,
3745                         struct media_request *req, bool set)
3746 {
3747         struct media_request_object *obj;
3748         struct v4l2_ctrl_handler *new_hdl;
3749         int ret;
3750
3751         if (IS_ERR(req))
3752                 return ERR_CAST(req);
3753
3754         if (set && WARN_ON(req->state != MEDIA_REQUEST_STATE_UPDATING))
3755                 return ERR_PTR(-EBUSY);
3756
3757         obj = media_request_object_find(req, &req_ops, hdl);
3758         if (obj)
3759                 return obj;
3760         if (!set)
3761                 return ERR_PTR(-ENOENT);
3762
3763         new_hdl = kzalloc(sizeof(*new_hdl), GFP_KERNEL);
3764         if (!new_hdl)
3765                 return ERR_PTR(-ENOMEM);
3766
3767         obj = &new_hdl->req_obj;
3768         ret = v4l2_ctrl_handler_init(new_hdl, (hdl->nr_of_buckets - 1) * 8);
3769         if (!ret)
3770                 ret = v4l2_ctrl_request_bind(req, new_hdl, hdl);
3771         if (ret) {
3772                 kfree(new_hdl);
3773
3774                 return ERR_PTR(ret);
3775         }
3776
3777         media_request_object_get(obj);
3778         return obj;
3779 }
3780
3781 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
3782                      struct media_device *mdev, struct v4l2_ext_controls *cs)
3783 {
3784         struct media_request_object *obj = NULL;
3785         struct media_request *req = NULL;
3786         int ret;
3787
3788         if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) {
3789                 if (!mdev || cs->request_fd < 0)
3790                         return -EINVAL;
3791
3792                 req = media_request_get_by_fd(mdev, cs->request_fd);
3793                 if (IS_ERR(req))
3794                         return PTR_ERR(req);
3795
3796                 if (req->state != MEDIA_REQUEST_STATE_COMPLETE) {
3797                         media_request_put(req);
3798                         return -EACCES;
3799                 }
3800
3801                 ret = media_request_lock_for_access(req);
3802                 if (ret) {
3803                         media_request_put(req);
3804                         return ret;
3805                 }
3806
3807                 obj = v4l2_ctrls_find_req_obj(hdl, req, false);
3808                 if (IS_ERR(obj)) {
3809                         media_request_unlock_for_access(req);
3810                         media_request_put(req);
3811                         return PTR_ERR(obj);
3812                 }
3813
3814                 hdl = container_of(obj, struct v4l2_ctrl_handler,
3815                                    req_obj);
3816         }
3817
3818         ret = v4l2_g_ext_ctrls_common(hdl, cs, vdev);
3819
3820         if (obj) {
3821                 media_request_unlock_for_access(req);
3822                 media_request_object_put(obj);
3823                 media_request_put(req);
3824         }
3825         return ret;
3826 }
3827 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
3828
3829 /* Helper function to get a single control */
3830 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
3831 {
3832         struct v4l2_ctrl *master = ctrl->cluster[0];
3833         int ret = 0;
3834         int i;
3835
3836         /* Compound controls are not supported. The new_to_user() and
3837          * cur_to_user() calls below would need to be modified not to access
3838          * userspace memory when called from get_ctrl().
3839          */
3840         if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64)
3841                 return -EINVAL;
3842
3843         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
3844                 return -EACCES;
3845
3846         v4l2_ctrl_lock(master);
3847         /* g_volatile_ctrl will update the current control values */
3848         if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
3849                 for (i = 0; i < master->ncontrols; i++)
3850                         cur_to_new(master->cluster[i]);
3851                 ret = call_op(master, g_volatile_ctrl);
3852                 new_to_user(c, ctrl);
3853         } else {
3854                 cur_to_user(c, ctrl);
3855         }
3856         v4l2_ctrl_unlock(master);
3857         return ret;
3858 }
3859
3860 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
3861 {
3862         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3863         struct v4l2_ext_control c;
3864         int ret;
3865
3866         if (ctrl == NULL || !ctrl->is_int)
3867                 return -EINVAL;
3868         ret = get_ctrl(ctrl, &c);
3869         control->value = c.value;
3870         return ret;
3871 }
3872 EXPORT_SYMBOL(v4l2_g_ctrl);
3873
3874 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
3875 {
3876         struct v4l2_ext_control c;
3877
3878         /* It's a driver bug if this happens. */
3879         if (WARN_ON(!ctrl->is_int))
3880                 return 0;
3881         c.value = 0;
3882         get_ctrl(ctrl, &c);
3883         return c.value;
3884 }
3885 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
3886
3887 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
3888 {
3889         struct v4l2_ext_control c;
3890
3891         /* It's a driver bug if this happens. */
3892         if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
3893                 return 0;
3894         c.value64 = 0;
3895         get_ctrl(ctrl, &c);
3896         return c.value64;
3897 }
3898 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
3899
3900
3901 /* Core function that calls try/s_ctrl and ensures that the new value is
3902    copied to the current value on a set.
3903    Must be called with ctrl->handler->lock held. */
3904 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
3905                               bool set, u32 ch_flags)
3906 {
3907         bool update_flag;
3908         int ret;
3909         int i;
3910
3911         /* Go through the cluster and either validate the new value or
3912            (if no new value was set), copy the current value to the new
3913            value, ensuring a consistent view for the control ops when
3914            called. */
3915         for (i = 0; i < master->ncontrols; i++) {
3916                 struct v4l2_ctrl *ctrl = master->cluster[i];
3917
3918                 if (ctrl == NULL)
3919                         continue;
3920
3921                 if (!ctrl->is_new) {
3922                         cur_to_new(ctrl);
3923                         continue;
3924                 }
3925                 /* Check again: it may have changed since the
3926                    previous check in try_or_set_ext_ctrls(). */
3927                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3928                         return -EBUSY;
3929         }
3930
3931         ret = call_op(master, try_ctrl);
3932
3933         /* Don't set if there is no change */
3934         if (ret || !set || !cluster_changed(master))
3935                 return ret;
3936         ret = call_op(master, s_ctrl);
3937         if (ret)
3938                 return ret;
3939
3940         /* If OK, then make the new values permanent. */
3941         update_flag = is_cur_manual(master) != is_new_manual(master);
3942
3943         for (i = 0; i < master->ncontrols; i++) {
3944                 /*
3945                  * If we switch from auto to manual mode, and this cluster
3946                  * contains volatile controls, then all non-master controls
3947                  * have to be marked as changed. The 'new' value contains
3948                  * the volatile value (obtained by update_from_auto_cluster),
3949                  * which now has to become the current value.
3950                  */
3951                 if (i && update_flag && is_new_manual(master) &&
3952                     master->has_volatiles && master->cluster[i])
3953                         master->cluster[i]->has_changed = true;
3954
3955                 new_to_cur(fh, master->cluster[i], ch_flags |
3956                         ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
3957         }
3958         return 0;
3959 }
3960
3961 /* Validate controls. */
3962 static int validate_ctrls(struct v4l2_ext_controls *cs,
3963                           struct v4l2_ctrl_helper *helpers,
3964                           struct video_device *vdev,
3965                           bool set)
3966 {
3967         unsigned i;
3968         int ret = 0;
3969
3970         cs->error_idx = cs->count;
3971         for (i = 0; i < cs->count; i++) {
3972                 struct v4l2_ctrl *ctrl = helpers[i].ref->ctrl;
3973                 union v4l2_ctrl_ptr p_new;
3974
3975                 cs->error_idx = i;
3976
3977                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) {
3978                         dprintk(vdev,
3979                                 "control id 0x%x is read-only\n",
3980                                 ctrl->id);
3981                         return -EACCES;
3982                 }
3983                 /* This test is also done in try_set_control_cluster() which
3984                    is called in atomic context, so that has the final say,
3985                    but it makes sense to do an up-front check as well. Once
3986                    an error occurs in try_set_control_cluster() some other
3987                    controls may have been set already and we want to do a
3988                    best-effort to avoid that. */
3989                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) {
3990                         dprintk(vdev,
3991                                 "control id 0x%x is grabbed, cannot set\n",
3992                                 ctrl->id);
3993                         return -EBUSY;
3994                 }
3995                 /*
3996                  * Skip validation for now if the payload needs to be copied
3997                  * from userspace into kernelspace. We'll validate those later.
3998                  */
3999                 if (ctrl->is_ptr)
4000                         continue;
4001                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4002                         p_new.p_s64 = &cs->controls[i].value64;
4003                 else
4004                         p_new.p_s32 = &cs->controls[i].value;
4005                 ret = validate_new(ctrl, p_new);
4006                 if (ret)
4007                         return ret;
4008         }
4009         return 0;
4010 }
4011
4012 /* Obtain the current volatile values of an autocluster and mark them
4013    as new. */
4014 static void update_from_auto_cluster(struct v4l2_ctrl *master)
4015 {
4016         int i;
4017
4018         for (i = 1; i < master->ncontrols; i++)
4019                 cur_to_new(master->cluster[i]);
4020         if (!call_op(master, g_volatile_ctrl))
4021                 for (i = 1; i < master->ncontrols; i++)
4022                         if (master->cluster[i])
4023                                 master->cluster[i]->is_new = 1;
4024 }
4025
4026 /* Try or try-and-set controls */
4027 static int try_set_ext_ctrls_common(struct v4l2_fh *fh,
4028                                     struct v4l2_ctrl_handler *hdl,
4029                                     struct v4l2_ext_controls *cs,
4030                                     struct video_device *vdev, bool set)
4031 {
4032         struct v4l2_ctrl_helper helper[4];
4033         struct v4l2_ctrl_helper *helpers = helper;
4034         unsigned i, j;
4035         int ret;
4036
4037         cs->error_idx = cs->count;
4038
4039         /* Default value cannot be changed */
4040         if (cs->which == V4L2_CTRL_WHICH_DEF_VAL) {
4041                 dprintk(vdev, "%s: cannot change default value\n",
4042                         video_device_node_name(vdev));
4043                 return -EINVAL;
4044         }
4045
4046         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
4047
4048         if (hdl == NULL) {
4049                 dprintk(vdev, "%s: invalid null control handler\n",
4050                         video_device_node_name(vdev));
4051                 return -EINVAL;
4052         }
4053
4054         if (cs->count == 0)
4055                 return class_check(hdl, cs->which);
4056
4057         if (cs->count > ARRAY_SIZE(helper)) {
4058                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
4059                                          GFP_KERNEL);
4060                 if (!helpers)
4061                         return -ENOMEM;
4062         }
4063         ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, false);
4064         if (!ret)
4065                 ret = validate_ctrls(cs, helpers, vdev, set);
4066         if (ret && set)
4067                 cs->error_idx = cs->count;
4068         for (i = 0; !ret && i < cs->count; i++) {
4069                 struct v4l2_ctrl *master;
4070                 u32 idx = i;
4071
4072                 if (helpers[i].mref == NULL)
4073                         continue;
4074
4075                 cs->error_idx = i;
4076                 master = helpers[i].mref->ctrl;
4077                 v4l2_ctrl_lock(master);
4078
4079                 /* Reset the 'is_new' flags of the cluster */
4080                 for (j = 0; j < master->ncontrols; j++)
4081                         if (master->cluster[j])
4082                                 master->cluster[j]->is_new = 0;
4083
4084                 /* For volatile autoclusters that are currently in auto mode
4085                    we need to discover if it will be set to manual mode.
4086                    If so, then we have to copy the current volatile values
4087                    first since those will become the new manual values (which
4088                    may be overwritten by explicit new values from this set
4089                    of controls). */
4090                 if (master->is_auto && master->has_volatiles &&
4091                                                 !is_cur_manual(master)) {
4092                         /* Pick an initial non-manual value */
4093                         s32 new_auto_val = master->manual_mode_value + 1;
4094                         u32 tmp_idx = idx;
4095
4096                         do {
4097                                 /* Check if the auto control is part of the
4098                                    list, and remember the new value. */
4099                                 if (helpers[tmp_idx].ref->ctrl == master)
4100                                         new_auto_val = cs->controls[tmp_idx].value;
4101                                 tmp_idx = helpers[tmp_idx].next;
4102                         } while (tmp_idx);
4103                         /* If the new value == the manual value, then copy
4104                            the current volatile values. */
4105                         if (new_auto_val == master->manual_mode_value)
4106                                 update_from_auto_cluster(master);
4107                 }
4108
4109                 /* Copy the new caller-supplied control values.
4110                    user_to_new() sets 'is_new' to 1. */
4111                 do {
4112                         struct v4l2_ctrl *ctrl = helpers[idx].ref->ctrl;
4113
4114                         ret = user_to_new(cs->controls + idx, ctrl);
4115                         if (!ret && ctrl->is_ptr) {
4116                                 ret = validate_new(ctrl, ctrl->p_new);
4117                                 if (ret)
4118                                         dprintk(vdev,
4119                                                 "failed to validate control %s (%d)\n",
4120                                                 v4l2_ctrl_get_name(ctrl->id), ret);
4121                         }
4122                         idx = helpers[idx].next;
4123                 } while (!ret && idx);
4124
4125                 if (!ret)
4126                         ret = try_or_set_cluster(fh, master,
4127                                                  !hdl->req_obj.req && set, 0);
4128                 if (!ret && hdl->req_obj.req && set) {
4129                         for (j = 0; j < master->ncontrols; j++) {
4130                                 struct v4l2_ctrl_ref *ref =
4131                                         find_ref(hdl, master->cluster[j]->id);
4132
4133                                 new_to_req(ref);
4134                         }
4135                 }
4136
4137                 /* Copy the new values back to userspace. */
4138                 if (!ret) {
4139                         idx = i;
4140                         do {
4141                                 ret = new_to_user(cs->controls + idx,
4142                                                 helpers[idx].ref->ctrl);
4143                                 idx = helpers[idx].next;
4144                         } while (!ret && idx);
4145                 }
4146                 v4l2_ctrl_unlock(master);
4147         }
4148
4149         if (cs->count > ARRAY_SIZE(helper))
4150                 kvfree(helpers);
4151         return ret;
4152 }
4153
4154 static int try_set_ext_ctrls(struct v4l2_fh *fh,
4155                              struct v4l2_ctrl_handler *hdl,
4156                              struct video_device *vdev,
4157                              struct media_device *mdev,
4158                              struct v4l2_ext_controls *cs, bool set)
4159 {
4160         struct media_request_object *obj = NULL;
4161         struct media_request *req = NULL;
4162         int ret;
4163
4164         if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) {
4165                 if (!mdev) {
4166                         dprintk(vdev, "%s: missing media device\n",
4167                                 video_device_node_name(vdev));
4168                         return -EINVAL;
4169                 }
4170
4171                 if (cs->request_fd < 0) {
4172                         dprintk(vdev, "%s: invalid request fd %d\n",
4173                                 video_device_node_name(vdev), cs->request_fd);
4174                         return -EINVAL;
4175                 }
4176
4177                 req = media_request_get_by_fd(mdev, cs->request_fd);
4178                 if (IS_ERR(req)) {
4179                         dprintk(vdev, "%s: cannot find request fd %d\n",
4180                                 video_device_node_name(vdev), cs->request_fd);
4181                         return PTR_ERR(req);
4182                 }
4183
4184                 ret = media_request_lock_for_update(req);
4185                 if (ret) {
4186                         dprintk(vdev, "%s: cannot lock request fd %d\n",
4187                                 video_device_node_name(vdev), cs->request_fd);
4188                         media_request_put(req);
4189                         return ret;
4190                 }
4191
4192                 obj = v4l2_ctrls_find_req_obj(hdl, req, set);
4193                 if (IS_ERR(obj)) {
4194                         dprintk(vdev,
4195                                 "%s: cannot find request object for request fd %d\n",
4196                                 video_device_node_name(vdev),
4197                                 cs->request_fd);
4198                         media_request_unlock_for_update(req);
4199                         media_request_put(req);
4200                         return PTR_ERR(obj);
4201                 }
4202                 hdl = container_of(obj, struct v4l2_ctrl_handler,
4203                                    req_obj);
4204         }
4205
4206         ret = try_set_ext_ctrls_common(fh, hdl, cs, vdev, set);
4207         if (ret)
4208                 dprintk(vdev,
4209                         "%s: try_set_ext_ctrls_common failed (%d)\n",
4210                         video_device_node_name(vdev), ret);
4211
4212         if (obj) {
4213                 media_request_unlock_for_update(req);
4214                 media_request_object_put(obj);
4215                 media_request_put(req);
4216         }
4217
4218         return ret;
4219 }
4220
4221 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl,
4222                        struct video_device *vdev,
4223                        struct media_device *mdev,
4224                        struct v4l2_ext_controls *cs)
4225 {
4226         return try_set_ext_ctrls(NULL, hdl, vdev, mdev, cs, false);
4227 }
4228 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
4229
4230 int v4l2_s_ext_ctrls(struct v4l2_fh *fh,
4231                      struct v4l2_ctrl_handler *hdl,
4232                      struct video_device *vdev,
4233                      struct media_device *mdev,
4234                      struct v4l2_ext_controls *cs)
4235 {
4236         return try_set_ext_ctrls(fh, hdl, vdev, mdev, cs, true);
4237 }
4238 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
4239
4240 /* Helper function for VIDIOC_S_CTRL compatibility */
4241 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
4242 {
4243         struct v4l2_ctrl *master = ctrl->cluster[0];
4244         int ret;
4245         int i;
4246
4247         /* Reset the 'is_new' flags of the cluster */
4248         for (i = 0; i < master->ncontrols; i++)
4249                 if (master->cluster[i])
4250                         master->cluster[i]->is_new = 0;
4251
4252         ret = validate_new(ctrl, ctrl->p_new);
4253         if (ret)
4254                 return ret;
4255
4256         /* For autoclusters with volatiles that are switched from auto to
4257            manual mode we have to update the current volatile values since
4258            those will become the initial manual values after such a switch. */
4259         if (master->is_auto && master->has_volatiles && ctrl == master &&
4260             !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
4261                 update_from_auto_cluster(master);
4262
4263         ctrl->is_new = 1;
4264         return try_or_set_cluster(fh, master, true, ch_flags);
4265 }
4266
4267 /* Helper function for VIDIOC_S_CTRL compatibility */
4268 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
4269                          struct v4l2_ext_control *c)
4270 {
4271         int ret;
4272
4273         v4l2_ctrl_lock(ctrl);
4274         user_to_new(c, ctrl);
4275         ret = set_ctrl(fh, ctrl, 0);
4276         if (!ret)
4277                 cur_to_user(c, ctrl);
4278         v4l2_ctrl_unlock(ctrl);
4279         return ret;
4280 }
4281
4282 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
4283                                         struct v4l2_control *control)
4284 {
4285         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
4286         struct v4l2_ext_control c = { control->id };
4287         int ret;
4288
4289         if (ctrl == NULL || !ctrl->is_int)
4290                 return -EINVAL;
4291
4292         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
4293                 return -EACCES;
4294
4295         c.value = control->value;
4296         ret = set_ctrl_lock(fh, ctrl, &c);
4297         control->value = c.value;
4298         return ret;
4299 }
4300 EXPORT_SYMBOL(v4l2_s_ctrl);
4301
4302 int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
4303 {
4304         lockdep_assert_held(ctrl->handler->lock);
4305
4306         /* It's a driver bug if this happens. */
4307         if (WARN_ON(!ctrl->is_int))
4308                 return -EINVAL;
4309         ctrl->val = val;
4310         return set_ctrl(NULL, ctrl, 0);
4311 }
4312 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
4313
4314 int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
4315 {
4316         lockdep_assert_held(ctrl->handler->lock);
4317
4318         /* It's a driver bug if this happens. */
4319         if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
4320                 return -EINVAL;
4321         *ctrl->p_new.p_s64 = val;
4322         return set_ctrl(NULL, ctrl, 0);
4323 }
4324 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
4325
4326 int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
4327 {
4328         lockdep_assert_held(ctrl->handler->lock);
4329
4330         /* It's a driver bug if this happens. */
4331         if (WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING))
4332                 return -EINVAL;
4333         strscpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
4334         return set_ctrl(NULL, ctrl, 0);
4335 }
4336 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
4337
4338 int __v4l2_ctrl_s_ctrl_compound(struct v4l2_ctrl *ctrl,
4339                                 enum v4l2_ctrl_type type, const void *p)
4340 {
4341         lockdep_assert_held(ctrl->handler->lock);
4342
4343         /* It's a driver bug if this happens. */
4344         if (WARN_ON(ctrl->type != type))
4345                 return -EINVAL;
4346         memcpy(ctrl->p_new.p, p, ctrl->elems * ctrl->elem_size);
4347         return set_ctrl(NULL, ctrl, 0);
4348 }
4349 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_compound);
4350
4351 void v4l2_ctrl_request_complete(struct media_request *req,
4352                                 struct v4l2_ctrl_handler *main_hdl)
4353 {
4354         struct media_request_object *obj;
4355         struct v4l2_ctrl_handler *hdl;
4356         struct v4l2_ctrl_ref *ref;
4357
4358         if (!req || !main_hdl)
4359                 return;
4360
4361         /*
4362          * Note that it is valid if nothing was found. It means
4363          * that this request doesn't have any controls and so just
4364          * wants to leave the controls unchanged.
4365          */
4366         obj = media_request_object_find(req, &req_ops, main_hdl);
4367         if (!obj)
4368                 return;
4369         hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
4370
4371         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
4372                 struct v4l2_ctrl *ctrl = ref->ctrl;
4373                 struct v4l2_ctrl *master = ctrl->cluster[0];
4374                 unsigned int i;
4375
4376                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
4377                         ref->req = ref;
4378
4379                         v4l2_ctrl_lock(master);
4380                         /* g_volatile_ctrl will update the current control values */
4381                         for (i = 0; i < master->ncontrols; i++)
4382                                 cur_to_new(master->cluster[i]);
4383                         call_op(master, g_volatile_ctrl);
4384                         new_to_req(ref);
4385                         v4l2_ctrl_unlock(master);
4386                         continue;
4387                 }
4388                 if (ref->req == ref)
4389                         continue;
4390
4391                 v4l2_ctrl_lock(ctrl);
4392                 if (ref->req) {
4393                         ptr_to_ptr(ctrl, ref->req->p_req, ref->p_req);
4394                 } else {
4395                         ptr_to_ptr(ctrl, ctrl->p_cur, ref->p_req);
4396                         /*
4397                          * Set ref->req to ensure that when userspace wants to
4398                          * obtain the controls of this request it will take
4399                          * this value and not the current value of the control.
4400                          */
4401                         ref->req = ref;
4402                 }
4403                 v4l2_ctrl_unlock(ctrl);
4404         }
4405
4406         mutex_lock(main_hdl->lock);
4407         WARN_ON(!hdl->request_is_queued);
4408         list_del_init(&hdl->requests_queued);
4409         hdl->request_is_queued = false;
4410         mutex_unlock(main_hdl->lock);
4411         media_request_object_complete(obj);
4412         media_request_object_put(obj);
4413 }
4414 EXPORT_SYMBOL(v4l2_ctrl_request_complete);
4415
4416 int v4l2_ctrl_request_setup(struct media_request *req,
4417                              struct v4l2_ctrl_handler *main_hdl)
4418 {
4419         struct media_request_object *obj;
4420         struct v4l2_ctrl_handler *hdl;
4421         struct v4l2_ctrl_ref *ref;
4422         int ret = 0;
4423
4424         if (!req || !main_hdl)
4425                 return 0;
4426
4427         if (WARN_ON(req->state != MEDIA_REQUEST_STATE_QUEUED))
4428                 return -EBUSY;
4429
4430         /*
4431          * Note that it is valid if nothing was found. It means
4432          * that this request doesn't have any controls and so just
4433          * wants to leave the controls unchanged.
4434          */
4435         obj = media_request_object_find(req, &req_ops, main_hdl);
4436         if (!obj)
4437                 return 0;
4438         if (obj->completed) {
4439                 media_request_object_put(obj);
4440                 return -EBUSY;
4441         }
4442         hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
4443
4444         list_for_each_entry(ref, &hdl->ctrl_refs, node)
4445                 ref->req_done = false;
4446
4447         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
4448                 struct v4l2_ctrl *ctrl = ref->ctrl;
4449                 struct v4l2_ctrl *master = ctrl->cluster[0];
4450                 bool have_new_data = false;
4451                 int i;
4452
4453                 /*
4454                  * Skip if this control was already handled by a cluster.
4455                  * Skip button controls and read-only controls.
4456                  */
4457                 if (ref->req_done || (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
4458                         continue;
4459
4460                 v4l2_ctrl_lock(master);
4461                 for (i = 0; i < master->ncontrols; i++) {
4462                         if (master->cluster[i]) {
4463                                 struct v4l2_ctrl_ref *r =
4464                                         find_ref(hdl, master->cluster[i]->id);
4465
4466                                 if (r->req && r == r->req) {
4467                                         have_new_data = true;
4468                                         break;
4469                                 }
4470                         }
4471                 }
4472                 if (!have_new_data) {
4473                         v4l2_ctrl_unlock(master);
4474                         continue;
4475                 }
4476
4477                 for (i = 0; i < master->ncontrols; i++) {
4478                         if (master->cluster[i]) {
4479                                 struct v4l2_ctrl_ref *r =
4480                                         find_ref(hdl, master->cluster[i]->id);
4481
4482                                 req_to_new(r);
4483                                 master->cluster[i]->is_new = 1;
4484                                 r->req_done = true;
4485                         }
4486                 }
4487                 /*
4488                  * For volatile autoclusters that are currently in auto mode
4489                  * we need to discover if it will be set to manual mode.
4490                  * If so, then we have to copy the current volatile values
4491                  * first since those will become the new manual values (which
4492                  * may be overwritten by explicit new values from this set
4493                  * of controls).
4494                  */
4495                 if (master->is_auto && master->has_volatiles &&
4496                     !is_cur_manual(master)) {
4497                         s32 new_auto_val = *master->p_new.p_s32;
4498
4499                         /*
4500                          * If the new value == the manual value, then copy
4501                          * the current volatile values.
4502                          */
4503                         if (new_auto_val == master->manual_mode_value)
4504                                 update_from_auto_cluster(master);
4505                 }
4506
4507                 ret = try_or_set_cluster(NULL, master, true, 0);
4508                 v4l2_ctrl_unlock(master);
4509
4510                 if (ret)
4511                         break;
4512         }
4513
4514         media_request_object_put(obj);
4515         return ret;
4516 }
4517 EXPORT_SYMBOL(v4l2_ctrl_request_setup);
4518
4519 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
4520 {
4521         if (ctrl == NULL)
4522                 return;
4523         if (notify == NULL) {
4524                 ctrl->call_notify = 0;
4525                 return;
4526         }
4527         if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
4528                 return;
4529         ctrl->handler->notify = notify;
4530         ctrl->handler->notify_priv = priv;
4531         ctrl->call_notify = 1;
4532 }
4533 EXPORT_SYMBOL(v4l2_ctrl_notify);
4534
4535 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
4536                         s64 min, s64 max, u64 step, s64 def)
4537 {
4538         bool value_changed;
4539         bool range_changed = false;
4540         int ret;
4541
4542         lockdep_assert_held(ctrl->handler->lock);
4543
4544         switch (ctrl->type) {
4545         case V4L2_CTRL_TYPE_INTEGER:
4546         case V4L2_CTRL_TYPE_INTEGER64:
4547         case V4L2_CTRL_TYPE_BOOLEAN:
4548         case V4L2_CTRL_TYPE_MENU:
4549         case V4L2_CTRL_TYPE_INTEGER_MENU:
4550         case V4L2_CTRL_TYPE_BITMASK:
4551         case V4L2_CTRL_TYPE_U8:
4552         case V4L2_CTRL_TYPE_U16:
4553         case V4L2_CTRL_TYPE_U32:
4554                 if (ctrl->is_array)
4555                         return -EINVAL;
4556                 ret = check_range(ctrl->type, min, max, step, def);
4557                 if (ret)
4558                         return ret;
4559                 break;
4560         default:
4561                 return -EINVAL;
4562         }
4563         if ((ctrl->minimum != min) || (ctrl->maximum != max) ||
4564                 (ctrl->step != step) || ctrl->default_value != def) {
4565                 range_changed = true;
4566                 ctrl->minimum = min;
4567                 ctrl->maximum = max;
4568                 ctrl->step = step;
4569                 ctrl->default_value = def;
4570         }
4571         cur_to_new(ctrl);
4572         if (validate_new(ctrl, ctrl->p_new)) {
4573                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4574                         *ctrl->p_new.p_s64 = def;
4575                 else
4576                         *ctrl->p_new.p_s32 = def;
4577         }
4578
4579         if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4580                 value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
4581         else
4582                 value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
4583         if (value_changed)
4584                 ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
4585         else if (range_changed)
4586                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
4587         return ret;
4588 }
4589 EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
4590
4591 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
4592 {
4593         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
4594
4595         if (ctrl == NULL)
4596                 return -EINVAL;
4597
4598         v4l2_ctrl_lock(ctrl);
4599         list_add_tail(&sev->node, &ctrl->ev_subs);
4600         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
4601             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
4602                 struct v4l2_event ev;
4603                 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
4604
4605                 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
4606                         changes |= V4L2_EVENT_CTRL_CH_VALUE;
4607                 fill_event(&ev, ctrl, changes);
4608                 /* Mark the queue as active, allowing this initial
4609                    event to be accepted. */
4610                 sev->elems = elems;
4611                 v4l2_event_queue_fh(sev->fh, &ev);
4612         }
4613         v4l2_ctrl_unlock(ctrl);
4614         return 0;
4615 }
4616
4617 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
4618 {
4619         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
4620
4621         if (ctrl == NULL)
4622                 return;
4623
4624         v4l2_ctrl_lock(ctrl);
4625         list_del(&sev->node);
4626         v4l2_ctrl_unlock(ctrl);
4627 }
4628
4629 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
4630 {
4631         u32 old_changes = old->u.ctrl.changes;
4632
4633         old->u.ctrl = new->u.ctrl;
4634         old->u.ctrl.changes |= old_changes;
4635 }
4636 EXPORT_SYMBOL(v4l2_ctrl_replace);
4637
4638 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
4639 {
4640         new->u.ctrl.changes |= old->u.ctrl.changes;
4641 }
4642 EXPORT_SYMBOL(v4l2_ctrl_merge);
4643
4644 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
4645         .add = v4l2_ctrl_add_event,
4646         .del = v4l2_ctrl_del_event,
4647         .replace = v4l2_ctrl_replace,
4648         .merge = v4l2_ctrl_merge,
4649 };
4650 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
4651
4652 int v4l2_ctrl_log_status(struct file *file, void *fh)
4653 {
4654         struct video_device *vfd = video_devdata(file);
4655         struct v4l2_fh *vfh = file->private_data;
4656
4657         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
4658                 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
4659                         vfd->v4l2_dev->name);
4660         return 0;
4661 }
4662 EXPORT_SYMBOL(v4l2_ctrl_log_status);
4663
4664 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
4665                                 const struct v4l2_event_subscription *sub)
4666 {
4667         if (sub->type == V4L2_EVENT_CTRL)
4668                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
4669         return -EINVAL;
4670 }
4671 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
4672
4673 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
4674                                      struct v4l2_event_subscription *sub)
4675 {
4676         if (!sd->ctrl_handler)
4677                 return -EINVAL;
4678         return v4l2_ctrl_subscribe_event(fh, sub);
4679 }
4680 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
4681
4682 __poll_t v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
4683 {
4684         struct v4l2_fh *fh = file->private_data;
4685
4686         poll_wait(file, &fh->wait, wait);
4687         if (v4l2_event_pending(fh))
4688                 return EPOLLPRI;
4689         return 0;
4690 }
4691 EXPORT_SYMBOL(v4l2_ctrl_poll);
4692
4693 int v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler *hdl,
4694                                     const struct v4l2_ctrl_ops *ctrl_ops,
4695                                     const struct v4l2_fwnode_device_properties *p)
4696 {
4697         if (p->orientation != V4L2_FWNODE_PROPERTY_UNSET) {
4698                 u32 orientation_ctrl;
4699
4700                 switch (p->orientation) {
4701                 case V4L2_FWNODE_ORIENTATION_FRONT:
4702                         orientation_ctrl = V4L2_CAMERA_ORIENTATION_FRONT;
4703                         break;
4704                 case V4L2_FWNODE_ORIENTATION_BACK:
4705                         orientation_ctrl = V4L2_CAMERA_ORIENTATION_BACK;
4706                         break;
4707                 case V4L2_FWNODE_ORIENTATION_EXTERNAL:
4708                         orientation_ctrl = V4L2_CAMERA_ORIENTATION_EXTERNAL;
4709                         break;
4710                 default:
4711                         return -EINVAL;
4712                 }
4713                 if (!v4l2_ctrl_new_std_menu(hdl, ctrl_ops,
4714                                             V4L2_CID_CAMERA_ORIENTATION,
4715                                             V4L2_CAMERA_ORIENTATION_EXTERNAL, 0,
4716                                             orientation_ctrl))
4717                         return hdl->error;
4718         }
4719
4720         if (p->rotation != V4L2_FWNODE_PROPERTY_UNSET) {
4721                 if (!v4l2_ctrl_new_std(hdl, ctrl_ops,
4722                                        V4L2_CID_CAMERA_SENSOR_ROTATION,
4723                                        p->rotation, p->rotation, 1,
4724                                        p->rotation))
4725                         return hdl->error;
4726         }
4727
4728         return hdl->error;
4729 }
4730 EXPORT_SYMBOL(v4l2_ctrl_new_fwnode_properties);