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

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * V4L2 controls framework core implementation.
   4  *
   5  * Copyright (C) 2010-2021  Hans Verkuil <[email protected]>
   6  */
   7
   8 #include <linux/export.h>
   9 #include <linux/mm.h>
  10 #include <linux/slab.h>
  11 #include <media/v4l2-ctrls.h>
  12 #include <media/v4l2-event.h>
  13 #include <media/v4l2-fwnode.h>
  14
  15 #include "v4l2-ctrls-priv.h"
  16
  17 static const union v4l2_ctrl_ptr ptr_null;
  18
  19 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl,
  20                        u32 changes)
  21 {
  22         memset(ev, 0, sizeof(*ev));
  23         ev->type = V4L2_EVENT_CTRL;
  24         ev->id = ctrl->id;
  25         ev->u.ctrl.changes = changes;
  26         ev->u.ctrl.type = ctrl->type;
  27         ev->u.ctrl.flags = user_flags(ctrl);
  28         if (ctrl->is_ptr)
  29                 ev->u.ctrl.value64 = 0;
  30         else
  31                 ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
  32         ev->u.ctrl.minimum = ctrl->minimum;
  33         ev->u.ctrl.maximum = ctrl->maximum;
  34         if (ctrl->type == V4L2_CTRL_TYPE_MENU
  35             || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
  36                 ev->u.ctrl.step = 1;
  37         else
  38                 ev->u.ctrl.step = ctrl->step;
  39         ev->u.ctrl.default_value = ctrl->default_value;
  40 }
  41
  42 void send_initial_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl)
  43 {
  44         struct v4l2_event ev;
  45         u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
  46
  47         if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
  48                 changes |= V4L2_EVENT_CTRL_CH_VALUE;
  49         fill_event(&ev, ctrl, changes);
  50         v4l2_event_queue_fh(fh, &ev);
  51 }
  52
  53 void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
  54 {
  55         struct v4l2_event ev;
  56         struct v4l2_subscribed_event *sev;
  57
  58         if (list_empty(&ctrl->ev_subs))
  59                 return;
  60         fill_event(&ev, ctrl, changes);
  61
  62         list_for_each_entry(sev, &ctrl->ev_subs, node)
  63                 if (sev->fh != fh ||
  64                     (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
  65                         v4l2_event_queue_fh(sev->fh, &ev);
  66 }
  67
  68 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
  69                       union v4l2_ctrl_ptr ptr1,
  70                       union v4l2_ctrl_ptr ptr2)
  71 {
  72         switch (ctrl->type) {
  73         case V4L2_CTRL_TYPE_BUTTON:
  74                 return false;
  75         case V4L2_CTRL_TYPE_STRING:
  76                 idx *= ctrl->elem_size;
  77                 /* strings are always 0-terminated */
  78                 return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
  79         case V4L2_CTRL_TYPE_INTEGER64:
  80                 return ptr1.p_s64[idx] == ptr2.p_s64[idx];
  81         case V4L2_CTRL_TYPE_U8:
  82                 return ptr1.p_u8[idx] == ptr2.p_u8[idx];
  83         case V4L2_CTRL_TYPE_U16:
  84                 return ptr1.p_u16[idx] == ptr2.p_u16[idx];
  85         case V4L2_CTRL_TYPE_U32:
  86                 return ptr1.p_u32[idx] == ptr2.p_u32[idx];
  87         default:
  88                 if (ctrl->is_int)
  89                         return ptr1.p_s32[idx] == ptr2.p_s32[idx];
  90                 idx *= ctrl->elem_size;
  91                 return !memcmp(ptr1.p_const + idx, ptr2.p_const + idx,
  92                                ctrl->elem_size);
  93         }
  94 }
  95
  96 /* Default intra MPEG-2 quantisation coefficients, from the specification. */
  97 static const u8 mpeg2_intra_quant_matrix[64] = {
  98         8,  16, 16, 19, 16, 19, 22, 22,
  99         22, 22, 22, 22, 26, 24, 26, 27,
 100         27, 27, 26, 26, 26, 26, 27, 27,
 101         27, 29, 29, 29, 34, 34, 34, 29,
 102         29, 29, 27, 27, 29, 29, 32, 32,
 103         34, 34, 37, 38, 37, 35, 35, 34,
 104         35, 38, 38, 40, 40, 40, 48, 48,
 105         46, 46, 56, 56, 58, 69, 69, 83
 106 };
 107
 108 static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
 109                               union v4l2_ctrl_ptr ptr)
 110 {
 111         struct v4l2_ctrl_mpeg2_sequence *p_mpeg2_sequence;
 112         struct v4l2_ctrl_mpeg2_picture *p_mpeg2_picture;
 113         struct v4l2_ctrl_mpeg2_quantisation *p_mpeg2_quant;
 114         struct v4l2_ctrl_vp8_frame *p_vp8_frame;
 115         struct v4l2_ctrl_fwht_params *p_fwht_params;
 116         void *p = ptr.p + idx * ctrl->elem_size;
 117
 118         if (ctrl->p_def.p_const)
 119                 memcpy(p, ctrl->p_def.p_const, ctrl->elem_size);
 120         else
 121                 memset(p, 0, ctrl->elem_size);
 122
 123         switch ((u32)ctrl->type) {
 124         case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
 125                 p_mpeg2_sequence = p;
 126
 127                 /* 4:2:0 */
 128                 p_mpeg2_sequence->chroma_format = 1;
 129                 break;
 130         case V4L2_CTRL_TYPE_MPEG2_PICTURE:
 131                 p_mpeg2_picture = p;
 132
 133                 /* interlaced top field */
 134                 p_mpeg2_picture->picture_structure = V4L2_MPEG2_PIC_TOP_FIELD;
 135                 p_mpeg2_picture->picture_coding_type =
 136                                         V4L2_MPEG2_PIC_CODING_TYPE_I;
 137                 break;
 138         case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
 139                 p_mpeg2_quant = p;
 140
 141                 memcpy(p_mpeg2_quant->intra_quantiser_matrix,
 142                        mpeg2_intra_quant_matrix,
 143                        ARRAY_SIZE(mpeg2_intra_quant_matrix));
 144                 /*
 145                  * The default non-intra MPEG-2 quantisation
 146                  * coefficients are all 16, as per the specification.
 147                  */
 148                 memset(p_mpeg2_quant->non_intra_quantiser_matrix, 16,
 149                        sizeof(p_mpeg2_quant->non_intra_quantiser_matrix));
 150                 break;
 151         case V4L2_CTRL_TYPE_VP8_FRAME:
 152                 p_vp8_frame = p;
 153                 p_vp8_frame->num_dct_parts = 1;
 154                 break;
 155         case V4L2_CTRL_TYPE_FWHT_PARAMS:
 156                 p_fwht_params = p;
 157                 p_fwht_params->version = V4L2_FWHT_VERSION;
 158                 p_fwht_params->width = 1280;
 159                 p_fwht_params->height = 720;
 160                 p_fwht_params->flags = V4L2_FWHT_FL_PIXENC_YUV |
 161                         (2 << V4L2_FWHT_FL_COMPONENTS_NUM_OFFSET);
 162                 break;
 163         }
 164 }
 165
 166 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
 167                      union v4l2_ctrl_ptr ptr)
 168 {
 169         switch (ctrl->type) {
 170         case V4L2_CTRL_TYPE_STRING:
 171                 idx *= ctrl->elem_size;
 172                 memset(ptr.p_char + idx, ' ', ctrl->minimum);
 173                 ptr.p_char[idx + ctrl->minimum] = '\0';
 174                 break;
 175         case V4L2_CTRL_TYPE_INTEGER64:
 176                 ptr.p_s64[idx] = ctrl->default_value;
 177                 break;
 178         case V4L2_CTRL_TYPE_INTEGER:
 179         case V4L2_CTRL_TYPE_INTEGER_MENU:
 180         case V4L2_CTRL_TYPE_MENU:
 181         case V4L2_CTRL_TYPE_BITMASK:
 182         case V4L2_CTRL_TYPE_BOOLEAN:
 183                 ptr.p_s32[idx] = ctrl->default_value;
 184                 break;
 185         case V4L2_CTRL_TYPE_BUTTON:
 186         case V4L2_CTRL_TYPE_CTRL_CLASS:
 187                 ptr.p_s32[idx] = 0;
 188                 break;
 189         case V4L2_CTRL_TYPE_U8:
 190                 ptr.p_u8[idx] = ctrl->default_value;
 191                 break;
 192         case V4L2_CTRL_TYPE_U16:
 193                 ptr.p_u16[idx] = ctrl->default_value;
 194                 break;
 195         case V4L2_CTRL_TYPE_U32:
 196                 ptr.p_u32[idx] = ctrl->default_value;
 197                 break;
 198         default:
 199                 std_init_compound(ctrl, idx, ptr);
 200                 break;
 201         }
 202 }
 203
 204 static void std_log(const struct v4l2_ctrl *ctrl)
 205 {
 206         union v4l2_ctrl_ptr ptr = ctrl->p_cur;
 207
 208         if (ctrl->is_array) {
 209                 unsigned i;
 210
 211                 for (i = 0; i < ctrl->nr_of_dims; i++)
 212                         pr_cont("[%u]", ctrl->dims[i]);
 213                 pr_cont(" ");
 214         }
 215
 216         switch (ctrl->type) {
 217         case V4L2_CTRL_TYPE_INTEGER:
 218                 pr_cont("%d", *ptr.p_s32);
 219                 break;
 220         case V4L2_CTRL_TYPE_BOOLEAN:
 221                 pr_cont("%s", *ptr.p_s32 ? "true" : "false");
 222                 break;
 223         case V4L2_CTRL_TYPE_MENU:
 224                 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
 225                 break;
 226         case V4L2_CTRL_TYPE_INTEGER_MENU:
 227                 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
 228                 break;
 229         case V4L2_CTRL_TYPE_BITMASK:
 230                 pr_cont("0x%08x", *ptr.p_s32);
 231                 break;
 232         case V4L2_CTRL_TYPE_INTEGER64:
 233                 pr_cont("%lld", *ptr.p_s64);
 234                 break;
 235         case V4L2_CTRL_TYPE_STRING:
 236                 pr_cont("%s", ptr.p_char);
 237                 break;
 238         case V4L2_CTRL_TYPE_U8:
 239                 pr_cont("%u", (unsigned)*ptr.p_u8);
 240                 break;
 241         case V4L2_CTRL_TYPE_U16:
 242                 pr_cont("%u", (unsigned)*ptr.p_u16);
 243                 break;
 244         case V4L2_CTRL_TYPE_U32:
 245                 pr_cont("%u", (unsigned)*ptr.p_u32);
 246                 break;
 247         case V4L2_CTRL_TYPE_H264_SPS:
 248                 pr_cont("H264_SPS");
 249                 break;
 250         case V4L2_CTRL_TYPE_H264_PPS:
 251                 pr_cont("H264_PPS");
 252                 break;
 253         case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
 254                 pr_cont("H264_SCALING_MATRIX");
 255                 break;
 256         case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
 257                 pr_cont("H264_SLICE_PARAMS");
 258                 break;
 259         case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
 260                 pr_cont("H264_DECODE_PARAMS");
 261                 break;
 262         case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
 263                 pr_cont("H264_PRED_WEIGHTS");
 264                 break;
 265         case V4L2_CTRL_TYPE_FWHT_PARAMS:
 266                 pr_cont("FWHT_PARAMS");
 267                 break;
 268         case V4L2_CTRL_TYPE_VP8_FRAME:
 269                 pr_cont("VP8_FRAME");
 270                 break;
 271         case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
 272                 pr_cont("HDR10_CLL_INFO");
 273                 break;
 274         case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
 275                 pr_cont("HDR10_MASTERING_DISPLAY");
 276                 break;
 277         case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
 278                 pr_cont("MPEG2_QUANTISATION");
 279                 break;
 280         case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
 281                 pr_cont("MPEG2_SEQUENCE");
 282                 break;
 283         case V4L2_CTRL_TYPE_MPEG2_PICTURE:
 284                 pr_cont("MPEG2_PICTURE");
 285                 break;
 286         case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
 287                 pr_cont("VP9_COMPRESSED_HDR");
 288                 break;
 289         case V4L2_CTRL_TYPE_VP9_FRAME:
 290                 pr_cont("VP9_FRAME");
 291                 break;
 292         default:
 293                 pr_cont("unknown type %d", ctrl->type);
 294                 break;
 295         }
 296 }
 297
 298 /*
 299  * Round towards the closest legal value. Be careful when we are
 300  * close to the maximum range of the control type to prevent
 301  * wrap-arounds.
 302  */
 303 #define ROUND_TO_RANGE(val, offset_type, ctrl)                  \
 304 ({                                                              \
 305         offset_type offset;                                     \
 306         if ((ctrl)->maximum >= 0 &&                             \
 307             val >= (ctrl)->maximum - (s32)((ctrl)->step / 2))   \
 308                 val = (ctrl)->maximum;                          \
 309         else                                                    \
 310                 val += (s32)((ctrl)->step / 2);                 \
 311         val = clamp_t(typeof(val), val,                         \
 312                       (ctrl)->minimum, (ctrl)->maximum);        \
 313         offset = (val) - (ctrl)->minimum;                       \
 314         offset = (ctrl)->step * (offset / (u32)(ctrl)->step);   \
 315         val = (ctrl)->minimum + offset;                         \
 316         0;                                                      \
 317 })
 318
 319 /* Validate a new control */
 320
 321 #define zero_padding(s) \
 322         memset(&(s).padding, 0, sizeof((s).padding))
 323 #define zero_reserved(s) \
 324         memset(&(s).reserved, 0, sizeof((s).reserved))
 325
 326 static int
 327 validate_vp9_lf_params(struct v4l2_vp9_loop_filter *lf)
 328 {
 329         unsigned int i;
 330
 331         if (lf->flags & ~(V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED |
 332                           V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE))
 333                 return -EINVAL;
 334
 335         /* That all values are in the accepted range. */
 336         if (lf->level > GENMASK(5, 0))
 337                 return -EINVAL;
 338
 339         if (lf->sharpness > GENMASK(2, 0))
 340                 return -EINVAL;
 341
 342         for (i = 0; i < ARRAY_SIZE(lf->ref_deltas); i++)
 343                 if (lf->ref_deltas[i] < -63 || lf->ref_deltas[i] > 63)
 344                         return -EINVAL;
 345
 346         for (i = 0; i < ARRAY_SIZE(lf->mode_deltas); i++)
 347                 if (lf->mode_deltas[i] < -63 || lf->mode_deltas[i] > 63)
 348                         return -EINVAL;
 349
 350         zero_reserved(*lf);
 351         return 0;
 352 }
 353
 354 static int
 355 validate_vp9_quant_params(struct v4l2_vp9_quantization *quant)
 356 {
 357         if (quant->delta_q_y_dc < -15 || quant->delta_q_y_dc > 15 ||
 358             quant->delta_q_uv_dc < -15 || quant->delta_q_uv_dc > 15 ||
 359             quant->delta_q_uv_ac < -15 || quant->delta_q_uv_ac > 15)
 360                 return -EINVAL;
 361
 362         zero_reserved(*quant);
 363         return 0;
 364 }
 365
 366 static int
 367 validate_vp9_seg_params(struct v4l2_vp9_segmentation *seg)
 368 {
 369         unsigned int i, j;
 370
 371         if (seg->flags & ~(V4L2_VP9_SEGMENTATION_FLAG_ENABLED |
 372                            V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP |
 373                            V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE |
 374                            V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA |
 375                            V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE))
 376                 return -EINVAL;
 377
 378         for (i = 0; i < ARRAY_SIZE(seg->feature_enabled); i++) {
 379                 if (seg->feature_enabled[i] &
 380                     ~V4L2_VP9_SEGMENT_FEATURE_ENABLED_MASK)
 381                         return -EINVAL;
 382         }
 383
 384         for (i = 0; i < ARRAY_SIZE(seg->feature_data); i++) {
 385                 const int range[] = { 255, 63, 3, 0 };
 386
 387                 for (j = 0; j < ARRAY_SIZE(seg->feature_data[j]); j++) {
 388                         if (seg->feature_data[i][j] < -range[j] ||
 389                             seg->feature_data[i][j] > range[j])
 390                                 return -EINVAL;
 391                 }
 392         }
 393
 394         zero_reserved(*seg);
 395         return 0;
 396 }
 397
 398 static int
 399 validate_vp9_compressed_hdr(struct v4l2_ctrl_vp9_compressed_hdr *hdr)
 400 {
 401         if (hdr->tx_mode > V4L2_VP9_TX_MODE_SELECT)
 402                 return -EINVAL;
 403
 404         return 0;
 405 }
 406
 407 static int
 408 validate_vp9_frame(struct v4l2_ctrl_vp9_frame *frame)
 409 {
 410         int ret;
 411
 412         /* Make sure we're not passed invalid flags. */
 413         if (frame->flags & ~(V4L2_VP9_FRAME_FLAG_KEY_FRAME |
 414                   V4L2_VP9_FRAME_FLAG_SHOW_FRAME |
 415                   V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT |
 416                   V4L2_VP9_FRAME_FLAG_INTRA_ONLY |
 417                   V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV |
 418                   V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX |
 419                   V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE |
 420                   V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING |
 421                   V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING |
 422                   V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING))
 423                 return -EINVAL;
 424
 425         if (frame->flags & V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT &&
 426             frame->flags & V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX)
 427                 return -EINVAL;
 428
 429         if (frame->profile > V4L2_VP9_PROFILE_MAX)
 430                 return -EINVAL;
 431
 432         if (frame->reset_frame_context > V4L2_VP9_RESET_FRAME_CTX_ALL)
 433                 return -EINVAL;
 434
 435         if (frame->frame_context_idx >= V4L2_VP9_NUM_FRAME_CTX)
 436                 return -EINVAL;
 437
 438         /*
 439          * Profiles 0 and 1 only support 8-bit depth, profiles 2 and 3 only 10
 440          * and 12 bit depths.
 441          */
 442         if ((frame->profile < 2 && frame->bit_depth != 8) ||
 443             (frame->profile >= 2 &&
 444              (frame->bit_depth != 10 && frame->bit_depth != 12)))
 445                 return -EINVAL;
 446
 447         /* Profile 0 and 2 only accept YUV 4:2:0. */
 448         if ((frame->profile == 0 || frame->profile == 2) &&
 449             (!(frame->flags & V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING) ||
 450              !(frame->flags & V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING)))
 451                 return -EINVAL;
 452
 453         /* Profile 1 and 3 only accept YUV 4:2:2, 4:4:0 and 4:4:4. */
 454         if ((frame->profile == 1 || frame->profile == 3) &&
 455             ((frame->flags & V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING) &&
 456              (frame->flags & V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING)))
 457                 return -EINVAL;
 458
 459         if (frame->interpolation_filter > V4L2_VP9_INTERP_FILTER_SWITCHABLE)
 460                 return -EINVAL;
 461
 462         /*
 463          * According to the spec, tile_cols_log2 shall be less than or equal
 464          * to 6.
 465          */
 466         if (frame->tile_cols_log2 > 6)
 467                 return -EINVAL;
 468
 469         if (frame->reference_mode > V4L2_VP9_REFERENCE_MODE_SELECT)
 470                 return -EINVAL;
 471
 472         ret = validate_vp9_lf_params(&frame->lf);
 473         if (ret)
 474                 return ret;
 475
 476         ret = validate_vp9_quant_params(&frame->quant);
 477         if (ret)
 478                 return ret;
 479
 480         ret = validate_vp9_seg_params(&frame->seg);
 481         if (ret)
 482                 return ret;
 483
 484         zero_reserved(*frame);
 485         return 0;
 486 }
 487
 488 /*
 489  * Compound controls validation requires setting unused fields/flags to zero
 490  * in order to properly detect unchanged controls with std_equal's memcmp.
 491  */
 492 static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
 493                                  union v4l2_ctrl_ptr ptr)
 494 {
 495         struct v4l2_ctrl_mpeg2_sequence *p_mpeg2_sequence;
 496         struct v4l2_ctrl_mpeg2_picture *p_mpeg2_picture;
 497         struct v4l2_ctrl_vp8_frame *p_vp8_frame;
 498         struct v4l2_ctrl_fwht_params *p_fwht_params;
 499         struct v4l2_ctrl_h264_sps *p_h264_sps;
 500         struct v4l2_ctrl_h264_pps *p_h264_pps;
 501         struct v4l2_ctrl_h264_pred_weights *p_h264_pred_weights;
 502         struct v4l2_ctrl_h264_slice_params *p_h264_slice_params;
 503         struct v4l2_ctrl_h264_decode_params *p_h264_dec_params;
 504         struct v4l2_ctrl_hevc_sps *p_hevc_sps;
 505         struct v4l2_ctrl_hevc_pps *p_hevc_pps;
 506         struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
 507         struct v4l2_ctrl_hdr10_mastering_display *p_hdr10_mastering;
 508         struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params;
 509         struct v4l2_area *area;
 510         void *p = ptr.p + idx * ctrl->elem_size;
 511         unsigned int i;
 512
 513         switch ((u32)ctrl->type) {
 514         case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
 515                 p_mpeg2_sequence = p;
 516
 517                 switch (p_mpeg2_sequence->chroma_format) {
 518                 case 1: /* 4:2:0 */
 519                 case 2: /* 4:2:2 */
 520                 case 3: /* 4:4:4 */
 521                         break;
 522                 default:
 523                         return -EINVAL;
 524                 }
 525                 break;
 526
 527         case V4L2_CTRL_TYPE_MPEG2_PICTURE:
 528                 p_mpeg2_picture = p;
 529
 530                 switch (p_mpeg2_picture->intra_dc_precision) {
 531                 case 0: /* 8 bits */
 532                 case 1: /* 9 bits */
 533                 case 2: /* 10 bits */
 534                 case 3: /* 11 bits */
 535                         break;
 536                 default:
 537                         return -EINVAL;
 538                 }
 539
 540                 switch (p_mpeg2_picture->picture_structure) {
 541                 case V4L2_MPEG2_PIC_TOP_FIELD:
 542                 case V4L2_MPEG2_PIC_BOTTOM_FIELD:
 543                 case V4L2_MPEG2_PIC_FRAME:
 544                         break;
 545                 default:
 546                         return -EINVAL;
 547                 }
 548
 549                 switch (p_mpeg2_picture->picture_coding_type) {
 550                 case V4L2_MPEG2_PIC_CODING_TYPE_I:
 551                 case V4L2_MPEG2_PIC_CODING_TYPE_P:
 552                 case V4L2_MPEG2_PIC_CODING_TYPE_B:
 553                         break;
 554                 default:
 555                         return -EINVAL;
 556                 }
 557                 zero_reserved(*p_mpeg2_picture);
 558                 break;
 559
 560         case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
 561                 break;
 562
 563         case V4L2_CTRL_TYPE_FWHT_PARAMS:
 564                 p_fwht_params = p;
 565                 if (p_fwht_params->version < V4L2_FWHT_VERSION)
 566                         return -EINVAL;
 567                 if (!p_fwht_params->width || !p_fwht_params->height)
 568                         return -EINVAL;
 569                 break;
 570
 571         case V4L2_CTRL_TYPE_H264_SPS:
 572                 p_h264_sps = p;
 573
 574                 /* Some syntax elements are only conditionally valid */
 575                 if (p_h264_sps->pic_order_cnt_type != 0) {
 576                         p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 = 0;
 577                 } else if (p_h264_sps->pic_order_cnt_type != 1) {
 578                         p_h264_sps->num_ref_frames_in_pic_order_cnt_cycle = 0;
 579                         p_h264_sps->offset_for_non_ref_pic = 0;
 580                         p_h264_sps->offset_for_top_to_bottom_field = 0;
 581                         memset(&p_h264_sps->offset_for_ref_frame, 0,
 582                                sizeof(p_h264_sps->offset_for_ref_frame));
 583                 }
 584
 585                 if (!V4L2_H264_SPS_HAS_CHROMA_FORMAT(p_h264_sps)) {
 586                         p_h264_sps->chroma_format_idc = 1;
 587                         p_h264_sps->bit_depth_luma_minus8 = 0;
 588                         p_h264_sps->bit_depth_chroma_minus8 = 0;
 589
 590                         p_h264_sps->flags &=
 591                                 ~V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS;
 592
 593                         if (p_h264_sps->chroma_format_idc < 3)
 594                                 p_h264_sps->flags &=
 595                                         ~V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE;
 596                 }
 597
 598                 if (p_h264_sps->flags & V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY)
 599                         p_h264_sps->flags &=
 600                                 ~V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD;
 601
 602                 /*
 603                  * Chroma 4:2:2 format require at least High 4:2:2 profile.
 604                  *
 605                  * The H264 specification and well-known parser implementations
 606                  * use profile-idc values directly, as that is clearer and
 607                  * less ambiguous. We do the same here.
 608                  */
 609                 if (p_h264_sps->profile_idc < 122 &&
 610                     p_h264_sps->chroma_format_idc > 1)
 611                         return -EINVAL;
 612                 /* Chroma 4:4:4 format require at least High 4:2:2 profile */
 613                 if (p_h264_sps->profile_idc < 244 &&
 614                     p_h264_sps->chroma_format_idc > 2)
 615                         return -EINVAL;
 616                 if (p_h264_sps->chroma_format_idc > 3)
 617                         return -EINVAL;
 618
 619                 if (p_h264_sps->bit_depth_luma_minus8 > 6)
 620                         return -EINVAL;
 621                 if (p_h264_sps->bit_depth_chroma_minus8 > 6)
 622                         return -EINVAL;
 623                 if (p_h264_sps->log2_max_frame_num_minus4 > 12)
 624                         return -EINVAL;
 625                 if (p_h264_sps->pic_order_cnt_type > 2)
 626                         return -EINVAL;
 627                 if (p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 > 12)
 628                         return -EINVAL;
 629                 if (p_h264_sps->max_num_ref_frames > V4L2_H264_REF_LIST_LEN)
 630                         return -EINVAL;
 631                 break;
 632
 633         case V4L2_CTRL_TYPE_H264_PPS:
 634                 p_h264_pps = p;
 635
 636                 if (p_h264_pps->num_slice_groups_minus1 > 7)
 637                         return -EINVAL;
 638                 if (p_h264_pps->num_ref_idx_l0_default_active_minus1 >
 639                     (V4L2_H264_REF_LIST_LEN - 1))
 640                         return -EINVAL;
 641                 if (p_h264_pps->num_ref_idx_l1_default_active_minus1 >
 642                     (V4L2_H264_REF_LIST_LEN - 1))
 643                         return -EINVAL;
 644                 if (p_h264_pps->weighted_bipred_idc > 2)
 645                         return -EINVAL;
 646                 /*
 647                  * pic_init_qp_minus26 shall be in the range of
 648                  * -(26 + QpBdOffset_y) to +25, inclusive,
 649                  *  where QpBdOffset_y is 6 * bit_depth_luma_minus8
 650                  */
 651                 if (p_h264_pps->pic_init_qp_minus26 < -62 ||
 652                     p_h264_pps->pic_init_qp_minus26 > 25)
 653                         return -EINVAL;
 654                 if (p_h264_pps->pic_init_qs_minus26 < -26 ||
 655                     p_h264_pps->pic_init_qs_minus26 > 25)
 656                         return -EINVAL;
 657                 if (p_h264_pps->chroma_qp_index_offset < -12 ||
 658                     p_h264_pps->chroma_qp_index_offset > 12)
 659                         return -EINVAL;
 660                 if (p_h264_pps->second_chroma_qp_index_offset < -12 ||
 661                     p_h264_pps->second_chroma_qp_index_offset > 12)
 662                         return -EINVAL;
 663                 break;
 664
 665         case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
 666                 break;
 667
 668         case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
 669                 p_h264_pred_weights = p;
 670
 671                 if (p_h264_pred_weights->luma_log2_weight_denom > 7)
 672                         return -EINVAL;
 673                 if (p_h264_pred_weights->chroma_log2_weight_denom > 7)
 674                         return -EINVAL;
 675                 break;
 676
 677         case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
 678                 p_h264_slice_params = p;
 679
 680                 if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
 681                         p_h264_slice_params->flags &=
 682                                 ~V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED;
 683
 684                 if (p_h264_slice_params->colour_plane_id > 2)
 685                         return -EINVAL;
 686                 if (p_h264_slice_params->cabac_init_idc > 2)
 687                         return -EINVAL;
 688                 if (p_h264_slice_params->disable_deblocking_filter_idc > 2)
 689                         return -EINVAL;
 690                 if (p_h264_slice_params->slice_alpha_c0_offset_div2 < -6 ||
 691                     p_h264_slice_params->slice_alpha_c0_offset_div2 > 6)
 692                         return -EINVAL;
 693                 if (p_h264_slice_params->slice_beta_offset_div2 < -6 ||
 694                     p_h264_slice_params->slice_beta_offset_div2 > 6)
 695                         return -EINVAL;
 696
 697                 if (p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_I ||
 698                     p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_SI)
 699                         p_h264_slice_params->num_ref_idx_l0_active_minus1 = 0;
 700                 if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
 701                         p_h264_slice_params->num_ref_idx_l1_active_minus1 = 0;
 702
 703                 if (p_h264_slice_params->num_ref_idx_l0_active_minus1 >
 704                     (V4L2_H264_REF_LIST_LEN - 1))
 705                         return -EINVAL;
 706                 if (p_h264_slice_params->num_ref_idx_l1_active_minus1 >
 707                     (V4L2_H264_REF_LIST_LEN - 1))
 708                         return -EINVAL;
 709                 zero_reserved(*p_h264_slice_params);
 710                 break;
 711
 712         case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
 713                 p_h264_dec_params = p;
 714
 715                 if (p_h264_dec_params->nal_ref_idc > 3)
 716                         return -EINVAL;
 717                 for (i = 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) {
 718                         struct v4l2_h264_dpb_entry *dpb_entry =
 719                                 &p_h264_dec_params->dpb[i];
 720
 721                         zero_reserved(*dpb_entry);
 722                 }
 723                 zero_reserved(*p_h264_dec_params);
 724                 break;
 725
 726         case V4L2_CTRL_TYPE_VP8_FRAME:
 727                 p_vp8_frame = p;
 728
 729                 switch (p_vp8_frame->num_dct_parts) {
 730                 case 1:
 731                 case 2:
 732                 case 4:
 733                 case 8:
 734                         break;
 735                 default:
 736                         return -EINVAL;
 737                 }
 738                 zero_padding(p_vp8_frame->segment);
 739                 zero_padding(p_vp8_frame->lf);
 740                 zero_padding(p_vp8_frame->quant);
 741                 zero_padding(p_vp8_frame->entropy);
 742                 zero_padding(p_vp8_frame->coder_state);
 743                 break;
 744
 745         case V4L2_CTRL_TYPE_HEVC_SPS:
 746                 p_hevc_sps = p;
 747
 748                 if (!(p_hevc_sps->flags & V4L2_HEVC_SPS_FLAG_PCM_ENABLED)) {
 749                         p_hevc_sps->pcm_sample_bit_depth_luma_minus1 = 0;
 750                         p_hevc_sps->pcm_sample_bit_depth_chroma_minus1 = 0;
 751                         p_hevc_sps->log2_min_pcm_luma_coding_block_size_minus3 = 0;
 752                         p_hevc_sps->log2_diff_max_min_pcm_luma_coding_block_size = 0;
 753                 }
 754
 755                 if (!(p_hevc_sps->flags &
 756                       V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT))
 757                         p_hevc_sps->num_long_term_ref_pics_sps = 0;
 758                 break;
 759
 760         case V4L2_CTRL_TYPE_HEVC_PPS:
 761                 p_hevc_pps = p;
 762
 763                 if (!(p_hevc_pps->flags &
 764                       V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED))
 765                         p_hevc_pps->diff_cu_qp_delta_depth = 0;
 766
 767                 if (!(p_hevc_pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED)) {
 768                         p_hevc_pps->num_tile_columns_minus1 = 0;
 769                         p_hevc_pps->num_tile_rows_minus1 = 0;
 770                         memset(&p_hevc_pps->column_width_minus1, 0,
 771                                sizeof(p_hevc_pps->column_width_minus1));
 772                         memset(&p_hevc_pps->row_height_minus1, 0,
 773                                sizeof(p_hevc_pps->row_height_minus1));
 774
 775                         p_hevc_pps->flags &=
 776                                 ~V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED;
 777                 }
 778
 779                 if (p_hevc_pps->flags &
 780                     V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER) {
 781                         p_hevc_pps->pps_beta_offset_div2 = 0;
 782                         p_hevc_pps->pps_tc_offset_div2 = 0;
 783                 }
 784
 785                 zero_padding(*p_hevc_pps);
 786                 break;
 787
 788         case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
 789                 p_hevc_decode_params = p;
 790
 791                 if (p_hevc_decode_params->num_active_dpb_entries >
 792                     V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
 793                         return -EINVAL;
 794
 795                 for (i = 0; i < p_hevc_decode_params->num_active_dpb_entries;
 796                      i++) {
 797                         struct v4l2_hevc_dpb_entry *dpb_entry =
 798                                 &p_hevc_decode_params->dpb[i];
 799
 800                         zero_padding(*dpb_entry);
 801                 }
 802                 break;
 803
 804         case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
 805                 p_hevc_slice_params = p;
 806
 807                 zero_padding(p_hevc_slice_params->pred_weight_table);
 808                 zero_padding(*p_hevc_slice_params);
 809                 break;
 810
 811         case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
 812                 break;
 813
 814         case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
 815                 p_hdr10_mastering = p;
 816
 817                 for (i = 0; i < 3; ++i) {
 818                         if (p_hdr10_mastering->display_primaries_x[i] <
 819                                 V4L2_HDR10_MASTERING_PRIMARIES_X_LOW ||
 820                             p_hdr10_mastering->display_primaries_x[i] >
 821                                 V4L2_HDR10_MASTERING_PRIMARIES_X_HIGH ||
 822                             p_hdr10_mastering->display_primaries_y[i] <
 823                                 V4L2_HDR10_MASTERING_PRIMARIES_Y_LOW ||
 824                             p_hdr10_mastering->display_primaries_y[i] >
 825                                 V4L2_HDR10_MASTERING_PRIMARIES_Y_HIGH)
 826                                 return -EINVAL;
 827                 }
 828
 829                 if (p_hdr10_mastering->white_point_x <
 830                         V4L2_HDR10_MASTERING_WHITE_POINT_X_LOW ||
 831                     p_hdr10_mastering->white_point_x >
 832                         V4L2_HDR10_MASTERING_WHITE_POINT_X_HIGH ||
 833                     p_hdr10_mastering->white_point_y <
 834                         V4L2_HDR10_MASTERING_WHITE_POINT_Y_LOW ||
 835                     p_hdr10_mastering->white_point_y >
 836                         V4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGH)
 837                         return -EINVAL;
 838
 839                 if (p_hdr10_mastering->max_display_mastering_luminance <
 840                         V4L2_HDR10_MASTERING_MAX_LUMA_LOW ||
 841                     p_hdr10_mastering->max_display_mastering_luminance >
 842                         V4L2_HDR10_MASTERING_MAX_LUMA_HIGH ||
 843                     p_hdr10_mastering->min_display_mastering_luminance <
 844                         V4L2_HDR10_MASTERING_MIN_LUMA_LOW ||
 845                     p_hdr10_mastering->min_display_mastering_luminance >
 846                         V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
 847                         return -EINVAL;
 848
 849                 /* The following restriction comes from ITU-T Rec. H.265 spec */
 850                 if (p_hdr10_mastering->max_display_mastering_luminance ==
 851                         V4L2_HDR10_MASTERING_MAX_LUMA_LOW &&
 852                     p_hdr10_mastering->min_display_mastering_luminance ==
 853                         V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
 854                         return -EINVAL;
 855
 856                 break;
 857
 858         case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
 859                 break;
 860
 861         case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
 862                 return validate_vp9_compressed_hdr(p);
 863
 864         case V4L2_CTRL_TYPE_VP9_FRAME:
 865                 return validate_vp9_frame(p);
 866
 867         case V4L2_CTRL_TYPE_AREA:
 868                 area = p;
 869                 if (!area->width || !area->height)
 870                         return -EINVAL;
 871                 break;
 872
 873         default:
 874                 return -EINVAL;
 875         }
 876
 877         return 0;
 878 }
 879
 880 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
 881                         union v4l2_ctrl_ptr ptr)
 882 {
 883         size_t len;
 884         u64 offset;
 885         s64 val;
 886
 887         switch ((u32)ctrl->type) {
 888         case V4L2_CTRL_TYPE_INTEGER:
 889                 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
 890         case V4L2_CTRL_TYPE_INTEGER64:
 891                 /*
 892                  * We can't use the ROUND_TO_RANGE define here due to
 893                  * the u64 divide that needs special care.
 894                  */
 895                 val = ptr.p_s64[idx];
 896                 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
 897                         val = ctrl->maximum;
 898                 else
 899                         val += (s64)(ctrl->step / 2);
 900                 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
 901                 offset = val - ctrl->minimum;
 902                 do_div(offset, ctrl->step);
 903                 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
 904                 return 0;
 905         case V4L2_CTRL_TYPE_U8:
 906                 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
 907         case V4L2_CTRL_TYPE_U16:
 908                 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
 909         case V4L2_CTRL_TYPE_U32:
 910                 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
 911
 912         case V4L2_CTRL_TYPE_BOOLEAN:
 913                 ptr.p_s32[idx] = !!ptr.p_s32[idx];
 914                 return 0;
 915
 916         case V4L2_CTRL_TYPE_MENU:
 917         case V4L2_CTRL_TYPE_INTEGER_MENU:
 918                 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
 919                         return -ERANGE;
 920                 if (ptr.p_s32[idx] < BITS_PER_LONG_LONG &&
 921                     (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx])))
 922                         return -EINVAL;
 923                 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
 924                     ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
 925                         return -EINVAL;
 926                 return 0;
 927
 928         case V4L2_CTRL_TYPE_BITMASK:
 929                 ptr.p_s32[idx] &= ctrl->maximum;
 930                 return 0;
 931
 932         case V4L2_CTRL_TYPE_BUTTON:
 933         case V4L2_CTRL_TYPE_CTRL_CLASS:
 934                 ptr.p_s32[idx] = 0;
 935                 return 0;
 936
 937         case V4L2_CTRL_TYPE_STRING:
 938                 idx *= ctrl->elem_size;
 939                 len = strlen(ptr.p_char + idx);
 940                 if (len < ctrl->minimum)
 941                         return -ERANGE;
 942                 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
 943                         return -ERANGE;
 944                 return 0;
 945
 946         default:
 947                 return std_validate_compound(ctrl, idx, ptr);
 948         }
 949 }
 950
 951 static const struct v4l2_ctrl_type_ops std_type_ops = {
 952         .equal = std_equal,
 953         .init = std_init,
 954         .log = std_log,
 955         .validate = std_validate,
 956 };
 957
 958 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
 959 {
 960         if (!ctrl)
 961                 return;
 962         if (!notify) {
 963                 ctrl->call_notify = 0;
 964                 return;
 965         }
 966         if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
 967                 return;
 968         ctrl->handler->notify = notify;
 969         ctrl->handler->notify_priv = priv;
 970         ctrl->call_notify = 1;
 971 }
 972 EXPORT_SYMBOL(v4l2_ctrl_notify);
 973
 974 /* Copy the one value to another. */
 975 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
 976                        union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
 977 {
 978         if (ctrl == NULL)
 979                 return;
 980         memcpy(to.p, from.p_const, ctrl->elems * ctrl->elem_size);
 981 }
 982
 983 /* Copy the new value to the current value. */
 984 void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
 985 {
 986         bool changed;
 987
 988         if (ctrl == NULL)
 989                 return;
 990
 991         /* has_changed is set by cluster_changed */
 992         changed = ctrl->has_changed;
 993         if (changed)
 994                 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
 995
 996         if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
 997                 /* Note: CH_FLAGS is only set for auto clusters. */
 998                 ctrl->flags &=
 999                         ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1000                 if (!is_cur_manual(ctrl->cluster[0])) {
1001                         ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1002                         if (ctrl->cluster[0]->has_volatiles)
1003                                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1004                 }
1005                 fh = NULL;
1006         }
1007         if (changed || ch_flags) {
1008                 /* If a control was changed that was not one of the controls
1009                    modified by the application, then send the event to all. */
1010                 if (!ctrl->is_new)
1011                         fh = NULL;
1012                 send_event(fh, ctrl,
1013                         (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1014                 if (ctrl->call_notify && changed && ctrl->handler->notify)
1015                         ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1016         }
1017 }
1018
1019 /* Copy the current value to the new value */
1020 void cur_to_new(struct v4l2_ctrl *ctrl)
1021 {
1022         if (ctrl == NULL)
1023                 return;
1024         ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1025 }
1026
1027 /* Copy the new value to the request value */
1028 void new_to_req(struct v4l2_ctrl_ref *ref)
1029 {
1030         if (!ref)
1031                 return;
1032         ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req);
1033         ref->valid_p_req = true;
1034 }
1035
1036 /* Copy the current value to the request value */
1037 void cur_to_req(struct v4l2_ctrl_ref *ref)
1038 {
1039         if (!ref)
1040                 return;
1041         ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->p_req);
1042         ref->valid_p_req = true;
1043 }
1044
1045 /* Copy the request value to the new value */
1046 void req_to_new(struct v4l2_ctrl_ref *ref)
1047 {
1048         if (!ref)
1049                 return;
1050         if (ref->valid_p_req)
1051                 ptr_to_ptr(ref->ctrl, ref->p_req, ref->ctrl->p_new);
1052         else
1053                 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new);
1054 }
1055
1056 /* Control range checking */
1057 int check_range(enum v4l2_ctrl_type type,
1058                 s64 min, s64 max, u64 step, s64 def)
1059 {
1060         switch (type) {
1061         case V4L2_CTRL_TYPE_BOOLEAN:
1062                 if (step != 1 || max > 1 || min < 0)
1063                         return -ERANGE;
1064                 fallthrough;
1065         case V4L2_CTRL_TYPE_U8:
1066         case V4L2_CTRL_TYPE_U16:
1067         case V4L2_CTRL_TYPE_U32:
1068         case V4L2_CTRL_TYPE_INTEGER:
1069         case V4L2_CTRL_TYPE_INTEGER64:
1070                 if (step == 0 || min > max || def < min || def > max)
1071                         return -ERANGE;
1072                 return 0;
1073         case V4L2_CTRL_TYPE_BITMASK:
1074                 if (step || min || !max || (def & ~max))
1075                         return -ERANGE;
1076                 return 0;
1077         case V4L2_CTRL_TYPE_MENU:
1078         case V4L2_CTRL_TYPE_INTEGER_MENU:
1079                 if (min > max || def < min || def > max)
1080                         return -ERANGE;
1081                 /* Note: step == menu_skip_mask for menu controls.
1082                    So here we check if the default value is masked out. */
1083                 if (step && ((1 << def) & step))
1084                         return -EINVAL;
1085                 return 0;
1086         case V4L2_CTRL_TYPE_STRING:
1087                 if (min > max || min < 0 || step < 1 || def)
1088                         return -ERANGE;
1089                 return 0;
1090         default:
1091                 return 0;
1092         }
1093 }
1094
1095 /* Validate a new control */
1096 int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
1097 {
1098         unsigned idx;
1099         int err = 0;
1100
1101         for (idx = 0; !err && idx < ctrl->elems; idx++)
1102                 err = ctrl->type_ops->validate(ctrl, idx, p_new);
1103         return err;
1104 }
1105
1106 /* Set the handler's error code if it wasn't set earlier already */
1107 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1108 {
1109         if (hdl->error == 0)
1110                 hdl->error = err;
1111         return err;
1112 }
1113
1114 /* Initialize the handler */
1115 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1116                                  unsigned nr_of_controls_hint,
1117                                  struct lock_class_key *key, const char *name)
1118 {
1119         mutex_init(&hdl->_lock);
1120         hdl->lock = &hdl->_lock;
1121         lockdep_set_class_and_name(hdl->lock, key, name);
1122         INIT_LIST_HEAD(&hdl->ctrls);
1123         INIT_LIST_HEAD(&hdl->ctrl_refs);
1124         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1125         hdl->buckets = kvmalloc_array(hdl->nr_of_buckets,
1126                                       sizeof(hdl->buckets[0]),
1127                                       GFP_KERNEL | __GFP_ZERO);
1128         hdl->error = hdl->buckets ? 0 : -ENOMEM;
1129         v4l2_ctrl_handler_init_request(hdl);
1130         return hdl->error;
1131 }
1132 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1133
1134 /* Free all controls and control refs */
1135 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1136 {
1137         struct v4l2_ctrl_ref *ref, *next_ref;
1138         struct v4l2_ctrl *ctrl, *next_ctrl;
1139         struct v4l2_subscribed_event *sev, *next_sev;
1140
1141         if (hdl == NULL || hdl->buckets == NULL)
1142                 return;
1143
1144         v4l2_ctrl_handler_free_request(hdl);
1145
1146         mutex_lock(hdl->lock);
1147         /* Free all nodes */
1148         list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1149                 list_del(&ref->node);
1150                 kfree(ref);
1151         }
1152         /* Free all controls owned by the handler */
1153         list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1154                 list_del(&ctrl->node);
1155                 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1156                         list_del(&sev->node);
1157                 kvfree(ctrl);
1158         }
1159         kvfree(hdl->buckets);
1160         hdl->buckets = NULL;
1161         hdl->cached = NULL;
1162         hdl->error = 0;
1163         mutex_unlock(hdl->lock);
1164         mutex_destroy(&hdl->_lock);
1165 }
1166 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1167
1168 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1169    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1170    with applications that do not use the NEXT_CTRL flag.
1171
1172    We just find the n-th private user control. It's O(N), but that should not
1173    be an issue in this particular case. */
1174 static struct v4l2_ctrl_ref *find_private_ref(
1175                 struct v4l2_ctrl_handler *hdl, u32 id)
1176 {
1177         struct v4l2_ctrl_ref *ref;
1178
1179         id -= V4L2_CID_PRIVATE_BASE;
1180         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1181                 /* Search for private user controls that are compatible with
1182                    VIDIOC_G/S_CTRL. */
1183                 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1184                     V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1185                         if (!ref->ctrl->is_int)
1186                                 continue;
1187                         if (id == 0)
1188                                 return ref;
1189                         id--;
1190                 }
1191         }
1192         return NULL;
1193 }
1194
1195 /* Find a control with the given ID. */
1196 struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1197 {
1198         struct v4l2_ctrl_ref *ref;
1199         int bucket;
1200
1201         id &= V4L2_CTRL_ID_MASK;
1202
1203         /* Old-style private controls need special handling */
1204         if (id >= V4L2_CID_PRIVATE_BASE)
1205                 return find_private_ref(hdl, id);
1206         bucket = id % hdl->nr_of_buckets;
1207
1208         /* Simple optimization: cache the last control found */
1209         if (hdl->cached && hdl->cached->ctrl->id == id)
1210                 return hdl->cached;
1211
1212         /* Not in cache, search the hash */
1213         ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1214         while (ref && ref->ctrl->id != id)
1215                 ref = ref->next;
1216
1217         if (ref)
1218                 hdl->cached = ref; /* cache it! */
1219         return ref;
1220 }
1221
1222 /* Find a control with the given ID. Take the handler's lock first. */
1223 struct v4l2_ctrl_ref *find_ref_lock(struct v4l2_ctrl_handler *hdl, u32 id)
1224 {
1225         struct v4l2_ctrl_ref *ref = NULL;
1226
1227         if (hdl) {
1228                 mutex_lock(hdl->lock);
1229                 ref = find_ref(hdl, id);
1230                 mutex_unlock(hdl->lock);
1231         }
1232         return ref;
1233 }
1234
1235 /* Find a control with the given ID. */
1236 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1237 {
1238         struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1239
1240         return ref ? ref->ctrl : NULL;
1241 }
1242 EXPORT_SYMBOL(v4l2_ctrl_find);
1243
1244 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1245 int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1246                     struct v4l2_ctrl *ctrl,
1247                     struct v4l2_ctrl_ref **ctrl_ref,
1248                     bool from_other_dev, bool allocate_req)
1249 {
1250         struct v4l2_ctrl_ref *ref;
1251         struct v4l2_ctrl_ref *new_ref;
1252         u32 id = ctrl->id;
1253         u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
1254         int bucket = id % hdl->nr_of_buckets;   /* which bucket to use */
1255         unsigned int size_extra_req = 0;
1256
1257         if (ctrl_ref)
1258                 *ctrl_ref = NULL;
1259
1260         /*
1261          * Automatically add the control class if it is not yet present and
1262          * the new control is not a compound control.
1263          */
1264         if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
1265             id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1266                 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1267                         return hdl->error;
1268
1269         if (hdl->error)
1270                 return hdl->error;
1271
1272         if (allocate_req)
1273                 size_extra_req = ctrl->elems * ctrl->elem_size;
1274         new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL);
1275         if (!new_ref)
1276                 return handler_set_err(hdl, -ENOMEM);
1277         new_ref->ctrl = ctrl;
1278         new_ref->from_other_dev = from_other_dev;
1279         if (size_extra_req)
1280                 new_ref->p_req.p = &new_ref[1];
1281
1282         INIT_LIST_HEAD(&new_ref->node);
1283
1284         mutex_lock(hdl->lock);
1285
1286         /* Add immediately at the end of the list if the list is empty, or if
1287            the last element in the list has a lower ID.
1288            This ensures that when elements are added in ascending order the
1289            insertion is an O(1) operation. */
1290         if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1291                 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1292                 goto insert_in_hash;
1293         }
1294
1295         /* Find insert position in sorted list */
1296         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1297                 if (ref->ctrl->id < id)
1298                         continue;
1299                 /* Don't add duplicates */
1300                 if (ref->ctrl->id == id) {
1301                         kfree(new_ref);
1302                         goto unlock;
1303                 }
1304                 list_add(&new_ref->node, ref->node.prev);
1305                 break;
1306         }
1307
1308 insert_in_hash:
1309         /* Insert the control node in the hash */
1310         new_ref->next = hdl->buckets[bucket];
1311         hdl->buckets[bucket] = new_ref;
1312         if (ctrl_ref)
1313                 *ctrl_ref = new_ref;
1314         if (ctrl->handler == hdl) {
1315                 /* By default each control starts in a cluster of its own.
1316                  * new_ref->ctrl is basically a cluster array with one
1317                  * element, so that's perfect to use as the cluster pointer.
1318                  * But only do this for the handler that owns the control.
1319                  */
1320                 ctrl->cluster = &new_ref->ctrl;
1321                 ctrl->ncontrols = 1;
1322         }
1323
1324 unlock:
1325         mutex_unlock(hdl->lock);
1326         return 0;
1327 }
1328
1329 /* Add a new control */
1330 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1331                         const struct v4l2_ctrl_ops *ops,
1332                         const struct v4l2_ctrl_type_ops *type_ops,
1333                         u32 id, const char *name, enum v4l2_ctrl_type type,
1334                         s64 min, s64 max, u64 step, s64 def,
1335                         const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
1336                         u32 flags, const char * const *qmenu,
1337                         const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def,
1338                         void *priv)
1339 {
1340         struct v4l2_ctrl *ctrl;
1341         unsigned sz_extra;
1342         unsigned nr_of_dims = 0;
1343         unsigned elems = 1;
1344         bool is_array;
1345         unsigned tot_ctrl_size;
1346         unsigned idx;
1347         void *data;
1348         int err;
1349
1350         if (hdl->error)
1351                 return NULL;
1352
1353         while (dims && dims[nr_of_dims]) {
1354                 elems *= dims[nr_of_dims];
1355                 nr_of_dims++;
1356                 if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
1357                         break;
1358         }
1359         is_array = nr_of_dims > 0;
1360
1361         /* Prefill elem_size for all types handled by std_type_ops */
1362         switch ((u32)type) {
1363         case V4L2_CTRL_TYPE_INTEGER64:
1364                 elem_size = sizeof(s64);
1365                 break;
1366         case V4L2_CTRL_TYPE_STRING:
1367                 elem_size = max + 1;
1368                 break;
1369         case V4L2_CTRL_TYPE_U8:
1370                 elem_size = sizeof(u8);
1371                 break;
1372         case V4L2_CTRL_TYPE_U16:
1373                 elem_size = sizeof(u16);
1374                 break;
1375         case V4L2_CTRL_TYPE_U32:
1376                 elem_size = sizeof(u32);
1377                 break;
1378         case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
1379                 elem_size = sizeof(struct v4l2_ctrl_mpeg2_sequence);
1380                 break;
1381         case V4L2_CTRL_TYPE_MPEG2_PICTURE:
1382                 elem_size = sizeof(struct v4l2_ctrl_mpeg2_picture);
1383                 break;
1384         case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
1385                 elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantisation);
1386                 break;
1387         case V4L2_CTRL_TYPE_FWHT_PARAMS:
1388                 elem_size = sizeof(struct v4l2_ctrl_fwht_params);
1389                 break;
1390         case V4L2_CTRL_TYPE_H264_SPS:
1391                 elem_size = sizeof(struct v4l2_ctrl_h264_sps);
1392                 break;
1393         case V4L2_CTRL_TYPE_H264_PPS:
1394                 elem_size = sizeof(struct v4l2_ctrl_h264_pps);
1395                 break;
1396         case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
1397                 elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix);
1398                 break;
1399         case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
1400                 elem_size = sizeof(struct v4l2_ctrl_h264_slice_params);
1401                 break;
1402         case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
1403                 elem_size = sizeof(struct v4l2_ctrl_h264_decode_params);
1404                 break;
1405         case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
1406                 elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights);
1407                 break;
1408         case V4L2_CTRL_TYPE_VP8_FRAME:
1409                 elem_size = sizeof(struct v4l2_ctrl_vp8_frame);
1410                 break;
1411         case V4L2_CTRL_TYPE_HEVC_SPS:
1412                 elem_size = sizeof(struct v4l2_ctrl_hevc_sps);
1413                 break;
1414         case V4L2_CTRL_TYPE_HEVC_PPS:
1415                 elem_size = sizeof(struct v4l2_ctrl_hevc_pps);
1416                 break;
1417         case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
1418                 elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params);
1419                 break;
1420         case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
1421                 elem_size = sizeof(struct v4l2_ctrl_hevc_scaling_matrix);
1422                 break;
1423         case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
1424                 elem_size = sizeof(struct v4l2_ctrl_hevc_decode_params);
1425                 break;
1426         case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
1427                 elem_size = sizeof(struct v4l2_ctrl_hdr10_cll_info);
1428                 break;
1429         case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
1430                 elem_size = sizeof(struct v4l2_ctrl_hdr10_mastering_display);
1431                 break;
1432         case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
1433                 elem_size = sizeof(struct v4l2_ctrl_vp9_compressed_hdr);
1434                 break;
1435         case V4L2_CTRL_TYPE_VP9_FRAME:
1436                 elem_size = sizeof(struct v4l2_ctrl_vp9_frame);
1437                 break;
1438         case V4L2_CTRL_TYPE_AREA:
1439                 elem_size = sizeof(struct v4l2_area);
1440                 break;
1441         default:
1442                 if (type < V4L2_CTRL_COMPOUND_TYPES)
1443                         elem_size = sizeof(s32);
1444                 break;
1445         }
1446         tot_ctrl_size = elem_size * elems;
1447
1448         /* Sanity checks */
1449         if (id == 0 || name == NULL || !elem_size ||
1450             id >= V4L2_CID_PRIVATE_BASE ||
1451             (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1452             (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1453                 handler_set_err(hdl, -ERANGE);
1454                 return NULL;
1455         }
1456         err = check_range(type, min, max, step, def);
1457         if (err) {
1458                 handler_set_err(hdl, err);
1459                 return NULL;
1460         }
1461         if (is_array &&
1462             (type == V4L2_CTRL_TYPE_BUTTON ||
1463              type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
1464                 handler_set_err(hdl, -EINVAL);
1465                 return NULL;
1466         }
1467
1468         sz_extra = 0;
1469         if (type == V4L2_CTRL_TYPE_BUTTON)
1470                 flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1471                         V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1472         else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1473                 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1474         else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
1475                  type == V4L2_CTRL_TYPE_STRING ||
1476                  type >= V4L2_CTRL_COMPOUND_TYPES ||
1477                  is_array)
1478                 sz_extra += 2 * tot_ctrl_size;
1479
1480         if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
1481                 sz_extra += elem_size;
1482
1483         ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1484         if (ctrl == NULL) {
1485                 handler_set_err(hdl, -ENOMEM);
1486                 return NULL;
1487         }
1488
1489         INIT_LIST_HEAD(&ctrl->node);
1490         INIT_LIST_HEAD(&ctrl->ev_subs);
1491         ctrl->handler = hdl;
1492         ctrl->ops = ops;
1493         ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
1494         ctrl->id = id;
1495         ctrl->name = name;
1496         ctrl->type = type;
1497         ctrl->flags = flags;
1498         ctrl->minimum = min;
1499         ctrl->maximum = max;
1500         ctrl->step = step;
1501         ctrl->default_value = def;
1502         ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
1503         ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
1504         ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
1505         ctrl->is_array = is_array;
1506         ctrl->elems = elems;
1507         ctrl->nr_of_dims = nr_of_dims;
1508         if (nr_of_dims)
1509                 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
1510         ctrl->elem_size = elem_size;
1511         if (type == V4L2_CTRL_TYPE_MENU)
1512                 ctrl->qmenu = qmenu;
1513         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1514                 ctrl->qmenu_int = qmenu_int;
1515         ctrl->priv = priv;
1516         ctrl->cur.val = ctrl->val = def;
1517         data = &ctrl[1];
1518
1519         if (!ctrl->is_int) {
1520                 ctrl->p_new.p = data;
1521                 ctrl->p_cur.p = data + tot_ctrl_size;
1522         } else {
1523                 ctrl->p_new.p = &ctrl->val;
1524                 ctrl->p_cur.p = &ctrl->cur.val;
1525         }
1526
1527         if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) {
1528                 ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
1529                 memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
1530         }
1531
1532         for (idx = 0; idx < elems; idx++) {
1533                 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
1534                 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
1535         }
1536
1537         if (handler_new_ref(hdl, ctrl, NULL, false, false)) {
1538                 kvfree(ctrl);
1539                 return NULL;
1540         }
1541         mutex_lock(hdl->lock);
1542         list_add_tail(&ctrl->node, &hdl->ctrls);
1543         mutex_unlock(hdl->lock);
1544         return ctrl;
1545 }
1546
1547 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1548                         const struct v4l2_ctrl_config *cfg, void *priv)
1549 {
1550         bool is_menu;
1551         struct v4l2_ctrl *ctrl;
1552         const char *name = cfg->name;
1553         const char * const *qmenu = cfg->qmenu;
1554         const s64 *qmenu_int = cfg->qmenu_int;
1555         enum v4l2_ctrl_type type = cfg->type;
1556         u32 flags = cfg->flags;
1557         s64 min = cfg->min;
1558         s64 max = cfg->max;
1559         u64 step = cfg->step;
1560         s64 def = cfg->def;
1561
1562         if (name == NULL)
1563                 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1564                                                                 &def, &flags);
1565
1566         is_menu = (type == V4L2_CTRL_TYPE_MENU ||
1567                    type == V4L2_CTRL_TYPE_INTEGER_MENU);
1568         if (is_menu)
1569                 WARN_ON(step);
1570         else
1571                 WARN_ON(cfg->menu_skip_mask);
1572         if (type == V4L2_CTRL_TYPE_MENU && !qmenu) {
1573                 qmenu = v4l2_ctrl_get_menu(cfg->id);
1574         } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) {
1575                 handler_set_err(hdl, -EINVAL);
1576                 return NULL;
1577         }
1578
1579         ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
1580                         type, min, max,
1581                         is_menu ? cfg->menu_skip_mask : step, def,
1582                         cfg->dims, cfg->elem_size,
1583                         flags, qmenu, qmenu_int, cfg->p_def, priv);
1584         if (ctrl)
1585                 ctrl->is_private = cfg->is_private;
1586         return ctrl;
1587 }
1588 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1589
1590 /* Helper function for standard non-menu controls */
1591 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1592                         const struct v4l2_ctrl_ops *ops,
1593                         u32 id, s64 min, s64 max, u64 step, s64 def)
1594 {
1595         const char *name;
1596         enum v4l2_ctrl_type type;
1597         u32 flags;
1598
1599         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1600         if (type == V4L2_CTRL_TYPE_MENU ||
1601             type == V4L2_CTRL_TYPE_INTEGER_MENU ||
1602             type >= V4L2_CTRL_COMPOUND_TYPES) {
1603                 handler_set_err(hdl, -EINVAL);
1604                 return NULL;
1605         }
1606         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1607                              min, max, step, def, NULL, 0,
1608                              flags, NULL, NULL, ptr_null, NULL);
1609 }
1610 EXPORT_SYMBOL(v4l2_ctrl_new_std);
1611
1612 /* Helper function for standard menu controls */
1613 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1614                         const struct v4l2_ctrl_ops *ops,
1615                         u32 id, u8 _max, u64 mask, u8 _def)
1616 {
1617         const char * const *qmenu = NULL;
1618         const s64 *qmenu_int = NULL;
1619         unsigned int qmenu_int_len = 0;
1620         const char *name;
1621         enum v4l2_ctrl_type type;
1622         s64 min;
1623         s64 max = _max;
1624         s64 def = _def;
1625         u64 step;
1626         u32 flags;
1627
1628         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1629
1630         if (type == V4L2_CTRL_TYPE_MENU)
1631                 qmenu = v4l2_ctrl_get_menu(id);
1632         else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1633                 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
1634
1635         if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
1636                 handler_set_err(hdl, -EINVAL);
1637                 return NULL;
1638         }
1639         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1640                              0, max, mask, def, NULL, 0,
1641                              flags, qmenu, qmenu_int, ptr_null, NULL);
1642 }
1643 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1644
1645 /* Helper function for standard menu controls with driver defined menu */
1646 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
1647                         const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
1648                         u64 mask, u8 _def, const char * const *qmenu)
1649 {
1650         enum v4l2_ctrl_type type;
1651         const char *name;
1652         u32 flags;
1653         u64 step;
1654         s64 min;
1655         s64 max = _max;
1656         s64 def = _def;
1657
1658         /* v4l2_ctrl_new_std_menu_items() should only be called for
1659          * standard controls without a standard menu.
1660          */
1661         if (v4l2_ctrl_get_menu(id)) {
1662                 handler_set_err(hdl, -EINVAL);
1663                 return NULL;
1664         }
1665
1666         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1667         if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
1668                 handler_set_err(hdl, -EINVAL);
1669                 return NULL;
1670         }
1671         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1672                              0, max, mask, def, NULL, 0,
1673                              flags, qmenu, NULL, ptr_null, NULL);
1674
1675 }
1676 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
1677
1678 /* Helper function for standard compound controls */
1679 struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
1680                                 const struct v4l2_ctrl_ops *ops, u32 id,
1681                                 const union v4l2_ctrl_ptr p_def)
1682 {
1683         const char *name;
1684         enum v4l2_ctrl_type type;
1685         u32 flags;
1686         s64 min, max, step, def;
1687
1688         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1689         if (type < V4L2_CTRL_COMPOUND_TYPES) {
1690                 handler_set_err(hdl, -EINVAL);
1691                 return NULL;
1692         }
1693         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1694                              min, max, step, def, NULL, 0,
1695                              flags, NULL, NULL, p_def, NULL);
1696 }
1697 EXPORT_SYMBOL(v4l2_ctrl_new_std_compound);
1698
1699 /* Helper function for standard integer menu controls */
1700 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
1701                         const struct v4l2_ctrl_ops *ops,
1702                         u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
1703 {
1704         const char *name;
1705         enum v4l2_ctrl_type type;
1706         s64 min;
1707         u64 step;
1708         s64 max = _max;
1709         s64 def = _def;
1710         u32 flags;
1711
1712         v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1713         if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
1714                 handler_set_err(hdl, -EINVAL);
1715                 return NULL;
1716         }
1717         return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1718                              0, max, 0, def, NULL, 0,
1719                              flags, NULL, qmenu_int, ptr_null, NULL);
1720 }
1721 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
1722
1723 /* Add the controls from another handler to our own. */
1724 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1725                           struct v4l2_ctrl_handler *add,
1726                           bool (*filter)(const struct v4l2_ctrl *ctrl),
1727                           bool from_other_dev)
1728 {
1729         struct v4l2_ctrl_ref *ref;
1730         int ret = 0;
1731
1732         /* Do nothing if either handler is NULL or if they are the same */
1733         if (!hdl || !add || hdl == add)
1734                 return 0;
1735         if (hdl->error)
1736                 return hdl->error;
1737         mutex_lock(add->lock);
1738         list_for_each_entry(ref, &add->ctrl_refs, node) {
1739                 struct v4l2_ctrl *ctrl = ref->ctrl;
1740
1741                 /* Skip handler-private controls. */
1742                 if (ctrl->is_private)
1743                         continue;
1744                 /* And control classes */
1745                 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1746                         continue;
1747                 /* Filter any unwanted controls */
1748                 if (filter && !filter(ctrl))
1749                         continue;
1750                 ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false);
1751                 if (ret)
1752                         break;
1753         }
1754         mutex_unlock(add->lock);
1755         return ret;
1756 }
1757 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1758
1759 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
1760 {
1761         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
1762                 return true;
1763         if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
1764                 return true;
1765         switch (ctrl->id) {
1766         case V4L2_CID_AUDIO_MUTE:
1767         case V4L2_CID_AUDIO_VOLUME:
1768         case V4L2_CID_AUDIO_BALANCE:
1769         case V4L2_CID_AUDIO_BASS:
1770         case V4L2_CID_AUDIO_TREBLE:
1771         case V4L2_CID_AUDIO_LOUDNESS:
1772                 return true;
1773         default:
1774                 break;
1775         }
1776         return false;
1777 }
1778 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
1779
1780 /* Cluster controls */
1781 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1782 {
1783         bool has_volatiles = false;
1784         int i;
1785
1786         /* The first control is the master control and it must not be NULL */
1787         if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
1788                 return;
1789
1790         for (i = 0; i < ncontrols; i++) {
1791                 if (controls[i]) {
1792                         controls[i]->cluster = controls;
1793                         controls[i]->ncontrols = ncontrols;
1794                         if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1795                                 has_volatiles = true;
1796                 }
1797         }
1798         controls[0]->has_volatiles = has_volatiles;
1799 }
1800 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1801
1802 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1803                             u8 manual_val, bool set_volatile)
1804 {
1805         struct v4l2_ctrl *master = controls[0];
1806         u32 flag = 0;
1807         int i;
1808
1809         v4l2_ctrl_cluster(ncontrols, controls);
1810         WARN_ON(ncontrols <= 1);
1811         WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1812         WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1813         master->is_auto = true;
1814         master->has_volatiles = set_volatile;
1815         master->manual_mode_value = manual_val;
1816         master->flags |= V4L2_CTRL_FLAG_UPDATE;
1817
1818         if (!is_cur_manual(master))
1819                 flag = V4L2_CTRL_FLAG_INACTIVE |
1820                         (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1821
1822         for (i = 1; i < ncontrols; i++)
1823                 if (controls[i])
1824                         controls[i]->flags |= flag;
1825 }
1826 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1827
1828 /*
1829  * Obtain the current volatile values of an autocluster and mark them
1830  * as new.
1831  */
1832 void update_from_auto_cluster(struct v4l2_ctrl *master)
1833 {
1834         int i;
1835
1836         for (i = 1; i < master->ncontrols; i++)
1837                 cur_to_new(master->cluster[i]);
1838         if (!call_op(master, g_volatile_ctrl))
1839                 for (i = 1; i < master->ncontrols; i++)
1840                         if (master->cluster[i])
1841                                 master->cluster[i]->is_new = 1;
1842 }
1843
1844 /*
1845  * Return non-zero if one or more of the controls in the cluster has a new
1846  * value that differs from the current value.
1847  */
1848 static int cluster_changed(struct v4l2_ctrl *master)
1849 {
1850         bool changed = false;
1851         unsigned int idx;
1852         int i;
1853
1854         for (i = 0; i < master->ncontrols; i++) {
1855                 struct v4l2_ctrl *ctrl = master->cluster[i];
1856                 bool ctrl_changed = false;
1857
1858                 if (!ctrl)
1859                         continue;
1860
1861                 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE) {
1862                         changed = true;
1863                         ctrl_changed = true;
1864                 }
1865
1866                 /*
1867                  * Set has_changed to false to avoid generating
1868                  * the event V4L2_EVENT_CTRL_CH_VALUE
1869                  */
1870                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
1871                         ctrl->has_changed = false;
1872                         continue;
1873                 }
1874
1875                 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1876                         ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1877                                 ctrl->p_cur, ctrl->p_new);
1878                 ctrl->has_changed = ctrl_changed;
1879                 changed |= ctrl->has_changed;
1880         }
1881         return changed;
1882 }
1883
1884 /*
1885  * Core function that calls try/s_ctrl and ensures that the new value is
1886  * copied to the current value on a set.
1887  * Must be called with ctrl->handler->lock held.
1888  */
1889 int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
1890                        bool set, u32 ch_flags)
1891 {
1892         bool update_flag;
1893         int ret;
1894         int i;
1895
1896         /*
1897          * Go through the cluster and either validate the new value or
1898          * (if no new value was set), copy the current value to the new
1899          * value, ensuring a consistent view for the control ops when
1900          * called.
1901          */
1902         for (i = 0; i < master->ncontrols; i++) {
1903                 struct v4l2_ctrl *ctrl = master->cluster[i];
1904
1905                 if (!ctrl)
1906                         continue;
1907
1908                 if (!ctrl->is_new) {
1909                         cur_to_new(ctrl);
1910                         continue;
1911                 }
1912                 /*
1913                  * Check again: it may have changed since the
1914                  * previous check in try_or_set_ext_ctrls().
1915                  */
1916                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
1917                         return -EBUSY;
1918         }
1919
1920         ret = call_op(master, try_ctrl);
1921
1922         /* Don't set if there is no change */
1923         if (ret || !set || !cluster_changed(master))
1924                 return ret;
1925         ret = call_op(master, s_ctrl);
1926         if (ret)
1927                 return ret;
1928
1929         /* If OK, then make the new values permanent. */
1930         update_flag = is_cur_manual(master) != is_new_manual(master);
1931
1932         for (i = 0; i < master->ncontrols; i++) {
1933                 /*
1934                  * If we switch from auto to manual mode, and this cluster
1935                  * contains volatile controls, then all non-master controls
1936                  * have to be marked as changed. The 'new' value contains
1937                  * the volatile value (obtained by update_from_auto_cluster),
1938                  * which now has to become the current value.
1939                  */
1940                 if (i && update_flag && is_new_manual(master) &&
1941                     master->has_volatiles && master->cluster[i])
1942                         master->cluster[i]->has_changed = true;
1943
1944                 new_to_cur(fh, master->cluster[i], ch_flags |
1945                         ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
1946         }
1947         return 0;
1948 }
1949
1950 /* Activate/deactivate a control. */
1951 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1952 {
1953         /* invert since the actual flag is called 'inactive' */
1954         bool inactive = !active;
1955         bool old;
1956
1957         if (ctrl == NULL)
1958                 return;
1959
1960         if (inactive)
1961                 /* set V4L2_CTRL_FLAG_INACTIVE */
1962                 old = test_and_set_bit(4, &ctrl->flags);
1963         else
1964                 /* clear V4L2_CTRL_FLAG_INACTIVE */
1965                 old = test_and_clear_bit(4, &ctrl->flags);
1966         if (old != inactive)
1967                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1968 }
1969 EXPORT_SYMBOL(v4l2_ctrl_activate);
1970
1971 void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1972 {
1973         bool old;
1974
1975         if (ctrl == NULL)
1976                 return;
1977
1978         lockdep_assert_held(ctrl->handler->lock);
1979
1980         if (grabbed)
1981                 /* set V4L2_CTRL_FLAG_GRABBED */
1982                 old = test_and_set_bit(1, &ctrl->flags);
1983         else
1984                 /* clear V4L2_CTRL_FLAG_GRABBED */
1985                 old = test_and_clear_bit(1, &ctrl->flags);
1986         if (old != grabbed)
1987                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1988 }
1989 EXPORT_SYMBOL(__v4l2_ctrl_grab);
1990
1991 /* Call s_ctrl for all controls owned by the handler */
1992 int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
1993 {
1994         struct v4l2_ctrl *ctrl;
1995         int ret = 0;
1996
1997         if (hdl == NULL)
1998                 return 0;
1999
2000         lockdep_assert_held(hdl->lock);
2001
2002         list_for_each_entry(ctrl, &hdl->ctrls, node)
2003                 ctrl->done = false;
2004
2005         list_for_each_entry(ctrl, &hdl->ctrls, node) {
2006                 struct v4l2_ctrl *master = ctrl->cluster[0];
2007                 int i;
2008
2009                 /* Skip if this control was already handled by a cluster. */
2010                 /* Skip button controls and read-only controls. */
2011                 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2012                     (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2013                         continue;
2014
2015                 for (i = 0; i < master->ncontrols; i++) {
2016                         if (master->cluster[i]) {
2017                                 cur_to_new(master->cluster[i]);
2018                                 master->cluster[i]->is_new = 1;
2019                                 master->cluster[i]->done = true;
2020                         }
2021                 }
2022                 ret = call_op(master, s_ctrl);
2023                 if (ret)
2024                         break;
2025         }
2026
2027         return ret;
2028 }
2029 EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup);
2030
2031 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2032 {
2033         int ret;
2034
2035         if (hdl == NULL)
2036                 return 0;
2037
2038         mutex_lock(hdl->lock);
2039         ret = __v4l2_ctrl_handler_setup(hdl);
2040         mutex_unlock(hdl->lock);
2041
2042         return ret;
2043 }
2044 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2045
2046 /* Log the control name and value */
2047 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2048                      const char *prefix, const char *colon)
2049 {
2050         if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2051                 return;
2052         if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2053                 return;
2054
2055         pr_info("%s%s%s: ", prefix, colon, ctrl->name);
2056
2057         ctrl->type_ops->log(ctrl);
2058
2059         if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2060                            V4L2_CTRL_FLAG_GRABBED |
2061                            V4L2_CTRL_FLAG_VOLATILE)) {
2062                 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2063                         pr_cont(" inactive");
2064                 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2065                         pr_cont(" grabbed");
2066                 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2067                         pr_cont(" volatile");
2068         }
2069         pr_cont("\n");
2070 }
2071
2072 /* Log all controls owned by the handler */
2073 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2074                                   const char *prefix)
2075 {
2076         struct v4l2_ctrl *ctrl;
2077         const char *colon = "";
2078         int len;
2079
2080         if (!hdl)
2081                 return;
2082         if (!prefix)
2083                 prefix = "";
2084         len = strlen(prefix);
2085         if (len && prefix[len - 1] != ' ')
2086                 colon = ": ";
2087         mutex_lock(hdl->lock);
2088         list_for_each_entry(ctrl, &hdl->ctrls, node)
2089                 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2090                         log_ctrl(ctrl, prefix, colon);
2091         mutex_unlock(hdl->lock);
2092 }
2093 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2094
2095 int v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler *hdl,
2096                                     const struct v4l2_ctrl_ops *ctrl_ops,
2097                                     const struct v4l2_fwnode_device_properties *p)
2098 {
2099         if (p->orientation != V4L2_FWNODE_PROPERTY_UNSET) {
2100                 u32 orientation_ctrl;
2101
2102                 switch (p->orientation) {
2103                 case V4L2_FWNODE_ORIENTATION_FRONT:
2104                         orientation_ctrl = V4L2_CAMERA_ORIENTATION_FRONT;
2105                         break;
2106                 case V4L2_FWNODE_ORIENTATION_BACK:
2107                         orientation_ctrl = V4L2_CAMERA_ORIENTATION_BACK;
2108                         break;
2109                 case V4L2_FWNODE_ORIENTATION_EXTERNAL:
2110                         orientation_ctrl = V4L2_CAMERA_ORIENTATION_EXTERNAL;
2111                         break;
2112                 default:
2113                         return -EINVAL;
2114                 }
2115                 if (!v4l2_ctrl_new_std_menu(hdl, ctrl_ops,
2116                                             V4L2_CID_CAMERA_ORIENTATION,
2117                                             V4L2_CAMERA_ORIENTATION_EXTERNAL, 0,
2118                                             orientation_ctrl))
2119                         return hdl->error;
2120         }
2121
2122         if (p->rotation != V4L2_FWNODE_PROPERTY_UNSET) {
2123                 if (!v4l2_ctrl_new_std(hdl, ctrl_ops,
2124                                        V4L2_CID_CAMERA_SENSOR_ROTATION,
2125                                        p->rotation, p->rotation, 1,
2126                                        p->rotation))
2127                         return hdl->error;
2128         }
2129
2130         return hdl->error;
2131 }
2132 EXPORT_SYMBOL(v4l2_ctrl_new_fwnode_properties);