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