1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Samsung LSI S5C73M3 8M pixel camera driver 4 * 5 * Copyright (C) 2012, Samsung Electronics, Co., Ltd. 6 * Sylwester Nawrocki <s.nawrocki@samsung.com> 7 * Andrzej Hajda <a.hajda@samsung.com> 8 */ 9 10#include <linux/sizes.h> 11#include <linux/delay.h> 12#include <linux/firmware.h> 13#include <linux/gpio.h> 14#include <linux/i2c.h> 15#include <linux/init.h> 16#include <linux/media.h> 17#include <linux/module.h> 18#include <linux/regulator/consumer.h> 19#include <linux/slab.h> 20#include <linux/spi/spi.h> 21#include <linux/videodev2.h> 22#include <media/media-entity.h> 23#include <media/v4l2-ctrls.h> 24#include <media/v4l2-device.h> 25#include <media/v4l2-subdev.h> 26#include <media/v4l2-mediabus.h> 27#include <media/i2c/s5c73m3.h> 28 29#include "s5c73m3.h" 30 31static int s5c73m3_get_af_status(struct s5c73m3 *state, struct v4l2_ctrl *ctrl) 32{ 33 u16 reg = REG_AF_STATUS_UNFOCUSED; 34 35 int ret = s5c73m3_read(state, REG_AF_STATUS, ®); 36 37 switch (reg) { 38 case REG_CAF_STATUS_FIND_SEARCH_DIR: 39 case REG_AF_STATUS_FOCUSING: 40 case REG_CAF_STATUS_FOCUSING: 41 ctrl->val = V4L2_AUTO_FOCUS_STATUS_BUSY; 42 break; 43 case REG_CAF_STATUS_FOCUSED: 44 case REG_AF_STATUS_FOCUSED: 45 ctrl->val = V4L2_AUTO_FOCUS_STATUS_REACHED; 46 break; 47 default: 48 v4l2_info(&state->sensor_sd, "Unknown AF status %#x\n", reg); 49 fallthrough; 50 case REG_CAF_STATUS_UNFOCUSED: 51 case REG_AF_STATUS_UNFOCUSED: 52 case REG_AF_STATUS_INVALID: 53 ctrl->val = V4L2_AUTO_FOCUS_STATUS_FAILED; 54 break; 55 } 56 57 return ret; 58} 59 60static int s5c73m3_g_volatile_ctrl(struct v4l2_ctrl *ctrl) 61{ 62 struct v4l2_subdev *sd = ctrl_to_sensor_sd(ctrl); 63 struct s5c73m3 *state = sensor_sd_to_s5c73m3(sd); 64 int ret; 65 66 if (state->power == 0) 67 return -EBUSY; 68 69 switch (ctrl->id) { 70 case V4L2_CID_FOCUS_AUTO: 71 ret = s5c73m3_get_af_status(state, state->ctrls.af_status); 72 if (ret) 73 return ret; 74 break; 75 } 76 77 return 0; 78} 79 80static int s5c73m3_set_colorfx(struct s5c73m3 *state, int val) 81{ 82 static const unsigned short colorfx[][2] = { 83 { V4L2_COLORFX_NONE, COMM_IMAGE_EFFECT_NONE }, 84 { V4L2_COLORFX_BW, COMM_IMAGE_EFFECT_MONO }, 85 { V4L2_COLORFX_SEPIA, COMM_IMAGE_EFFECT_SEPIA }, 86 { V4L2_COLORFX_NEGATIVE, COMM_IMAGE_EFFECT_NEGATIVE }, 87 { V4L2_COLORFX_AQUA, COMM_IMAGE_EFFECT_AQUA }, 88 }; 89 int i; 90 91 for (i = 0; i < ARRAY_SIZE(colorfx); i++) { 92 if (colorfx[i][0] != val) 93 continue; 94 95 v4l2_dbg(1, s5c73m3_dbg, &state->sensor_sd, 96 "Setting %s color effect\n", 97 v4l2_ctrl_get_menu(state->ctrls.colorfx->id)[i]); 98 99 return s5c73m3_isp_command(state, COMM_IMAGE_EFFECT, 100 colorfx[i][1]); 101 } 102 return -EINVAL; 103} 104 105/* Set exposure metering/exposure bias */ 106static int s5c73m3_set_exposure(struct s5c73m3 *state, int auto_exp) 107{ 108 struct v4l2_subdev *sd = &state->sensor_sd; 109 struct s5c73m3_ctrls *ctrls = &state->ctrls; 110 int ret = 0; 111 112 if (ctrls->exposure_metering->is_new) { 113 u16 metering; 114 115 switch (ctrls->exposure_metering->val) { 116 case V4L2_EXPOSURE_METERING_CENTER_WEIGHTED: 117 metering = COMM_METERING_CENTER; 118 break; 119 case V4L2_EXPOSURE_METERING_SPOT: 120 metering = COMM_METERING_SPOT; 121 break; 122 default: 123 metering = COMM_METERING_AVERAGE; 124 break; 125 } 126 127 ret = s5c73m3_isp_command(state, COMM_METERING, metering); 128 } 129 130 if (!ret && ctrls->exposure_bias->is_new) { 131 u16 exp_bias = ctrls->exposure_bias->val; 132 ret = s5c73m3_isp_command(state, COMM_EV, exp_bias); 133 } 134 135 v4l2_dbg(1, s5c73m3_dbg, sd, 136 "%s: exposure bias: %#x, metering: %#x (%d)\n", __func__, 137 ctrls->exposure_bias->val, ctrls->exposure_metering->val, ret); 138 139 return ret; 140} 141 142static int s5c73m3_set_white_balance(struct s5c73m3 *state, int val) 143{ 144 static const unsigned short wb[][2] = { 145 { V4L2_WHITE_BALANCE_INCANDESCENT, COMM_AWB_MODE_INCANDESCENT}, 146 { V4L2_WHITE_BALANCE_FLUORESCENT, COMM_AWB_MODE_FLUORESCENT1}, 147 { V4L2_WHITE_BALANCE_FLUORESCENT_H, COMM_AWB_MODE_FLUORESCENT2}, 148 { V4L2_WHITE_BALANCE_CLOUDY, COMM_AWB_MODE_CLOUDY}, 149 { V4L2_WHITE_BALANCE_DAYLIGHT, COMM_AWB_MODE_DAYLIGHT}, 150 { V4L2_WHITE_BALANCE_AUTO, COMM_AWB_MODE_AUTO}, 151 }; 152 int i; 153 154 for (i = 0; i < ARRAY_SIZE(wb); i++) { 155 if (wb[i][0] != val) 156 continue; 157 158 v4l2_dbg(1, s5c73m3_dbg, &state->sensor_sd, 159 "Setting white balance to: %s\n", 160 v4l2_ctrl_get_menu(state->ctrls.auto_wb->id)[i]); 161 162 return s5c73m3_isp_command(state, COMM_AWB_MODE, wb[i][1]); 163 } 164 165 return -EINVAL; 166} 167 168static int s5c73m3_af_run(struct s5c73m3 *state, bool on) 169{ 170 struct s5c73m3_ctrls *c = &state->ctrls; 171 172 if (!on) 173 return s5c73m3_isp_command(state, COMM_AF_CON, 174 COMM_AF_CON_STOP); 175 176 if (c->focus_auto->val) 177 return s5c73m3_isp_command(state, COMM_AF_MODE, 178 COMM_AF_MODE_PREVIEW_CAF_START); 179 180 return s5c73m3_isp_command(state, COMM_AF_CON, COMM_AF_CON_START); 181} 182 183static int s5c73m3_3a_lock(struct s5c73m3 *state, struct v4l2_ctrl *ctrl) 184{ 185 bool awb_lock = ctrl->val & V4L2_LOCK_WHITE_BALANCE; 186 bool ae_lock = ctrl->val & V4L2_LOCK_EXPOSURE; 187 bool af_lock = ctrl->val & V4L2_LOCK_FOCUS; 188 int ret = 0; 189 190 if ((ctrl->val ^ ctrl->cur.val) & V4L2_LOCK_EXPOSURE) { 191 ret = s5c73m3_isp_command(state, COMM_AE_CON, 192 ae_lock ? COMM_AE_STOP : COMM_AE_START); 193 if (ret) 194 return ret; 195 } 196 197 if (((ctrl->val ^ ctrl->cur.val) & V4L2_LOCK_WHITE_BALANCE) 198 && state->ctrls.auto_wb->val) { 199 ret = s5c73m3_isp_command(state, COMM_AWB_CON, 200 awb_lock ? COMM_AWB_STOP : COMM_AWB_START); 201 if (ret) 202 return ret; 203 } 204 205 if ((ctrl->val ^ ctrl->cur.val) & V4L2_LOCK_FOCUS) 206 ret = s5c73m3_af_run(state, !af_lock); 207 208 return ret; 209} 210 211static int s5c73m3_set_auto_focus(struct s5c73m3 *state, int caf) 212{ 213 struct s5c73m3_ctrls *c = &state->ctrls; 214 int ret = 1; 215 216 if (c->af_distance->is_new) { 217 u16 mode = (c->af_distance->val == V4L2_AUTO_FOCUS_RANGE_MACRO) 218 ? COMM_AF_MODE_MACRO : COMM_AF_MODE_NORMAL; 219 ret = s5c73m3_isp_command(state, COMM_AF_MODE, mode); 220 if (ret != 0) 221 return ret; 222 } 223 224 if (!ret || (c->focus_auto->is_new && c->focus_auto->val) || 225 c->af_start->is_new) 226 ret = s5c73m3_af_run(state, 1); 227 else if ((c->focus_auto->is_new && !c->focus_auto->val) || 228 c->af_stop->is_new) 229 ret = s5c73m3_af_run(state, 0); 230 else 231 ret = 0; 232 233 return ret; 234} 235 236static int s5c73m3_set_contrast(struct s5c73m3 *state, int val) 237{ 238 u16 reg = (val < 0) ? -val + 2 : val; 239 return s5c73m3_isp_command(state, COMM_CONTRAST, reg); 240} 241 242static int s5c73m3_set_saturation(struct s5c73m3 *state, int val) 243{ 244 u16 reg = (val < 0) ? -val + 2 : val; 245 return s5c73m3_isp_command(state, COMM_SATURATION, reg); 246} 247 248static int s5c73m3_set_sharpness(struct s5c73m3 *state, int val) 249{ 250 u16 reg = (val < 0) ? -val + 2 : val; 251 return s5c73m3_isp_command(state, COMM_SHARPNESS, reg); 252} 253 254static int s5c73m3_set_iso(struct s5c73m3 *state, int val) 255{ 256 u32 iso; 257 258 if (val == V4L2_ISO_SENSITIVITY_MANUAL) 259 iso = state->ctrls.iso->val + 1; 260 else 261 iso = 0; 262 263 return s5c73m3_isp_command(state, COMM_ISO, iso); 264} 265 266static int s5c73m3_set_stabilization(struct s5c73m3 *state, int val) 267{ 268 struct v4l2_subdev *sd = &state->sensor_sd; 269 270 v4l2_dbg(1, s5c73m3_dbg, sd, "Image stabilization: %d\n", val); 271 272 return s5c73m3_isp_command(state, COMM_FRAME_RATE, val ? 273 COMM_FRAME_RATE_ANTI_SHAKE : COMM_FRAME_RATE_AUTO_SET); 274} 275 276static int s5c73m3_set_jpeg_quality(struct s5c73m3 *state, int quality) 277{ 278 int reg; 279 280 if (quality <= 65) 281 reg = COMM_IMAGE_QUALITY_NORMAL; 282 else if (quality <= 75) 283 reg = COMM_IMAGE_QUALITY_FINE; 284 else 285 reg = COMM_IMAGE_QUALITY_SUPERFINE; 286 287 return s5c73m3_isp_command(state, COMM_IMAGE_QUALITY, reg); 288} 289 290static int s5c73m3_set_scene_program(struct s5c73m3 *state, int val) 291{ 292 static const unsigned short scene_lookup[] = { 293 COMM_SCENE_MODE_NONE, /* V4L2_SCENE_MODE_NONE */ 294 COMM_SCENE_MODE_AGAINST_LIGHT,/* V4L2_SCENE_MODE_BACKLIGHT */ 295 COMM_SCENE_MODE_BEACH, /* V4L2_SCENE_MODE_BEACH_SNOW */ 296 COMM_SCENE_MODE_CANDLE, /* V4L2_SCENE_MODE_CANDLE_LIGHT */ 297 COMM_SCENE_MODE_DAWN, /* V4L2_SCENE_MODE_DAWN_DUSK */ 298 COMM_SCENE_MODE_FALL, /* V4L2_SCENE_MODE_FALL_COLORS */ 299 COMM_SCENE_MODE_FIRE, /* V4L2_SCENE_MODE_FIREWORKS */ 300 COMM_SCENE_MODE_LANDSCAPE, /* V4L2_SCENE_MODE_LANDSCAPE */ 301 COMM_SCENE_MODE_NIGHT, /* V4L2_SCENE_MODE_NIGHT */ 302 COMM_SCENE_MODE_INDOOR, /* V4L2_SCENE_MODE_PARTY_INDOOR */ 303 COMM_SCENE_MODE_PORTRAIT, /* V4L2_SCENE_MODE_PORTRAIT */ 304 COMM_SCENE_MODE_SPORTS, /* V4L2_SCENE_MODE_SPORTS */ 305 COMM_SCENE_MODE_SUNSET, /* V4L2_SCENE_MODE_SUNSET */ 306 COMM_SCENE_MODE_TEXT, /* V4L2_SCENE_MODE_TEXT */ 307 }; 308 309 v4l2_dbg(1, s5c73m3_dbg, &state->sensor_sd, "Setting %s scene mode\n", 310 v4l2_ctrl_get_menu(state->ctrls.scene_mode->id)[val]); 311 312 return s5c73m3_isp_command(state, COMM_SCENE_MODE, scene_lookup[val]); 313} 314 315static int s5c73m3_set_power_line_freq(struct s5c73m3 *state, int val) 316{ 317 unsigned int pwr_line_freq = COMM_FLICKER_NONE; 318 319 switch (val) { 320 case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED: 321 pwr_line_freq = COMM_FLICKER_NONE; 322 break; 323 case V4L2_CID_POWER_LINE_FREQUENCY_50HZ: 324 pwr_line_freq = COMM_FLICKER_AUTO_50HZ; 325 break; 326 case V4L2_CID_POWER_LINE_FREQUENCY_60HZ: 327 pwr_line_freq = COMM_FLICKER_AUTO_60HZ; 328 break; 329 default: 330 case V4L2_CID_POWER_LINE_FREQUENCY_AUTO: 331 pwr_line_freq = COMM_FLICKER_NONE; 332 } 333 334 return s5c73m3_isp_command(state, COMM_FLICKER_MODE, pwr_line_freq); 335} 336 337static int s5c73m3_s_ctrl(struct v4l2_ctrl *ctrl) 338{ 339 struct v4l2_subdev *sd = ctrl_to_sensor_sd(ctrl); 340 struct s5c73m3 *state = sensor_sd_to_s5c73m3(sd); 341 int ret = 0; 342 343 v4l2_dbg(1, s5c73m3_dbg, sd, "set_ctrl: %s, value: %d\n", 344 ctrl->name, ctrl->val); 345 346 mutex_lock(&state->lock); 347 /* 348 * If the device is not powered up by the host driver do 349 * not apply any controls to H/W at this time. Instead 350 * the controls will be restored right after power-up. 351 */ 352 if (state->power == 0) 353 goto unlock; 354 355 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE) { 356 ret = -EINVAL; 357 goto unlock; 358 } 359 360 switch (ctrl->id) { 361 case V4L2_CID_3A_LOCK: 362 ret = s5c73m3_3a_lock(state, ctrl); 363 break; 364 365 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: 366 ret = s5c73m3_set_white_balance(state, ctrl->val); 367 break; 368 369 case V4L2_CID_CONTRAST: 370 ret = s5c73m3_set_contrast(state, ctrl->val); 371 break; 372 373 case V4L2_CID_COLORFX: 374 ret = s5c73m3_set_colorfx(state, ctrl->val); 375 break; 376 377 case V4L2_CID_EXPOSURE_AUTO: 378 ret = s5c73m3_set_exposure(state, ctrl->val); 379 break; 380 381 case V4L2_CID_FOCUS_AUTO: 382 ret = s5c73m3_set_auto_focus(state, ctrl->val); 383 break; 384 385 case V4L2_CID_IMAGE_STABILIZATION: 386 ret = s5c73m3_set_stabilization(state, ctrl->val); 387 break; 388 389 case V4L2_CID_ISO_SENSITIVITY: 390 ret = s5c73m3_set_iso(state, ctrl->val); 391 break; 392 393 case V4L2_CID_JPEG_COMPRESSION_QUALITY: 394 ret = s5c73m3_set_jpeg_quality(state, ctrl->val); 395 break; 396 397 case V4L2_CID_POWER_LINE_FREQUENCY: 398 ret = s5c73m3_set_power_line_freq(state, ctrl->val); 399 break; 400 401 case V4L2_CID_SATURATION: 402 ret = s5c73m3_set_saturation(state, ctrl->val); 403 break; 404 405 case V4L2_CID_SCENE_MODE: 406 ret = s5c73m3_set_scene_program(state, ctrl->val); 407 break; 408 409 case V4L2_CID_SHARPNESS: 410 ret = s5c73m3_set_sharpness(state, ctrl->val); 411 break; 412 413 case V4L2_CID_WIDE_DYNAMIC_RANGE: 414 ret = s5c73m3_isp_command(state, COMM_WDR, !!ctrl->val); 415 break; 416 417 case V4L2_CID_ZOOM_ABSOLUTE: 418 ret = s5c73m3_isp_command(state, COMM_ZOOM_STEP, ctrl->val); 419 break; 420 } 421unlock: 422 mutex_unlock(&state->lock); 423 return ret; 424} 425 426static const struct v4l2_ctrl_ops s5c73m3_ctrl_ops = { 427 .g_volatile_ctrl = s5c73m3_g_volatile_ctrl, 428 .s_ctrl = s5c73m3_s_ctrl, 429}; 430 431/* Supported manual ISO values */ 432static const s64 iso_qmenu[] = { 433 /* COMM_ISO: 0x0001...0x0004 */ 434 100, 200, 400, 800, 435}; 436 437/* Supported exposure bias values (-2.0EV...+2.0EV) */ 438static const s64 ev_bias_qmenu[] = { 439 /* COMM_EV: 0x0000...0x0008 */ 440 -2000, -1500, -1000, -500, 0, 500, 1000, 1500, 2000 441}; 442 443int s5c73m3_init_controls(struct s5c73m3 *state) 444{ 445 const struct v4l2_ctrl_ops *ops = &s5c73m3_ctrl_ops; 446 struct s5c73m3_ctrls *ctrls = &state->ctrls; 447 struct v4l2_ctrl_handler *hdl = &ctrls->handler; 448 449 int ret = v4l2_ctrl_handler_init(hdl, 22); 450 if (ret) 451 return ret; 452 453 /* White balance */ 454 ctrls->auto_wb = v4l2_ctrl_new_std_menu(hdl, ops, 455 V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE, 456 9, ~0x15e, V4L2_WHITE_BALANCE_AUTO); 457 458 /* Exposure (only automatic exposure) */ 459 ctrls->auto_exposure = v4l2_ctrl_new_std_menu(hdl, ops, 460 V4L2_CID_EXPOSURE_AUTO, 0, ~0x01, V4L2_EXPOSURE_AUTO); 461 462 ctrls->exposure_bias = v4l2_ctrl_new_int_menu(hdl, ops, 463 V4L2_CID_AUTO_EXPOSURE_BIAS, 464 ARRAY_SIZE(ev_bias_qmenu) - 1, 465 ARRAY_SIZE(ev_bias_qmenu)/2 - 1, 466 ev_bias_qmenu); 467 468 ctrls->exposure_metering = v4l2_ctrl_new_std_menu(hdl, ops, 469 V4L2_CID_EXPOSURE_METERING, 470 2, ~0x7, V4L2_EXPOSURE_METERING_AVERAGE); 471 472 /* Auto focus */ 473 ctrls->focus_auto = v4l2_ctrl_new_std(hdl, ops, 474 V4L2_CID_FOCUS_AUTO, 0, 1, 1, 0); 475 476 ctrls->af_start = v4l2_ctrl_new_std(hdl, ops, 477 V4L2_CID_AUTO_FOCUS_START, 0, 1, 1, 0); 478 479 ctrls->af_stop = v4l2_ctrl_new_std(hdl, ops, 480 V4L2_CID_AUTO_FOCUS_STOP, 0, 1, 1, 0); 481 482 ctrls->af_status = v4l2_ctrl_new_std(hdl, ops, 483 V4L2_CID_AUTO_FOCUS_STATUS, 0, 484 (V4L2_AUTO_FOCUS_STATUS_BUSY | 485 V4L2_AUTO_FOCUS_STATUS_REACHED | 486 V4L2_AUTO_FOCUS_STATUS_FAILED), 487 0, V4L2_AUTO_FOCUS_STATUS_IDLE); 488 489 ctrls->af_distance = v4l2_ctrl_new_std_menu(hdl, ops, 490 V4L2_CID_AUTO_FOCUS_RANGE, 491 V4L2_AUTO_FOCUS_RANGE_MACRO, 492 ~(1 << V4L2_AUTO_FOCUS_RANGE_NORMAL | 493 1 << V4L2_AUTO_FOCUS_RANGE_MACRO), 494 V4L2_AUTO_FOCUS_RANGE_NORMAL); 495 /* ISO sensitivity */ 496 ctrls->auto_iso = v4l2_ctrl_new_std_menu(hdl, ops, 497 V4L2_CID_ISO_SENSITIVITY_AUTO, 1, 0, 498 V4L2_ISO_SENSITIVITY_AUTO); 499 500 ctrls->iso = v4l2_ctrl_new_int_menu(hdl, ops, 501 V4L2_CID_ISO_SENSITIVITY, ARRAY_SIZE(iso_qmenu) - 1, 502 ARRAY_SIZE(iso_qmenu)/2 - 1, iso_qmenu); 503 504 ctrls->contrast = v4l2_ctrl_new_std(hdl, ops, 505 V4L2_CID_CONTRAST, -2, 2, 1, 0); 506 507 ctrls->saturation = v4l2_ctrl_new_std(hdl, ops, 508 V4L2_CID_SATURATION, -2, 2, 1, 0); 509 510 ctrls->sharpness = v4l2_ctrl_new_std(hdl, ops, 511 V4L2_CID_SHARPNESS, -2, 2, 1, 0); 512 513 ctrls->zoom = v4l2_ctrl_new_std(hdl, ops, 514 V4L2_CID_ZOOM_ABSOLUTE, 0, 30, 1, 0); 515 516 ctrls->colorfx = v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_COLORFX, 517 V4L2_COLORFX_AQUA, ~0x40f, V4L2_COLORFX_NONE); 518 519 ctrls->wdr = v4l2_ctrl_new_std(hdl, ops, 520 V4L2_CID_WIDE_DYNAMIC_RANGE, 0, 1, 1, 0); 521 522 ctrls->stabilization = v4l2_ctrl_new_std(hdl, ops, 523 V4L2_CID_IMAGE_STABILIZATION, 0, 1, 1, 0); 524 525 v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_POWER_LINE_FREQUENCY, 526 V4L2_CID_POWER_LINE_FREQUENCY_AUTO, 0, 527 V4L2_CID_POWER_LINE_FREQUENCY_AUTO); 528 529 ctrls->jpeg_quality = v4l2_ctrl_new_std(hdl, ops, 530 V4L2_CID_JPEG_COMPRESSION_QUALITY, 1, 100, 1, 80); 531 532 ctrls->scene_mode = v4l2_ctrl_new_std_menu(hdl, ops, 533 V4L2_CID_SCENE_MODE, V4L2_SCENE_MODE_TEXT, ~0x3fff, 534 V4L2_SCENE_MODE_NONE); 535 536 ctrls->aaa_lock = v4l2_ctrl_new_std(hdl, ops, 537 V4L2_CID_3A_LOCK, 0, 0x7, 0, 0); 538 539 if (hdl->error) { 540 ret = hdl->error; 541 v4l2_ctrl_handler_free(hdl); 542 return ret; 543 } 544 545 v4l2_ctrl_auto_cluster(3, &ctrls->auto_exposure, 0, false); 546 ctrls->auto_iso->flags |= V4L2_CTRL_FLAG_VOLATILE | 547 V4L2_CTRL_FLAG_UPDATE; 548 v4l2_ctrl_auto_cluster(2, &ctrls->auto_iso, 0, false); 549 ctrls->af_status->flags |= V4L2_CTRL_FLAG_VOLATILE; 550 v4l2_ctrl_cluster(5, &ctrls->focus_auto); 551 552 state->sensor_sd.ctrl_handler = hdl; 553 554 return 0; 555} 556