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