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