kernel/drivers/media/v4l2-core/v4l2-ctrls.c

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