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