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

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