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