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_HEVC_SCALING_MATRIX: 691 break; 692 693 case V4L2_CTRL_TYPE_AREA: 694 area = p; 695 if (!area->width || !area->height) 696 return -EINVAL; 697 break; 698 699 default: 700 return -EINVAL; 701 } 702 703 return 0; 704 } 705 706 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx, 707 union v4l2_ctrl_ptr ptr) 708 { 709 size_t len; 710 u64 offset; 711 s64 val; 712 713 switch ((u32)ctrl->type) { 714 case V4L2_CTRL_TYPE_INTEGER: 715 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl); 716 case V4L2_CTRL_TYPE_INTEGER64: 717 /* 718 * We can't use the ROUND_TO_RANGE define here due to 719 * the u64 divide that needs special care. 720 */ 721 val = ptr.p_s64[idx]; 722 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2)) 723 val = ctrl->maximum; 724 else 725 val += (s64)(ctrl->step / 2); 726 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum); 727 offset = val - ctrl->minimum; 728 do_div(offset, ctrl->step); 729 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step; 730 return 0; 731 case V4L2_CTRL_TYPE_U8: 732 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl); 733 case V4L2_CTRL_TYPE_U16: 734 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl); 735 case V4L2_CTRL_TYPE_U32: 736 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl); 737 738 case V4L2_CTRL_TYPE_BOOLEAN: 739 ptr.p_s32[idx] = !!ptr.p_s32[idx]; 740 return 0; 741 742 case V4L2_CTRL_TYPE_MENU: 743 case V4L2_CTRL_TYPE_INTEGER_MENU: 744 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum) 745 return -ERANGE; 746 if (ptr.p_s32[idx] < BITS_PER_LONG_LONG && 747 (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx]))) 748 return -EINVAL; 749 if (ctrl->type == V4L2_CTRL_TYPE_MENU && 750 ctrl->qmenu[ptr.p_s32[idx]][0] == '\0') 751 return -EINVAL; 752 return 0; 753 754 case V4L2_CTRL_TYPE_BITMASK: 755 ptr.p_s32[idx] &= ctrl->maximum; 756 return 0; 757 758 case V4L2_CTRL_TYPE_BUTTON: 759 case V4L2_CTRL_TYPE_CTRL_CLASS: 760 ptr.p_s32[idx] = 0; 761 return 0; 762 763 case V4L2_CTRL_TYPE_STRING: 764 idx *= ctrl->elem_size; 765 len = strlen(ptr.p_char + idx); 766 if (len < ctrl->minimum) 767 return -ERANGE; 768 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step) 769 return -ERANGE; 770 return 0; 771 772 default: 773 return std_validate_compound(ctrl, idx, ptr); 774 } 775 } 776 777 static const struct v4l2_ctrl_type_ops std_type_ops = { 778 .equal = std_equal, 779 .init = std_init, 780 .log = std_log, 781 .validate = std_validate, 782 }; 783 784 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv) 785 { 786 if (!ctrl) 787 return; 788 if (!notify) { 789 ctrl->call_notify = 0; 790 return; 791 } 792 if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify)) 793 return; 794 ctrl->handler->notify = notify; 795 ctrl->handler->notify_priv = priv; 796 ctrl->call_notify = 1; 797 } 798 EXPORT_SYMBOL(v4l2_ctrl_notify); 799 800 /* Copy the one value to another. */ 801 static void ptr_to_ptr(struct v4l2_ctrl *ctrl, 802 union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to) 803 { 804 if (ctrl == NULL) 805 return; 806 memcpy(to.p, from.p_const, ctrl->elems * ctrl->elem_size); 807 } 808 809 /* Copy the new value to the current value. */ 810 void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags) 811 { 812 bool changed; 813 814 if (ctrl == NULL) 815 return; 816 817 /* has_changed is set by cluster_changed */ 818 changed = ctrl->has_changed; 819 if (changed) 820 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur); 821 822 if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) { 823 /* Note: CH_FLAGS is only set for auto clusters. */ 824 ctrl->flags &= 825 ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE); 826 if (!is_cur_manual(ctrl->cluster[0])) { 827 ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE; 828 if (ctrl->cluster[0]->has_volatiles) 829 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE; 830 } 831 fh = NULL; 832 } 833 if (changed || ch_flags) { 834 /* If a control was changed that was not one of the controls 835 modified by the application, then send the event to all. */ 836 if (!ctrl->is_new) 837 fh = NULL; 838 send_event(fh, ctrl, 839 (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags); 840 if (ctrl->call_notify && changed && ctrl->handler->notify) 841 ctrl->handler->notify(ctrl, ctrl->handler->notify_priv); 842 } 843 } 844 845 /* Copy the current value to the new value */ 846 void cur_to_new(struct v4l2_ctrl *ctrl) 847 { 848 if (ctrl == NULL) 849 return; 850 ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new); 851 } 852 853 /* Copy the new value to the request value */ 854 void new_to_req(struct v4l2_ctrl_ref *ref) 855 { 856 if (!ref) 857 return; 858 ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req); 859 ref->valid_p_req = true; 860 } 861 862 /* Copy the current value to the request value */ 863 void cur_to_req(struct v4l2_ctrl_ref *ref) 864 { 865 if (!ref) 866 return; 867 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->p_req); 868 ref->valid_p_req = true; 869 } 870 871 /* Copy the request value to the new value */ 872 void req_to_new(struct v4l2_ctrl_ref *ref) 873 { 874 if (!ref) 875 return; 876 if (ref->valid_p_req) 877 ptr_to_ptr(ref->ctrl, ref->p_req, ref->ctrl->p_new); 878 else 879 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new); 880 } 881 882 /* Control range checking */ 883 int check_range(enum v4l2_ctrl_type type, 884 s64 min, s64 max, u64 step, s64 def) 885 { 886 switch (type) { 887 case V4L2_CTRL_TYPE_BOOLEAN: 888 if (step != 1 || max > 1 || min < 0) 889 return -ERANGE; 890 fallthrough; 891 case V4L2_CTRL_TYPE_U8: 892 case V4L2_CTRL_TYPE_U16: 893 case V4L2_CTRL_TYPE_U32: 894 case V4L2_CTRL_TYPE_INTEGER: 895 case V4L2_CTRL_TYPE_INTEGER64: 896 if (step == 0 || min > max || def < min || def > max) 897 return -ERANGE; 898 return 0; 899 case V4L2_CTRL_TYPE_BITMASK: 900 if (step || min || !max || (def & ~max)) 901 return -ERANGE; 902 return 0; 903 case V4L2_CTRL_TYPE_MENU: 904 case V4L2_CTRL_TYPE_INTEGER_MENU: 905 if (min > max || def < min || def > max) 906 return -ERANGE; 907 /* Note: step == menu_skip_mask for menu controls. 908 So here we check if the default value is masked out. */ 909 if (step && ((1 << def) & step)) 910 return -EINVAL; 911 return 0; 912 case V4L2_CTRL_TYPE_STRING: 913 if (min > max || min < 0 || step < 1 || def) 914 return -ERANGE; 915 return 0; 916 default: 917 return 0; 918 } 919 } 920 921 /* Validate a new control */ 922 int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new) 923 { 924 unsigned idx; 925 int err = 0; 926 927 for (idx = 0; !err && idx < ctrl->elems; idx++) 928 err = ctrl->type_ops->validate(ctrl, idx, p_new); 929 return err; 930 } 931 932 /* Set the handler's error code if it wasn't set earlier already */ 933 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err) 934 { 935 if (hdl->error == 0) 936 hdl->error = err; 937 return err; 938 } 939 940 /* Initialize the handler */ 941 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl, 942 unsigned nr_of_controls_hint, 943 struct lock_class_key *key, const char *name) 944 { 945 mutex_init(&hdl->_lock); 946 hdl->lock = &hdl->_lock; 947 lockdep_set_class_and_name(hdl->lock, key, name); 948 INIT_LIST_HEAD(&hdl->ctrls); 949 INIT_LIST_HEAD(&hdl->ctrl_refs); 950 hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8; 951 hdl->buckets = kvmalloc_array(hdl->nr_of_buckets, 952 sizeof(hdl->buckets[0]), 953 GFP_KERNEL | __GFP_ZERO); 954 hdl->error = hdl->buckets ? 0 : -ENOMEM; 955 v4l2_ctrl_handler_init_request(hdl); 956 return hdl->error; 957 } 958 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class); 959 960 /* Free all controls and control refs */ 961 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl) 962 { 963 struct v4l2_ctrl_ref *ref, *next_ref; 964 struct v4l2_ctrl *ctrl, *next_ctrl; 965 struct v4l2_subscribed_event *sev, *next_sev; 966 967 if (hdl == NULL || hdl->buckets == NULL) 968 return; 969 970 v4l2_ctrl_handler_free_request(hdl); 971 972 mutex_lock(hdl->lock); 973 /* Free all nodes */ 974 list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) { 975 list_del(&ref->node); 976 kfree(ref); 977 } 978 /* Free all controls owned by the handler */ 979 list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) { 980 list_del(&ctrl->node); 981 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node) 982 list_del(&sev->node); 983 kvfree(ctrl); 984 } 985 kvfree(hdl->buckets); 986 hdl->buckets = NULL; 987 hdl->cached = NULL; 988 hdl->error = 0; 989 mutex_unlock(hdl->lock); 990 mutex_destroy(&hdl->_lock); 991 } 992 EXPORT_SYMBOL(v4l2_ctrl_handler_free); 993 994 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer 995 be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing 996 with applications that do not use the NEXT_CTRL flag. 997 998 We just find the n-th private user control. It's O(N), but that should not 999 be an issue in this particular case. */ 1000 static struct v4l2_ctrl_ref *find_private_ref( 1001 struct v4l2_ctrl_handler *hdl, u32 id) 1002 { 1003 struct v4l2_ctrl_ref *ref; 1004 1005 id -= V4L2_CID_PRIVATE_BASE; 1006 list_for_each_entry(ref, &hdl->ctrl_refs, node) { 1007 /* Search for private user controls that are compatible with 1008 VIDIOC_G/S_CTRL. */ 1009 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER && 1010 V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) { 1011 if (!ref->ctrl->is_int) 1012 continue; 1013 if (id == 0) 1014 return ref; 1015 id--; 1016 } 1017 } 1018 return NULL; 1019 } 1020 1021 /* Find a control with the given ID. */ 1022 struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id) 1023 { 1024 struct v4l2_ctrl_ref *ref; 1025 int bucket; 1026 1027 id &= V4L2_CTRL_ID_MASK; 1028 1029 /* Old-style private controls need special handling */ 1030 if (id >= V4L2_CID_PRIVATE_BASE) 1031 return find_private_ref(hdl, id); 1032 bucket = id % hdl->nr_of_buckets; 1033 1034 /* Simple optimization: cache the last control found */ 1035 if (hdl->cached && hdl->cached->ctrl->id == id) 1036 return hdl->cached; 1037 1038 /* Not in cache, search the hash */ 1039 ref = hdl->buckets ? hdl->buckets[bucket] : NULL; 1040 while (ref && ref->ctrl->id != id) 1041 ref = ref->next; 1042 1043 if (ref) 1044 hdl->cached = ref; /* cache it! */ 1045 return ref; 1046 } 1047 1048 /* Find a control with the given ID. Take the handler's lock first. */ 1049 struct v4l2_ctrl_ref *find_ref_lock(struct v4l2_ctrl_handler *hdl, u32 id) 1050 { 1051 struct v4l2_ctrl_ref *ref = NULL; 1052 1053 if (hdl) { 1054 mutex_lock(hdl->lock); 1055 ref = find_ref(hdl, id); 1056 mutex_unlock(hdl->lock); 1057 } 1058 return ref; 1059 } 1060 1061 /* Find a control with the given ID. */ 1062 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id) 1063 { 1064 struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id); 1065 1066 return ref ? ref->ctrl : NULL; 1067 } 1068 EXPORT_SYMBOL(v4l2_ctrl_find); 1069 1070 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */ 1071 int handler_new_ref(struct v4l2_ctrl_handler *hdl, 1072 struct v4l2_ctrl *ctrl, 1073 struct v4l2_ctrl_ref **ctrl_ref, 1074 bool from_other_dev, bool allocate_req) 1075 { 1076 struct v4l2_ctrl_ref *ref; 1077 struct v4l2_ctrl_ref *new_ref; 1078 u32 id = ctrl->id; 1079 u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1; 1080 int bucket = id % hdl->nr_of_buckets; /* which bucket to use */ 1081 unsigned int size_extra_req = 0; 1082 1083 if (ctrl_ref) 1084 *ctrl_ref = NULL; 1085 1086 /* 1087 * Automatically add the control class if it is not yet present and 1088 * the new control is not a compound control. 1089 */ 1090 if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES && 1091 id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL) 1092 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0)) 1093 return hdl->error; 1094 1095 if (hdl->error) 1096 return hdl->error; 1097 1098 if (allocate_req) 1099 size_extra_req = ctrl->elems * ctrl->elem_size; 1100 new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL); 1101 if (!new_ref) 1102 return handler_set_err(hdl, -ENOMEM); 1103 new_ref->ctrl = ctrl; 1104 new_ref->from_other_dev = from_other_dev; 1105 if (size_extra_req) 1106 new_ref->p_req.p = &new_ref[1]; 1107 1108 INIT_LIST_HEAD(&new_ref->node); 1109 1110 mutex_lock(hdl->lock); 1111 1112 /* Add immediately at the end of the list if the list is empty, or if 1113 the last element in the list has a lower ID. 1114 This ensures that when elements are added in ascending order the 1115 insertion is an O(1) operation. */ 1116 if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) { 1117 list_add_tail(&new_ref->node, &hdl->ctrl_refs); 1118 goto insert_in_hash; 1119 } 1120 1121 /* Find insert position in sorted list */ 1122 list_for_each_entry(ref, &hdl->ctrl_refs, node) { 1123 if (ref->ctrl->id < id) 1124 continue; 1125 /* Don't add duplicates */ 1126 if (ref->ctrl->id == id) { 1127 kfree(new_ref); 1128 goto unlock; 1129 } 1130 list_add(&new_ref->node, ref->node.prev); 1131 break; 1132 } 1133 1134 insert_in_hash: 1135 /* Insert the control node in the hash */ 1136 new_ref->next = hdl->buckets[bucket]; 1137 hdl->buckets[bucket] = new_ref; 1138 if (ctrl_ref) 1139 *ctrl_ref = new_ref; 1140 if (ctrl->handler == hdl) { 1141 /* By default each control starts in a cluster of its own. 1142 * new_ref->ctrl is basically a cluster array with one 1143 * element, so that's perfect to use as the cluster pointer. 1144 * But only do this for the handler that owns the control. 1145 */ 1146 ctrl->cluster = &new_ref->ctrl; 1147 ctrl->ncontrols = 1; 1148 } 1149 1150 unlock: 1151 mutex_unlock(hdl->lock); 1152 return 0; 1153 } 1154 1155 /* Add a new control */ 1156 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl, 1157 const struct v4l2_ctrl_ops *ops, 1158 const struct v4l2_ctrl_type_ops *type_ops, 1159 u32 id, const char *name, enum v4l2_ctrl_type type, 1160 s64 min, s64 max, u64 step, s64 def, 1161 const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size, 1162 u32 flags, const char * const *qmenu, 1163 const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def, 1164 void *priv) 1165 { 1166 struct v4l2_ctrl *ctrl; 1167 unsigned sz_extra; 1168 unsigned nr_of_dims = 0; 1169 unsigned elems = 1; 1170 bool is_array; 1171 unsigned tot_ctrl_size; 1172 unsigned idx; 1173 void *data; 1174 int err; 1175 1176 if (hdl->error) 1177 return NULL; 1178 1179 while (dims && dims[nr_of_dims]) { 1180 elems *= dims[nr_of_dims]; 1181 nr_of_dims++; 1182 if (nr_of_dims == V4L2_CTRL_MAX_DIMS) 1183 break; 1184 } 1185 is_array = nr_of_dims > 0; 1186 1187 /* Prefill elem_size for all types handled by std_type_ops */ 1188 switch ((u32)type) { 1189 case V4L2_CTRL_TYPE_INTEGER64: 1190 elem_size = sizeof(s64); 1191 break; 1192 case V4L2_CTRL_TYPE_STRING: 1193 elem_size = max + 1; 1194 break; 1195 case V4L2_CTRL_TYPE_U8: 1196 elem_size = sizeof(u8); 1197 break; 1198 case V4L2_CTRL_TYPE_U16: 1199 elem_size = sizeof(u16); 1200 break; 1201 case V4L2_CTRL_TYPE_U32: 1202 elem_size = sizeof(u32); 1203 break; 1204 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE: 1205 elem_size = sizeof(struct v4l2_ctrl_mpeg2_sequence); 1206 break; 1207 case V4L2_CTRL_TYPE_MPEG2_PICTURE: 1208 elem_size = sizeof(struct v4l2_ctrl_mpeg2_picture); 1209 break; 1210 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION: 1211 elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantisation); 1212 break; 1213 case V4L2_CTRL_TYPE_FWHT_PARAMS: 1214 elem_size = sizeof(struct v4l2_ctrl_fwht_params); 1215 break; 1216 case V4L2_CTRL_TYPE_H264_SPS: 1217 elem_size = sizeof(struct v4l2_ctrl_h264_sps); 1218 break; 1219 case V4L2_CTRL_TYPE_H264_PPS: 1220 elem_size = sizeof(struct v4l2_ctrl_h264_pps); 1221 break; 1222 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX: 1223 elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix); 1224 break; 1225 case V4L2_CTRL_TYPE_H264_SLICE_PARAMS: 1226 elem_size = sizeof(struct v4l2_ctrl_h264_slice_params); 1227 break; 1228 case V4L2_CTRL_TYPE_H264_DECODE_PARAMS: 1229 elem_size = sizeof(struct v4l2_ctrl_h264_decode_params); 1230 break; 1231 case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS: 1232 elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights); 1233 break; 1234 case V4L2_CTRL_TYPE_VP8_FRAME: 1235 elem_size = sizeof(struct v4l2_ctrl_vp8_frame); 1236 break; 1237 case V4L2_CTRL_TYPE_HEVC_SPS: 1238 elem_size = sizeof(struct v4l2_ctrl_hevc_sps); 1239 break; 1240 case V4L2_CTRL_TYPE_HEVC_PPS: 1241 elem_size = sizeof(struct v4l2_ctrl_hevc_pps); 1242 break; 1243 case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS: 1244 elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params); 1245 break; 1246 case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX: 1247 elem_size = sizeof(struct v4l2_ctrl_hevc_scaling_matrix); 1248 break; 1249 case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS: 1250 elem_size = sizeof(struct v4l2_ctrl_hevc_decode_params); 1251 break; 1252 case V4L2_CTRL_TYPE_HDR10_CLL_INFO: 1253 elem_size = sizeof(struct v4l2_ctrl_hdr10_cll_info); 1254 break; 1255 case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY: 1256 elem_size = sizeof(struct v4l2_ctrl_hdr10_mastering_display); 1257 break; 1258 case V4L2_CTRL_TYPE_AREA: 1259 elem_size = sizeof(struct v4l2_area); 1260 break; 1261 default: 1262 if (type < V4L2_CTRL_COMPOUND_TYPES) 1263 elem_size = sizeof(s32); 1264 break; 1265 } 1266 tot_ctrl_size = elem_size * elems; 1267 1268 /* Sanity checks */ 1269 if (id == 0 || name == NULL || !elem_size || 1270 id >= V4L2_CID_PRIVATE_BASE || 1271 (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) || 1272 (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) { 1273 handler_set_err(hdl, -ERANGE); 1274 return NULL; 1275 } 1276 err = check_range(type, min, max, step, def); 1277 if (err) { 1278 handler_set_err(hdl, err); 1279 return NULL; 1280 } 1281 if (is_array && 1282 (type == V4L2_CTRL_TYPE_BUTTON || 1283 type == V4L2_CTRL_TYPE_CTRL_CLASS)) { 1284 handler_set_err(hdl, -EINVAL); 1285 return NULL; 1286 } 1287 1288 sz_extra = 0; 1289 if (type == V4L2_CTRL_TYPE_BUTTON) 1290 flags |= V4L2_CTRL_FLAG_WRITE_ONLY | 1291 V4L2_CTRL_FLAG_EXECUTE_ON_WRITE; 1292 else if (type == V4L2_CTRL_TYPE_CTRL_CLASS) 1293 flags |= V4L2_CTRL_FLAG_READ_ONLY; 1294 else if (type == V4L2_CTRL_TYPE_INTEGER64 || 1295 type == V4L2_CTRL_TYPE_STRING || 1296 type >= V4L2_CTRL_COMPOUND_TYPES || 1297 is_array) 1298 sz_extra += 2 * tot_ctrl_size; 1299 1300 if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) 1301 sz_extra += elem_size; 1302 1303 ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL); 1304 if (ctrl == NULL) { 1305 handler_set_err(hdl, -ENOMEM); 1306 return NULL; 1307 } 1308 1309 INIT_LIST_HEAD(&ctrl->node); 1310 INIT_LIST_HEAD(&ctrl->ev_subs); 1311 ctrl->handler = hdl; 1312 ctrl->ops = ops; 1313 ctrl->type_ops = type_ops ? type_ops : &std_type_ops; 1314 ctrl->id = id; 1315 ctrl->name = name; 1316 ctrl->type = type; 1317 ctrl->flags = flags; 1318 ctrl->minimum = min; 1319 ctrl->maximum = max; 1320 ctrl->step = step; 1321 ctrl->default_value = def; 1322 ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING; 1323 ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string; 1324 ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64; 1325 ctrl->is_array = is_array; 1326 ctrl->elems = elems; 1327 ctrl->nr_of_dims = nr_of_dims; 1328 if (nr_of_dims) 1329 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0])); 1330 ctrl->elem_size = elem_size; 1331 if (type == V4L2_CTRL_TYPE_MENU) 1332 ctrl->qmenu = qmenu; 1333 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU) 1334 ctrl->qmenu_int = qmenu_int; 1335 ctrl->priv = priv; 1336 ctrl->cur.val = ctrl->val = def; 1337 data = &ctrl[1]; 1338 1339 if (!ctrl->is_int) { 1340 ctrl->p_new.p = data; 1341 ctrl->p_cur.p = data + tot_ctrl_size; 1342 } else { 1343 ctrl->p_new.p = &ctrl->val; 1344 ctrl->p_cur.p = &ctrl->cur.val; 1345 } 1346 1347 if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) { 1348 ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size; 1349 memcpy(ctrl->p_def.p, p_def.p_const, elem_size); 1350 } 1351 1352 for (idx = 0; idx < elems; idx++) { 1353 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur); 1354 ctrl->type_ops->init(ctrl, idx, ctrl->p_new); 1355 } 1356 1357 if (handler_new_ref(hdl, ctrl, NULL, false, false)) { 1358 kvfree(ctrl); 1359 return NULL; 1360 } 1361 mutex_lock(hdl->lock); 1362 list_add_tail(&ctrl->node, &hdl->ctrls); 1363 mutex_unlock(hdl->lock); 1364 return ctrl; 1365 } 1366 1367 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl, 1368 const struct v4l2_ctrl_config *cfg, void *priv) 1369 { 1370 bool is_menu; 1371 struct v4l2_ctrl *ctrl; 1372 const char *name = cfg->name; 1373 const char * const *qmenu = cfg->qmenu; 1374 const s64 *qmenu_int = cfg->qmenu_int; 1375 enum v4l2_ctrl_type type = cfg->type; 1376 u32 flags = cfg->flags; 1377 s64 min = cfg->min; 1378 s64 max = cfg->max; 1379 u64 step = cfg->step; 1380 s64 def = cfg->def; 1381 1382 if (name == NULL) 1383 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step, 1384 &def, &flags); 1385 1386 is_menu = (type == V4L2_CTRL_TYPE_MENU || 1387 type == V4L2_CTRL_TYPE_INTEGER_MENU); 1388 if (is_menu) 1389 WARN_ON(step); 1390 else 1391 WARN_ON(cfg->menu_skip_mask); 1392 if (type == V4L2_CTRL_TYPE_MENU && !qmenu) { 1393 qmenu = v4l2_ctrl_get_menu(cfg->id); 1394 } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) { 1395 handler_set_err(hdl, -EINVAL); 1396 return NULL; 1397 } 1398 1399 ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name, 1400 type, min, max, 1401 is_menu ? cfg->menu_skip_mask : step, def, 1402 cfg->dims, cfg->elem_size, 1403 flags, qmenu, qmenu_int, cfg->p_def, priv); 1404 if (ctrl) 1405 ctrl->is_private = cfg->is_private; 1406 return ctrl; 1407 } 1408 EXPORT_SYMBOL(v4l2_ctrl_new_custom); 1409 1410 /* Helper function for standard non-menu controls */ 1411 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl, 1412 const struct v4l2_ctrl_ops *ops, 1413 u32 id, s64 min, s64 max, u64 step, s64 def) 1414 { 1415 const char *name; 1416 enum v4l2_ctrl_type type; 1417 u32 flags; 1418 1419 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); 1420 if (type == V4L2_CTRL_TYPE_MENU || 1421 type == V4L2_CTRL_TYPE_INTEGER_MENU || 1422 type >= V4L2_CTRL_COMPOUND_TYPES) { 1423 handler_set_err(hdl, -EINVAL); 1424 return NULL; 1425 } 1426 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, 1427 min, max, step, def, NULL, 0, 1428 flags, NULL, NULL, ptr_null, NULL); 1429 } 1430 EXPORT_SYMBOL(v4l2_ctrl_new_std); 1431 1432 /* Helper function for standard menu controls */ 1433 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl, 1434 const struct v4l2_ctrl_ops *ops, 1435 u32 id, u8 _max, u64 mask, u8 _def) 1436 { 1437 const char * const *qmenu = NULL; 1438 const s64 *qmenu_int = NULL; 1439 unsigned int qmenu_int_len = 0; 1440 const char *name; 1441 enum v4l2_ctrl_type type; 1442 s64 min; 1443 s64 max = _max; 1444 s64 def = _def; 1445 u64 step; 1446 u32 flags; 1447 1448 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); 1449 1450 if (type == V4L2_CTRL_TYPE_MENU) 1451 qmenu = v4l2_ctrl_get_menu(id); 1452 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU) 1453 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len); 1454 1455 if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) { 1456 handler_set_err(hdl, -EINVAL); 1457 return NULL; 1458 } 1459 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, 1460 0, max, mask, def, NULL, 0, 1461 flags, qmenu, qmenu_int, ptr_null, NULL); 1462 } 1463 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu); 1464 1465 /* Helper function for standard menu controls with driver defined menu */ 1466 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl, 1467 const struct v4l2_ctrl_ops *ops, u32 id, u8 _max, 1468 u64 mask, u8 _def, const char * const *qmenu) 1469 { 1470 enum v4l2_ctrl_type type; 1471 const char *name; 1472 u32 flags; 1473 u64 step; 1474 s64 min; 1475 s64 max = _max; 1476 s64 def = _def; 1477 1478 /* v4l2_ctrl_new_std_menu_items() should only be called for 1479 * standard controls without a standard menu. 1480 */ 1481 if (v4l2_ctrl_get_menu(id)) { 1482 handler_set_err(hdl, -EINVAL); 1483 return NULL; 1484 } 1485 1486 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); 1487 if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) { 1488 handler_set_err(hdl, -EINVAL); 1489 return NULL; 1490 } 1491 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, 1492 0, max, mask, def, NULL, 0, 1493 flags, qmenu, NULL, ptr_null, NULL); 1494 1495 } 1496 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items); 1497 1498 /* Helper function for standard compound controls */ 1499 struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl, 1500 const struct v4l2_ctrl_ops *ops, u32 id, 1501 const union v4l2_ctrl_ptr p_def) 1502 { 1503 const char *name; 1504 enum v4l2_ctrl_type type; 1505 u32 flags; 1506 s64 min, max, step, def; 1507 1508 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); 1509 if (type < V4L2_CTRL_COMPOUND_TYPES) { 1510 handler_set_err(hdl, -EINVAL); 1511 return NULL; 1512 } 1513 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, 1514 min, max, step, def, NULL, 0, 1515 flags, NULL, NULL, p_def, NULL); 1516 } 1517 EXPORT_SYMBOL(v4l2_ctrl_new_std_compound); 1518 1519 /* Helper function for standard integer menu controls */ 1520 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl, 1521 const struct v4l2_ctrl_ops *ops, 1522 u32 id, u8 _max, u8 _def, const s64 *qmenu_int) 1523 { 1524 const char *name; 1525 enum v4l2_ctrl_type type; 1526 s64 min; 1527 u64 step; 1528 s64 max = _max; 1529 s64 def = _def; 1530 u32 flags; 1531 1532 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); 1533 if (type != V4L2_CTRL_TYPE_INTEGER_MENU) { 1534 handler_set_err(hdl, -EINVAL); 1535 return NULL; 1536 } 1537 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, 1538 0, max, 0, def, NULL, 0, 1539 flags, NULL, qmenu_int, ptr_null, NULL); 1540 } 1541 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu); 1542 1543 /* Add the controls from another handler to our own. */ 1544 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl, 1545 struct v4l2_ctrl_handler *add, 1546 bool (*filter)(const struct v4l2_ctrl *ctrl), 1547 bool from_other_dev) 1548 { 1549 struct v4l2_ctrl_ref *ref; 1550 int ret = 0; 1551 1552 /* Do nothing if either handler is NULL or if they are the same */ 1553 if (!hdl || !add || hdl == add) 1554 return 0; 1555 if (hdl->error) 1556 return hdl->error; 1557 mutex_lock(add->lock); 1558 list_for_each_entry(ref, &add->ctrl_refs, node) { 1559 struct v4l2_ctrl *ctrl = ref->ctrl; 1560 1561 /* Skip handler-private controls. */ 1562 if (ctrl->is_private) 1563 continue; 1564 /* And control classes */ 1565 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) 1566 continue; 1567 /* Filter any unwanted controls */ 1568 if (filter && !filter(ctrl)) 1569 continue; 1570 ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false); 1571 if (ret) 1572 break; 1573 } 1574 mutex_unlock(add->lock); 1575 return ret; 1576 } 1577 EXPORT_SYMBOL(v4l2_ctrl_add_handler); 1578 1579 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl) 1580 { 1581 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX) 1582 return true; 1583 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX) 1584 return true; 1585 switch (ctrl->id) { 1586 case V4L2_CID_AUDIO_MUTE: 1587 case V4L2_CID_AUDIO_VOLUME: 1588 case V4L2_CID_AUDIO_BALANCE: 1589 case V4L2_CID_AUDIO_BASS: 1590 case V4L2_CID_AUDIO_TREBLE: 1591 case V4L2_CID_AUDIO_LOUDNESS: 1592 return true; 1593 default: 1594 break; 1595 } 1596 return false; 1597 } 1598 EXPORT_SYMBOL(v4l2_ctrl_radio_filter); 1599 1600 /* Cluster controls */ 1601 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls) 1602 { 1603 bool has_volatiles = false; 1604 int i; 1605 1606 /* The first control is the master control and it must not be NULL */ 1607 if (WARN_ON(ncontrols == 0 || controls[0] == NULL)) 1608 return; 1609 1610 for (i = 0; i < ncontrols; i++) { 1611 if (controls[i]) { 1612 controls[i]->cluster = controls; 1613 controls[i]->ncontrols = ncontrols; 1614 if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE) 1615 has_volatiles = true; 1616 } 1617 } 1618 controls[0]->has_volatiles = has_volatiles; 1619 } 1620 EXPORT_SYMBOL(v4l2_ctrl_cluster); 1621 1622 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls, 1623 u8 manual_val, bool set_volatile) 1624 { 1625 struct v4l2_ctrl *master = controls[0]; 1626 u32 flag = 0; 1627 int i; 1628 1629 v4l2_ctrl_cluster(ncontrols, controls); 1630 WARN_ON(ncontrols <= 1); 1631 WARN_ON(manual_val < master->minimum || manual_val > master->maximum); 1632 WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl)); 1633 master->is_auto = true; 1634 master->has_volatiles = set_volatile; 1635 master->manual_mode_value = manual_val; 1636 master->flags |= V4L2_CTRL_FLAG_UPDATE; 1637 1638 if (!is_cur_manual(master)) 1639 flag = V4L2_CTRL_FLAG_INACTIVE | 1640 (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0); 1641 1642 for (i = 1; i < ncontrols; i++) 1643 if (controls[i]) 1644 controls[i]->flags |= flag; 1645 } 1646 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster); 1647 1648 /* 1649 * Obtain the current volatile values of an autocluster and mark them 1650 * as new. 1651 */ 1652 void update_from_auto_cluster(struct v4l2_ctrl *master) 1653 { 1654 int i; 1655 1656 for (i = 1; i < master->ncontrols; i++) 1657 cur_to_new(master->cluster[i]); 1658 if (!call_op(master, g_volatile_ctrl)) 1659 for (i = 1; i < master->ncontrols; i++) 1660 if (master->cluster[i]) 1661 master->cluster[i]->is_new = 1; 1662 } 1663 1664 /* 1665 * Return non-zero if one or more of the controls in the cluster has a new 1666 * value that differs from the current value. 1667 */ 1668 static int cluster_changed(struct v4l2_ctrl *master) 1669 { 1670 bool changed = false; 1671 unsigned int idx; 1672 int i; 1673 1674 for (i = 0; i < master->ncontrols; i++) { 1675 struct v4l2_ctrl *ctrl = master->cluster[i]; 1676 bool ctrl_changed = false; 1677 1678 if (!ctrl) 1679 continue; 1680 1681 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE) { 1682 changed = true; 1683 ctrl_changed = true; 1684 } 1685 1686 /* 1687 * Set has_changed to false to avoid generating 1688 * the event V4L2_EVENT_CTRL_CH_VALUE 1689 */ 1690 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) { 1691 ctrl->has_changed = false; 1692 continue; 1693 } 1694 1695 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++) 1696 ctrl_changed = !ctrl->type_ops->equal(ctrl, idx, 1697 ctrl->p_cur, ctrl->p_new); 1698 ctrl->has_changed = ctrl_changed; 1699 changed |= ctrl->has_changed; 1700 } 1701 return changed; 1702 } 1703 1704 /* 1705 * Core function that calls try/s_ctrl and ensures that the new value is 1706 * copied to the current value on a set. 1707 * Must be called with ctrl->handler->lock held. 1708 */ 1709 int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master, 1710 bool set, u32 ch_flags) 1711 { 1712 bool update_flag; 1713 int ret; 1714 int i; 1715 1716 /* 1717 * Go through the cluster and either validate the new value or 1718 * (if no new value was set), copy the current value to the new 1719 * value, ensuring a consistent view for the control ops when 1720 * called. 1721 */ 1722 for (i = 0; i < master->ncontrols; i++) { 1723 struct v4l2_ctrl *ctrl = master->cluster[i]; 1724 1725 if (!ctrl) 1726 continue; 1727 1728 if (!ctrl->is_new) { 1729 cur_to_new(ctrl); 1730 continue; 1731 } 1732 /* 1733 * Check again: it may have changed since the 1734 * previous check in try_or_set_ext_ctrls(). 1735 */ 1736 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) 1737 return -EBUSY; 1738 } 1739 1740 ret = call_op(master, try_ctrl); 1741 1742 /* Don't set if there is no change */ 1743 if (ret || !set || !cluster_changed(master)) 1744 return ret; 1745 ret = call_op(master, s_ctrl); 1746 if (ret) 1747 return ret; 1748 1749 /* If OK, then make the new values permanent. */ 1750 update_flag = is_cur_manual(master) != is_new_manual(master); 1751 1752 for (i = 0; i < master->ncontrols; i++) { 1753 /* 1754 * If we switch from auto to manual mode, and this cluster 1755 * contains volatile controls, then all non-master controls 1756 * have to be marked as changed. The 'new' value contains 1757 * the volatile value (obtained by update_from_auto_cluster), 1758 * which now has to become the current value. 1759 */ 1760 if (i && update_flag && is_new_manual(master) && 1761 master->has_volatiles && master->cluster[i]) 1762 master->cluster[i]->has_changed = true; 1763 1764 new_to_cur(fh, master->cluster[i], ch_flags | 1765 ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0)); 1766 } 1767 return 0; 1768 } 1769 1770 /* Activate/deactivate a control. */ 1771 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active) 1772 { 1773 /* invert since the actual flag is called 'inactive' */ 1774 bool inactive = !active; 1775 bool old; 1776 1777 if (ctrl == NULL) 1778 return; 1779 1780 if (inactive) 1781 /* set V4L2_CTRL_FLAG_INACTIVE */ 1782 old = test_and_set_bit(4, &ctrl->flags); 1783 else 1784 /* clear V4L2_CTRL_FLAG_INACTIVE */ 1785 old = test_and_clear_bit(4, &ctrl->flags); 1786 if (old != inactive) 1787 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS); 1788 } 1789 EXPORT_SYMBOL(v4l2_ctrl_activate); 1790 1791 void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed) 1792 { 1793 bool old; 1794 1795 if (ctrl == NULL) 1796 return; 1797 1798 lockdep_assert_held(ctrl->handler->lock); 1799 1800 if (grabbed) 1801 /* set V4L2_CTRL_FLAG_GRABBED */ 1802 old = test_and_set_bit(1, &ctrl->flags); 1803 else 1804 /* clear V4L2_CTRL_FLAG_GRABBED */ 1805 old = test_and_clear_bit(1, &ctrl->flags); 1806 if (old != grabbed) 1807 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS); 1808 } 1809 EXPORT_SYMBOL(__v4l2_ctrl_grab); 1810 1811 /* Call s_ctrl for all controls owned by the handler */ 1812 int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl) 1813 { 1814 struct v4l2_ctrl *ctrl; 1815 int ret = 0; 1816 1817 if (hdl == NULL) 1818 return 0; 1819 1820 lockdep_assert_held(hdl->lock); 1821 1822 list_for_each_entry(ctrl, &hdl->ctrls, node) 1823 ctrl->done = false; 1824 1825 list_for_each_entry(ctrl, &hdl->ctrls, node) { 1826 struct v4l2_ctrl *master = ctrl->cluster[0]; 1827 int i; 1828 1829 /* Skip if this control was already handled by a cluster. */ 1830 /* Skip button controls and read-only controls. */ 1831 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON || 1832 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)) 1833 continue; 1834 1835 for (i = 0; i < master->ncontrols; i++) { 1836 if (master->cluster[i]) { 1837 cur_to_new(master->cluster[i]); 1838 master->cluster[i]->is_new = 1; 1839 master->cluster[i]->done = true; 1840 } 1841 } 1842 ret = call_op(master, s_ctrl); 1843 if (ret) 1844 break; 1845 } 1846 1847 return ret; 1848 } 1849 EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup); 1850 1851 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl) 1852 { 1853 int ret; 1854 1855 if (hdl == NULL) 1856 return 0; 1857 1858 mutex_lock(hdl->lock); 1859 ret = __v4l2_ctrl_handler_setup(hdl); 1860 mutex_unlock(hdl->lock); 1861 1862 return ret; 1863 } 1864 EXPORT_SYMBOL(v4l2_ctrl_handler_setup); 1865 1866 /* Log the control name and value */ 1867 static void log_ctrl(const struct v4l2_ctrl *ctrl, 1868 const char *prefix, const char *colon) 1869 { 1870 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY)) 1871 return; 1872 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) 1873 return; 1874 1875 pr_info("%s%s%s: ", prefix, colon, ctrl->name); 1876 1877 ctrl->type_ops->log(ctrl); 1878 1879 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE | 1880 V4L2_CTRL_FLAG_GRABBED | 1881 V4L2_CTRL_FLAG_VOLATILE)) { 1882 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE) 1883 pr_cont(" inactive"); 1884 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED) 1885 pr_cont(" grabbed"); 1886 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) 1887 pr_cont(" volatile"); 1888 } 1889 pr_cont("\n"); 1890 } 1891 1892 /* Log all controls owned by the handler */ 1893 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl, 1894 const char *prefix) 1895 { 1896 struct v4l2_ctrl *ctrl; 1897 const char *colon = ""; 1898 int len; 1899 1900 if (!hdl) 1901 return; 1902 if (!prefix) 1903 prefix = ""; 1904 len = strlen(prefix); 1905 if (len && prefix[len - 1] != ' ') 1906 colon = ": "; 1907 mutex_lock(hdl->lock); 1908 list_for_each_entry(ctrl, &hdl->ctrls, node) 1909 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED)) 1910 log_ctrl(ctrl, prefix, colon); 1911 mutex_unlock(hdl->lock); 1912 } 1913 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status); 1914 1915 int v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler *hdl, 1916 const struct v4l2_ctrl_ops *ctrl_ops, 1917 const struct v4l2_fwnode_device_properties *p) 1918 { 1919 if (p->orientation != V4L2_FWNODE_PROPERTY_UNSET) { 1920 u32 orientation_ctrl; 1921 1922 switch (p->orientation) { 1923 case V4L2_FWNODE_ORIENTATION_FRONT: 1924 orientation_ctrl = V4L2_CAMERA_ORIENTATION_FRONT; 1925 break; 1926 case V4L2_FWNODE_ORIENTATION_BACK: 1927 orientation_ctrl = V4L2_CAMERA_ORIENTATION_BACK; 1928 break; 1929 case V4L2_FWNODE_ORIENTATION_EXTERNAL: 1930 orientation_ctrl = V4L2_CAMERA_ORIENTATION_EXTERNAL; 1931 break; 1932 default: 1933 return -EINVAL; 1934 } 1935 if (!v4l2_ctrl_new_std_menu(hdl, ctrl_ops, 1936 V4L2_CID_CAMERA_ORIENTATION, 1937 V4L2_CAMERA_ORIENTATION_EXTERNAL, 0, 1938 orientation_ctrl)) 1939 return hdl->error; 1940 } 1941 1942 if (p->rotation != V4L2_FWNODE_PROPERTY_UNSET) { 1943 if (!v4l2_ctrl_new_std(hdl, ctrl_ops, 1944 V4L2_CID_CAMERA_SENSOR_ROTATION, 1945 p->rotation, p->rotation, 1, 1946 p->rotation)) 1947 return hdl->error; 1948 } 1949 1950 return hdl->error; 1951 } 1952 EXPORT_SYMBOL(v4l2_ctrl_new_fwnode_properties); 1953