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