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         default:
 873                 return NULL;
 874         }
 875 }
 876 EXPORT_SYMBOL(v4l2_ctrl_get_name);
 877
 878 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
 879                     s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags)
 880 {
 881         *name = v4l2_ctrl_get_name(id);
 882         *flags = 0;
 883
 884         switch (id) {
 885         case V4L2_CID_AUDIO_MUTE:
 886         case V4L2_CID_AUDIO_LOUDNESS:
 887         case V4L2_CID_AUTO_WHITE_BALANCE:
 888         case V4L2_CID_AUTOGAIN:
 889         case V4L2_CID_HFLIP:
 890         case V4L2_CID_VFLIP:
 891         case V4L2_CID_HUE_AUTO:
 892         case V4L2_CID_CHROMA_AGC:
 893         case V4L2_CID_COLOR_KILLER:
 894         case V4L2_CID_AUTOBRIGHTNESS:
 895         case V4L2_CID_MPEG_AUDIO_MUTE:
 896         case V4L2_CID_MPEG_VIDEO_MUTE:
 897         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
 898         case V4L2_CID_MPEG_VIDEO_PULLDOWN:
 899         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
 900         case V4L2_CID_FOCUS_AUTO:
 901         case V4L2_CID_PRIVACY:
 902         case V4L2_CID_AUDIO_LIMITER_ENABLED:
 903         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
 904         case V4L2_CID_PILOT_TONE_ENABLED:
 905         case V4L2_CID_ILLUMINATORS_1:
 906         case V4L2_CID_ILLUMINATORS_2:
 907         case V4L2_CID_FLASH_STROBE_STATUS:
 908         case V4L2_CID_FLASH_CHARGE:
 909         case V4L2_CID_FLASH_READY:
 910         case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
 911         case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
 912         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
 913         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
 914         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
 915         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
 916         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
 917         case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
 918         case V4L2_CID_WIDE_DYNAMIC_RANGE:
 919         case V4L2_CID_IMAGE_STABILIZATION:
 920         case V4L2_CID_RDS_RECEPTION:
 921         case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
 922         case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
 923         case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:
 924         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
 925                 *type = V4L2_CTRL_TYPE_BOOLEAN;
 926                 *min = 0;
 927                 *max = *step = 1;
 928                 break;
 929         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
 930         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
 931                 *type = V4L2_CTRL_TYPE_INTEGER;
 932                 break;
 933         case V4L2_CID_PAN_RESET:
 934         case V4L2_CID_TILT_RESET:
 935         case V4L2_CID_FLASH_STROBE:
 936         case V4L2_CID_FLASH_STROBE_STOP:
 937         case V4L2_CID_AUTO_FOCUS_START:
 938         case V4L2_CID_AUTO_FOCUS_STOP:
 939                 *type = V4L2_CTRL_TYPE_BUTTON;
 940                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
 941                 *min = *max = *step = *def = 0;
 942                 break;
 943         case V4L2_CID_POWER_LINE_FREQUENCY:
 944         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 945         case V4L2_CID_MPEG_AUDIO_ENCODING:
 946         case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
 947         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 948         case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
 949         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 950         case V4L2_CID_MPEG_AUDIO_MODE:
 951         case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
 952         case V4L2_CID_MPEG_AUDIO_EMPHASIS:
 953         case V4L2_CID_MPEG_AUDIO_CRC:
 954         case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
 955         case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
 956         case V4L2_CID_MPEG_VIDEO_ENCODING:
 957         case V4L2_CID_MPEG_VIDEO_ASPECT:
 958         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 959         case V4L2_CID_MPEG_STREAM_TYPE:
 960         case V4L2_CID_MPEG_STREAM_VBI_FMT:
 961         case V4L2_CID_EXPOSURE_AUTO:
 962         case V4L2_CID_AUTO_FOCUS_RANGE:
 963         case V4L2_CID_COLORFX:
 964         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
 965         case V4L2_CID_TUNE_PREEMPHASIS:
 966         case V4L2_CID_FLASH_LED_MODE:
 967         case V4L2_CID_FLASH_STROBE_SOURCE:
 968         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
 969         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
 970         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
 971         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
 972         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
 973         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
 974         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
 975         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
 976         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
 977         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
 978         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
 979         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
 980         case V4L2_CID_ISO_SENSITIVITY_AUTO:
 981         case V4L2_CID_EXPOSURE_METERING:
 982         case V4L2_CID_SCENE_MODE:
 983         case V4L2_CID_DV_TX_MODE:
 984         case V4L2_CID_DV_TX_RGB_RANGE:
 985         case V4L2_CID_DV_RX_RGB_RANGE:
 986         case V4L2_CID_TEST_PATTERN:
 987         case V4L2_CID_TUNE_DEEMPHASIS:
 988         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
 989                 *type = V4L2_CTRL_TYPE_MENU;
 990                 break;
 991         case V4L2_CID_LINK_FREQ:
 992                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
 993                 break;
 994         case V4L2_CID_RDS_TX_PS_NAME:
 995         case V4L2_CID_RDS_TX_RADIO_TEXT:
 996                 *type = V4L2_CTRL_TYPE_STRING;
 997                 break;
 998         case V4L2_CID_ISO_SENSITIVITY:
 999         case V4L2_CID_AUTO_EXPOSURE_BIAS:
1000         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1001         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1002                 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1003                 break;
1004         case V4L2_CID_USER_CLASS:
1005         case V4L2_CID_CAMERA_CLASS:
1006         case V4L2_CID_MPEG_CLASS:
1007         case V4L2_CID_FM_TX_CLASS:
1008         case V4L2_CID_FLASH_CLASS:
1009         case V4L2_CID_JPEG_CLASS:
1010         case V4L2_CID_IMAGE_SOURCE_CLASS:
1011         case V4L2_CID_IMAGE_PROC_CLASS:
1012         case V4L2_CID_DV_CLASS:
1013         case V4L2_CID_FM_RX_CLASS:
1014         case V4L2_CID_RF_TUNER_CLASS:
1015                 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
1016                 /* You can neither read not write these */
1017                 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1018                 *min = *max = *step = *def = 0;
1019                 break;
1020         case V4L2_CID_BG_COLOR:
1021                 *type = V4L2_CTRL_TYPE_INTEGER;
1022                 *step = 1;
1023                 *min = 0;
1024                 /* Max is calculated as RGB888 that is 2^24 */
1025                 *max = 0xFFFFFF;
1026                 break;
1027         case V4L2_CID_FLASH_FAULT:
1028         case V4L2_CID_JPEG_ACTIVE_MARKER:
1029         case V4L2_CID_3A_LOCK:
1030         case V4L2_CID_AUTO_FOCUS_STATUS:
1031         case V4L2_CID_DV_TX_HOTPLUG:
1032         case V4L2_CID_DV_TX_RXSENSE:
1033         case V4L2_CID_DV_TX_EDID_PRESENT:
1034         case V4L2_CID_DV_RX_POWER_PRESENT:
1035                 *type = V4L2_CTRL_TYPE_BITMASK;
1036                 break;
1037         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1038         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1039                 *type = V4L2_CTRL_TYPE_INTEGER;
1040                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1041                 break;
1042         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1043         case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1044                 *flags |= V4L2_CTRL_FLAG_VOLATILE;
1045                 /* Fall through */
1046         case V4L2_CID_PIXEL_RATE:
1047                 *type = V4L2_CTRL_TYPE_INTEGER64;
1048                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1049                 *min = *max = *step = *def = 0;
1050                 break;
1051         default:
1052                 *type = V4L2_CTRL_TYPE_INTEGER;
1053                 break;
1054         }
1055         switch (id) {
1056         case V4L2_CID_MPEG_AUDIO_ENCODING:
1057         case V4L2_CID_MPEG_AUDIO_MODE:
1058         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1059         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1060         case V4L2_CID_MPEG_STREAM_TYPE:
1061                 *flags |= V4L2_CTRL_FLAG_UPDATE;
1062                 break;
1063         case V4L2_CID_AUDIO_VOLUME:
1064         case V4L2_CID_AUDIO_BALANCE:
1065         case V4L2_CID_AUDIO_BASS:
1066         case V4L2_CID_AUDIO_TREBLE:
1067         case V4L2_CID_BRIGHTNESS:
1068         case V4L2_CID_CONTRAST:
1069         case V4L2_CID_SATURATION:
1070         case V4L2_CID_HUE:
1071         case V4L2_CID_RED_BALANCE:
1072         case V4L2_CID_BLUE_BALANCE:
1073         case V4L2_CID_GAMMA:
1074         case V4L2_CID_SHARPNESS:
1075         case V4L2_CID_CHROMA_GAIN:
1076         case V4L2_CID_RDS_TX_DEVIATION:
1077         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1078         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1079         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1080         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1081         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1082         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1083         case V4L2_CID_PILOT_TONE_DEVIATION:
1084         case V4L2_CID_PILOT_TONE_FREQUENCY:
1085         case V4L2_CID_TUNE_POWER_LEVEL:
1086         case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1087         case V4L2_CID_RF_TUNER_LNA_GAIN:
1088         case V4L2_CID_RF_TUNER_MIXER_GAIN:
1089         case V4L2_CID_RF_TUNER_IF_GAIN:
1090         case V4L2_CID_RF_TUNER_BANDWIDTH:
1091                 *flags |= V4L2_CTRL_FLAG_SLIDER;
1092                 break;
1093         case V4L2_CID_PAN_RELATIVE:
1094         case V4L2_CID_TILT_RELATIVE:
1095         case V4L2_CID_FOCUS_RELATIVE:
1096         case V4L2_CID_IRIS_RELATIVE:
1097         case V4L2_CID_ZOOM_RELATIVE:
1098                 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1099                 break;
1100         case V4L2_CID_FLASH_STROBE_STATUS:
1101         case V4L2_CID_AUTO_FOCUS_STATUS:
1102         case V4L2_CID_FLASH_READY:
1103         case V4L2_CID_DV_TX_HOTPLUG:
1104         case V4L2_CID_DV_TX_RXSENSE:
1105         case V4L2_CID_DV_TX_EDID_PRESENT:
1106         case V4L2_CID_DV_RX_POWER_PRESENT:
1107                 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1108                 break;
1109         }
1110 }
1111 EXPORT_SYMBOL(v4l2_ctrl_fill);
1112
1113 /* Helper function to determine whether the control type is compatible with
1114    VIDIOC_G/S_CTRL. */
1115 static bool type_is_int(const struct v4l2_ctrl *ctrl)
1116 {
1117         switch (ctrl->type) {
1118         case V4L2_CTRL_TYPE_INTEGER64:
1119         case V4L2_CTRL_TYPE_STRING:
1120                 /* Nope, these need v4l2_ext_control */
1121                 return false;
1122         default:
1123                 return true;
1124         }
1125 }
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->type == V4L2_CTRL_TYPE_STRING)
1136                 ev->u.ctrl.value64 = 0;
1137         else
1138                 ev->u.ctrl.value64 = ctrl->cur.val64;
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 /* Helper function: copy the current control value back to the caller */
1165 static int cur_to_user(struct v4l2_ext_control *c,
1166                        struct v4l2_ctrl *ctrl)
1167 {
1168         u32 len;
1169
1170         switch (ctrl->type) {
1171         case V4L2_CTRL_TYPE_STRING:
1172                 len = strlen(ctrl->cur.string);
1173                 if (c->size < len + 1) {
1174                         c->size = len + 1;
1175                         return -ENOSPC;
1176                 }
1177                 return copy_to_user(c->string, ctrl->cur.string,
1178                                                 len + 1) ? -EFAULT : 0;
1179         case V4L2_CTRL_TYPE_INTEGER64:
1180                 c->value64 = ctrl->cur.val64;
1181                 break;
1182         default:
1183                 c->value = ctrl->cur.val;
1184                 break;
1185         }
1186         return 0;
1187 }
1188
1189 /* Helper function: copy the caller-provider value as the new control value */
1190 static int user_to_new(struct v4l2_ext_control *c,
1191                        struct v4l2_ctrl *ctrl)
1192 {
1193         int ret;
1194         u32 size;
1195
1196         ctrl->is_new = 1;
1197         switch (ctrl->type) {
1198         case V4L2_CTRL_TYPE_INTEGER64:
1199                 ctrl->val64 = c->value64;
1200                 break;
1201         case V4L2_CTRL_TYPE_STRING:
1202                 size = c->size;
1203                 if (size == 0)
1204                         return -ERANGE;
1205                 if (size > ctrl->maximum + 1)
1206                         size = ctrl->maximum + 1;
1207                 ret = copy_from_user(ctrl->string, c->string, size);
1208                 if (!ret) {
1209                         char last = ctrl->string[size - 1];
1210
1211                         ctrl->string[size - 1] = 0;
1212                         /* If the string was longer than ctrl->maximum,
1213                            then return an error. */
1214                         if (strlen(ctrl->string) == ctrl->maximum && last)
1215                                 return -ERANGE;
1216                 }
1217                 return ret ? -EFAULT : 0;
1218         default:
1219                 ctrl->val = c->value;
1220                 break;
1221         }
1222         return 0;
1223 }
1224
1225 /* Helper function: copy the new control value back to the caller */
1226 static int new_to_user(struct v4l2_ext_control *c,
1227                        struct v4l2_ctrl *ctrl)
1228 {
1229         u32 len;
1230
1231         switch (ctrl->type) {
1232         case V4L2_CTRL_TYPE_STRING:
1233                 len = strlen(ctrl->string);
1234                 if (c->size < len + 1) {
1235                         c->size = ctrl->maximum + 1;
1236                         return -ENOSPC;
1237                 }
1238                 return copy_to_user(c->string, ctrl->string,
1239                                                 len + 1) ? -EFAULT : 0;
1240         case V4L2_CTRL_TYPE_INTEGER64:
1241                 c->value64 = ctrl->val64;
1242                 break;
1243         default:
1244                 c->value = ctrl->val;
1245                 break;
1246         }
1247         return 0;
1248 }
1249
1250 /* Copy the new value to the current value. */
1251 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1252 {
1253         bool changed = false;
1254
1255         if (ctrl == NULL)
1256                 return;
1257         switch (ctrl->type) {
1258         case V4L2_CTRL_TYPE_BUTTON:
1259                 changed = true;
1260                 break;
1261         case V4L2_CTRL_TYPE_STRING:
1262                 /* strings are always 0-terminated */
1263                 changed = strcmp(ctrl->string, ctrl->cur.string);
1264                 strcpy(ctrl->cur.string, ctrl->string);
1265                 break;
1266         case V4L2_CTRL_TYPE_INTEGER64:
1267                 changed = ctrl->val64 != ctrl->cur.val64;
1268                 ctrl->cur.val64 = ctrl->val64;
1269                 break;
1270         default:
1271                 changed = ctrl->val != ctrl->cur.val;
1272                 ctrl->cur.val = ctrl->val;
1273                 break;
1274         }
1275         if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1276                 /* Note: CH_FLAGS is only set for auto clusters. */
1277                 ctrl->flags &=
1278                         ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1279                 if (!is_cur_manual(ctrl->cluster[0])) {
1280                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1281                         if (ctrl->cluster[0]->has_volatiles)
1282                                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1283                 }
1284                 fh = NULL;
1285         }
1286         if (changed || ch_flags) {
1287                 /* If a control was changed that was not one of the controls
1288                    modified by the application, then send the event to all. */
1289                 if (!ctrl->is_new)
1290                         fh = NULL;
1291                 send_event(fh, ctrl,
1292                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1293                 if (ctrl->call_notify && changed && ctrl->handler->notify)
1294                         ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1295         }
1296 }
1297
1298 /* Copy the current value to the new value */
1299 static void cur_to_new(struct v4l2_ctrl *ctrl)
1300 {
1301         if (ctrl == NULL)
1302                 return;
1303         switch (ctrl->type) {
1304         case V4L2_CTRL_TYPE_STRING:
1305                 /* strings are always 0-terminated */
1306                 strcpy(ctrl->string, ctrl->cur.string);
1307                 break;
1308         case V4L2_CTRL_TYPE_INTEGER64:
1309                 ctrl->val64 = ctrl->cur.val64;
1310                 break;
1311         default:
1312                 ctrl->val = ctrl->cur.val;
1313                 break;
1314         }
1315 }
1316
1317 /* Return non-zero if one or more of the controls in the cluster has a new
1318    value that differs from the current value. */
1319 static int cluster_changed(struct v4l2_ctrl *master)
1320 {
1321         int diff = 0;
1322         int i;
1323
1324         for (i = 0; !diff && i < master->ncontrols; i++) {
1325                 struct v4l2_ctrl *ctrl = master->cluster[i];
1326
1327                 if (ctrl == NULL)
1328                         continue;
1329                 switch (ctrl->type) {
1330                 case V4L2_CTRL_TYPE_BUTTON:
1331                         /* Button controls are always 'different' */
1332                         return 1;
1333                 case V4L2_CTRL_TYPE_STRING:
1334                         /* strings are always 0-terminated */
1335                         diff = strcmp(ctrl->string, ctrl->cur.string);
1336                         break;
1337                 case V4L2_CTRL_TYPE_INTEGER64:
1338                         diff = ctrl->val64 != ctrl->cur.val64;
1339                         break;
1340                 default:
1341                         diff = ctrl->val != ctrl->cur.val;
1342                         break;
1343                 }
1344         }
1345         return diff;
1346 }
1347
1348 /* Control range checking */
1349 static int check_range(enum v4l2_ctrl_type type,
1350                 s32 min, s32 max, u32 step, s32 def)
1351 {
1352         switch (type) {
1353         case V4L2_CTRL_TYPE_BOOLEAN:
1354                 if (step != 1 || max > 1 || min < 0)
1355                         return -ERANGE;
1356                 /* fall through */
1357         case V4L2_CTRL_TYPE_INTEGER:
1358                 if (step <= 0 || min > max || def < min || def > max)
1359                         return -ERANGE;
1360                 return 0;
1361         case V4L2_CTRL_TYPE_BITMASK:
1362                 if (step || min || !max || (def & ~max))
1363                         return -ERANGE;
1364                 return 0;
1365         case V4L2_CTRL_TYPE_MENU:
1366         case V4L2_CTRL_TYPE_INTEGER_MENU:
1367                 if (min > max || def < min || def > max)
1368                         return -ERANGE;
1369                 /* Note: step == menu_skip_mask for menu controls.
1370                    So here we check if the default value is masked out. */
1371                 if (step && ((1 << def) & step))
1372                         return -EINVAL;
1373                 return 0;
1374         case V4L2_CTRL_TYPE_STRING:
1375                 if (min > max || min < 0 || step < 1 || def)
1376                         return -ERANGE;
1377                 return 0;
1378         default:
1379                 return 0;
1380         }
1381 }
1382
1383 /* Validate a new control */
1384 static int validate_new(const struct v4l2_ctrl *ctrl,
1385                         struct v4l2_ext_control *c)
1386 {
1387         size_t len;
1388         u32 offset;
1389         s32 val;
1390
1391         switch (ctrl->type) {
1392         case V4L2_CTRL_TYPE_INTEGER:
1393                 /* Round towards the closest legal value */
1394                 val = c->value + ctrl->step / 2;
1395                 val = clamp(val, ctrl->minimum, ctrl->maximum);
1396                 offset = val - ctrl->minimum;
1397                 offset = ctrl->step * (offset / ctrl->step);
1398                 c->value = ctrl->minimum + offset;
1399                 return 0;
1400
1401         case V4L2_CTRL_TYPE_BOOLEAN:
1402                 c->value = !!c->value;
1403                 return 0;
1404
1405         case V4L2_CTRL_TYPE_MENU:
1406         case V4L2_CTRL_TYPE_INTEGER_MENU:
1407                 if (c->value < ctrl->minimum || c->value > ctrl->maximum)
1408                         return -ERANGE;
1409                 if (ctrl->menu_skip_mask & (1 << c->value))
1410                         return -EINVAL;
1411                 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1412                     ctrl->qmenu[c->value][0] == '\0')
1413                         return -EINVAL;
1414                 return 0;
1415
1416         case V4L2_CTRL_TYPE_BITMASK:
1417                 c->value &= ctrl->maximum;
1418                 return 0;
1419
1420         case V4L2_CTRL_TYPE_BUTTON:
1421         case V4L2_CTRL_TYPE_CTRL_CLASS:
1422                 c->value = 0;
1423                 return 0;
1424
1425         case V4L2_CTRL_TYPE_INTEGER64:
1426                 return 0;
1427
1428         case V4L2_CTRL_TYPE_STRING:
1429                 len = strlen(c->string);
1430                 if (len < ctrl->minimum)
1431                         return -ERANGE;
1432                 if ((len - ctrl->minimum) % ctrl->step)
1433                         return -ERANGE;
1434                 return 0;
1435
1436         default:
1437                 return -EINVAL;
1438         }
1439 }
1440
1441 static inline u32 node2id(struct list_head *node)
1442 {
1443         return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1444 }
1445
1446 /* Set the handler's error code if it wasn't set earlier already */
1447 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1448 {
1449         if (hdl->error == 0)
1450                 hdl->error = err;
1451         return err;
1452 }
1453
1454 /* Initialize the handler */
1455 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1456                                  unsigned nr_of_controls_hint,
1457                                  struct lock_class_key *key, const char *name)
1458 {
1459         hdl->lock = &hdl->_lock;
1460         mutex_init(hdl->lock);
1461         lockdep_set_class_and_name(hdl->lock, key, name);
1462         INIT_LIST_HEAD(&hdl->ctrls);
1463         INIT_LIST_HEAD(&hdl->ctrl_refs);
1464         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1465         hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1466                                GFP_KERNEL);
1467         hdl->error = hdl->buckets ? 0 : -ENOMEM;
1468         return hdl->error;
1469 }
1470 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1471
1472 /* Free all controls and control refs */
1473 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1474 {
1475         struct v4l2_ctrl_ref *ref, *next_ref;
1476         struct v4l2_ctrl *ctrl, *next_ctrl;
1477         struct v4l2_subscribed_event *sev, *next_sev;
1478
1479         if (hdl == NULL || hdl->buckets == NULL)
1480                 return;
1481
1482         mutex_lock(hdl->lock);
1483         /* Free all nodes */
1484         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1485                 list_del(&ref->node);
1486                 kfree(ref);
1487         }
1488         /* Free all controls owned by the handler */
1489         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1490                 list_del(&ctrl->node);
1491                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1492                         list_del(&sev->node);
1493                 kfree(ctrl);
1494         }
1495         kfree(hdl->buckets);
1496         hdl->buckets = NULL;
1497         hdl->cached = NULL;
1498         hdl->error = 0;
1499         mutex_unlock(hdl->lock);
1500 }
1501 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1502
1503 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1504    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1505    with applications that do not use the NEXT_CTRL flag.
1506
1507    We just find the n-th private user control. It's O(N), but that should not
1508    be an issue in this particular case. */
1509 static struct v4l2_ctrl_ref *find_private_ref(
1510                 struct v4l2_ctrl_handler *hdl, u32 id)
1511 {
1512         struct v4l2_ctrl_ref *ref;
1513
1514         id -= V4L2_CID_PRIVATE_BASE;
1515         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1516                 /* Search for private user controls that are compatible with
1517                    VIDIOC_G/S_CTRL. */
1518                 if (V4L2_CTRL_ID2CLASS(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1519                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1520                         if (!type_is_int(ref->ctrl))
1521                                 continue;
1522                         if (id == 0)
1523                                 return ref;
1524                         id--;
1525                 }
1526         }
1527         return NULL;
1528 }
1529
1530 /* Find a control with the given ID. */
1531 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1532 {
1533         struct v4l2_ctrl_ref *ref;
1534         int bucket;
1535
1536         id &= V4L2_CTRL_ID_MASK;
1537
1538         /* Old-style private controls need special handling */
1539         if (id >= V4L2_CID_PRIVATE_BASE)
1540                 return find_private_ref(hdl, id);
1541         bucket = id % hdl->nr_of_buckets;
1542
1543         /* Simple optimization: cache the last control found */
1544         if (hdl->cached && hdl->cached->ctrl->id == id)
1545                 return hdl->cached;
1546
1547         /* Not in cache, search the hash */
1548         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1549         while (ref && ref->ctrl->id != id)
1550                 ref = ref->next;
1551
1552         if (ref)
1553                 hdl->cached = ref; /* cache it! */
1554         return ref;
1555 }
1556
1557 /* Find a control with the given ID. Take the handler's lock first. */
1558 static struct v4l2_ctrl_ref *find_ref_lock(
1559                 struct v4l2_ctrl_handler *hdl, u32 id)
1560 {
1561         struct v4l2_ctrl_ref *ref = NULL;
1562
1563         if (hdl) {
1564                 mutex_lock(hdl->lock);
1565                 ref = find_ref(hdl, id);
1566                 mutex_unlock(hdl->lock);
1567         }
1568         return ref;
1569 }
1570
1571 /* Find a control with the given ID. */
1572 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1573 {
1574         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1575
1576         return ref ? ref->ctrl : NULL;
1577 }
1578 EXPORT_SYMBOL(v4l2_ctrl_find);
1579
1580 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1581 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1582                            struct v4l2_ctrl *ctrl)
1583 {
1584         struct v4l2_ctrl_ref *ref;
1585         struct v4l2_ctrl_ref *new_ref;
1586         u32 id = ctrl->id;
1587         u32 class_ctrl = V4L2_CTRL_ID2CLASS(id) | 1;
1588         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
1589
1590         /* Automatically add the control class if it is not yet present. */
1591         if (id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1592                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1593                         return hdl->error;
1594
1595         if (hdl->error)
1596                 return hdl->error;
1597
1598         new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1599         if (!new_ref)
1600                 return handler_set_err(hdl, -ENOMEM);
1601         new_ref->ctrl = ctrl;
1602         if (ctrl->handler == hdl) {
1603                 /* By default each control starts in a cluster of its own.
1604                    new_ref->ctrl is basically a cluster array with one
1605                    element, so that's perfect to use as the cluster pointer.
1606                    But only do this for the handler that owns the control. */
1607                 ctrl->cluster = &new_ref->ctrl;
1608                 ctrl->ncontrols = 1;
1609         }
1610
1611         INIT_LIST_HEAD(&new_ref->node);
1612
1613         mutex_lock(hdl->lock);
1614
1615         /* Add immediately at the end of the list if the list is empty, or if
1616            the last element in the list has a lower ID.
1617            This ensures that when elements are added in ascending order the
1618            insertion is an O(1) operation. */
1619         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1620                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1621                 goto insert_in_hash;
1622         }
1623
1624         /* Find insert position in sorted list */
1625         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1626                 if (ref->ctrl->id < id)
1627                         continue;
1628                 /* Don't add duplicates */
1629                 if (ref->ctrl->id == id) {
1630                         kfree(new_ref);
1631                         goto unlock;
1632                 }
1633                 list_add(&new_ref->node, ref->node.prev);
1634                 break;
1635         }
1636
1637 insert_in_hash:
1638         /* Insert the control node in the hash */
1639         new_ref->next = hdl->buckets[bucket];
1640         hdl->buckets[bucket] = new_ref;
1641
1642 unlock:
1643         mutex_unlock(hdl->lock);
1644         return 0;
1645 }
1646
1647 /* Add a new control */
1648 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1649                         const struct v4l2_ctrl_ops *ops,
1650                         u32 id, const char *name, enum v4l2_ctrl_type type,
1651                         s32 min, s32 max, u32 step, s32 def,
1652                         u32 flags, const char * const *qmenu,
1653                         const s64 *qmenu_int, void *priv)
1654 {
1655         struct v4l2_ctrl *ctrl;
1656         unsigned sz_extra = 0;
1657         int err;
1658
1659         if (hdl->error)
1660                 return NULL;
1661
1662         /* Sanity checks */
1663         if (id == 0 || name == NULL || id >= V4L2_CID_PRIVATE_BASE ||
1664             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1665             (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1666                 handler_set_err(hdl, -ERANGE);
1667                 return NULL;
1668         }
1669         err = check_range(type, min, max, step, def);
1670         if (err) {
1671                 handler_set_err(hdl, err);
1672                 return NULL;
1673         }
1674         if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1675                 handler_set_err(hdl, -ERANGE);
1676                 return NULL;
1677         }
1678
1679         if (type == V4L2_CTRL_TYPE_BUTTON)
1680                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1681         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1682                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1683         else if (type == V4L2_CTRL_TYPE_STRING)
1684                 sz_extra += 2 * (max + 1);
1685
1686         ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1687         if (ctrl == NULL) {
1688                 handler_set_err(hdl, -ENOMEM);
1689                 return NULL;
1690         }
1691
1692         INIT_LIST_HEAD(&ctrl->node);
1693         INIT_LIST_HEAD(&ctrl->ev_subs);
1694         ctrl->handler = hdl;
1695         ctrl->ops = ops;
1696         ctrl->id = id;
1697         ctrl->name = name;
1698         ctrl->type = type;
1699         ctrl->flags = flags;
1700         ctrl->minimum = min;
1701         ctrl->maximum = max;
1702         ctrl->step = step;
1703         if (type == V4L2_CTRL_TYPE_MENU)
1704                 ctrl->qmenu = qmenu;
1705         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1706                 ctrl->qmenu_int = qmenu_int;
1707         ctrl->priv = priv;
1708         ctrl->cur.val = ctrl->val = ctrl->default_value = def;
1709
1710         if (ctrl->type == V4L2_CTRL_TYPE_STRING) {
1711                 ctrl->cur.string = (char *)&ctrl[1] + sz_extra - (max + 1);
1712                 ctrl->string = (char *)&ctrl[1] + sz_extra - 2 * (max + 1);
1713                 if (ctrl->minimum)
1714                         memset(ctrl->cur.string, ' ', ctrl->minimum);
1715         }
1716         if (handler_new_ref(hdl, ctrl)) {
1717                 kfree(ctrl);
1718                 return NULL;
1719         }
1720         mutex_lock(hdl->lock);
1721         list_add_tail(&ctrl->node, &hdl->ctrls);
1722         mutex_unlock(hdl->lock);
1723         return ctrl;
1724 }
1725
1726 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1727                         const struct v4l2_ctrl_config *cfg, void *priv)
1728 {
1729         bool is_menu;
1730         struct v4l2_ctrl *ctrl;
1731         const char *name = cfg->name;
1732         const char * const *qmenu = cfg->qmenu;
1733         const s64 *qmenu_int = cfg->qmenu_int;
1734         enum v4l2_ctrl_type type = cfg->type;
1735         u32 flags = cfg->flags;
1736         s32 min = cfg->min;
1737         s32 max = cfg->max;
1738         u32 step = cfg->step;
1739         s32 def = cfg->def;
1740
1741         if (name == NULL)
1742                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1743                                                                 &def, &flags);
1744
1745         is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
1746                    cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
1747         if (is_menu)
1748                 WARN_ON(step);
1749         else
1750                 WARN_ON(cfg->menu_skip_mask);
1751         if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
1752                 qmenu = v4l2_ctrl_get_menu(cfg->id);
1753         else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
1754                  qmenu_int == NULL) {
1755                 handler_set_err(hdl, -EINVAL);
1756                 return NULL;
1757         }
1758
1759         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->id, name,
1760                         type, min, max,
1761                         is_menu ? cfg->menu_skip_mask : step,
1762                         def, flags, qmenu, qmenu_int, priv);
1763         if (ctrl)
1764                 ctrl->is_private = cfg->is_private;
1765         return ctrl;
1766 }
1767 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1768
1769 /* Helper function for standard non-menu controls */
1770 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1771                         const struct v4l2_ctrl_ops *ops,
1772                         u32 id, s32 min, s32 max, u32 step, s32 def)
1773 {
1774         const char *name;
1775         enum v4l2_ctrl_type type;
1776         u32 flags;
1777
1778         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1779         if (type == V4L2_CTRL_TYPE_MENU
1780             || type == V4L2_CTRL_TYPE_INTEGER_MENU) {
1781                 handler_set_err(hdl, -EINVAL);
1782                 return NULL;
1783         }
1784         return v4l2_ctrl_new(hdl, ops, id, name, type,
1785                              min, max, step, def, flags, NULL, NULL, NULL);
1786 }
1787 EXPORT_SYMBOL(v4l2_ctrl_new_std);
1788
1789 /* Helper function for standard menu controls */
1790 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1791                         const struct v4l2_ctrl_ops *ops,
1792                         u32 id, s32 max, s32 mask, s32 def)
1793 {
1794         const char * const *qmenu = NULL;
1795         const s64 *qmenu_int = NULL;
1796         unsigned int qmenu_int_len = 0;
1797         const char *name;
1798         enum v4l2_ctrl_type type;
1799         s32 min;
1800         s32 step;
1801         u32 flags;
1802
1803         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1804
1805         if (type == V4L2_CTRL_TYPE_MENU)
1806                 qmenu = v4l2_ctrl_get_menu(id);
1807         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1808                 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
1809
1810         if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
1811                 handler_set_err(hdl, -EINVAL);
1812                 return NULL;
1813         }
1814         return v4l2_ctrl_new(hdl, ops, id, name, type,
1815                              0, max, mask, def, flags, qmenu, qmenu_int, NULL);
1816 }
1817 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1818
1819 /* Helper function for standard menu controls with driver defined menu */
1820 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
1821                         const struct v4l2_ctrl_ops *ops, u32 id, s32 max,
1822                         s32 mask, s32 def, const char * const *qmenu)
1823 {
1824         enum v4l2_ctrl_type type;
1825         const char *name;
1826         u32 flags;
1827         s32 step;
1828         s32 min;
1829
1830         /* v4l2_ctrl_new_std_menu_items() should only be called for
1831          * standard controls without a standard menu.
1832          */
1833         if (v4l2_ctrl_get_menu(id)) {
1834                 handler_set_err(hdl, -EINVAL);
1835                 return NULL;
1836         }
1837
1838         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1839         if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
1840                 handler_set_err(hdl, -EINVAL);
1841                 return NULL;
1842         }
1843         return v4l2_ctrl_new(hdl, ops, id, name, type, 0, max, mask, def,
1844                              flags, qmenu, NULL, NULL);
1845
1846 }
1847 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
1848
1849 /* Helper function for standard integer menu controls */
1850 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
1851                         const struct v4l2_ctrl_ops *ops,
1852                         u32 id, s32 max, s32 def, const s64 *qmenu_int)
1853 {
1854         const char *name;
1855         enum v4l2_ctrl_type type;
1856         s32 min;
1857         s32 step;
1858         u32 flags;
1859
1860         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1861         if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
1862                 handler_set_err(hdl, -EINVAL);
1863                 return NULL;
1864         }
1865         return v4l2_ctrl_new(hdl, ops, id, name, type,
1866                              0, max, 0, def, flags, NULL, qmenu_int, NULL);
1867 }
1868 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
1869
1870 /* Add a control from another handler to this handler */
1871 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
1872                                           struct v4l2_ctrl *ctrl)
1873 {
1874         if (hdl == NULL || hdl->error)
1875                 return NULL;
1876         if (ctrl == NULL) {
1877                 handler_set_err(hdl, -EINVAL);
1878                 return NULL;
1879         }
1880         if (ctrl->handler == hdl)
1881                 return ctrl;
1882         return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
1883 }
1884 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
1885
1886 /* Add the controls from another handler to our own. */
1887 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1888                           struct v4l2_ctrl_handler *add,
1889                           bool (*filter)(const struct v4l2_ctrl *ctrl))
1890 {
1891         struct v4l2_ctrl_ref *ref;
1892         int ret = 0;
1893
1894         /* Do nothing if either handler is NULL or if they are the same */
1895         if (!hdl || !add || hdl == add)
1896                 return 0;
1897         if (hdl->error)
1898                 return hdl->error;
1899         mutex_lock(add->lock);
1900         list_for_each_entry(ref, &add->ctrl_refs, node) {
1901                 struct v4l2_ctrl *ctrl = ref->ctrl;
1902
1903                 /* Skip handler-private controls. */
1904                 if (ctrl->is_private)
1905                         continue;
1906                 /* And control classes */
1907                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1908                         continue;
1909                 /* Filter any unwanted controls */
1910                 if (filter && !filter(ctrl))
1911                         continue;
1912                 ret = handler_new_ref(hdl, ctrl);
1913                 if (ret)
1914                         break;
1915         }
1916         mutex_unlock(add->lock);
1917         return ret;
1918 }
1919 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1920
1921 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
1922 {
1923         if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
1924                 return true;
1925         if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
1926                 return true;
1927         switch (ctrl->id) {
1928         case V4L2_CID_AUDIO_MUTE:
1929         case V4L2_CID_AUDIO_VOLUME:
1930         case V4L2_CID_AUDIO_BALANCE:
1931         case V4L2_CID_AUDIO_BASS:
1932         case V4L2_CID_AUDIO_TREBLE:
1933         case V4L2_CID_AUDIO_LOUDNESS:
1934                 return true;
1935         default:
1936                 break;
1937         }
1938         return false;
1939 }
1940 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
1941
1942 /* Cluster controls */
1943 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1944 {
1945         bool has_volatiles = false;
1946         int i;
1947
1948         /* The first control is the master control and it must not be NULL */
1949         if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
1950                 return;
1951
1952         for (i = 0; i < ncontrols; i++) {
1953                 if (controls[i]) {
1954                         controls[i]->cluster = controls;
1955                         controls[i]->ncontrols = ncontrols;
1956                         if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1957                                 has_volatiles = true;
1958                 }
1959         }
1960         controls[0]->has_volatiles = has_volatiles;
1961 }
1962 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1963
1964 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1965                             u8 manual_val, bool set_volatile)
1966 {
1967         struct v4l2_ctrl *master = controls[0];
1968         u32 flag = 0;
1969         int i;
1970
1971         v4l2_ctrl_cluster(ncontrols, controls);
1972         WARN_ON(ncontrols <= 1);
1973         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1974         WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1975         master->is_auto = true;
1976         master->has_volatiles = set_volatile;
1977         master->manual_mode_value = manual_val;
1978         master->flags |= V4L2_CTRL_FLAG_UPDATE;
1979
1980         if (!is_cur_manual(master))
1981                 flag = V4L2_CTRL_FLAG_INACTIVE |
1982                         (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1983
1984         for (i = 1; i < ncontrols; i++)
1985                 if (controls[i])
1986                         controls[i]->flags |= flag;
1987 }
1988 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1989
1990 /* Activate/deactivate a control. */
1991 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1992 {
1993         /* invert since the actual flag is called 'inactive' */
1994         bool inactive = !active;
1995         bool old;
1996
1997         if (ctrl == NULL)
1998                 return;
1999
2000         if (inactive)
2001                 /* set V4L2_CTRL_FLAG_INACTIVE */
2002                 old = test_and_set_bit(4, &ctrl->flags);
2003         else
2004                 /* clear V4L2_CTRL_FLAG_INACTIVE */
2005                 old = test_and_clear_bit(4, &ctrl->flags);
2006         if (old != inactive)
2007                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2008 }
2009 EXPORT_SYMBOL(v4l2_ctrl_activate);
2010
2011 /* Grab/ungrab a control.
2012    Typically used when streaming starts and you want to grab controls,
2013    preventing the user from changing them.
2014
2015    Just call this and the framework will block any attempts to change
2016    these controls. */
2017 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
2018 {
2019         bool old;
2020
2021         if (ctrl == NULL)
2022                 return;
2023
2024         v4l2_ctrl_lock(ctrl);
2025         if (grabbed)
2026                 /* set V4L2_CTRL_FLAG_GRABBED */
2027                 old = test_and_set_bit(1, &ctrl->flags);
2028         else
2029                 /* clear V4L2_CTRL_FLAG_GRABBED */
2030                 old = test_and_clear_bit(1, &ctrl->flags);
2031         if (old != grabbed)
2032                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2033         v4l2_ctrl_unlock(ctrl);
2034 }
2035 EXPORT_SYMBOL(v4l2_ctrl_grab);
2036
2037 /* Log the control name and value */
2038 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2039                      const char *prefix, const char *colon)
2040 {
2041         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2042                 return;
2043         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2044                 return;
2045
2046         printk(KERN_INFO "%s%s%s: ", prefix, colon, ctrl->name);
2047
2048         switch (ctrl->type) {
2049         case V4L2_CTRL_TYPE_INTEGER:
2050                 printk(KERN_CONT "%d", ctrl->cur.val);
2051                 break;
2052         case V4L2_CTRL_TYPE_BOOLEAN:
2053                 printk(KERN_CONT "%s", ctrl->cur.val ? "true" : "false");
2054                 break;
2055         case V4L2_CTRL_TYPE_MENU:
2056                 printk(KERN_CONT "%s", ctrl->qmenu[ctrl->cur.val]);
2057                 break;
2058         case V4L2_CTRL_TYPE_INTEGER_MENU:
2059                 printk(KERN_CONT "%lld", ctrl->qmenu_int[ctrl->cur.val]);
2060                 break;
2061         case V4L2_CTRL_TYPE_BITMASK:
2062                 printk(KERN_CONT "0x%08x", ctrl->cur.val);
2063                 break;
2064         case V4L2_CTRL_TYPE_INTEGER64:
2065                 printk(KERN_CONT "%lld", ctrl->cur.val64);
2066                 break;
2067         case V4L2_CTRL_TYPE_STRING:
2068                 printk(KERN_CONT "%s", ctrl->cur.string);
2069                 break;
2070         default:
2071                 printk(KERN_CONT "unknown type %d", ctrl->type);
2072                 break;
2073         }
2074         if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2075                            V4L2_CTRL_FLAG_GRABBED |
2076                            V4L2_CTRL_FLAG_VOLATILE)) {
2077                 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2078                         printk(KERN_CONT " inactive");
2079                 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2080                         printk(KERN_CONT " grabbed");
2081                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2082                         printk(KERN_CONT " volatile");
2083         }
2084         printk(KERN_CONT "\n");
2085 }
2086
2087 /* Log all controls owned by the handler */
2088 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2089                                   const char *prefix)
2090 {
2091         struct v4l2_ctrl *ctrl;
2092         const char *colon = "";
2093         int len;
2094
2095         if (hdl == NULL)
2096                 return;
2097         if (prefix == NULL)
2098                 prefix = "";
2099         len = strlen(prefix);
2100         if (len && prefix[len - 1] != ' ')
2101                 colon = ": ";
2102         mutex_lock(hdl->lock);
2103         list_for_each_entry(ctrl, &hdl->ctrls, node)
2104                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2105                         log_ctrl(ctrl, prefix, colon);
2106         mutex_unlock(hdl->lock);
2107 }
2108 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2109
2110 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2111 {
2112         v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2113         return 0;
2114 }
2115 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2116
2117 /* Call s_ctrl for all controls owned by the handler */
2118 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2119 {
2120         struct v4l2_ctrl *ctrl;
2121         int ret = 0;
2122
2123         if (hdl == NULL)
2124                 return 0;
2125         mutex_lock(hdl->lock);
2126         list_for_each_entry(ctrl, &hdl->ctrls, node)
2127                 ctrl->done = false;
2128
2129         list_for_each_entry(ctrl, &hdl->ctrls, node) {
2130                 struct v4l2_ctrl *master = ctrl->cluster[0];
2131                 int i;
2132
2133                 /* Skip if this control was already handled by a cluster. */
2134                 /* Skip button controls and read-only controls. */
2135                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2136                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2137                         continue;
2138
2139                 for (i = 0; i < master->ncontrols; i++) {
2140                         if (master->cluster[i]) {
2141                                 cur_to_new(master->cluster[i]);
2142                                 master->cluster[i]->is_new = 1;
2143                                 master->cluster[i]->done = true;
2144                         }
2145                 }
2146                 ret = call_op(master, s_ctrl);
2147                 if (ret)
2148                         break;
2149         }
2150         mutex_unlock(hdl->lock);
2151         return ret;
2152 }
2153 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2154
2155 /* Implement VIDIOC_QUERYCTRL */
2156 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2157 {
2158         u32 id = qc->id & V4L2_CTRL_ID_MASK;
2159         struct v4l2_ctrl_ref *ref;
2160         struct v4l2_ctrl *ctrl;
2161
2162         if (hdl == NULL)
2163                 return -EINVAL;
2164
2165         mutex_lock(hdl->lock);
2166
2167         /* Try to find it */
2168         ref = find_ref(hdl, id);
2169
2170         if ((qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) && !list_empty(&hdl->ctrl_refs)) {
2171                 /* Find the next control with ID > qc->id */
2172
2173                 /* Did we reach the end of the control list? */
2174                 if (id >= node2id(hdl->ctrl_refs.prev)) {
2175                         ref = NULL; /* Yes, so there is no next control */
2176                 } else if (ref) {
2177                         /* We found a control with the given ID, so just get
2178                            the next one in the list. */
2179                         ref = list_entry(ref->node.next, typeof(*ref), node);
2180                 } else {
2181                         /* No control with the given ID exists, so start
2182                            searching for the next largest ID. We know there
2183                            is one, otherwise the first 'if' above would have
2184                            been true. */
2185                         list_for_each_entry(ref, &hdl->ctrl_refs, node)
2186                                 if (id < ref->ctrl->id)
2187                                         break;
2188                 }
2189         }
2190         mutex_unlock(hdl->lock);
2191         if (!ref)
2192                 return -EINVAL;
2193
2194         ctrl = ref->ctrl;
2195         memset(qc, 0, sizeof(*qc));
2196         if (id >= V4L2_CID_PRIVATE_BASE)
2197                 qc->id = id;
2198         else
2199                 qc->id = ctrl->id;
2200         strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2201         qc->minimum = ctrl->minimum;
2202         qc->maximum = ctrl->maximum;
2203         qc->default_value = ctrl->default_value;
2204         if (ctrl->type == V4L2_CTRL_TYPE_MENU
2205             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2206                 qc->step = 1;
2207         else
2208                 qc->step = ctrl->step;
2209         qc->flags = ctrl->flags;
2210         qc->type = ctrl->type;
2211         return 0;
2212 }
2213 EXPORT_SYMBOL(v4l2_queryctrl);
2214
2215 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
2216 {
2217         if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
2218                 return -EINVAL;
2219         return v4l2_queryctrl(sd->ctrl_handler, qc);
2220 }
2221 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
2222
2223 /* Implement VIDIOC_QUERYMENU */
2224 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2225 {
2226         struct v4l2_ctrl *ctrl;
2227         u32 i = qm->index;
2228
2229         ctrl = v4l2_ctrl_find(hdl, qm->id);
2230         if (!ctrl)
2231                 return -EINVAL;
2232
2233         qm->reserved = 0;
2234         /* Sanity checks */
2235         switch (ctrl->type) {
2236         case V4L2_CTRL_TYPE_MENU:
2237                 if (ctrl->qmenu == NULL)
2238                         return -EINVAL;
2239                 break;
2240         case V4L2_CTRL_TYPE_INTEGER_MENU:
2241                 if (ctrl->qmenu_int == NULL)
2242                         return -EINVAL;
2243                 break;
2244         default:
2245                 return -EINVAL;
2246         }
2247
2248         if (i < ctrl->minimum || i > ctrl->maximum)
2249                 return -EINVAL;
2250
2251         /* Use mask to see if this menu item should be skipped */
2252         if (ctrl->menu_skip_mask & (1 << i))
2253                 return -EINVAL;
2254         /* Empty menu items should also be skipped */
2255         if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2256                 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2257                         return -EINVAL;
2258                 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2259         } else {
2260                 qm->value = ctrl->qmenu_int[i];
2261         }
2262         return 0;
2263 }
2264 EXPORT_SYMBOL(v4l2_querymenu);
2265
2266 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2267 {
2268         return v4l2_querymenu(sd->ctrl_handler, qm);
2269 }
2270 EXPORT_SYMBOL(v4l2_subdev_querymenu);
2271
2272
2273
2274 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2275
2276    It is not a fully atomic operation, just best-effort only. After all, if
2277    multiple controls have to be set through multiple i2c writes (for example)
2278    then some initial writes may succeed while others fail. Thus leaving the
2279    system in an inconsistent state. The question is how much effort you are
2280    willing to spend on trying to make something atomic that really isn't.
2281
2282    From the point of view of an application the main requirement is that
2283    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2284    error should be returned without actually affecting any controls.
2285
2286    If all the values are correct, then it is acceptable to just give up
2287    in case of low-level errors.
2288
2289    It is important though that the application can tell when only a partial
2290    configuration was done. The way we do that is through the error_idx field
2291    of struct v4l2_ext_controls: if that is equal to the count field then no
2292    controls were affected. Otherwise all controls before that index were
2293    successful in performing their 'get' or 'set' operation, the control at
2294    the given index failed, and you don't know what happened with the controls
2295    after the failed one. Since if they were part of a control cluster they
2296    could have been successfully processed (if a cluster member was encountered
2297    at index < error_idx), they could have failed (if a cluster member was at
2298    error_idx), or they may not have been processed yet (if the first cluster
2299    member appeared after error_idx).
2300
2301    It is all fairly theoretical, though. In practice all you can do is to
2302    bail out. If error_idx == count, then it is an application bug. If
2303    error_idx < count then it is only an application bug if the error code was
2304    EBUSY. That usually means that something started streaming just when you
2305    tried to set the controls. In all other cases it is a driver/hardware
2306    problem and all you can do is to retry or bail out.
2307
2308    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2309    never modifies controls the error_idx is just set to whatever control
2310    has an invalid value.
2311  */
2312
2313 /* Prepare for the extended g/s/try functions.
2314    Find the controls in the control array and do some basic checks. */
2315 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2316                              struct v4l2_ext_controls *cs,
2317                              struct v4l2_ctrl_helper *helpers)
2318 {
2319         struct v4l2_ctrl_helper *h;
2320         bool have_clusters = false;
2321         u32 i;
2322
2323         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2324                 struct v4l2_ext_control *c = &cs->controls[i];
2325                 struct v4l2_ctrl_ref *ref;
2326                 struct v4l2_ctrl *ctrl;
2327                 u32 id = c->id & V4L2_CTRL_ID_MASK;
2328
2329                 cs->error_idx = i;
2330
2331                 if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2332                         return -EINVAL;
2333
2334                 /* Old-style private controls are not allowed for
2335                    extended controls */
2336                 if (id >= V4L2_CID_PRIVATE_BASE)
2337                         return -EINVAL;
2338                 ref = find_ref_lock(hdl, id);
2339                 if (ref == NULL)
2340                         return -EINVAL;
2341                 ctrl = ref->ctrl;
2342                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2343                         return -EINVAL;
2344
2345                 if (ctrl->cluster[0]->ncontrols > 1)
2346                         have_clusters = true;
2347                 if (ctrl->cluster[0] != ctrl)
2348                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2349                 /* Store the ref to the master control of the cluster */
2350                 h->mref = ref;
2351                 h->ctrl = ctrl;
2352                 /* Initially set next to 0, meaning that there is no other
2353                    control in this helper array belonging to the same
2354                    cluster */
2355                 h->next = 0;
2356         }
2357
2358         /* We are done if there were no controls that belong to a multi-
2359            control cluster. */
2360         if (!have_clusters)
2361                 return 0;
2362
2363         /* The code below figures out in O(n) time which controls in the list
2364            belong to the same cluster. */
2365
2366         /* This has to be done with the handler lock taken. */
2367         mutex_lock(hdl->lock);
2368
2369         /* First zero the helper field in the master control references */
2370         for (i = 0; i < cs->count; i++)
2371                 helpers[i].mref->helper = NULL;
2372         for (i = 0, h = helpers; i < cs->count; i++, h++) {
2373                 struct v4l2_ctrl_ref *mref = h->mref;
2374
2375                 /* If the mref->helper is set, then it points to an earlier
2376                    helper that belongs to the same cluster. */
2377                 if (mref->helper) {
2378                         /* Set the next field of mref->helper to the current
2379                            index: this means that that earlier helper now
2380                            points to the next helper in the same cluster. */
2381                         mref->helper->next = i;
2382                         /* mref should be set only for the first helper in the
2383                            cluster, clear the others. */
2384                         h->mref = NULL;
2385                 }
2386                 /* Point the mref helper to the current helper struct. */
2387                 mref->helper = h;
2388         }
2389         mutex_unlock(hdl->lock);
2390         return 0;
2391 }
2392
2393 /* Handles the corner case where cs->count == 0. It checks whether the
2394    specified control class exists. If that class ID is 0, then it checks
2395    whether there are any controls at all. */
2396 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2397 {
2398         if (ctrl_class == 0)
2399                 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2400         return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2401 }
2402
2403
2404
2405 /* Get extended controls. Allocates the helpers array if needed. */
2406 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2407 {
2408         struct v4l2_ctrl_helper helper[4];
2409         struct v4l2_ctrl_helper *helpers = helper;
2410         int ret;
2411         int i, j;
2412
2413         cs->error_idx = cs->count;
2414         cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2415
2416         if (hdl == NULL)
2417                 return -EINVAL;
2418
2419         if (cs->count == 0)
2420                 return class_check(hdl, cs->ctrl_class);
2421
2422         if (cs->count > ARRAY_SIZE(helper)) {
2423                 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2424                                         GFP_KERNEL);
2425                 if (helpers == NULL)
2426                         return -ENOMEM;
2427         }
2428
2429         ret = prepare_ext_ctrls(hdl, cs, helpers);
2430         cs->error_idx = cs->count;
2431
2432         for (i = 0; !ret && i < cs->count; i++)
2433                 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2434                         ret = -EACCES;
2435
2436         for (i = 0; !ret && i < cs->count; i++) {
2437                 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2438                                     struct v4l2_ctrl *ctrl) = cur_to_user;
2439                 struct v4l2_ctrl *master;
2440
2441                 if (helpers[i].mref == NULL)
2442                         continue;
2443
2444                 master = helpers[i].mref->ctrl;
2445                 cs->error_idx = i;
2446
2447                 v4l2_ctrl_lock(master);
2448
2449                 /* g_volatile_ctrl will update the new control values */
2450                 if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2451                         (master->has_volatiles && !is_cur_manual(master))) {
2452                         for (j = 0; j < master->ncontrols; j++)
2453                                 cur_to_new(master->cluster[j]);
2454                         ret = call_op(master, g_volatile_ctrl);
2455                         ctrl_to_user = new_to_user;
2456                 }
2457                 /* If OK, then copy the current (for non-volatile controls)
2458                    or the new (for volatile controls) control values to the
2459                    caller */
2460                 if (!ret) {
2461                         u32 idx = i;
2462
2463                         do {
2464                                 ret = ctrl_to_user(cs->controls + idx,
2465                                                    helpers[idx].ctrl);
2466                                 idx = helpers[idx].next;
2467                         } while (!ret && idx);
2468                 }
2469                 v4l2_ctrl_unlock(master);
2470         }
2471
2472         if (cs->count > ARRAY_SIZE(helper))
2473                 kfree(helpers);
2474         return ret;
2475 }
2476 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2477
2478 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2479 {
2480         return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2481 }
2482 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2483
2484 /* Helper function to get a single control */
2485 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
2486 {
2487         struct v4l2_ctrl *master = ctrl->cluster[0];
2488         int ret = 0;
2489         int i;
2490
2491         /* String controls are not supported. The new_to_user() and
2492          * cur_to_user() calls below would need to be modified not to access
2493          * userspace memory when called from get_ctrl().
2494          */
2495         if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2496                 return -EINVAL;
2497
2498         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2499                 return -EACCES;
2500
2501         v4l2_ctrl_lock(master);
2502         /* g_volatile_ctrl will update the current control values */
2503         if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2504                 for (i = 0; i < master->ncontrols; i++)
2505                         cur_to_new(master->cluster[i]);
2506                 ret = call_op(master, g_volatile_ctrl);
2507                 new_to_user(c, ctrl);
2508         } else {
2509                 cur_to_user(c, ctrl);
2510         }
2511         v4l2_ctrl_unlock(master);
2512         return ret;
2513 }
2514
2515 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2516 {
2517         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2518         struct v4l2_ext_control c;
2519         int ret;
2520
2521         if (ctrl == NULL || !type_is_int(ctrl))
2522                 return -EINVAL;
2523         ret = get_ctrl(ctrl, &c);
2524         control->value = c.value;
2525         return ret;
2526 }
2527 EXPORT_SYMBOL(v4l2_g_ctrl);
2528
2529 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2530 {
2531         return v4l2_g_ctrl(sd->ctrl_handler, control);
2532 }
2533 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2534
2535 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2536 {
2537         struct v4l2_ext_control c;
2538
2539         /* It's a driver bug if this happens. */
2540         WARN_ON(!type_is_int(ctrl));
2541         c.value = 0;
2542         get_ctrl(ctrl, &c);
2543         return c.value;
2544 }
2545 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2546
2547 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
2548 {
2549         struct v4l2_ext_control c;
2550
2551         /* It's a driver bug if this happens. */
2552         WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2553         c.value = 0;
2554         get_ctrl(ctrl, &c);
2555         return c.value;
2556 }
2557 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
2558
2559
2560 /* Core function that calls try/s_ctrl and ensures that the new value is
2561    copied to the current value on a set.
2562    Must be called with ctrl->handler->lock held. */
2563 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
2564                               bool set, u32 ch_flags)
2565 {
2566         bool update_flag;
2567         int ret;
2568         int i;
2569
2570         /* Go through the cluster and either validate the new value or
2571            (if no new value was set), copy the current value to the new
2572            value, ensuring a consistent view for the control ops when
2573            called. */
2574         for (i = 0; i < master->ncontrols; i++) {
2575                 struct v4l2_ctrl *ctrl = master->cluster[i];
2576
2577                 if (ctrl == NULL)
2578                         continue;
2579
2580                 if (!ctrl->is_new) {
2581                         cur_to_new(ctrl);
2582                         continue;
2583                 }
2584                 /* Check again: it may have changed since the
2585                    previous check in try_or_set_ext_ctrls(). */
2586                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2587                         return -EBUSY;
2588         }
2589
2590         ret = call_op(master, try_ctrl);
2591
2592         /* Don't set if there is no change */
2593         if (ret || !set || !cluster_changed(master))
2594                 return ret;
2595         ret = call_op(master, s_ctrl);
2596         if (ret)
2597                 return ret;
2598
2599         /* If OK, then make the new values permanent. */
2600         update_flag = is_cur_manual(master) != is_new_manual(master);
2601         for (i = 0; i < master->ncontrols; i++)
2602                 new_to_cur(fh, master->cluster[i], ch_flags |
2603                         ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
2604         return 0;
2605 }
2606
2607 /* Validate controls. */
2608 static int validate_ctrls(struct v4l2_ext_controls *cs,
2609                           struct v4l2_ctrl_helper *helpers, bool set)
2610 {
2611         unsigned i;
2612         int ret = 0;
2613
2614         cs->error_idx = cs->count;
2615         for (i = 0; i < cs->count; i++) {
2616                 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
2617
2618                 cs->error_idx = i;
2619
2620                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2621                         return -EACCES;
2622                 /* This test is also done in try_set_control_cluster() which
2623                    is called in atomic context, so that has the final say,
2624                    but it makes sense to do an up-front check as well. Once
2625                    an error occurs in try_set_control_cluster() some other
2626                    controls may have been set already and we want to do a
2627                    best-effort to avoid that. */
2628                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2629                         return -EBUSY;
2630                 ret = validate_new(ctrl, &cs->controls[i]);
2631                 if (ret)
2632                         return ret;
2633         }
2634         return 0;
2635 }
2636
2637 /* Obtain the current volatile values of an autocluster and mark them
2638    as new. */
2639 static void update_from_auto_cluster(struct v4l2_ctrl *master)
2640 {
2641         int i;
2642
2643         for (i = 0; i < master->ncontrols; i++)
2644                 cur_to_new(master->cluster[i]);
2645         if (!call_op(master, g_volatile_ctrl))
2646                 for (i = 1; i < master->ncontrols; i++)
2647                         if (master->cluster[i])
2648                                 master->cluster[i]->is_new = 1;
2649 }
2650
2651 /* Try or try-and-set controls */
2652 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2653                              struct v4l2_ext_controls *cs,
2654                              bool set)
2655 {
2656         struct v4l2_ctrl_helper helper[4];
2657         struct v4l2_ctrl_helper *helpers = helper;
2658         unsigned i, j;
2659         int ret;
2660
2661         cs->error_idx = cs->count;
2662         cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2663
2664         if (hdl == NULL)
2665                 return -EINVAL;
2666
2667         if (cs->count == 0)
2668                 return class_check(hdl, cs->ctrl_class);
2669
2670         if (cs->count > ARRAY_SIZE(helper)) {
2671                 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2672                                         GFP_KERNEL);
2673                 if (!helpers)
2674                         return -ENOMEM;
2675         }
2676         ret = prepare_ext_ctrls(hdl, cs, helpers);
2677         if (!ret)
2678                 ret = validate_ctrls(cs, helpers, set);
2679         if (ret && set)
2680                 cs->error_idx = cs->count;
2681         for (i = 0; !ret && i < cs->count; i++) {
2682                 struct v4l2_ctrl *master;
2683                 u32 idx = i;
2684
2685                 if (helpers[i].mref == NULL)
2686                         continue;
2687
2688                 cs->error_idx = i;
2689                 master = helpers[i].mref->ctrl;
2690                 v4l2_ctrl_lock(master);
2691
2692                 /* Reset the 'is_new' flags of the cluster */
2693                 for (j = 0; j < master->ncontrols; j++)
2694                         if (master->cluster[j])
2695                                 master->cluster[j]->is_new = 0;
2696
2697                 /* For volatile autoclusters that are currently in auto mode
2698                    we need to discover if it will be set to manual mode.
2699                    If so, then we have to copy the current volatile values
2700                    first since those will become the new manual values (which
2701                    may be overwritten by explicit new values from this set
2702                    of controls). */
2703                 if (master->is_auto && master->has_volatiles &&
2704                                                 !is_cur_manual(master)) {
2705                         /* Pick an initial non-manual value */
2706                         s32 new_auto_val = master->manual_mode_value + 1;
2707                         u32 tmp_idx = idx;
2708
2709                         do {
2710                                 /* Check if the auto control is part of the
2711                                    list, and remember the new value. */
2712                                 if (helpers[tmp_idx].ctrl == master)
2713                                         new_auto_val = cs->controls[tmp_idx].value;
2714                                 tmp_idx = helpers[tmp_idx].next;
2715                         } while (tmp_idx);
2716                         /* If the new value == the manual value, then copy
2717                            the current volatile values. */
2718                         if (new_auto_val == master->manual_mode_value)
2719                                 update_from_auto_cluster(master);
2720                 }
2721
2722                 /* Copy the new caller-supplied control values.
2723                    user_to_new() sets 'is_new' to 1. */
2724                 do {
2725                         ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
2726                         idx = helpers[idx].next;
2727                 } while (!ret && idx);
2728
2729                 if (!ret)
2730                         ret = try_or_set_cluster(fh, master, set, 0);
2731
2732                 /* Copy the new values back to userspace. */
2733                 if (!ret) {
2734                         idx = i;
2735                         do {
2736                                 ret = new_to_user(cs->controls + idx,
2737                                                 helpers[idx].ctrl);
2738                                 idx = helpers[idx].next;
2739                         } while (!ret && idx);
2740                 }
2741                 v4l2_ctrl_unlock(master);
2742         }
2743
2744         if (cs->count > ARRAY_SIZE(helper))
2745                 kfree(helpers);
2746         return ret;
2747 }
2748
2749 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2750 {
2751         return try_set_ext_ctrls(NULL, hdl, cs, false);
2752 }
2753 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
2754
2755 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2756                                         struct v4l2_ext_controls *cs)
2757 {
2758         return try_set_ext_ctrls(fh, hdl, cs, true);
2759 }
2760 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
2761
2762 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2763 {
2764         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
2765 }
2766 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
2767
2768 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2769 {
2770         return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
2771 }
2772 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
2773
2774 /* Helper function for VIDIOC_S_CTRL compatibility */
2775 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2776                     struct v4l2_ext_control *c, u32 ch_flags)
2777 {
2778         struct v4l2_ctrl *master = ctrl->cluster[0];
2779         int i;
2780
2781         /* String controls are not supported. The user_to_new() and
2782          * cur_to_user() calls below would need to be modified not to access
2783          * userspace memory when called from set_ctrl().
2784          */
2785         if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2786                 return -EINVAL;
2787
2788         /* Reset the 'is_new' flags of the cluster */
2789         for (i = 0; i < master->ncontrols; i++)
2790                 if (master->cluster[i])
2791                         master->cluster[i]->is_new = 0;
2792
2793         /* For autoclusters with volatiles that are switched from auto to
2794            manual mode we have to update the current volatile values since
2795            those will become the initial manual values after such a switch. */
2796         if (master->is_auto && master->has_volatiles && ctrl == master &&
2797             !is_cur_manual(master) && c->value == master->manual_mode_value)
2798                 update_from_auto_cluster(master);
2799
2800         user_to_new(c, ctrl);
2801         return try_or_set_cluster(fh, master, true, ch_flags);
2802 }
2803
2804 /* Helper function for VIDIOC_S_CTRL compatibility */
2805 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2806                          struct v4l2_ext_control *c)
2807 {
2808         int ret = validate_new(ctrl, c);
2809
2810         if (!ret) {
2811                 v4l2_ctrl_lock(ctrl);
2812                 ret = set_ctrl(fh, ctrl, c, 0);
2813                 if (!ret)
2814                         cur_to_user(c, ctrl);
2815                 v4l2_ctrl_unlock(ctrl);
2816         }
2817         return ret;
2818 }
2819
2820 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2821                                         struct v4l2_control *control)
2822 {
2823         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2824         struct v4l2_ext_control c;
2825         int ret;
2826
2827         if (ctrl == NULL || !type_is_int(ctrl))
2828                 return -EINVAL;
2829
2830         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2831                 return -EACCES;
2832
2833         c.value = control->value;
2834         ret = set_ctrl_lock(fh, ctrl, &c);
2835         control->value = c.value;
2836         return ret;
2837 }
2838 EXPORT_SYMBOL(v4l2_s_ctrl);
2839
2840 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2841 {
2842         return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
2843 }
2844 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
2845
2846 int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
2847 {
2848         struct v4l2_ext_control c;
2849
2850         /* It's a driver bug if this happens. */
2851         WARN_ON(!type_is_int(ctrl));
2852         c.value = val;
2853         return set_ctrl_lock(NULL, ctrl, &c);
2854 }
2855 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
2856
2857 int v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
2858 {
2859         struct v4l2_ext_control c;
2860
2861         /* It's a driver bug if this happens. */
2862         WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2863         c.value64 = val;
2864         return set_ctrl_lock(NULL, ctrl, &c);
2865 }
2866 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl_int64);
2867
2868 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
2869 {
2870         if (ctrl == NULL)
2871                 return;
2872         if (notify == NULL) {
2873                 ctrl->call_notify = 0;
2874                 return;
2875         }
2876         if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
2877                 return;
2878         ctrl->handler->notify = notify;
2879         ctrl->handler->notify_priv = priv;
2880         ctrl->call_notify = 1;
2881 }
2882 EXPORT_SYMBOL(v4l2_ctrl_notify);
2883
2884 int v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
2885                         s32 min, s32 max, u32 step, s32 def)
2886 {
2887         int ret = check_range(ctrl->type, min, max, step, def);
2888         struct v4l2_ext_control c;
2889
2890         switch (ctrl->type) {
2891         case V4L2_CTRL_TYPE_INTEGER:
2892         case V4L2_CTRL_TYPE_BOOLEAN:
2893         case V4L2_CTRL_TYPE_MENU:
2894         case V4L2_CTRL_TYPE_INTEGER_MENU:
2895         case V4L2_CTRL_TYPE_BITMASK:
2896                 if (ret)
2897                         return ret;
2898                 break;
2899         default:
2900                 return -EINVAL;
2901         }
2902         v4l2_ctrl_lock(ctrl);
2903         ctrl->minimum = min;
2904         ctrl->maximum = max;
2905         ctrl->step = step;
2906         ctrl->default_value = def;
2907         c.value = ctrl->cur.val;
2908         if (validate_new(ctrl, &c))
2909                 c.value = def;
2910         if (c.value != ctrl->cur.val)
2911                 ret = set_ctrl(NULL, ctrl, &c, V4L2_EVENT_CTRL_CH_RANGE);
2912         else
2913                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
2914         v4l2_ctrl_unlock(ctrl);
2915         return ret;
2916 }
2917 EXPORT_SYMBOL(v4l2_ctrl_modify_range);
2918
2919 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
2920 {
2921         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2922
2923         if (ctrl == NULL)
2924                 return -EINVAL;
2925
2926         v4l2_ctrl_lock(ctrl);
2927         list_add_tail(&sev->node, &ctrl->ev_subs);
2928         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
2929             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
2930                 struct v4l2_event ev;
2931                 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
2932
2933                 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
2934                         changes |= V4L2_EVENT_CTRL_CH_VALUE;
2935                 fill_event(&ev, ctrl, changes);
2936                 /* Mark the queue as active, allowing this initial
2937                    event to be accepted. */
2938                 sev->elems = elems;
2939                 v4l2_event_queue_fh(sev->fh, &ev);
2940         }
2941         v4l2_ctrl_unlock(ctrl);
2942         return 0;
2943 }
2944
2945 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
2946 {
2947         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2948
2949         v4l2_ctrl_lock(ctrl);
2950         list_del(&sev->node);
2951         v4l2_ctrl_unlock(ctrl);
2952 }
2953
2954 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
2955 {
2956         u32 old_changes = old->u.ctrl.changes;
2957
2958         old->u.ctrl = new->u.ctrl;
2959         old->u.ctrl.changes |= old_changes;
2960 }
2961 EXPORT_SYMBOL(v4l2_ctrl_replace);
2962
2963 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
2964 {
2965         new->u.ctrl.changes |= old->u.ctrl.changes;
2966 }
2967 EXPORT_SYMBOL(v4l2_ctrl_merge);
2968
2969 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
2970         .add = v4l2_ctrl_add_event,
2971         .del = v4l2_ctrl_del_event,
2972         .replace = v4l2_ctrl_replace,
2973         .merge = v4l2_ctrl_merge,
2974 };
2975 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
2976
2977 int v4l2_ctrl_log_status(struct file *file, void *fh)
2978 {
2979         struct video_device *vfd = video_devdata(file);
2980         struct v4l2_fh *vfh = file->private_data;
2981
2982         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
2983                 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
2984                         vfd->v4l2_dev->name);
2985         return 0;
2986 }
2987 EXPORT_SYMBOL(v4l2_ctrl_log_status);
2988
2989 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
2990                                 const struct v4l2_event_subscription *sub)
2991 {
2992         if (sub->type == V4L2_EVENT_CTRL)
2993                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
2994         return -EINVAL;
2995 }
2996 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
2997
2998 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
2999                                      struct v4l2_event_subscription *sub)
3000 {
3001         if (!sd->ctrl_handler)
3002                 return -EINVAL;
3003         return v4l2_ctrl_subscribe_event(fh, sub);
3004 }
3005 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
3006
3007 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
3008 {
3009         struct v4l2_fh *fh = file->private_data;
3010
3011         if (v4l2_event_pending(fh))
3012                 return POLLPRI;
3013         poll_wait(file, &fh->wait, wait);
3014         return 0;
3015 }
3016 EXPORT_SYMBOL(v4l2_ctrl_poll);