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         case V4L2_CID_DO_WHITE_BALANCE:
1018                 *type = V4L2_CTRL_TYPE_BUTTON;
1019                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1020                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1021                 *min = *max = *step = *def = 0;
1022                 break;
1023         case V4L2_CID_POWER_LINE_FREQUENCY:
1024         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1025         case V4L2_CID_MPEG_AUDIO_ENCODING:
1026         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1027         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1028         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1029         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
1030         case V4L2_CID_MPEG_AUDIO_MODE:
1031         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1032         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1033         case V4L2_CID_MPEG_AUDIO_CRC:
1034         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
1035         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
1036         case V4L2_CID_MPEG_VIDEO_ENCODING:
1037         case V4L2_CID_MPEG_VIDEO_ASPECT:
1038         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1039         case V4L2_CID_MPEG_STREAM_TYPE:
1040         case V4L2_CID_MPEG_STREAM_VBI_FMT:
1041         case V4L2_CID_EXPOSURE_AUTO:
1042         case V4L2_CID_AUTO_FOCUS_RANGE:
1043         case V4L2_CID_COLORFX:
1044         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1045         case V4L2_CID_TUNE_PREEMPHASIS:
1046         case V4L2_CID_FLASH_LED_MODE:
1047         case V4L2_CID_FLASH_STROBE_SOURCE:
1048         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1049         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1050         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1051         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1052         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1053         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1054         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1055         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1056         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1057         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1058         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1059         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1060         case V4L2_CID_ISO_SENSITIVITY_AUTO:
1061         case V4L2_CID_EXPOSURE_METERING:
1062         case V4L2_CID_SCENE_MODE:
1063         case V4L2_CID_DV_TX_MODE:
1064         case V4L2_CID_DV_TX_RGB_RANGE:
1065         case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
1066         case V4L2_CID_DV_RX_RGB_RANGE:
1067         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1068         case V4L2_CID_TEST_PATTERN:
1069         case V4L2_CID_DEINTERLACING_MODE:
1070         case V4L2_CID_TUNE_DEEMPHASIS:
1071         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1072         case V4L2_CID_DETECT_MD_MODE:
1073                 *type = V4L2_CTRL_TYPE_MENU;
1074                 break;
1075         case V4L2_CID_LINK_FREQ:
1076                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1077                 break;
1078         case V4L2_CID_RDS_TX_PS_NAME:
1079         case V4L2_CID_RDS_TX_RADIO_TEXT:
1080         case V4L2_CID_RDS_RX_PS_NAME:
1081         case V4L2_CID_RDS_RX_RADIO_TEXT:
1082                 *type = V4L2_CTRL_TYPE_STRING;
1083                 break;
1084         case V4L2_CID_ISO_SENSITIVITY:
1085         case V4L2_CID_AUTO_EXPOSURE_BIAS:
1086         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1087         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1088                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1089                 break;
1090         case V4L2_CID_USER_CLASS:
1091         case V4L2_CID_CAMERA_CLASS:
1092         case V4L2_CID_MPEG_CLASS:
1093         case V4L2_CID_FM_TX_CLASS:
1094         case V4L2_CID_FLASH_CLASS:
1095         case V4L2_CID_JPEG_CLASS:
1096         case V4L2_CID_IMAGE_SOURCE_CLASS:
1097         case V4L2_CID_IMAGE_PROC_CLASS:
1098         case V4L2_CID_DV_CLASS:
1099         case V4L2_CID_FM_RX_CLASS:
1100         case V4L2_CID_RF_TUNER_CLASS:
1101         case V4L2_CID_DETECT_CLASS:
1102                 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
1103                 /* You can neither read not write these */
1104                 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1105                 *min = *max = *step = *def = 0;
1106                 break;
1107         case V4L2_CID_BG_COLOR:
1108                 *type = V4L2_CTRL_TYPE_INTEGER;
1109                 *step = 1;
1110                 *min = 0;
1111                 /* Max is calculated as RGB888 that is 2^24 */
1112                 *max = 0xFFFFFF;
1113                 break;
1114         case V4L2_CID_FLASH_FAULT:
1115         case V4L2_CID_JPEG_ACTIVE_MARKER:
1116         case V4L2_CID_3A_LOCK:
1117         case V4L2_CID_AUTO_FOCUS_STATUS:
1118         case V4L2_CID_DV_TX_HOTPLUG:
1119         case V4L2_CID_DV_TX_RXSENSE:
1120         case V4L2_CID_DV_TX_EDID_PRESENT:
1121         case V4L2_CID_DV_RX_POWER_PRESENT:
1122                 *type = V4L2_CTRL_TYPE_BITMASK;
1123                 break;
1124         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1125         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1126                 *type = V4L2_CTRL_TYPE_INTEGER;
1127                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1128                 break;
1129         case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1130                 *type = V4L2_CTRL_TYPE_INTEGER64;
1131                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1132                 *min = *def = 0;
1133                 *max = 0x1ffffffffLL;
1134                 *step = 1;
1135                 break;
1136         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1137                 *type = V4L2_CTRL_TYPE_INTEGER64;
1138                 *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1139                 *min = *def = 0;
1140                 *max = 0x7fffffffffffffffLL;
1141                 *step = 1;
1142                 break;
1143         case V4L2_CID_PIXEL_RATE:
1144                 *type = V4L2_CTRL_TYPE_INTEGER64;
1145                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1146                 break;
1147         case V4L2_CID_DETECT_MD_REGION_GRID:
1148                 *type = V4L2_CTRL_TYPE_U8;
1149                 break;
1150         case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
1151                 *type = V4L2_CTRL_TYPE_U16;
1152                 break;
1153         case V4L2_CID_RDS_TX_ALT_FREQS:
1154                 *type = V4L2_CTRL_TYPE_U32;
1155                 break;
1156         default:
1157                 *type = V4L2_CTRL_TYPE_INTEGER;
1158                 break;
1159         }
1160         switch (id) {
1161         case V4L2_CID_MPEG_AUDIO_ENCODING:
1162         case V4L2_CID_MPEG_AUDIO_MODE:
1163         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1164         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1165         case V4L2_CID_MPEG_STREAM_TYPE:
1166                 *flags |= V4L2_CTRL_FLAG_UPDATE;
1167                 break;
1168         case V4L2_CID_AUDIO_VOLUME:
1169         case V4L2_CID_AUDIO_BALANCE:
1170         case V4L2_CID_AUDIO_BASS:
1171         case V4L2_CID_AUDIO_TREBLE:
1172         case V4L2_CID_BRIGHTNESS:
1173         case V4L2_CID_CONTRAST:
1174         case V4L2_CID_SATURATION:
1175         case V4L2_CID_HUE:
1176         case V4L2_CID_RED_BALANCE:
1177         case V4L2_CID_BLUE_BALANCE:
1178         case V4L2_CID_GAMMA:
1179         case V4L2_CID_SHARPNESS:
1180         case V4L2_CID_CHROMA_GAIN:
1181         case V4L2_CID_RDS_TX_DEVIATION:
1182         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1183         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1184         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1185         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1186         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1187         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1188         case V4L2_CID_PILOT_TONE_DEVIATION:
1189         case V4L2_CID_PILOT_TONE_FREQUENCY:
1190         case V4L2_CID_TUNE_POWER_LEVEL:
1191         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1192         case V4L2_CID_RF_TUNER_RF_GAIN:
1193         case V4L2_CID_RF_TUNER_LNA_GAIN:
1194         case V4L2_CID_RF_TUNER_MIXER_GAIN:
1195         case V4L2_CID_RF_TUNER_IF_GAIN:
1196         case V4L2_CID_RF_TUNER_BANDWIDTH:
1197         case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
1198                 *flags |= V4L2_CTRL_FLAG_SLIDER;
1199                 break;
1200         case V4L2_CID_PAN_RELATIVE:
1201         case V4L2_CID_TILT_RELATIVE:
1202         case V4L2_CID_FOCUS_RELATIVE:
1203         case V4L2_CID_IRIS_RELATIVE:
1204         case V4L2_CID_ZOOM_RELATIVE:
1205                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1206                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1207                 break;
1208         case V4L2_CID_FLASH_STROBE_STATUS:
1209         case V4L2_CID_AUTO_FOCUS_STATUS:
1210         case V4L2_CID_FLASH_READY:
1211         case V4L2_CID_DV_TX_HOTPLUG:
1212         case V4L2_CID_DV_TX_RXSENSE:
1213         case V4L2_CID_DV_TX_EDID_PRESENT:
1214         case V4L2_CID_DV_RX_POWER_PRESENT:
1215         case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1216         case V4L2_CID_RDS_RX_PTY:
1217         case V4L2_CID_RDS_RX_PS_NAME:
1218         case V4L2_CID_RDS_RX_RADIO_TEXT:
1219         case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1220         case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1221         case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1222                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1223                 break;
1224         case V4L2_CID_RF_TUNER_PLL_LOCK:
1225                 *flags |= V4L2_CTRL_FLAG_VOLATILE;
1226                 break;
1227         }
1228 }
1229 EXPORT_SYMBOL(v4l2_ctrl_fill);
1230
1231 static u32 user_flags(const struct v4l2_ctrl *ctrl)
1232 {
1233         u32 flags = ctrl->flags;
1234
1235         if (ctrl->is_ptr)
1236                 flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD;
1237
1238         return flags;
1239 }
1240
1241 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1242 {
1243         memset(ev, 0, sizeof(*ev));
1244         ev->type = V4L2_EVENT_CTRL;
1245         ev->id = ctrl->id;
1246         ev->u.ctrl.changes = changes;
1247         ev->u.ctrl.type = ctrl->type;
1248         ev->u.ctrl.flags = user_flags(ctrl);
1249         if (ctrl->is_ptr)
1250                 ev->u.ctrl.value64 = 0;
1251         else
1252                 ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
1253         ev->u.ctrl.minimum = ctrl->minimum;
1254         ev->u.ctrl.maximum = ctrl->maximum;
1255         if (ctrl->type == V4L2_CTRL_TYPE_MENU
1256             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1257                 ev->u.ctrl.step = 1;
1258         else
1259                 ev->u.ctrl.step = ctrl->step;
1260         ev->u.ctrl.default_value = ctrl->default_value;
1261 }
1262
1263 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1264 {
1265         struct v4l2_event ev;
1266         struct v4l2_subscribed_event *sev;
1267
1268         if (list_empty(&ctrl->ev_subs))
1269                 return;
1270         fill_event(&ev, ctrl, changes);
1271
1272         list_for_each_entry(sev, &ctrl->ev_subs, node)
1273                 if (sev->fh != fh ||
1274                     (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1275                         v4l2_event_queue_fh(sev->fh, &ev);
1276 }
1277
1278 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
1279                       union v4l2_ctrl_ptr ptr1,
1280                       union v4l2_ctrl_ptr ptr2)
1281 {
1282         switch (ctrl->type) {
1283         case V4L2_CTRL_TYPE_BUTTON:
1284                 return false;
1285         case V4L2_CTRL_TYPE_STRING:
1286                 idx *= ctrl->elem_size;
1287                 /* strings are always 0-terminated */
1288                 return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
1289         case V4L2_CTRL_TYPE_INTEGER64:
1290                 return ptr1.p_s64[idx] == ptr2.p_s64[idx];
1291         case V4L2_CTRL_TYPE_U8:
1292                 return ptr1.p_u8[idx] == ptr2.p_u8[idx];
1293         case V4L2_CTRL_TYPE_U16:
1294                 return ptr1.p_u16[idx] == ptr2.p_u16[idx];
1295         case V4L2_CTRL_TYPE_U32:
1296                 return ptr1.p_u32[idx] == ptr2.p_u32[idx];
1297         default:
1298                 if (ctrl->is_int)
1299                         return ptr1.p_s32[idx] == ptr2.p_s32[idx];
1300                 idx *= ctrl->elem_size;
1301                 return !memcmp(ptr1.p + idx, ptr2.p + idx, ctrl->elem_size);
1302         }
1303 }
1304
1305 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
1306                      union v4l2_ctrl_ptr ptr)
1307 {
1308         switch (ctrl->type) {
1309         case V4L2_CTRL_TYPE_STRING:
1310                 idx *= ctrl->elem_size;
1311                 memset(ptr.p_char + idx, ' ', ctrl->minimum);
1312                 ptr.p_char[idx + ctrl->minimum] = '\0';
1313                 break;
1314         case V4L2_CTRL_TYPE_INTEGER64:
1315                 ptr.p_s64[idx] = ctrl->default_value;
1316                 break;
1317         case V4L2_CTRL_TYPE_INTEGER:
1318         case V4L2_CTRL_TYPE_INTEGER_MENU:
1319         case V4L2_CTRL_TYPE_MENU:
1320         case V4L2_CTRL_TYPE_BITMASK:
1321         case V4L2_CTRL_TYPE_BOOLEAN:
1322                 ptr.p_s32[idx] = ctrl->default_value;
1323                 break;
1324         case V4L2_CTRL_TYPE_U8:
1325                 ptr.p_u8[idx] = ctrl->default_value;
1326                 break;
1327         case V4L2_CTRL_TYPE_U16:
1328                 ptr.p_u16[idx] = ctrl->default_value;
1329                 break;
1330         case V4L2_CTRL_TYPE_U32:
1331                 ptr.p_u32[idx] = ctrl->default_value;
1332                 break;
1333         default:
1334                 idx *= ctrl->elem_size;
1335                 memset(ptr.p + idx, 0, ctrl->elem_size);
1336                 break;
1337         }
1338 }
1339
1340 static void std_log(const struct v4l2_ctrl *ctrl)
1341 {
1342         union v4l2_ctrl_ptr ptr = ctrl->p_cur;
1343
1344         if (ctrl->is_array) {
1345                 unsigned i;
1346
1347                 for (i = 0; i < ctrl->nr_of_dims; i++)
1348                         pr_cont("[%u]", ctrl->dims[i]);
1349                 pr_cont(" ");
1350         }
1351
1352         switch (ctrl->type) {
1353         case V4L2_CTRL_TYPE_INTEGER:
1354                 pr_cont("%d", *ptr.p_s32);
1355                 break;
1356         case V4L2_CTRL_TYPE_BOOLEAN:
1357                 pr_cont("%s", *ptr.p_s32 ? "true" : "false");
1358                 break;
1359         case V4L2_CTRL_TYPE_MENU:
1360                 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
1361                 break;
1362         case V4L2_CTRL_TYPE_INTEGER_MENU:
1363                 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
1364                 break;
1365         case V4L2_CTRL_TYPE_BITMASK:
1366                 pr_cont("0x%08x", *ptr.p_s32);
1367                 break;
1368         case V4L2_CTRL_TYPE_INTEGER64:
1369                 pr_cont("%lld", *ptr.p_s64);
1370                 break;
1371         case V4L2_CTRL_TYPE_STRING:
1372                 pr_cont("%s", ptr.p_char);
1373                 break;
1374         case V4L2_CTRL_TYPE_U8:
1375                 pr_cont("%u", (unsigned)*ptr.p_u8);
1376                 break;
1377         case V4L2_CTRL_TYPE_U16:
1378                 pr_cont("%u", (unsigned)*ptr.p_u16);
1379                 break;
1380         case V4L2_CTRL_TYPE_U32:
1381                 pr_cont("%u", (unsigned)*ptr.p_u32);
1382                 break;
1383         default:
1384                 pr_cont("unknown type %d", ctrl->type);
1385                 break;
1386         }
1387 }
1388
1389 /*
1390  * Round towards the closest legal value. Be careful when we are
1391  * close to the maximum range of the control type to prevent
1392  * wrap-arounds.
1393  */
1394 #define ROUND_TO_RANGE(val, offset_type, ctrl)                  \
1395 ({                                                              \
1396         offset_type offset;                                     \
1397         if ((ctrl)->maximum >= 0 &&                             \
1398             val >= (ctrl)->maximum - (s32)((ctrl)->step / 2))   \
1399                 val = (ctrl)->maximum;                          \
1400         else                                                    \
1401                 val += (s32)((ctrl)->step / 2);                 \
1402         val = clamp_t(typeof(val), val,                         \
1403                       (ctrl)->minimum, (ctrl)->maximum);        \
1404         offset = (val) - (ctrl)->minimum;                       \
1405         offset = (ctrl)->step * (offset / (u32)(ctrl)->step);   \
1406         val = (ctrl)->minimum + offset;                         \
1407         0;                                                      \
1408 })
1409
1410 /* Validate a new control */
1411 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
1412                         union v4l2_ctrl_ptr ptr)
1413 {
1414         size_t len;
1415         u64 offset;
1416         s64 val;
1417
1418         switch (ctrl->type) {
1419         case V4L2_CTRL_TYPE_INTEGER:
1420                 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
1421         case V4L2_CTRL_TYPE_INTEGER64:
1422                 /*
1423                  * We can't use the ROUND_TO_RANGE define here due to
1424                  * the u64 divide that needs special care.
1425                  */
1426                 val = ptr.p_s64[idx];
1427                 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
1428                         val = ctrl->maximum;
1429                 else
1430                         val += (s64)(ctrl->step / 2);
1431                 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
1432                 offset = val - ctrl->minimum;
1433                 do_div(offset, ctrl->step);
1434                 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
1435                 return 0;
1436         case V4L2_CTRL_TYPE_U8:
1437                 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
1438         case V4L2_CTRL_TYPE_U16:
1439                 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
1440         case V4L2_CTRL_TYPE_U32:
1441                 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
1442
1443         case V4L2_CTRL_TYPE_BOOLEAN:
1444                 ptr.p_s32[idx] = !!ptr.p_s32[idx];
1445                 return 0;
1446
1447         case V4L2_CTRL_TYPE_MENU:
1448         case V4L2_CTRL_TYPE_INTEGER_MENU:
1449                 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
1450                         return -ERANGE;
1451                 if (ctrl->menu_skip_mask & (1 << ptr.p_s32[idx]))
1452                         return -EINVAL;
1453                 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1454                     ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
1455                         return -EINVAL;
1456                 return 0;
1457
1458         case V4L2_CTRL_TYPE_BITMASK:
1459                 ptr.p_s32[idx] &= ctrl->maximum;
1460                 return 0;
1461
1462         case V4L2_CTRL_TYPE_BUTTON:
1463         case V4L2_CTRL_TYPE_CTRL_CLASS:
1464                 ptr.p_s32[idx] = 0;
1465                 return 0;
1466
1467         case V4L2_CTRL_TYPE_STRING:
1468                 idx *= ctrl->elem_size;
1469                 len = strlen(ptr.p_char + idx);
1470                 if (len < ctrl->minimum)
1471                         return -ERANGE;
1472                 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
1473                         return -ERANGE;
1474                 return 0;
1475
1476         default:
1477                 return -EINVAL;
1478         }
1479 }
1480
1481 static const struct v4l2_ctrl_type_ops std_type_ops = {
1482         .equal = std_equal,
1483         .init = std_init,
1484         .log = std_log,
1485         .validate = std_validate,
1486 };
1487
1488 /* Helper function: copy the given control value back to the caller */
1489 static int ptr_to_user(struct v4l2_ext_control *c,
1490                        struct v4l2_ctrl *ctrl,
1491                        union v4l2_ctrl_ptr ptr)
1492 {
1493         u32 len;
1494
1495         if (ctrl->is_ptr && !ctrl->is_string)
1496                 return copy_to_user(c->ptr, ptr.p, c->size) ?
1497                        -EFAULT : 0;
1498
1499         switch (ctrl->type) {
1500         case V4L2_CTRL_TYPE_STRING:
1501                 len = strlen(ptr.p_char);
1502                 if (c->size < len + 1) {
1503                         c->size = ctrl->elem_size;
1504                         return -ENOSPC;
1505                 }
1506                 return copy_to_user(c->string, ptr.p_char, len + 1) ?
1507                        -EFAULT : 0;
1508         case V4L2_CTRL_TYPE_INTEGER64:
1509                 c->value64 = *ptr.p_s64;
1510                 break;
1511         default:
1512                 c->value = *ptr.p_s32;
1513                 break;
1514         }
1515         return 0;
1516 }
1517
1518 /* Helper function: copy the current control value back to the caller */
1519 static int cur_to_user(struct v4l2_ext_control *c,
1520                        struct v4l2_ctrl *ctrl)
1521 {
1522         return ptr_to_user(c, ctrl, ctrl->p_cur);
1523 }
1524
1525 /* Helper function: copy the new control value back to the caller */
1526 static int new_to_user(struct v4l2_ext_control *c,
1527                        struct v4l2_ctrl *ctrl)
1528 {
1529         return ptr_to_user(c, ctrl, ctrl->p_new);
1530 }
1531
1532 /* Helper function: copy the initial control value back to the caller */
1533 static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
1534 {
1535         int idx;
1536
1537         for (idx = 0; idx < ctrl->elems; idx++)
1538                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
1539
1540         return ptr_to_user(c, ctrl, ctrl->p_new);
1541 }
1542
1543 /* Helper function: copy the caller-provider value to the given control value */
1544 static int user_to_ptr(struct v4l2_ext_control *c,
1545                        struct v4l2_ctrl *ctrl,
1546                        union v4l2_ctrl_ptr ptr)
1547 {
1548         int ret;
1549         u32 size;
1550
1551         ctrl->is_new = 1;
1552         if (ctrl->is_ptr && !ctrl->is_string) {
1553                 unsigned idx;
1554
1555                 ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0;
1556                 if (ret || !ctrl->is_array)
1557                         return ret;
1558                 for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++)
1559                         ctrl->type_ops->init(ctrl, idx, ptr);
1560                 return 0;
1561         }
1562
1563         switch (ctrl->type) {
1564         case V4L2_CTRL_TYPE_INTEGER64:
1565                 *ptr.p_s64 = c->value64;
1566                 break;
1567         case V4L2_CTRL_TYPE_STRING:
1568                 size = c->size;
1569                 if (size == 0)
1570                         return -ERANGE;
1571                 if (size > ctrl->maximum + 1)
1572                         size = ctrl->maximum + 1;
1573                 ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0;
1574                 if (!ret) {
1575                         char last = ptr.p_char[size - 1];
1576
1577                         ptr.p_char[size - 1] = 0;
1578                         /* If the string was longer than ctrl->maximum,
1579                            then return an error. */
1580                         if (strlen(ptr.p_char) == ctrl->maximum && last)
1581                                 return -ERANGE;
1582                 }
1583                 return ret;
1584         default:
1585                 *ptr.p_s32 = c->value;
1586                 break;
1587         }
1588         return 0;
1589 }
1590
1591 /* Helper function: copy the caller-provider value as the new control value */
1592 static int user_to_new(struct v4l2_ext_control *c,
1593                        struct v4l2_ctrl *ctrl)
1594 {
1595         return user_to_ptr(c, ctrl, ctrl->p_new);
1596 }
1597
1598 /* Copy the one value to another. */
1599 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
1600                        union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
1601 {
1602         if (ctrl == NULL)
1603                 return;
1604         memcpy(to.p, from.p, ctrl->elems * ctrl->elem_size);
1605 }
1606
1607 /* Copy the new value to the current value. */
1608 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1609 {
1610         bool changed;
1611
1612         if (ctrl == NULL)
1613                 return;
1614
1615         /* has_changed is set by cluster_changed */
1616         changed = ctrl->has_changed;
1617         if (changed)
1618                 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
1619
1620         if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1621                 /* Note: CH_FLAGS is only set for auto clusters. */
1622                 ctrl->flags &=
1623                         ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1624                 if (!is_cur_manual(ctrl->cluster[0])) {
1625                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1626                         if (ctrl->cluster[0]->has_volatiles)
1627                                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1628                 }
1629                 fh = NULL;
1630         }
1631         if (changed || ch_flags) {
1632                 /* If a control was changed that was not one of the controls
1633                    modified by the application, then send the event to all. */
1634                 if (!ctrl->is_new)
1635                         fh = NULL;
1636                 send_event(fh, ctrl,
1637                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1638                 if (ctrl->call_notify && changed && ctrl->handler->notify)
1639                         ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1640         }
1641 }
1642
1643 /* Copy the current value to the new value */
1644 static void cur_to_new(struct v4l2_ctrl *ctrl)
1645 {
1646         if (ctrl == NULL)
1647                 return;
1648         ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1649 }
1650
1651 /* Return non-zero if one or more of the controls in the cluster has a new
1652    value that differs from the current value. */
1653 static int cluster_changed(struct v4l2_ctrl *master)
1654 {
1655         bool changed = false;
1656         unsigned idx;
1657         int i;
1658
1659         for (i = 0; i < master->ncontrols; i++) {
1660                 struct v4l2_ctrl *ctrl = master->cluster[i];
1661                 bool ctrl_changed = false;
1662
1663                 if (ctrl == NULL)
1664                         continue;
1665
1666                 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE)
1667                         changed = ctrl_changed = true;
1668
1669                 /*
1670                  * Set has_changed to false to avoid generating
1671                  * the event V4L2_EVENT_CTRL_CH_VALUE
1672                  */
1673                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
1674                         ctrl->has_changed = false;
1675                         continue;
1676                 }
1677
1678                 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1679                         ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1680                                 ctrl->p_cur, ctrl->p_new);
1681                 ctrl->has_changed = ctrl_changed;
1682                 changed |= ctrl->has_changed;
1683         }
1684         return changed;
1685 }
1686
1687 /* Control range checking */
1688 static int check_range(enum v4l2_ctrl_type type,
1689                 s64 min, s64 max, u64 step, s64 def)
1690 {
1691         switch (type) {
1692         case V4L2_CTRL_TYPE_BOOLEAN:
1693                 if (step != 1 || max > 1 || min < 0)
1694                         return -ERANGE;
1695                 /* fall through */
1696         case V4L2_CTRL_TYPE_U8:
1697         case V4L2_CTRL_TYPE_U16:
1698         case V4L2_CTRL_TYPE_U32:
1699         case V4L2_CTRL_TYPE_INTEGER:
1700         case V4L2_CTRL_TYPE_INTEGER64:
1701                 if (step == 0 || min > max || def < min || def > max)
1702                         return -ERANGE;
1703                 return 0;
1704         case V4L2_CTRL_TYPE_BITMASK:
1705                 if (step || min || !max || (def & ~max))
1706                         return -ERANGE;
1707                 return 0;
1708         case V4L2_CTRL_TYPE_MENU:
1709         case V4L2_CTRL_TYPE_INTEGER_MENU:
1710                 if (min > max || def < min || def > max)
1711                         return -ERANGE;
1712                 /* Note: step == menu_skip_mask for menu controls.
1713                    So here we check if the default value is masked out. */
1714                 if (step && ((1 << def) & step))
1715                         return -EINVAL;
1716                 return 0;
1717         case V4L2_CTRL_TYPE_STRING:
1718                 if (min > max || min < 0 || step < 1 || def)
1719                         return -ERANGE;
1720                 return 0;
1721         default:
1722                 return 0;
1723         }
1724 }
1725
1726 /* Validate a new control */
1727 static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
1728 {
1729         unsigned idx;
1730         int err = 0;
1731
1732         for (idx = 0; !err && idx < ctrl->elems; idx++)
1733                 err = ctrl->type_ops->validate(ctrl, idx, p_new);
1734         return err;
1735 }
1736
1737 static inline u32 node2id(struct list_head *node)
1738 {
1739         return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1740 }
1741
1742 /* Set the handler's error code if it wasn't set earlier already */
1743 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1744 {
1745         if (hdl->error == 0)
1746                 hdl->error = err;
1747         return err;
1748 }
1749
1750 /* Initialize the handler */
1751 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1752                                  unsigned nr_of_controls_hint,
1753                                  struct lock_class_key *key, const char *name)
1754 {
1755         mutex_init(&hdl->_lock);
1756         hdl->lock = &hdl->_lock;
1757         lockdep_set_class_and_name(hdl->lock, key, name);
1758         INIT_LIST_HEAD(&hdl->ctrls);
1759         INIT_LIST_HEAD(&hdl->ctrl_refs);
1760         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1761         hdl->buckets = kvmalloc_array(hdl->nr_of_buckets,
1762                                       sizeof(hdl->buckets[0]),
1763                                       GFP_KERNEL | __GFP_ZERO);
1764         hdl->error = hdl->buckets ? 0 : -ENOMEM;
1765         return hdl->error;
1766 }
1767 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1768
1769 /* Free all controls and control refs */
1770 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1771 {
1772         struct v4l2_ctrl_ref *ref, *next_ref;
1773         struct v4l2_ctrl *ctrl, *next_ctrl;
1774         struct v4l2_subscribed_event *sev, *next_sev;
1775
1776         if (hdl == NULL || hdl->buckets == NULL)
1777                 return;
1778
1779         mutex_lock(hdl->lock);
1780         /* Free all nodes */
1781         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1782                 list_del(&ref->node);
1783                 kfree(ref);
1784         }
1785         /* Free all controls owned by the handler */
1786         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1787                 list_del(&ctrl->node);
1788                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1789                         list_del(&sev->node);
1790                 kvfree(ctrl);
1791         }
1792         kvfree(hdl->buckets);
1793         hdl->buckets = NULL;
1794         hdl->cached = NULL;
1795         hdl->error = 0;
1796         mutex_unlock(hdl->lock);
1797         mutex_destroy(&hdl->_lock);
1798 }
1799 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1800
1801 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1802    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1803    with applications that do not use the NEXT_CTRL flag.
1804
1805    We just find the n-th private user control. It's O(N), but that should not
1806    be an issue in this particular case. */
1807 static struct v4l2_ctrl_ref *find_private_ref(
1808                 struct v4l2_ctrl_handler *hdl, u32 id)
1809 {
1810         struct v4l2_ctrl_ref *ref;
1811
1812         id -= V4L2_CID_PRIVATE_BASE;
1813         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1814                 /* Search for private user controls that are compatible with
1815                    VIDIOC_G/S_CTRL. */
1816                 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1817                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1818                         if (!ref->ctrl->is_int)
1819                                 continue;
1820                         if (id == 0)
1821                                 return ref;
1822                         id--;
1823                 }
1824         }
1825         return NULL;
1826 }
1827
1828 /* Find a control with the given ID. */
1829 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1830 {
1831         struct v4l2_ctrl_ref *ref;
1832         int bucket;
1833
1834         id &= V4L2_CTRL_ID_MASK;
1835
1836         /* Old-style private controls need special handling */
1837         if (id >= V4L2_CID_PRIVATE_BASE)
1838                 return find_private_ref(hdl, id);
1839         bucket = id % hdl->nr_of_buckets;
1840
1841         /* Simple optimization: cache the last control found */
1842         if (hdl->cached && hdl->cached->ctrl->id == id)
1843                 return hdl->cached;
1844
1845         /* Not in cache, search the hash */
1846         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1847         while (ref && ref->ctrl->id != id)
1848                 ref = ref->next;
1849
1850         if (ref)
1851                 hdl->cached = ref; /* cache it! */
1852         return ref;
1853 }
1854
1855 /* Find a control with the given ID. Take the handler's lock first. */
1856 static struct v4l2_ctrl_ref *find_ref_lock(
1857                 struct v4l2_ctrl_handler *hdl, u32 id)
1858 {
1859         struct v4l2_ctrl_ref *ref = NULL;
1860
1861         if (hdl) {
1862                 mutex_lock(hdl->lock);
1863                 ref = find_ref(hdl, id);
1864                 mutex_unlock(hdl->lock);
1865         }
1866         return ref;
1867 }
1868
1869 /* Find a control with the given ID. */
1870 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1871 {
1872         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1873
1874         return ref ? ref->ctrl : NULL;
1875 }
1876 EXPORT_SYMBOL(v4l2_ctrl_find);
1877
1878 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1879 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1880                            struct v4l2_ctrl *ctrl)
1881 {
1882         struct v4l2_ctrl_ref *ref;
1883         struct v4l2_ctrl_ref *new_ref;
1884         u32 id = ctrl->id;
1885         u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
1886         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
1887
1888         /*
1889          * Automatically add the control class if it is not yet present and
1890          * the new control is not a compound control.
1891          */
1892         if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
1893             id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1894                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1895                         return hdl->error;
1896
1897         if (hdl->error)
1898                 return hdl->error;
1899
1900         new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1901         if (!new_ref)
1902                 return handler_set_err(hdl, -ENOMEM);
1903         new_ref->ctrl = ctrl;
1904         if (ctrl->handler == hdl) {
1905                 /* By default each control starts in a cluster of its own.
1906                    new_ref->ctrl is basically a cluster array with one
1907                    element, so that's perfect to use as the cluster pointer.
1908                    But only do this for the handler that owns the control. */
1909                 ctrl->cluster = &new_ref->ctrl;
1910                 ctrl->ncontrols = 1;
1911         }
1912
1913         INIT_LIST_HEAD(&new_ref->node);
1914
1915         mutex_lock(hdl->lock);
1916
1917         /* Add immediately at the end of the list if the list is empty, or if
1918            the last element in the list has a lower ID.
1919            This ensures that when elements are added in ascending order the
1920            insertion is an O(1) operation. */
1921         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1922                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1923                 goto insert_in_hash;
1924         }
1925
1926         /* Find insert position in sorted list */
1927         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1928                 if (ref->ctrl->id < id)
1929                         continue;
1930                 /* Don't add duplicates */
1931                 if (ref->ctrl->id == id) {
1932                         kfree(new_ref);
1933                         goto unlock;
1934                 }
1935                 list_add(&new_ref->node, ref->node.prev);
1936                 break;
1937         }
1938
1939 insert_in_hash:
1940         /* Insert the control node in the hash */
1941         new_ref->next = hdl->buckets[bucket];
1942         hdl->buckets[bucket] = new_ref;
1943
1944 unlock:
1945         mutex_unlock(hdl->lock);
1946         return 0;
1947 }
1948
1949 /* Add a new control */
1950 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1951                         const struct v4l2_ctrl_ops *ops,
1952                         const struct v4l2_ctrl_type_ops *type_ops,
1953                         u32 id, const char *name, enum v4l2_ctrl_type type,
1954                         s64 min, s64 max, u64 step, s64 def,
1955                         const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
1956                         u32 flags, const char * const *qmenu,
1957                         const s64 *qmenu_int, void *priv)
1958 {
1959         struct v4l2_ctrl *ctrl;
1960         unsigned sz_extra;
1961         unsigned nr_of_dims = 0;
1962         unsigned elems = 1;
1963         bool is_array;
1964         unsigned tot_ctrl_size;
1965         unsigned idx;
1966         void *data;
1967         int err;
1968
1969         if (hdl->error)
1970                 return NULL;
1971
1972         while (dims && dims[nr_of_dims]) {
1973                 elems *= dims[nr_of_dims];
1974                 nr_of_dims++;
1975                 if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
1976                         break;
1977         }
1978         is_array = nr_of_dims > 0;
1979
1980         /* Prefill elem_size for all types handled by std_type_ops */
1981         switch (type) {
1982         case V4L2_CTRL_TYPE_INTEGER64:
1983                 elem_size = sizeof(s64);
1984                 break;
1985         case V4L2_CTRL_TYPE_STRING:
1986                 elem_size = max + 1;
1987                 break;
1988         case V4L2_CTRL_TYPE_U8:
1989                 elem_size = sizeof(u8);
1990                 break;
1991         case V4L2_CTRL_TYPE_U16:
1992                 elem_size = sizeof(u16);
1993                 break;
1994         case V4L2_CTRL_TYPE_U32:
1995                 elem_size = sizeof(u32);
1996                 break;
1997         default:
1998                 if (type < V4L2_CTRL_COMPOUND_TYPES)
1999                         elem_size = sizeof(s32);
2000                 break;
2001         }
2002         tot_ctrl_size = elem_size * elems;
2003
2004         /* Sanity checks */
2005         if (id == 0 || name == NULL || !elem_size ||
2006             id >= V4L2_CID_PRIVATE_BASE ||
2007             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
2008             (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
2009                 handler_set_err(hdl, -ERANGE);
2010                 return NULL;
2011         }
2012         err = check_range(type, min, max, step, def);
2013         if (err) {
2014                 handler_set_err(hdl, err);
2015                 return NULL;
2016         }
2017         if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
2018                 handler_set_err(hdl, -ERANGE);
2019                 return NULL;
2020         }
2021         if (is_array &&
2022             (type == V4L2_CTRL_TYPE_BUTTON ||
2023              type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
2024                 handler_set_err(hdl, -EINVAL);
2025                 return NULL;
2026         }
2027
2028         sz_extra = 0;
2029         if (type == V4L2_CTRL_TYPE_BUTTON)
2030                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
2031                         V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
2032         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
2033                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
2034         else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
2035                  type == V4L2_CTRL_TYPE_STRING ||
2036                  type >= V4L2_CTRL_COMPOUND_TYPES ||
2037                  is_array)
2038                 sz_extra += 2 * tot_ctrl_size;
2039
2040         ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
2041         if (ctrl == NULL) {
2042                 handler_set_err(hdl, -ENOMEM);
2043                 return NULL;
2044         }
2045
2046         INIT_LIST_HEAD(&ctrl->node);
2047         INIT_LIST_HEAD(&ctrl->ev_subs);
2048         ctrl->handler = hdl;
2049         ctrl->ops = ops;
2050         ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
2051         ctrl->id = id;
2052         ctrl->name = name;
2053         ctrl->type = type;
2054         ctrl->flags = flags;
2055         ctrl->minimum = min;
2056         ctrl->maximum = max;
2057         ctrl->step = step;
2058         ctrl->default_value = def;
2059         ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
2060         ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
2061         ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
2062         ctrl->is_array = is_array;
2063         ctrl->elems = elems;
2064         ctrl->nr_of_dims = nr_of_dims;
2065         if (nr_of_dims)
2066                 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
2067         ctrl->elem_size = elem_size;
2068         if (type == V4L2_CTRL_TYPE_MENU)
2069                 ctrl->qmenu = qmenu;
2070         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2071                 ctrl->qmenu_int = qmenu_int;
2072         ctrl->priv = priv;
2073         ctrl->cur.val = ctrl->val = def;
2074         data = &ctrl[1];
2075
2076         if (!ctrl->is_int) {
2077                 ctrl->p_new.p = data;
2078                 ctrl->p_cur.p = data + tot_ctrl_size;
2079         } else {
2080                 ctrl->p_new.p = &ctrl->val;
2081                 ctrl->p_cur.p = &ctrl->cur.val;
2082         }
2083         for (idx = 0; idx < elems; idx++) {
2084                 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
2085                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2086         }
2087
2088         if (handler_new_ref(hdl, ctrl)) {
2089                 kvfree(ctrl);
2090                 return NULL;
2091         }
2092         mutex_lock(hdl->lock);
2093         list_add_tail(&ctrl->node, &hdl->ctrls);
2094         mutex_unlock(hdl->lock);
2095         return ctrl;
2096 }
2097
2098 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
2099                         const struct v4l2_ctrl_config *cfg, void *priv)
2100 {
2101         bool is_menu;
2102         struct v4l2_ctrl *ctrl;
2103         const char *name = cfg->name;
2104         const char * const *qmenu = cfg->qmenu;
2105         const s64 *qmenu_int = cfg->qmenu_int;
2106         enum v4l2_ctrl_type type = cfg->type;
2107         u32 flags = cfg->flags;
2108         s64 min = cfg->min;
2109         s64 max = cfg->max;
2110         u64 step = cfg->step;
2111         s64 def = cfg->def;
2112
2113         if (name == NULL)
2114                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
2115                                                                 &def, &flags);
2116
2117         is_menu = (type == V4L2_CTRL_TYPE_MENU ||
2118                    type == V4L2_CTRL_TYPE_INTEGER_MENU);
2119         if (is_menu)
2120                 WARN_ON(step);
2121         else
2122                 WARN_ON(cfg->menu_skip_mask);
2123         if (type == V4L2_CTRL_TYPE_MENU && !qmenu) {
2124                 qmenu = v4l2_ctrl_get_menu(cfg->id);
2125         } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) {
2126                 handler_set_err(hdl, -EINVAL);
2127                 return NULL;
2128         }
2129
2130         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
2131                         type, min, max,
2132                         is_menu ? cfg->menu_skip_mask : step, def,
2133                         cfg->dims, cfg->elem_size,
2134                         flags, qmenu, qmenu_int, priv);
2135         if (ctrl)
2136                 ctrl->is_private = cfg->is_private;
2137         return ctrl;
2138 }
2139 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
2140
2141 /* Helper function for standard non-menu controls */
2142 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
2143                         const struct v4l2_ctrl_ops *ops,
2144                         u32 id, s64 min, s64 max, u64 step, s64 def)
2145 {
2146         const char *name;
2147         enum v4l2_ctrl_type type;
2148         u32 flags;
2149
2150         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2151         if (type == V4L2_CTRL_TYPE_MENU ||
2152             type == V4L2_CTRL_TYPE_INTEGER_MENU ||
2153             type >= V4L2_CTRL_COMPOUND_TYPES) {
2154                 handler_set_err(hdl, -EINVAL);
2155                 return NULL;
2156         }
2157         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2158                              min, max, step, def, NULL, 0,
2159                              flags, NULL, NULL, NULL);
2160 }
2161 EXPORT_SYMBOL(v4l2_ctrl_new_std);
2162
2163 /* Helper function for standard menu controls */
2164 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
2165                         const struct v4l2_ctrl_ops *ops,
2166                         u32 id, u8 _max, u64 mask, u8 _def)
2167 {
2168         const char * const *qmenu = NULL;
2169         const s64 *qmenu_int = NULL;
2170         unsigned int qmenu_int_len = 0;
2171         const char *name;
2172         enum v4l2_ctrl_type type;
2173         s64 min;
2174         s64 max = _max;
2175         s64 def = _def;
2176         u64 step;
2177         u32 flags;
2178
2179         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2180
2181         if (type == V4L2_CTRL_TYPE_MENU)
2182                 qmenu = v4l2_ctrl_get_menu(id);
2183         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2184                 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
2185
2186         if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
2187                 handler_set_err(hdl, -EINVAL);
2188                 return NULL;
2189         }
2190         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2191                              0, max, mask, def, NULL, 0,
2192                              flags, qmenu, qmenu_int, NULL);
2193 }
2194 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
2195
2196 /* Helper function for standard menu controls with driver defined menu */
2197 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
2198                         const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
2199                         u64 mask, u8 _def, const char * const *qmenu)
2200 {
2201         enum v4l2_ctrl_type type;
2202         const char *name;
2203         u32 flags;
2204         u64 step;
2205         s64 min;
2206         s64 max = _max;
2207         s64 def = _def;
2208
2209         /* v4l2_ctrl_new_std_menu_items() should only be called for
2210          * standard controls without a standard menu.
2211          */
2212         if (v4l2_ctrl_get_menu(id)) {
2213                 handler_set_err(hdl, -EINVAL);
2214                 return NULL;
2215         }
2216
2217         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2218         if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
2219                 handler_set_err(hdl, -EINVAL);
2220                 return NULL;
2221         }
2222         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2223                              0, max, mask, def, NULL, 0,
2224                              flags, qmenu, NULL, NULL);
2225
2226 }
2227 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
2228
2229 /* Helper function for standard integer menu controls */
2230 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
2231                         const struct v4l2_ctrl_ops *ops,
2232                         u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
2233 {
2234         const char *name;
2235         enum v4l2_ctrl_type type;
2236         s64 min;
2237         u64 step;
2238         s64 max = _max;
2239         s64 def = _def;
2240         u32 flags;
2241
2242         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2243         if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
2244                 handler_set_err(hdl, -EINVAL);
2245                 return NULL;
2246         }
2247         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2248                              0, max, 0, def, NULL, 0,
2249                              flags, NULL, qmenu_int, NULL);
2250 }
2251 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
2252
2253 /* Add the controls from another handler to our own. */
2254 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
2255                           struct v4l2_ctrl_handler *add,
2256                           bool (*filter)(const struct v4l2_ctrl *ctrl))
2257 {
2258         struct v4l2_ctrl_ref *ref;
2259         int ret = 0;
2260
2261         /* Do nothing if either handler is NULL or if they are the same */
2262         if (!hdl || !add || hdl == add)
2263                 return 0;
2264         if (hdl->error)
2265                 return hdl->error;
2266         mutex_lock(add->lock);
2267         list_for_each_entry(ref, &add->ctrl_refs, node) {
2268                 struct v4l2_ctrl *ctrl = ref->ctrl;
2269
2270                 /* Skip handler-private controls. */
2271                 if (ctrl->is_private)
2272                         continue;
2273                 /* And control classes */
2274                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2275                         continue;
2276                 /* Filter any unwanted controls */
2277                 if (filter && !filter(ctrl))
2278                         continue;
2279                 ret = handler_new_ref(hdl, ctrl);
2280                 if (ret)
2281                         break;
2282         }
2283         mutex_unlock(add->lock);
2284         return ret;
2285 }
2286 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
2287
2288 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
2289 {
2290         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
2291                 return true;
2292         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
2293                 return true;
2294         switch (ctrl->id) {
2295         case V4L2_CID_AUDIO_MUTE:
2296         case V4L2_CID_AUDIO_VOLUME:
2297         case V4L2_CID_AUDIO_BALANCE:
2298         case V4L2_CID_AUDIO_BASS:
2299         case V4L2_CID_AUDIO_TREBLE:
2300         case V4L2_CID_AUDIO_LOUDNESS:
2301                 return true;
2302         default:
2303                 break;
2304         }
2305         return false;
2306 }
2307 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
2308
2309 /* Cluster controls */
2310 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
2311 {
2312         bool has_volatiles = false;
2313         int i;
2314
2315         /* The first control is the master control and it must not be NULL */
2316         if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
2317                 return;
2318
2319         for (i = 0; i < ncontrols; i++) {
2320                 if (controls[i]) {
2321                         controls[i]->cluster = controls;
2322                         controls[i]->ncontrols = ncontrols;
2323                         if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
2324                                 has_volatiles = true;
2325                 }
2326         }
2327         controls[0]->has_volatiles = has_volatiles;
2328 }
2329 EXPORT_SYMBOL(v4l2_ctrl_cluster);
2330
2331 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
2332                             u8 manual_val, bool set_volatile)
2333 {
2334         struct v4l2_ctrl *master = controls[0];
2335         u32 flag = 0;
2336         int i;
2337
2338         v4l2_ctrl_cluster(ncontrols, controls);
2339         WARN_ON(ncontrols <= 1);
2340         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
2341         WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
2342         master->is_auto = true;
2343         master->has_volatiles = set_volatile;
2344         master->manual_mode_value = manual_val;
2345         master->flags |= V4L2_CTRL_FLAG_UPDATE;
2346
2347         if (!is_cur_manual(master))
2348                 flag = V4L2_CTRL_FLAG_INACTIVE |
2349                         (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
2350
2351         for (i = 1; i < ncontrols; i++)
2352                 if (controls[i])
2353                         controls[i]->flags |= flag;
2354 }
2355 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
2356
2357 /* Activate/deactivate a control. */
2358 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
2359 {
2360         /* invert since the actual flag is called 'inactive' */
2361         bool inactive = !active;
2362         bool old;
2363
2364         if (ctrl == NULL)
2365                 return;
2366
2367         if (inactive)
2368                 /* set V4L2_CTRL_FLAG_INACTIVE */
2369                 old = test_and_set_bit(4, &ctrl->flags);
2370         else
2371                 /* clear V4L2_CTRL_FLAG_INACTIVE */
2372                 old = test_and_clear_bit(4, &ctrl->flags);
2373         if (old != inactive)
2374                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2375 }
2376 EXPORT_SYMBOL(v4l2_ctrl_activate);
2377
2378 /* Grab/ungrab a control.
2379    Typically used when streaming starts and you want to grab controls,
2380    preventing the user from changing them.
2381
2382    Just call this and the framework will block any attempts to change
2383    these controls. */
2384 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
2385 {
2386         bool old;
2387
2388         if (ctrl == NULL)
2389                 return;
2390
2391         v4l2_ctrl_lock(ctrl);
2392         if (grabbed)
2393                 /* set V4L2_CTRL_FLAG_GRABBED */
2394                 old = test_and_set_bit(1, &ctrl->flags);
2395         else
2396                 /* clear V4L2_CTRL_FLAG_GRABBED */
2397                 old = test_and_clear_bit(1, &ctrl->flags);
2398         if (old != grabbed)
2399                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2400         v4l2_ctrl_unlock(ctrl);
2401 }
2402 EXPORT_SYMBOL(v4l2_ctrl_grab);
2403
2404 /* Log the control name and value */
2405 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2406                      const char *prefix, const char *colon)
2407 {
2408         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2409                 return;
2410         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2411                 return;
2412
2413         pr_info("%s%s%s: ", prefix, colon, ctrl->name);
2414
2415         ctrl->type_ops->log(ctrl);
2416
2417         if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2418                            V4L2_CTRL_FLAG_GRABBED |
2419                            V4L2_CTRL_FLAG_VOLATILE)) {
2420                 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2421                         pr_cont(" inactive");
2422                 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2423                         pr_cont(" grabbed");
2424                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2425                         pr_cont(" volatile");
2426         }
2427         pr_cont("\n");
2428 }
2429
2430 /* Log all controls owned by the handler */
2431 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2432                                   const char *prefix)
2433 {
2434         struct v4l2_ctrl *ctrl;
2435         const char *colon = "";
2436         int len;
2437
2438         if (hdl == NULL)
2439                 return;
2440         if (prefix == NULL)
2441                 prefix = "";
2442         len = strlen(prefix);
2443         if (len && prefix[len - 1] != ' ')
2444                 colon = ": ";
2445         mutex_lock(hdl->lock);
2446         list_for_each_entry(ctrl, &hdl->ctrls, node)
2447                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2448                         log_ctrl(ctrl, prefix, colon);
2449         mutex_unlock(hdl->lock);
2450 }
2451 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2452
2453 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2454 {
2455         v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2456         return 0;
2457 }
2458 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2459
2460 /* Call s_ctrl for all controls owned by the handler */
2461 int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2462 {
2463         struct v4l2_ctrl *ctrl;
2464         int ret = 0;
2465
2466         if (hdl == NULL)
2467                 return 0;
2468
2469         lockdep_assert_held(hdl->lock);
2470
2471         list_for_each_entry(ctrl, &hdl->ctrls, node)
2472                 ctrl->done = false;
2473
2474         list_for_each_entry(ctrl, &hdl->ctrls, node) {
2475                 struct v4l2_ctrl *master = ctrl->cluster[0];
2476                 int i;
2477
2478                 /* Skip if this control was already handled by a cluster. */
2479                 /* Skip button controls and read-only controls. */
2480                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2481                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2482                         continue;
2483
2484                 for (i = 0; i < master->ncontrols; i++) {
2485                         if (master->cluster[i]) {
2486                                 cur_to_new(master->cluster[i]);
2487                                 master->cluster[i]->is_new = 1;
2488                                 master->cluster[i]->done = true;
2489                         }
2490                 }
2491                 ret = call_op(master, s_ctrl);
2492                 if (ret)
2493                         break;
2494         }
2495
2496         return ret;
2497 }
2498 EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup);
2499
2500 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2501 {
2502         int ret;
2503
2504         if (hdl == NULL)
2505                 return 0;
2506
2507         mutex_lock(hdl->lock);
2508         ret = __v4l2_ctrl_handler_setup(hdl);
2509         mutex_unlock(hdl->lock);
2510
2511         return ret;
2512 }
2513 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2514
2515 /* Implement VIDIOC_QUERY_EXT_CTRL */
2516 int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
2517 {
2518         const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
2519         u32 id = qc->id & V4L2_CTRL_ID_MASK;
2520         struct v4l2_ctrl_ref *ref;
2521         struct v4l2_ctrl *ctrl;
2522
2523         if (hdl == NULL)
2524                 return -EINVAL;
2525
2526         mutex_lock(hdl->lock);
2527
2528         /* Try to find it */
2529         ref = find_ref(hdl, id);
2530
2531         if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
2532                 bool is_compound;
2533                 /* Match any control that is not hidden */
2534                 unsigned mask = 1;
2535                 bool match = false;
2536
2537                 if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
2538                         /* Match any hidden control */
2539                         match = true;
2540                 } else if ((qc->id & next_flags) == next_flags) {
2541                         /* Match any control, compound or not */
2542                         mask = 0;
2543                 }
2544
2545                 /* Find the next control with ID > qc->id */
2546
2547                 /* Did we reach the end of the control list? */
2548                 if (id >= node2id(hdl->ctrl_refs.prev)) {
2549                         ref = NULL; /* Yes, so there is no next control */
2550                 } else if (ref) {
2551                         /* We found a control with the given ID, so just get
2552                            the next valid one in the list. */
2553                         list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
2554                                 is_compound = ref->ctrl->is_array ||
2555                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2556                                 if (id < ref->ctrl->id &&
2557                                     (is_compound & mask) == match)
2558                                         break;
2559                         }
2560                         if (&ref->node == &hdl->ctrl_refs)
2561                                 ref = NULL;
2562                 } else {
2563                         /* No control with the given ID exists, so start
2564                            searching for the next largest ID. We know there
2565                            is one, otherwise the first 'if' above would have
2566                            been true. */
2567                         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2568                                 is_compound = ref->ctrl->is_array ||
2569                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2570                                 if (id < ref->ctrl->id &&
2571                                     (is_compound & mask) == match)
2572                                         break;
2573                         }
2574                         if (&ref->node == &hdl->ctrl_refs)
2575                                 ref = NULL;
2576                 }
2577         }
2578         mutex_unlock(hdl->lock);
2579
2580         if (!ref)
2581                 return -EINVAL;
2582
2583         ctrl = ref->ctrl;
2584         memset(qc, 0, sizeof(*qc));
2585         if (id >= V4L2_CID_PRIVATE_BASE)
2586                 qc->id = id;
2587         else
2588                 qc->id = ctrl->id;
2589         strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2590         qc->flags = user_flags(ctrl);
2591         qc->type = ctrl->type;
2592         qc->elem_size = ctrl->elem_size;
2593         qc->elems = ctrl->elems;
2594         qc->nr_of_dims = ctrl->nr_of_dims;
2595         memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
2596         qc->minimum = ctrl->minimum;
2597         qc->maximum = ctrl->maximum;
2598         qc->default_value = ctrl->default_value;
2599         if (ctrl->type == V4L2_CTRL_TYPE_MENU
2600             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2601                 qc->step = 1;
2602         else
2603                 qc->step = ctrl->step;
2604         return 0;
2605 }
2606 EXPORT_SYMBOL(v4l2_query_ext_ctrl);
2607
2608 /* Implement VIDIOC_QUERYCTRL */
2609 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2610 {
2611         struct v4l2_query_ext_ctrl qec = { qc->id };
2612         int rc;
2613
2614         rc = v4l2_query_ext_ctrl(hdl, &qec);
2615         if (rc)
2616                 return rc;
2617
2618         qc->id = qec.id;
2619         qc->type = qec.type;
2620         qc->flags = qec.flags;
2621         strlcpy(qc->name, qec.name, sizeof(qc->name));
2622         switch (qc->type) {
2623         case V4L2_CTRL_TYPE_INTEGER:
2624         case V4L2_CTRL_TYPE_BOOLEAN:
2625         case V4L2_CTRL_TYPE_MENU:
2626         case V4L2_CTRL_TYPE_INTEGER_MENU:
2627         case V4L2_CTRL_TYPE_STRING:
2628         case V4L2_CTRL_TYPE_BITMASK:
2629                 qc->minimum = qec.minimum;
2630                 qc->maximum = qec.maximum;
2631                 qc->step = qec.step;
2632                 qc->default_value = qec.default_value;
2633                 break;
2634         default:
2635                 qc->minimum = 0;
2636                 qc->maximum = 0;
2637                 qc->step = 0;
2638                 qc->default_value = 0;
2639                 break;
2640         }
2641         return 0;
2642 }
2643 EXPORT_SYMBOL(v4l2_queryctrl);
2644
2645 /* Implement VIDIOC_QUERYMENU */
2646 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2647 {
2648         struct v4l2_ctrl *ctrl;
2649         u32 i = qm->index;
2650
2651         ctrl = v4l2_ctrl_find(hdl, qm->id);
2652         if (!ctrl)
2653                 return -EINVAL;
2654
2655         qm->reserved = 0;
2656         /* Sanity checks */
2657         switch (ctrl->type) {
2658         case V4L2_CTRL_TYPE_MENU:
2659                 if (ctrl->qmenu == NULL)
2660                         return -EINVAL;
2661                 break;
2662         case V4L2_CTRL_TYPE_INTEGER_MENU:
2663                 if (ctrl->qmenu_int == NULL)
2664                         return -EINVAL;
2665                 break;
2666         default:
2667                 return -EINVAL;
2668         }
2669
2670         if (i < ctrl->minimum || i > ctrl->maximum)
2671                 return -EINVAL;
2672
2673         /* Use mask to see if this menu item should be skipped */
2674         if (ctrl->menu_skip_mask & (1 << i))
2675                 return -EINVAL;
2676         /* Empty menu items should also be skipped */
2677         if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2678                 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2679                         return -EINVAL;
2680                 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2681         } else {
2682                 qm->value = ctrl->qmenu_int[i];
2683         }
2684         return 0;
2685 }
2686 EXPORT_SYMBOL(v4l2_querymenu);
2687
2688
2689 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2690
2691    It is not a fully atomic operation, just best-effort only. After all, if
2692    multiple controls have to be set through multiple i2c writes (for example)
2693    then some initial writes may succeed while others fail. Thus leaving the
2694    system in an inconsistent state. The question is how much effort you are
2695    willing to spend on trying to make something atomic that really isn't.
2696
2697    From the point of view of an application the main requirement is that
2698    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2699    error should be returned without actually affecting any controls.
2700
2701    If all the values are correct, then it is acceptable to just give up
2702    in case of low-level errors.
2703
2704    It is important though that the application can tell when only a partial
2705    configuration was done. The way we do that is through the error_idx field
2706    of struct v4l2_ext_controls: if that is equal to the count field then no
2707    controls were affected. Otherwise all controls before that index were
2708    successful in performing their 'get' or 'set' operation, the control at
2709    the given index failed, and you don't know what happened with the controls
2710    after the failed one. Since if they were part of a control cluster they
2711    could have been successfully processed (if a cluster member was encountered
2712    at index < error_idx), they could have failed (if a cluster member was at
2713    error_idx), or they may not have been processed yet (if the first cluster
2714    member appeared after error_idx).
2715
2716    It is all fairly theoretical, though. In practice all you can do is to
2717    bail out. If error_idx == count, then it is an application bug. If
2718    error_idx < count then it is only an application bug if the error code was
2719    EBUSY. That usually means that something started streaming just when you
2720    tried to set the controls. In all other cases it is a driver/hardware
2721    problem and all you can do is to retry or bail out.
2722
2723    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2724    never modifies controls the error_idx is just set to whatever control
2725    has an invalid value.
2726  */
2727
2728 /* Prepare for the extended g/s/try functions.
2729    Find the controls in the control array and do some basic checks. */
2730 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2731                              struct v4l2_ext_controls *cs,
2732                              struct v4l2_ctrl_helper *helpers,
2733                              bool get)
2734 {
2735         struct v4l2_ctrl_helper *h;
2736         bool have_clusters = false;
2737         u32 i;
2738
2739         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2740                 struct v4l2_ext_control *c = &cs->controls[i];
2741                 struct v4l2_ctrl_ref *ref;
2742                 struct v4l2_ctrl *ctrl;
2743                 u32 id = c->id & V4L2_CTRL_ID_MASK;
2744
2745                 cs->error_idx = i;
2746
2747                 if (cs->which &&
2748                     cs->which != V4L2_CTRL_WHICH_DEF_VAL &&
2749                     V4L2_CTRL_ID2WHICH(id) != cs->which)
2750                         return -EINVAL;
2751
2752                 /* Old-style private controls are not allowed for
2753                    extended controls */
2754                 if (id >= V4L2_CID_PRIVATE_BASE)
2755                         return -EINVAL;
2756                 ref = find_ref_lock(hdl, id);
2757                 if (ref == NULL)
2758                         return -EINVAL;
2759                 ctrl = ref->ctrl;
2760                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2761                         return -EINVAL;
2762
2763                 if (ctrl->cluster[0]->ncontrols > 1)
2764                         have_clusters = true;
2765                 if (ctrl->cluster[0] != ctrl)
2766                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2767                 if (ctrl->is_ptr && !ctrl->is_string) {
2768                         unsigned tot_size = ctrl->elems * ctrl->elem_size;
2769
2770                         if (c->size < tot_size) {
2771                                 if (get) {
2772                                         c->size = tot_size;
2773                                         return -ENOSPC;
2774                                 }
2775                                 return -EFAULT;
2776                         }
2777                         c->size = tot_size;
2778                 }
2779                 /* Store the ref to the master control of the cluster */
2780                 h->mref = ref;
2781                 h->ctrl = ctrl;
2782                 /* Initially set next to 0, meaning that there is no other
2783                    control in this helper array belonging to the same
2784                    cluster */
2785                 h->next = 0;
2786         }
2787
2788         /* We are done if there were no controls that belong to a multi-
2789            control cluster. */
2790         if (!have_clusters)
2791                 return 0;
2792
2793         /* The code below figures out in O(n) time which controls in the list
2794            belong to the same cluster. */
2795
2796         /* This has to be done with the handler lock taken. */
2797         mutex_lock(hdl->lock);
2798
2799         /* First zero the helper field in the master control references */
2800         for (i = 0; i < cs->count; i++)
2801                 helpers[i].mref->helper = NULL;
2802         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2803                 struct v4l2_ctrl_ref *mref = h->mref;
2804
2805                 /* If the mref->helper is set, then it points to an earlier
2806                    helper that belongs to the same cluster. */
2807                 if (mref->helper) {
2808                         /* Set the next field of mref->helper to the current
2809                            index: this means that that earlier helper now
2810                            points to the next helper in the same cluster. */
2811                         mref->helper->next = i;
2812                         /* mref should be set only for the first helper in the
2813                            cluster, clear the others. */
2814                         h->mref = NULL;
2815                 }
2816                 /* Point the mref helper to the current helper struct. */
2817                 mref->helper = h;
2818         }
2819         mutex_unlock(hdl->lock);
2820         return 0;
2821 }
2822
2823 /* Handles the corner case where cs->count == 0. It checks whether the
2824    specified control class exists. If that class ID is 0, then it checks
2825    whether there are any controls at all. */
2826 static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
2827 {
2828         if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL)
2829                 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2830         return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
2831 }
2832
2833
2834
2835 /* Get extended controls. Allocates the helpers array if needed. */
2836 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2837 {
2838         struct v4l2_ctrl_helper helper[4];
2839         struct v4l2_ctrl_helper *helpers = helper;
2840         int ret;
2841         int i, j;
2842         bool def_value;
2843
2844         def_value = (cs->which == V4L2_CTRL_WHICH_DEF_VAL);
2845
2846         cs->error_idx = cs->count;
2847         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
2848
2849         if (hdl == NULL)
2850                 return -EINVAL;
2851
2852         if (cs->count == 0)
2853                 return class_check(hdl, cs->which);
2854
2855         if (cs->count > ARRAY_SIZE(helper)) {
2856                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
2857                                          GFP_KERNEL);
2858                 if (helpers == NULL)
2859                         return -ENOMEM;
2860         }
2861
2862         ret = prepare_ext_ctrls(hdl, cs, helpers, true);
2863         cs->error_idx = cs->count;
2864
2865         for (i = 0; !ret && i < cs->count; i++)
2866                 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2867                         ret = -EACCES;
2868
2869         for (i = 0; !ret && i < cs->count; i++) {
2870                 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2871                                     struct v4l2_ctrl *ctrl);
2872                 struct v4l2_ctrl *master;
2873
2874                 ctrl_to_user = def_value ? def_to_user : cur_to_user;
2875
2876                 if (helpers[i].mref == NULL)
2877                         continue;
2878
2879                 master = helpers[i].mref->ctrl;
2880                 cs->error_idx = i;
2881
2882                 v4l2_ctrl_lock(master);
2883
2884                 /* g_volatile_ctrl will update the new control values */
2885                 if (!def_value &&
2886                     ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2887                     (master->has_volatiles && !is_cur_manual(master)))) {
2888                         for (j = 0; j < master->ncontrols; j++)
2889                                 cur_to_new(master->cluster[j]);
2890                         ret = call_op(master, g_volatile_ctrl);
2891                         ctrl_to_user = new_to_user;
2892                 }
2893                 /* If OK, then copy the current (for non-volatile controls)
2894                    or the new (for volatile controls) control values to the
2895                    caller */
2896                 if (!ret) {
2897                         u32 idx = i;
2898
2899                         do {
2900                                 ret = ctrl_to_user(cs->controls + idx,
2901                                                    helpers[idx].ctrl);
2902                                 idx = helpers[idx].next;
2903                         } while (!ret && idx);
2904                 }
2905                 v4l2_ctrl_unlock(master);
2906         }
2907
2908         if (cs->count > ARRAY_SIZE(helper))
2909                 kvfree(helpers);
2910         return ret;
2911 }
2912 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2913
2914 /* Helper function to get a single control */
2915 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
2916 {
2917         struct v4l2_ctrl *master = ctrl->cluster[0];
2918         int ret = 0;
2919         int i;
2920
2921         /* Compound controls are not supported. The new_to_user() and
2922          * cur_to_user() calls below would need to be modified not to access
2923          * userspace memory when called from get_ctrl().
2924          */
2925         if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64)
2926                 return -EINVAL;
2927
2928         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2929                 return -EACCES;
2930
2931         v4l2_ctrl_lock(master);
2932         /* g_volatile_ctrl will update the current control values */
2933         if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2934                 for (i = 0; i < master->ncontrols; i++)
2935                         cur_to_new(master->cluster[i]);
2936                 ret = call_op(master, g_volatile_ctrl);
2937                 new_to_user(c, ctrl);
2938         } else {
2939                 cur_to_user(c, ctrl);
2940         }
2941         v4l2_ctrl_unlock(master);
2942         return ret;
2943 }
2944
2945 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2946 {
2947         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2948         struct v4l2_ext_control c;
2949         int ret;
2950
2951         if (ctrl == NULL || !ctrl->is_int)
2952                 return -EINVAL;
2953         ret = get_ctrl(ctrl, &c);
2954         control->value = c.value;
2955         return ret;
2956 }
2957 EXPORT_SYMBOL(v4l2_g_ctrl);
2958
2959 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2960 {
2961         struct v4l2_ext_control c;
2962
2963         /* It's a driver bug if this happens. */
2964         WARN_ON(!ctrl->is_int);
2965         c.value = 0;
2966         get_ctrl(ctrl, &c);
2967         return c.value;
2968 }
2969 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2970
2971 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
2972 {
2973         struct v4l2_ext_control c;
2974
2975         /* It's a driver bug if this happens. */
2976         WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2977         c.value64 = 0;
2978         get_ctrl(ctrl, &c);
2979         return c.value64;
2980 }
2981 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
2982
2983
2984 /* Core function that calls try/s_ctrl and ensures that the new value is
2985    copied to the current value on a set.
2986    Must be called with ctrl->handler->lock held. */
2987 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
2988                               bool set, u32 ch_flags)
2989 {
2990         bool update_flag;
2991         int ret;
2992         int i;
2993
2994         /* Go through the cluster and either validate the new value or
2995            (if no new value was set), copy the current value to the new
2996            value, ensuring a consistent view for the control ops when
2997            called. */
2998         for (i = 0; i < master->ncontrols; i++) {
2999                 struct v4l2_ctrl *ctrl = master->cluster[i];
3000
3001                 if (ctrl == NULL)
3002                         continue;
3003
3004                 if (!ctrl->is_new) {
3005                         cur_to_new(ctrl);
3006                         continue;
3007                 }
3008                 /* Check again: it may have changed since the
3009                    previous check in try_or_set_ext_ctrls(). */
3010                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3011                         return -EBUSY;
3012         }
3013
3014         ret = call_op(master, try_ctrl);
3015
3016         /* Don't set if there is no change */
3017         if (ret || !set || !cluster_changed(master))
3018                 return ret;
3019         ret = call_op(master, s_ctrl);
3020         if (ret)
3021                 return ret;
3022
3023         /* If OK, then make the new values permanent. */
3024         update_flag = is_cur_manual(master) != is_new_manual(master);
3025         for (i = 0; i < master->ncontrols; i++)
3026                 new_to_cur(fh, master->cluster[i], ch_flags |
3027                         ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
3028         return 0;
3029 }
3030
3031 /* Validate controls. */
3032 static int validate_ctrls(struct v4l2_ext_controls *cs,
3033                           struct v4l2_ctrl_helper *helpers, bool set)
3034 {
3035         unsigned i;
3036         int ret = 0;
3037
3038         cs->error_idx = cs->count;
3039         for (i = 0; i < cs->count; i++) {
3040                 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
3041                 union v4l2_ctrl_ptr p_new;
3042
3043                 cs->error_idx = i;
3044
3045                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3046                         return -EACCES;
3047                 /* This test is also done in try_set_control_cluster() which
3048                    is called in atomic context, so that has the final say,
3049                    but it makes sense to do an up-front check as well. Once
3050                    an error occurs in try_set_control_cluster() some other
3051                    controls may have been set already and we want to do a
3052                    best-effort to avoid that. */
3053                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3054                         return -EBUSY;
3055                 /*
3056                  * Skip validation for now if the payload needs to be copied
3057                  * from userspace into kernelspace. We'll validate those later.
3058                  */
3059                 if (ctrl->is_ptr)
3060                         continue;
3061                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3062                         p_new.p_s64 = &cs->controls[i].value64;
3063                 else
3064                         p_new.p_s32 = &cs->controls[i].value;
3065                 ret = validate_new(ctrl, p_new);
3066                 if (ret)
3067                         return ret;
3068         }
3069         return 0;
3070 }
3071
3072 /* Obtain the current volatile values of an autocluster and mark them
3073    as new. */
3074 static void update_from_auto_cluster(struct v4l2_ctrl *master)
3075 {
3076         int i;
3077
3078         for (i = 1; i < master->ncontrols; i++)
3079                 cur_to_new(master->cluster[i]);
3080         if (!call_op(master, g_volatile_ctrl))
3081                 for (i = 1; i < master->ncontrols; i++)
3082                         if (master->cluster[i])
3083                                 master->cluster[i]->is_new = 1;
3084 }
3085
3086 /* Try or try-and-set controls */
3087 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3088                              struct v4l2_ext_controls *cs,
3089                              bool set)
3090 {
3091         struct v4l2_ctrl_helper helper[4];
3092         struct v4l2_ctrl_helper *helpers = helper;
3093         unsigned i, j;
3094         int ret;
3095
3096         cs->error_idx = cs->count;
3097
3098         /* Default value cannot be changed */
3099         if (cs->which == V4L2_CTRL_WHICH_DEF_VAL)
3100                 return -EINVAL;
3101
3102         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
3103
3104         if (hdl == NULL)
3105                 return -EINVAL;
3106
3107         if (cs->count == 0)
3108                 return class_check(hdl, cs->which);
3109
3110         if (cs->count > ARRAY_SIZE(helper)) {
3111                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
3112                                          GFP_KERNEL);
3113                 if (!helpers)
3114                         return -ENOMEM;
3115         }
3116         ret = prepare_ext_ctrls(hdl, cs, helpers, false);
3117         if (!ret)
3118                 ret = validate_ctrls(cs, helpers, set);
3119         if (ret && set)
3120                 cs->error_idx = cs->count;
3121         for (i = 0; !ret && i < cs->count; i++) {
3122                 struct v4l2_ctrl *master;
3123                 u32 idx = i;
3124
3125                 if (helpers[i].mref == NULL)
3126                         continue;
3127
3128                 cs->error_idx = i;
3129                 master = helpers[i].mref->ctrl;
3130                 v4l2_ctrl_lock(master);
3131
3132                 /* Reset the 'is_new' flags of the cluster */
3133                 for (j = 0; j < master->ncontrols; j++)
3134                         if (master->cluster[j])
3135                                 master->cluster[j]->is_new = 0;
3136
3137                 /* For volatile autoclusters that are currently in auto mode
3138                    we need to discover if it will be set to manual mode.
3139                    If so, then we have to copy the current volatile values
3140                    first since those will become the new manual values (which
3141                    may be overwritten by explicit new values from this set
3142                    of controls). */
3143                 if (master->is_auto && master->has_volatiles &&
3144                                                 !is_cur_manual(master)) {
3145                         /* Pick an initial non-manual value */
3146                         s32 new_auto_val = master->manual_mode_value + 1;
3147                         u32 tmp_idx = idx;
3148
3149                         do {
3150                                 /* Check if the auto control is part of the
3151                                    list, and remember the new value. */
3152                                 if (helpers[tmp_idx].ctrl == master)
3153                                         new_auto_val = cs->controls[tmp_idx].value;
3154                                 tmp_idx = helpers[tmp_idx].next;
3155                         } while (tmp_idx);
3156                         /* If the new value == the manual value, then copy
3157                            the current volatile values. */
3158                         if (new_auto_val == master->manual_mode_value)
3159                                 update_from_auto_cluster(master);
3160                 }
3161
3162                 /* Copy the new caller-supplied control values.
3163                    user_to_new() sets 'is_new' to 1. */
3164                 do {
3165                         struct v4l2_ctrl *ctrl = helpers[idx].ctrl;
3166
3167                         ret = user_to_new(cs->controls + idx, ctrl);
3168                         if (!ret && ctrl->is_ptr)
3169                                 ret = validate_new(ctrl, ctrl->p_new);
3170                         idx = helpers[idx].next;
3171                 } while (!ret && idx);
3172
3173                 if (!ret)
3174                         ret = try_or_set_cluster(fh, master, set, 0);
3175
3176                 /* Copy the new values back to userspace. */
3177                 if (!ret) {
3178                         idx = i;
3179                         do {
3180                                 ret = new_to_user(cs->controls + idx,
3181                                                 helpers[idx].ctrl);
3182                                 idx = helpers[idx].next;
3183                         } while (!ret && idx);
3184                 }
3185                 v4l2_ctrl_unlock(master);
3186         }
3187
3188         if (cs->count > ARRAY_SIZE(helper))
3189                 kvfree(helpers);
3190         return ret;
3191 }
3192
3193 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
3194 {
3195         return try_set_ext_ctrls(NULL, hdl, cs, false);
3196 }
3197 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
3198
3199 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3200                                         struct v4l2_ext_controls *cs)
3201 {
3202         return try_set_ext_ctrls(fh, hdl, cs, true);
3203 }
3204 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
3205
3206 /* Helper function for VIDIOC_S_CTRL compatibility */
3207 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
3208 {
3209         struct v4l2_ctrl *master = ctrl->cluster[0];
3210         int ret;
3211         int i;
3212
3213         /* Reset the 'is_new' flags of the cluster */
3214         for (i = 0; i < master->ncontrols; i++)
3215                 if (master->cluster[i])
3216                         master->cluster[i]->is_new = 0;
3217
3218         ret = validate_new(ctrl, ctrl->p_new);
3219         if (ret)
3220                 return ret;
3221
3222         /* For autoclusters with volatiles that are switched from auto to
3223            manual mode we have to update the current volatile values since
3224            those will become the initial manual values after such a switch. */
3225         if (master->is_auto && master->has_volatiles && ctrl == master &&
3226             !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
3227                 update_from_auto_cluster(master);
3228
3229         ctrl->is_new = 1;
3230         return try_or_set_cluster(fh, master, true, ch_flags);
3231 }
3232
3233 /* Helper function for VIDIOC_S_CTRL compatibility */
3234 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
3235                          struct v4l2_ext_control *c)
3236 {
3237         int ret;
3238
3239         v4l2_ctrl_lock(ctrl);
3240         user_to_new(c, ctrl);
3241         ret = set_ctrl(fh, ctrl, 0);
3242         if (!ret)
3243                 cur_to_user(c, ctrl);
3244         v4l2_ctrl_unlock(ctrl);
3245         return ret;
3246 }
3247
3248 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3249                                         struct v4l2_control *control)
3250 {
3251         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3252         struct v4l2_ext_control c = { control->id };
3253         int ret;
3254
3255         if (ctrl == NULL || !ctrl->is_int)
3256                 return -EINVAL;
3257
3258         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3259                 return -EACCES;
3260
3261         c.value = control->value;
3262         ret = set_ctrl_lock(fh, ctrl, &c);
3263         control->value = c.value;
3264         return ret;
3265 }
3266 EXPORT_SYMBOL(v4l2_s_ctrl);
3267
3268 int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
3269 {
3270         lockdep_assert_held(ctrl->handler->lock);
3271
3272         /* It's a driver bug if this happens. */
3273         WARN_ON(!ctrl->is_int);
3274         ctrl->val = val;
3275         return set_ctrl(NULL, ctrl, 0);
3276 }
3277 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
3278
3279 int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
3280 {
3281         lockdep_assert_held(ctrl->handler->lock);
3282
3283         /* It's a driver bug if this happens. */
3284         WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
3285         *ctrl->p_new.p_s64 = val;
3286         return set_ctrl(NULL, ctrl, 0);
3287 }
3288 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
3289
3290 int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
3291 {
3292         lockdep_assert_held(ctrl->handler->lock);
3293
3294         /* It's a driver bug if this happens. */
3295         WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING);
3296         strlcpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
3297         return set_ctrl(NULL, ctrl, 0);
3298 }
3299 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
3300
3301 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
3302 {
3303         if (ctrl == NULL)
3304                 return;
3305         if (notify == NULL) {
3306                 ctrl->call_notify = 0;
3307                 return;
3308         }
3309         if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
3310                 return;
3311         ctrl->handler->notify = notify;
3312         ctrl->handler->notify_priv = priv;
3313         ctrl->call_notify = 1;
3314 }
3315 EXPORT_SYMBOL(v4l2_ctrl_notify);
3316
3317 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
3318                         s64 min, s64 max, u64 step, s64 def)
3319 {
3320         bool value_changed;
3321         bool range_changed = false;
3322         int ret;
3323
3324         lockdep_assert_held(ctrl->handler->lock);
3325
3326         switch (ctrl->type) {
3327         case V4L2_CTRL_TYPE_INTEGER:
3328         case V4L2_CTRL_TYPE_INTEGER64:
3329         case V4L2_CTRL_TYPE_BOOLEAN:
3330         case V4L2_CTRL_TYPE_MENU:
3331         case V4L2_CTRL_TYPE_INTEGER_MENU:
3332         case V4L2_CTRL_TYPE_BITMASK:
3333         case V4L2_CTRL_TYPE_U8:
3334         case V4L2_CTRL_TYPE_U16:
3335         case V4L2_CTRL_TYPE_U32:
3336                 if (ctrl->is_array)
3337                         return -EINVAL;
3338                 ret = check_range(ctrl->type, min, max, step, def);
3339                 if (ret)
3340                         return ret;
3341                 break;
3342         default:
3343                 return -EINVAL;
3344         }
3345         if ((ctrl->minimum != min) || (ctrl->maximum != max) ||
3346                 (ctrl->step != step) || ctrl->default_value != def) {
3347                 range_changed = true;
3348                 ctrl->minimum = min;
3349                 ctrl->maximum = max;
3350                 ctrl->step = step;
3351                 ctrl->default_value = def;
3352         }
3353         cur_to_new(ctrl);
3354         if (validate_new(ctrl, ctrl->p_new)) {
3355                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3356                         *ctrl->p_new.p_s64 = def;
3357                 else
3358                         *ctrl->p_new.p_s32 = def;
3359         }
3360
3361         if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3362                 value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
3363         else
3364                 value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
3365         if (value_changed)
3366                 ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
3367         else if (range_changed)
3368                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
3369         return ret;
3370 }
3371 EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
3372
3373 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
3374 {
3375         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3376
3377         if (ctrl == NULL)
3378                 return -EINVAL;
3379
3380         v4l2_ctrl_lock(ctrl);
3381         list_add_tail(&sev->node, &ctrl->ev_subs);
3382         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
3383             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
3384                 struct v4l2_event ev;
3385                 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
3386
3387                 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
3388                         changes |= V4L2_EVENT_CTRL_CH_VALUE;
3389                 fill_event(&ev, ctrl, changes);
3390                 /* Mark the queue as active, allowing this initial
3391                    event to be accepted. */
3392                 sev->elems = elems;
3393                 v4l2_event_queue_fh(sev->fh, &ev);
3394         }
3395         v4l2_ctrl_unlock(ctrl);
3396         return 0;
3397 }
3398
3399 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
3400 {
3401         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3402
3403         if (ctrl == NULL)
3404                 return;
3405
3406         v4l2_ctrl_lock(ctrl);
3407         list_del(&sev->node);
3408         v4l2_ctrl_unlock(ctrl);
3409 }
3410
3411 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
3412 {
3413         u32 old_changes = old->u.ctrl.changes;
3414
3415         old->u.ctrl = new->u.ctrl;
3416         old->u.ctrl.changes |= old_changes;
3417 }
3418 EXPORT_SYMBOL(v4l2_ctrl_replace);
3419
3420 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
3421 {
3422         new->u.ctrl.changes |= old->u.ctrl.changes;
3423 }
3424 EXPORT_SYMBOL(v4l2_ctrl_merge);
3425
3426 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
3427         .add = v4l2_ctrl_add_event,
3428         .del = v4l2_ctrl_del_event,
3429         .replace = v4l2_ctrl_replace,
3430         .merge = v4l2_ctrl_merge,
3431 };
3432 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
3433
3434 int v4l2_ctrl_log_status(struct file *file, void *fh)
3435 {
3436         struct video_device *vfd = video_devdata(file);
3437         struct v4l2_fh *vfh = file->private_data;
3438
3439         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
3440                 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
3441                         vfd->v4l2_dev->name);
3442         return 0;
3443 }
3444 EXPORT_SYMBOL(v4l2_ctrl_log_status);
3445
3446 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
3447                                 const struct v4l2_event_subscription *sub)
3448 {
3449         if (sub->type == V4L2_EVENT_CTRL)
3450                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
3451         return -EINVAL;
3452 }
3453 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
3454
3455 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
3456                                      struct v4l2_event_subscription *sub)
3457 {
3458         if (!sd->ctrl_handler)
3459                 return -EINVAL;
3460         return v4l2_ctrl_subscribe_event(fh, sub);
3461 }
3462 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
3463
3464 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
3465 {
3466         struct v4l2_fh *fh = file->private_data;
3467
3468         if (v4l2_event_pending(fh))
3469                 return POLLPRI;
3470         poll_wait(file, &fh->wait, wait);
3471         return 0;
3472 }
3473 EXPORT_SYMBOL(v4l2_ctrl_poll);