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

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