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