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

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. is_cur_manual
  2. is_new_manual
  3. v4l2_ctrl_get_menu
  4. v4l2_ctrl_get_int_menu
  5. v4l2_ctrl_get_name
  6. v4l2_ctrl_fill
  7. user_flags
  8. fill_event
  9. send_event
  10. std_equal
  11. std_init_compound
  12. std_init
  13. std_log
  14. std_validate_compound
  15. std_validate
  16. ptr_to_user
  17. cur_to_user
  18. new_to_user
  19. req_to_user
  20. def_to_user
  21. user_to_ptr
  22. user_to_new
  23. ptr_to_ptr
  24. new_to_cur
  25. cur_to_new
  26. new_to_req
  27. req_to_new
  28. cluster_changed
  29. check_range
  30. validate_new
  31. node2id
  32. handler_set_err
  33. v4l2_ctrl_handler_init_class
  34. v4l2_ctrl_handler_free
  35. find_private_ref
  36. find_ref
  37. find_ref_lock
  38. v4l2_ctrl_find
  39. handler_new_ref
  40. v4l2_ctrl_new
  41. v4l2_ctrl_new_custom
  42. v4l2_ctrl_new_std
  43. v4l2_ctrl_new_std_menu
  44. v4l2_ctrl_new_std_menu_items
  45. v4l2_ctrl_new_int_menu
  46. v4l2_ctrl_add_handler
  47. v4l2_ctrl_radio_filter
  48. v4l2_ctrl_cluster
  49. v4l2_ctrl_auto_cluster
  50. v4l2_ctrl_activate
  51. __v4l2_ctrl_grab
  52. log_ctrl
  53. v4l2_ctrl_handler_log_status
  54. v4l2_ctrl_subdev_log_status
  55. __v4l2_ctrl_handler_setup
  56. v4l2_ctrl_handler_setup
  57. v4l2_query_ext_ctrl
  58. v4l2_queryctrl
  59. v4l2_querymenu
  60. v4l2_ctrl_request_clone
  61. v4l2_ctrl_request_queue
  62. v4l2_ctrl_request_unbind
  63. v4l2_ctrl_request_release
  64. v4l2_ctrl_request_hdl_find
  65. v4l2_ctrl_request_hdl_ctrl_find
  66. v4l2_ctrl_request_bind
  67. prepare_ext_ctrls
  68. class_check
  69. v4l2_g_ext_ctrls_common
  70. v4l2_ctrls_find_req_obj
  71. v4l2_g_ext_ctrls
  72. get_ctrl
  73. v4l2_g_ctrl
  74. v4l2_ctrl_g_ctrl
  75. v4l2_ctrl_g_ctrl_int64
  76. try_or_set_cluster
  77. validate_ctrls
  78. update_from_auto_cluster
  79. try_set_ext_ctrls_common
  80. try_set_ext_ctrls
  81. v4l2_try_ext_ctrls
  82. v4l2_s_ext_ctrls
  83. set_ctrl
  84. set_ctrl_lock
  85. v4l2_s_ctrl
  86. __v4l2_ctrl_s_ctrl
  87. __v4l2_ctrl_s_ctrl_int64
  88. __v4l2_ctrl_s_ctrl_string
  89. v4l2_ctrl_request_complete
  90. v4l2_ctrl_request_setup
  91. v4l2_ctrl_notify
  92. __v4l2_ctrl_modify_range
  93. v4l2_ctrl_add_event
  94. v4l2_ctrl_del_event
  95. v4l2_ctrl_replace
  96. v4l2_ctrl_merge
  97. v4l2_ctrl_log_status
  98. v4l2_ctrl_subscribe_event
  99. v4l2_ctrl_subdev_subscribe_event
  100. v4l2_ctrl_poll

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

/* [<][>][^][v][top][bottom][index][help] */