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

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