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