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