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