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