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

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