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