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