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

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