1 /*
2 * Copyright (c) 2019 Rockchip Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 */
17
18 #include "SensorHw.h"
19
20 #include <linux/v4l2-subdev.h>
21
22 #include <algorithm>
23
24 #include "code_to_pixel_format.h"
25
26 namespace RkCam {
27
28 uint16_t SensorHw::DEFAULT_POOL_SIZE = MAX_AEC_EFFECT_FNUM * 4;
29
SensorHw(const char * name)30 SensorHw::SensorHw(const char* name)
31 : BaseSensorHw (name)
32 , _working_mode(RK_AIQ_WORKING_MODE_NORMAL)
33 , _first(true)
34 {
35 ENTER_CAMHW_FUNCTION();
36 _last_exp_time = nullptr;
37 _last_exp_gain = nullptr;
38 _gain_delay = 0;
39 _time_delay = 0;
40 _gain_delayed = false;
41 _frame_sequence = -1;
42 _dcg_gain_mode_delay = 0;
43 _dcg_gain_mode_delayed = false;
44 _expParamsPool = new RkAiqSensorExpParamsPool("SensorLocalExpParams", SensorHw::DEFAULT_POOL_SIZE);
45 _flip = false;
46 _mirror = false;
47 _update_mirror_flip = false;
48 _is_i2c_exp = false;
49 mTbIsPreAiq = false;
50
51 EXIT_CAMHW_FUNCTION();
52 }
53
~SensorHw()54 SensorHw::~SensorHw()
55 {
56 ENTER_CAMHW_FUNCTION();
57 EXIT_CAMHW_FUNCTION();
58 }
59
60 XCamReturn
setHdrSensorExposure(RKAiqAecExpInfo_t * expPar)61 SensorHw::setHdrSensorExposure(RKAiqAecExpInfo_t* expPar)
62 {
63 ENTER_CAMHW_FUNCTION();
64 struct hdrae_exp_s hdrExp;
65 int frame_line_length;
66 struct v4l2_control ctrl;
67 rk_aiq_exposure_sensor_descriptor sensor_desc;
68
69 LOGD_CAMHW_SUBM(SENSOR_SUBM, "camId: %d, frameId: %d: lexp: 0x%x-0x%x, mexp: 0x%x-0x%x, sexp: 0x%x-0x%x, "
70 "l-dcg %d, m-dcg %d, s-dcg %d\n",
71 mCamPhyId, _frame_sequence,
72 expPar->HdrExp[2].exp_sensor_params.analog_gain_code_global,
73 expPar->HdrExp[2].exp_sensor_params.coarse_integration_time,
74 expPar->HdrExp[1].exp_sensor_params.analog_gain_code_global,
75 expPar->HdrExp[1].exp_sensor_params.coarse_integration_time,
76 expPar->HdrExp[0].exp_sensor_params.analog_gain_code_global,
77 expPar->HdrExp[0].exp_sensor_params.coarse_integration_time,
78 expPar->HdrExp[2].exp_real_params.dcg_mode,
79 expPar->HdrExp[1].exp_real_params.dcg_mode,
80 expPar->HdrExp[0].exp_real_params.dcg_mode);
81
82 get_sensor_descriptor (&sensor_desc);
83
84 frame_line_length = expPar->frame_length_lines > sensor_desc.line_periods_per_field ?
85 expPar->frame_length_lines : sensor_desc.line_periods_per_field;
86
87 memset(&ctrl, 0, sizeof(ctrl));
88 ctrl.id = V4L2_CID_VBLANK;
89 ctrl.value = frame_line_length - sensor_desc.sensor_output_height;
90 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
91 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set vblank result(val: %d)", ctrl.value);
92 return XCAM_RETURN_ERROR_IOCTL;
93 }
94
95 memset(&ctrl, 0, sizeof(ctrl));
96 ctrl.id = V4L2_CID_ANALOGUE_GAIN;
97 ctrl.value = expPar->LinearExp.exp_sensor_params.analog_gain_code_global;
98 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
99 LOGD_CAMHW_SUBM(SENSOR_SUBM, "failed to set again result(val: %d)", ctrl.value);
100 return XCAM_RETURN_ERROR_IOCTL;
101 }
102
103 memset(&hdrExp, 0, sizeof(hdrExp));
104 hdrExp.long_exp_reg =
105 expPar->HdrExp[2].exp_sensor_params.coarse_integration_time;
106 hdrExp.long_gain_reg =
107 expPar->HdrExp[2].exp_sensor_params.analog_gain_code_global;
108 hdrExp.middle_exp_reg =
109 expPar->HdrExp[1].exp_sensor_params.coarse_integration_time;
110 hdrExp.middle_gain_reg =
111 expPar->HdrExp[1].exp_sensor_params.analog_gain_code_global;
112 hdrExp.short_exp_reg =
113 expPar->HdrExp[0].exp_sensor_params.coarse_integration_time;
114 hdrExp.short_gain_reg =
115 expPar->HdrExp[0].exp_sensor_params.analog_gain_code_global;
116
117 int dcg_mode = expPar->HdrExp[2].exp_real_params.dcg_mode;
118
119 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
120 hdrExp.long_cg_mode = GAIN_MODE_HCG;
121 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
122 hdrExp.long_cg_mode = GAIN_MODE_LCG;
123 else //default
124 hdrExp.long_cg_mode = GAIN_MODE_LCG;
125
126 dcg_mode = expPar->HdrExp[1].exp_real_params.dcg_mode;
127
128 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
129 hdrExp.middle_cg_mode = GAIN_MODE_HCG;
130 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
131 hdrExp.middle_cg_mode = GAIN_MODE_LCG;
132 else //default
133 hdrExp.middle_cg_mode = GAIN_MODE_LCG;
134
135 dcg_mode = expPar->HdrExp[0].exp_real_params.dcg_mode;
136
137 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
138 hdrExp.short_cg_mode = GAIN_MODE_HCG;
139 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
140 hdrExp.short_cg_mode = GAIN_MODE_LCG;
141 else //default
142 hdrExp.short_cg_mode = GAIN_MODE_LCG;
143
144 if (io_control(SENSOR_CMD_SET_HDRAE_EXP, &hdrExp) < 0) {
145 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set hdrExp exp");
146 return XCAM_RETURN_ERROR_IOCTL;
147 }
148
149 EXIT_CAMHW_FUNCTION();
150 return XCAM_RETURN_NO_ERROR;
151 }
152
153 XCamReturn
setSensorDpcc(Sensor_dpcc_res_t * SensorDpccInfo)154 SensorHw::setSensorDpcc(Sensor_dpcc_res_t* SensorDpccInfo)
155 {
156 struct rkmodule_dpcc_cfg dpcc_cfg;
157
158 dpcc_cfg.enable = SensorDpccInfo->enable;
159 dpcc_cfg.cur_single_dpcc = SensorDpccInfo->cur_single_dpcc;
160 dpcc_cfg.cur_multiple_dpcc = SensorDpccInfo->cur_multiple_dpcc;
161 dpcc_cfg.total_dpcc = SensorDpccInfo->total_dpcc;
162 LOG1_CAMHW_SUBM(SENSOR_SUBM, "camId: %d, frameId: %d: enable:%d,single:%d,multi:%d,total:%d",
163 mCamPhyId, _frame_sequence,
164 dpcc_cfg.enable, dpcc_cfg.cur_single_dpcc,
165 dpcc_cfg.cur_multiple_dpcc, dpcc_cfg.total_dpcc);
166 if (io_control(RKMODULE_SET_DPCC_CFG, &dpcc_cfg) < 0) {
167 //LOGE_CAMHW_SUBM(SENSOR_SUBM,"failed to set sensor dpcc");
168 return XCAM_RETURN_ERROR_IOCTL;
169 }
170
171 return XCAM_RETURN_NO_ERROR;
172 }
173
174 XCamReturn
setLinearSensorExposure(RKAiqAecExpInfo_t * expPar)175 SensorHw::setLinearSensorExposure(RKAiqAecExpInfo_t* expPar)
176 {
177 ENTER_CAMHW_FUNCTION();
178 int frame_line_length;
179 struct v4l2_control ctrl;
180 rk_aiq_exposure_sensor_descriptor sensor_desc;
181
182 LOGD_CAMHW_SUBM(SENSOR_SUBM, "camId: %d, frameId: %d: a-gain: %d, time: %d, dcg: %d, snr: %d\n",
183 mCamPhyId, _frame_sequence,
184 expPar->LinearExp.exp_sensor_params.analog_gain_code_global,
185 expPar->LinearExp.exp_sensor_params.coarse_integration_time,
186 expPar->LinearExp.exp_real_params.dcg_mode,
187 expPar->CISFeature.SNR);
188
189 // set vts before exposure time firstly
190 get_sensor_descriptor (&sensor_desc);
191
192 frame_line_length = expPar->frame_length_lines > sensor_desc.line_periods_per_field ?
193 expPar->frame_length_lines : sensor_desc.line_periods_per_field;
194
195 memset(&ctrl, 0, sizeof(ctrl));
196 ctrl.id = V4L2_CID_VBLANK;
197 ctrl.value = frame_line_length - sensor_desc.sensor_output_height;
198 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
199 LOGE_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set vblank result(val: %d)", mCamPhyId, ctrl.value);
200 return XCAM_RETURN_ERROR_IOCTL;
201 }
202
203 int dcg_mode = expPar->LinearExp.exp_real_params.dcg_mode;
204 int dcg_mode_drv;
205
206 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
207 dcg_mode_drv = GAIN_MODE_HCG;
208 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
209 dcg_mode_drv = GAIN_MODE_LCG;
210 else //default
211 dcg_mode_drv = -1;
212
213 if (dcg_mode_drv != -1 ) {
214 if (io_control(RKMODULE_SET_CONVERSION_GAIN, &dcg_mode_drv) < 0) {
215 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set conversion gain !", mCamPhyId);
216 return XCAM_RETURN_ERROR_IOCTL;
217 }
218 }
219
220 memset(&ctrl, 0, sizeof(ctrl));
221 ctrl.id = V4L2_CID_ANALOGUE_GAIN;
222 ctrl.value = expPar->LinearExp.exp_sensor_params.analog_gain_code_global;
223 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
224 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set again result(val: %d)", mCamPhyId, ctrl.value);
225 return XCAM_RETURN_ERROR_IOCTL;
226 }
227
228 if (expPar->LinearExp.exp_sensor_params.digital_gain_global != 0) {
229 memset(&ctrl, 0, sizeof(ctrl));
230 ctrl.id = V4L2_CID_GAIN;
231 ctrl.value = expPar->LinearExp.exp_sensor_params.digital_gain_global;
232 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
233 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set dgain result(val: %d)", mCamPhyId, ctrl.value);
234 return XCAM_RETURN_ERROR_IOCTL;
235 }
236 }
237
238 if (expPar->LinearExp.exp_sensor_params.coarse_integration_time != 0) {
239 memset(&ctrl, 0, sizeof(ctrl));
240 ctrl.id = V4L2_CID_EXPOSURE;
241 ctrl.value = expPar->LinearExp.exp_sensor_params.coarse_integration_time;
242 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
243 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set dgain result(val: %d)", mCamPhyId, ctrl.value);
244 return XCAM_RETURN_ERROR_IOCTL;
245 }
246 }
247
248 EXIT_CAMHW_FUNCTION();
249 return XCAM_RETURN_NO_ERROR;
250 }
251
252 XCamReturn
setLinearSensorExposure(pending_split_exps_t * expPar)253 SensorHw::setLinearSensorExposure(pending_split_exps_t* expPar)
254 {
255 ENTER_CAMHW_FUNCTION();
256 int frame_line_length;
257 struct v4l2_control ctrl;
258 rk_aiq_exposure_sensor_descriptor sensor_desc;
259
260 LOGD_CAMHW_SUBM(SENSOR_SUBM, "%s: cam%d frameid: %u, a-gain: %d, time: %d, dcg: %d\n", __FUNCTION__,
261 mCamPhyId,
262 _frame_sequence, expPar->rk_exp_res.sensor_params[0].analog_gain_code_global,
263 expPar->rk_exp_res.sensor_params[0].coarse_integration_time,
264 expPar->rk_exp_res.dcg_mode[0]);
265
266 // set vts before exposure time firstly
267 get_sensor_descriptor (&sensor_desc);
268
269 frame_line_length = expPar->rk_exp_res.frame_length_lines > sensor_desc.line_periods_per_field ?
270 expPar->rk_exp_res.frame_length_lines : sensor_desc.line_periods_per_field;
271
272 memset(&ctrl, 0, sizeof(ctrl));
273 ctrl.id = V4L2_CID_VBLANK;
274 ctrl.value = frame_line_length - sensor_desc.sensor_output_height;
275 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
276 LOGE_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set vblank result(val: %d)", mCamPhyId, ctrl.value);
277 return XCAM_RETURN_ERROR_IOCTL;
278 }
279
280 if (expPar->rk_exp_res.update_bits & (1 << RK_EXP_UPDATE_DCG)) {
281 int dcg_mode = expPar->rk_exp_res.dcg_mode[0];
282 int dcg_mode_drv;
283
284 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
285 dcg_mode_drv = GAIN_MODE_HCG;
286 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
287 dcg_mode_drv = GAIN_MODE_LCG;
288 else //default
289 dcg_mode_drv = -1;
290
291 if (dcg_mode_drv != -1 ) {
292 if (io_control(RKMODULE_SET_CONVERSION_GAIN, &dcg_mode_drv) < 0) {
293 LOGD_CAMHW_SUBM(SENSOR_SUBM, "failed to set conversion gain !");
294 return XCAM_RETURN_ERROR_IOCTL;
295 }
296 }
297 }
298
299 if (expPar->rk_exp_res.update_bits & (1 << RK_EXP_UPDATE_GAIN)) {
300 memset(&ctrl, 0, sizeof(ctrl));
301 ctrl.id = V4L2_CID_ANALOGUE_GAIN;
302 ctrl.value = expPar->rk_exp_res.sensor_params[0].analog_gain_code_global;
303 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
304 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set again result(val: %d)", mCamPhyId, ctrl.value);
305 return XCAM_RETURN_ERROR_IOCTL;
306 }
307
308 if (expPar->rk_exp_res.sensor_params[0].digital_gain_global != 0) {
309 memset(&ctrl, 0, sizeof(ctrl));
310 ctrl.id = V4L2_CID_GAIN;
311 ctrl.value = expPar->rk_exp_res.sensor_params[0].digital_gain_global;
312 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
313 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set dgain result(val: %d)", mCamPhyId, ctrl.value);
314 return XCAM_RETURN_ERROR_IOCTL;
315 }
316 }
317 }
318
319 if (expPar->rk_exp_res.update_bits & (1 << RK_EXP_UPDATE_TIME)) {
320 if (expPar->rk_exp_res.sensor_params[0].coarse_integration_time != 0) {
321 memset(&ctrl, 0, sizeof(ctrl));
322 ctrl.id = V4L2_CID_EXPOSURE;
323 ctrl.value = expPar->rk_exp_res.sensor_params[0].coarse_integration_time;
324 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
325 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set dgain result(val: %d)", mCamPhyId, ctrl.value);
326 return XCAM_RETURN_ERROR_IOCTL;
327 }
328 }
329 }
330
331 EXIT_CAMHW_FUNCTION();
332 return XCAM_RETURN_NO_ERROR;
333 }
334
335 XCamReturn
setHdrSensorExposure(pending_split_exps_t * expPar)336 SensorHw::setHdrSensorExposure(pending_split_exps_t* expPar)
337 {
338 ENTER_CAMHW_FUNCTION();
339 struct hdrae_exp_s hdrExp;
340 int frame_line_length;
341 struct v4l2_control ctrl;
342 rk_aiq_exposure_sensor_descriptor sensor_desc;
343
344 LOGD_CAMHW_SUBM(SENSOR_SUBM, "camId: %d, frameId: %d: lexp: 0x%x-0x%x, mexp: 0x%x-0x%x, sexp: 0x%x-0x%x, "
345 "l-dcg %d, m-dcg %d, s-dcg %d\n",
346 mCamPhyId, _frame_sequence,
347 expPar->rk_exp_res.sensor_params[2].analog_gain_code_global,
348 expPar->rk_exp_res.sensor_params[2].coarse_integration_time,
349 expPar->rk_exp_res.sensor_params[1].analog_gain_code_global,
350 expPar->rk_exp_res.sensor_params[1].coarse_integration_time,
351 expPar->rk_exp_res.sensor_params[0].analog_gain_code_global,
352 expPar->rk_exp_res.sensor_params[0].coarse_integration_time,
353 expPar->rk_exp_res.dcg_mode[2],
354 expPar->rk_exp_res.dcg_mode[1],
355 expPar->rk_exp_res.dcg_mode[0]);
356
357 get_sensor_descriptor (&sensor_desc);
358
359 frame_line_length = expPar->rk_exp_res.frame_length_lines > sensor_desc.line_periods_per_field ?
360 expPar->rk_exp_res.frame_length_lines : sensor_desc.line_periods_per_field;
361
362 memset(&ctrl, 0, sizeof(ctrl));
363 ctrl.id = V4L2_CID_VBLANK;
364 ctrl.value = frame_line_length - sensor_desc.sensor_output_height;
365 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
366 LOGE_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set vblank result(val: %d)", mCamPhyId, ctrl.value);
367 return XCAM_RETURN_ERROR_IOCTL;
368 }
369
370 memset(&hdrExp, 0, sizeof(hdrExp));
371 hdrExp.long_exp_reg =
372 expPar->rk_exp_res.sensor_params[2].coarse_integration_time;
373 hdrExp.long_gain_reg =
374 expPar->rk_exp_res.sensor_params[2].analog_gain_code_global;
375 hdrExp.middle_exp_reg =
376 expPar->rk_exp_res.sensor_params[1].coarse_integration_time;
377 hdrExp.middle_gain_reg =
378 expPar->rk_exp_res.sensor_params[1].analog_gain_code_global;
379 hdrExp.short_exp_reg =
380 expPar->rk_exp_res.sensor_params[0].coarse_integration_time;
381 hdrExp.short_gain_reg =
382 expPar->rk_exp_res.sensor_params[0].analog_gain_code_global;
383
384 int dcg_mode = expPar->rk_exp_res.dcg_mode[2];
385
386 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
387 hdrExp.long_cg_mode = GAIN_MODE_HCG;
388 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
389 hdrExp.long_cg_mode = GAIN_MODE_LCG;
390 else //default
391 hdrExp.long_cg_mode = GAIN_MODE_LCG;
392
393 dcg_mode = expPar->rk_exp_res.dcg_mode[1];
394
395 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
396 hdrExp.middle_cg_mode = GAIN_MODE_HCG;
397 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
398 hdrExp.middle_cg_mode = GAIN_MODE_LCG;
399 else //default
400 hdrExp.middle_cg_mode = GAIN_MODE_LCG;
401
402 dcg_mode = expPar->rk_exp_res.dcg_mode[0];
403
404 if (dcg_mode == 1/*AEC_DCG_MODE_HCG*/)
405 hdrExp.short_cg_mode = GAIN_MODE_HCG;
406 else if (dcg_mode == 0/*AEC_DCG_MODE_LCG*/)
407 hdrExp.short_cg_mode = GAIN_MODE_LCG;
408 else //default
409 hdrExp.short_cg_mode = GAIN_MODE_LCG;
410
411 if (io_control(SENSOR_CMD_SET_HDRAE_EXP, &hdrExp) < 0) {
412 LOGD_CAMHW_SUBM(SENSOR_SUBM, "cam%d failed to set hdrExp exp", mCamPhyId);
413 return XCAM_RETURN_ERROR_IOCTL;
414 }
415
416 EXIT_CAMHW_FUNCTION();
417 return XCAM_RETURN_NO_ERROR;
418 }
419
420 int
get_blank(rk_aiq_exposure_sensor_descriptor * sns_des)421 SensorHw::get_blank(rk_aiq_exposure_sensor_descriptor* sns_des)
422 {
423 struct v4l2_queryctrl ctrl;
424 int horzBlank, vertBlank;
425
426 memset(&ctrl, 0, sizeof(ctrl));
427 ctrl.id = V4L2_CID_HBLANK;
428 if (io_control(VIDIOC_QUERYCTRL, &ctrl) < 0) {
429 return -errno;
430 }
431 horzBlank = ctrl.minimum;
432
433 memset(&ctrl, 0, sizeof(ctrl));
434 ctrl.id = V4L2_CID_VBLANK;
435 if (io_control(VIDIOC_QUERYCTRL, &ctrl) < 0) {
436 return -errno;
437 }
438 vertBlank = ctrl.minimum;
439
440 sns_des->pixel_periods_per_line = horzBlank + sns_des->sensor_output_width;
441 sns_des->line_periods_per_field = vertBlank + sns_des->sensor_output_height;
442
443 return 0;
444 }
445
446 int
get_pixel(rk_aiq_exposure_sensor_descriptor * sns_des)447 SensorHw::get_pixel(rk_aiq_exposure_sensor_descriptor* sns_des)
448 {
449 struct v4l2_ext_controls controls;
450 struct v4l2_ext_control ext_control;
451 signed long pixel;
452
453 memset(&controls, 0, sizeof(controls));
454 memset(&ext_control, 0, sizeof(ext_control));
455
456 ext_control.id = V4L2_CID_PIXEL_RATE;
457 controls.ctrl_class = V4L2_CTRL_ID2CLASS(ext_control.id);
458 controls.count = 1;
459 controls.controls = &ext_control;
460
461 if (io_control(VIDIOC_G_EXT_CTRLS, &controls) < 0)
462 return -errno;
463
464 pixel = ext_control.value64;
465
466 sns_des->pixel_clock_freq_mhz = (float)pixel / 1000000;
467
468 return 0;
469 }
470
471 int
get_sensor_fps(float & fps)472 SensorHw::get_sensor_fps(float& fps)
473 {
474 struct v4l2_subdev_frame_interval finterval;
475
476 memset(&finterval, 0, sizeof(finterval));
477 finterval.pad = 0;
478
479 if (io_control(VIDIOC_SUBDEV_G_FRAME_INTERVAL, &finterval) < 0)
480 return -errno;
481
482 fps = (float)(finterval.interval.denominator) / finterval.interval.numerator;
483
484 return 0;
485 }
486
487 int
get_sensor_desc(rk_aiq_exposure_sensor_descriptor * sns_des)488 SensorHw::get_sensor_desc(rk_aiq_exposure_sensor_descriptor* sns_des)
489 {
490 struct v4l2_subdev_format fmt;
491 uint32_t format_code;
492
493 memset(&fmt, 0, sizeof(fmt));
494 fmt.pad = 0;
495 fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
496
497 if (io_control(VIDIOC_SUBDEV_G_FMT, &fmt) < 0)
498 return -errno;
499
500 sns_des->sensor_output_width = fmt.format.width;
501 sns_des->sensor_output_height = fmt.format.height;
502 sns_des->sensor_pixelformat = get_v4l2_pixelformat(fmt.format.code);
503 return 0;
504 }
505
506 int
get_exposure_range(rk_aiq_exposure_sensor_descriptor * sns_des)507 SensorHw::get_exposure_range(rk_aiq_exposure_sensor_descriptor* sns_des)
508 {
509 struct v4l2_queryctrl ctrl;
510
511 memset(&ctrl, 0, sizeof(ctrl));
512 ctrl.id = V4L2_CID_EXPOSURE;
513
514 if (io_control(VIDIOC_QUERYCTRL, &ctrl) < 0)
515 return -errno;
516
517 sns_des->coarse_integration_time_min = ctrl.minimum;
518 sns_des->coarse_integration_time_max_margin = 10;
519
520 return 0;
521 }
522
523 int
get_nr_switch(rk_aiq_sensor_nr_switch_t * nr_switch)524 SensorHw::get_nr_switch(rk_aiq_sensor_nr_switch_t* nr_switch)
525 {
526 struct rkmodule_nr_switch_threshold nr_switch_drv;
527
528 if (io_control(RKMODULE_GET_NR_SWITCH_THRESHOLD, &nr_switch_drv) < 0) {
529 //LOGE_CAMHW_SUBM(SENSOR_SUBM,"failed to get sensor nr switch");
530 nr_switch->valid = false;
531 return XCAM_RETURN_ERROR_IOCTL;
532 }
533
534 nr_switch->valid = true;
535 nr_switch->direct = nr_switch_drv.direct;
536 nr_switch->up_thres = nr_switch_drv.up_thres;
537 nr_switch->down_thres = nr_switch_drv.down_thres;
538 nr_switch->div_coeff = nr_switch_drv.div_coeff;
539
540 return 0;
541 }
542
543 XCamReturn
get_sensor_descriptor(rk_aiq_exposure_sensor_descriptor * sns_des)544 SensorHw::get_sensor_descriptor(rk_aiq_exposure_sensor_descriptor *sns_des)
545 {
546 memset(sns_des, 0, sizeof(rk_aiq_exposure_sensor_descriptor));
547
548 if (get_sensor_desc(sns_des))
549 return XCAM_RETURN_ERROR_IOCTL;
550
551 if (get_blank(sns_des))
552 return XCAM_RETURN_ERROR_IOCTL;
553
554 /*
555 * pixel rate is not equal to pclk sometimes
556 * prefer to use pclk = ppl * lpp * fps
557 */
558 float fps = 0;
559 if (get_sensor_fps(fps) == 0)
560 sns_des->pixel_clock_freq_mhz =
561 (float)(sns_des->pixel_periods_per_line) *
562 sns_des->line_periods_per_field * fps / 1000000.0;
563 else if (get_pixel(sns_des))
564 return XCAM_RETURN_ERROR_IOCTL;
565
566 if (get_exposure_range(sns_des))
567 return XCAM_RETURN_ERROR_IOCTL;
568
569 if (get_nr_switch(&sns_des->nr_switch)) {
570 // do nothing;
571 }
572
573 return XCAM_RETURN_NO_ERROR;
574 }
575
576 XCamReturn
setI2cDAta(pending_split_exps_t * exps)577 SensorHw::setI2cDAta(pending_split_exps_t* exps) {
578 struct rkmodule_reg regs;
579
580 regs.num_regs = (__u64)(exps->i2c_exp_res.nNumRegs);
581 regs.preg_addr = (__u64)(exps->i2c_exp_res.RegAddr);
582 regs.preg_value = (__u64)(exps->i2c_exp_res.RegValue);
583 regs.preg_addr_bytes = (__u64)(exps->i2c_exp_res.AddrByteNum);
584 regs.preg_value_bytes = (__u64)(exps->i2c_exp_res.ValueByteNum);
585
586 LOG1_CAMHW_SUBM(SENSOR_SUBM, "set sensor reg array num %d ------", exps->i2c_exp_res.nNumRegs);
587 if (exps->i2c_exp_res.nNumRegs <= 0)
588 return XCAM_RETURN_NO_ERROR;
589
590 for (uint32_t i = 0; i < regs.num_regs; i++) {
591 LOG1_CAMHW_SUBM(SENSOR_SUBM, "reg:(0x%04x,%d,0x%04x,%d)",
592 exps->i2c_exp_res.RegAddr[i], exps->i2c_exp_res.AddrByteNum[i],
593 exps->i2c_exp_res.RegValue[i], exps->i2c_exp_res.ValueByteNum[i]);
594 }
595
596 if (io_control(RKMODULE_SET_REGISTER, ®s) < 0) {
597 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set i2c regs !");
598 return XCAM_RETURN_ERROR_IOCTL;
599 }
600
601 return XCAM_RETURN_NO_ERROR;
602 }
603
604 XCamReturn
setExposureParams(SmartPtr<RkAiqExpParamsProxy> & expPar)605 SensorHw::setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar)
606 {
607 ENTER_CAMHW_FUNCTION();
608 SmartLock locker (_mutex);
609 RKAiqAecExpInfoWrapper_t* exp = &expPar->data()->result;
610
611 if (_first) {
612 if (exp->algo_id == 0) {
613 if (exp->ae_proc_res_rk.exp_set_cnt > 0) {
614 int lastIdx = exp->ae_proc_res_rk.exp_set_cnt - 1;
615 exp->new_ae_exp = exp->ae_proc_res_rk.exp_set_tbl[lastIdx];
616 }
617 }
618 if (!exp->exp_i2c_params.bValid) {
619 _is_i2c_exp = false;
620 if (!mTbIsPreAiq) {
621 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL)
622 setLinearSensorExposure(&exp->new_ae_exp);
623 else
624 setHdrSensorExposure(&exp->new_ae_exp);
625 setSensorDpcc(&exp->SensorDpccInfo);
626 }
627 } else {
628 _is_i2c_exp = true;
629 pending_split_exps_t new_exps;
630 memset(&new_exps, 0, sizeof(pending_split_exps_t));
631 new_exps.i2c_exp_res.nNumRegs = exp->exp_i2c_params.nNumRegs;
632 for (uint32_t i = 0; i < exp->exp_i2c_params.nNumRegs; i++) {
633 new_exps.i2c_exp_res.RegAddr[i] = exp->exp_i2c_params.RegAddr[i];
634 new_exps.i2c_exp_res.RegValue[i] = exp->exp_i2c_params.RegValue[i];
635 new_exps.i2c_exp_res.AddrByteNum[i] = exp->exp_i2c_params.AddrByteNum[i];
636 new_exps.i2c_exp_res.ValueByteNum[i] = exp->exp_i2c_params.ValueByteNum[i];
637 }
638 setI2cDAta(&new_exps);
639 }
640
641 SmartPtr<RkAiqSensorExpParamsProxy> expParamsProxy = NULL;
642 if (_expParamsPool->has_free_items()) {
643 expParamsProxy = _expParamsPool->get_item();
644 } else {
645 LOGE_CAMHW_SUBM(SENSOR_SUBM, "%s: no free params buffer!\n", __FUNCTION__);
646 return XCAM_RETURN_ERROR_MEM;
647 }
648 expParamsProxy->data()->aecExpInfo = exp->new_ae_exp;
649 expParamsProxy->data()->SensorDpccInfo = exp->SensorDpccInfo;
650 expParamsProxy->data()->exp_i2c_params = &exp->exp_i2c_params ;
651 _effecting_exp_map[0] = expParamsProxy;
652 _first = false;
653 _last_exp_time = expParamsProxy;
654 _last_exp_gain = expParamsProxy;
655 _last_dcg_gain_mode = expParamsProxy;
656 exp->exp_i2c_params.bValid = false;
657 exp->ae_proc_res_rk.exp_set_cnt = 0;
658 LOGD_CAMHW_SUBM(SENSOR_SUBM, "exp-sync: first set exp, add id[0] to the effected exp map\n");
659 } else {
660 if (mTbIsPreAiq)
661 return XCAM_RETURN_NO_ERROR;
662 if (exp->algo_id == 0) {
663 if (exp->ae_proc_res_rk.exp_set_cnt > 0) {
664 SmartPtr<RkAiqSensorExpParamsProxy> expParamsProxy = NULL;
665
666 LOGV_CAMHW_SUBM(SENSOR_SUBM, "%s: exp_tbl_size:%d, exp_list remain:%d\n", __FUNCTION__,
667 exp->ae_proc_res_rk.exp_set_cnt, _exp_list.size());
668 /* when new exp-table comes, remove elem until meet the first one of last exp-table */
669 if (!_exp_list.empty()) {
670 _exp_list.erase(std::remove_if(
671 _exp_list.begin(), _exp_list.end(),
672 [](const std::pair<SmartPtr<RkAiqSensorExpParamsProxy>, bool>& p) {
673 return !p.second;
674 }), _exp_list.end());
675 }
676
677 SmartPtr<rk_aiq_sensor_exp_info_t> tmp;
678 for(int i = 0; i < exp->ae_proc_res_rk.exp_set_cnt; i++) {
679 if (_expParamsPool->has_free_items()) {
680 expParamsProxy = _expParamsPool->get_item();
681 tmp = expParamsProxy->data();
682 } else {
683 LOGE_CAMHW_SUBM(SENSOR_SUBM, "%s: no free params buffer!\n", __FUNCTION__);
684 return XCAM_RETURN_ERROR_MEM;
685 }
686
687 tmp->aecExpInfo = exp->new_ae_exp;
688 tmp->aecExpInfo.LinearExp = exp->ae_proc_res_rk.exp_set_tbl[i].LinearExp;
689 tmp->aecExpInfo.HdrExp[0] = exp->ae_proc_res_rk.exp_set_tbl[i].HdrExp[0];
690 tmp->aecExpInfo.HdrExp[1] = exp->ae_proc_res_rk.exp_set_tbl[i].HdrExp[1];
691 tmp->aecExpInfo.HdrExp[2] = exp->ae_proc_res_rk.exp_set_tbl[i].HdrExp[2];
692 tmp->aecExpInfo.frame_length_lines = exp->ae_proc_res_rk.exp_set_tbl[i].frame_length_lines;
693 tmp->aecExpInfo.CISFeature.SNR = exp->ae_proc_res_rk.exp_set_tbl[i].CISFeature.SNR;
694 tmp->SensorDpccInfo = exp->SensorDpccInfo;
695 tmp->exp_i2c_params = &exp->exp_i2c_params;
696
697 /* set a flag when it's fisrt elem of exp-table*/
698 _exp_list.push_back(std::make_pair(expParamsProxy, (i == 0 ? true : false)));
699
700 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
701 LOGV_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d add tbl[%d] to list: a-gain: %d, time: %d, snr: %d\n",
702 __FUNCTION__, mCamPhyId, i,
703 tmp->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
704 tmp->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time,
705 tmp->aecExpInfo.CISFeature.SNR);
706 } else {
707 LOGV_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d add tbl[%d] to list: lexp: 0x%x-0x%x, mexp: 0x%x-0x%x, sexp: 0x%x-0x%x\n",
708 __FUNCTION__, mCamPhyId, i,
709 tmp->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
710 tmp->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
711 tmp->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
712 tmp->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
713 tmp->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global,
714 tmp->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time);
715 }
716 }
717 exp->exp_i2c_params.bValid = false;
718 exp->ae_proc_res_rk.exp_set_cnt = 0;
719 }
720 } else {
721 LOGE_CAMHW_SUBM(SENSOR_SUBM, "unsurpported now !");
722 }
723 }
724 EXIT_CAMHW_FUNCTION();
725 return XCAM_RETURN_NO_ERROR;
726 }
727
728 XCamReturn
getEffectiveExpParams(SmartPtr<RkAiqSensorExpParamsProxy> & expParams,uint32_t frame_id)729 SensorHw::getEffectiveExpParams(SmartPtr<RkAiqSensorExpParamsProxy>& expParams, uint32_t frame_id)
730 {
731 ENTER_CAMHW_FUNCTION();
732
733 XCamReturn ret = XCAM_RETURN_NO_ERROR;
734 std::map<int, SmartPtr<RkAiqSensorExpParamsProxy>>::iterator it;
735 int search_id = frame_id == (uint32_t)(-1) ? 0 : frame_id;
736 //#ifdef ADD_LOCK
737 SmartLock locker (_mutex);
738 //#endif
739
740 it = _effecting_exp_map.find(search_id);
741 // havn't found
742 if (it == _effecting_exp_map.end()) {
743 /* use the latest */
744 std::map<int, SmartPtr<RkAiqSensorExpParamsProxy>>::reverse_iterator rit;
745
746 for (rit = _effecting_exp_map.rbegin(); rit != _effecting_exp_map.rend(); rit++) {
747 if (rit->first <= search_id)
748 break;
749 }
750
751 if (rit == _effecting_exp_map.rend()) {
752 if (_effecting_exp_map.size() > 0) {
753 rit = _effecting_exp_map.rbegin();
754 LOGW_CAMHW_SUBM(SENSOR_SUBM, "use effecting exposure of %d for %d, may be something wrong !",
755 rit->first, search_id);
756 } else {
757 LOGE_CAMHW_SUBM(SENSOR_SUBM, "can't find the latest effecting exposure for id %d, impossible case !", search_id);
758 return XCAM_RETURN_ERROR_PARAM;
759 }
760 }
761
762 expParams = rit->second;
763 if (expParams.ptr()) {
764 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
765 LOG1_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d search_id: %d, get-last %d, a-gain: %d, time: %d\n",
766 __FUNCTION__, mCamPhyId, search_id, rit->first,
767 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
768 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time);
769 } else {
770 LOG1_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d search_id: %d, get-last %d, lexp: 0x%x-0x%x, mexp: 0x%x-0x%x, sexp: 0x%x-0x%x\n",
771 __FUNCTION__, mCamPhyId, search_id, rit->first,
772 expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
773 expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
774 expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
775 expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
776 expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global,
777 expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time);
778 }
779 } else {
780 LOGE_CAMHW_SUBM(SENSOR_SUBM, "%s: expParams is invalid!", __FUNCTION__);
781 }
782 ret = XCAM_RETURN_BYPASS;
783 } else {
784 expParams = it->second;
785 if (expParams.ptr()) {
786 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
787 LOG1_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d search_id: %d, get-find %d, a-gain: %d, time: %d\n",
788 __FUNCTION__, mCamPhyId, search_id, it->first,
789 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
790 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time);
791 } else {
792 LOG1_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d search_id: %d, get-find %d, lexp: 0x%x-0x%x, mexp: 0x%x-0x%x, sexp: 0x%x-0x%x\n",
793 __FUNCTION__, mCamPhyId, search_id, it->first,
794 expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
795 expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
796 expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
797 expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
798 expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global,
799 expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time);
800 }
801 } else {
802 LOGE_CAMHW_SUBM(SENSOR_SUBM, "%s: expParams is invalid!", __FUNCTION__);
803 }
804 ret = XCAM_RETURN_NO_ERROR;
805 }
806
807 EXIT_CAMHW_FUNCTION();
808
809 return ret;
810 }
811
812 XCamReturn
getSensorModeData(const char * sns_ent_name,rk_aiq_exposure_sensor_descriptor & sns_des)813 SensorHw::getSensorModeData(const char* sns_ent_name,
814 rk_aiq_exposure_sensor_descriptor& sns_des)
815 {
816 rk_aiq_exposure_sensor_descriptor sensor_desc;
817
818 get_sensor_descriptor (&sensor_desc);
819
820 _sns_entity_name = sns_ent_name;
821 sns_des.coarse_integration_time_min =
822 sensor_desc.coarse_integration_time_min;
823 sns_des.coarse_integration_time_max_margin =
824 sensor_desc.coarse_integration_time_max_margin;
825 sns_des.fine_integration_time_min =
826 sensor_desc.fine_integration_time_min;
827 sns_des.fine_integration_time_max_margin =
828 sensor_desc.fine_integration_time_max_margin;
829
830 sns_des.frame_length_lines = sensor_desc.line_periods_per_field;
831 sns_des.line_length_pck = sensor_desc.pixel_periods_per_line;
832 sns_des.vt_pix_clk_freq_hz = sensor_desc.pixel_clock_freq_mhz * 1000000;
833 sns_des.pixel_clock_freq_mhz = sensor_desc.pixel_clock_freq_mhz/* * 1000000 */;
834
835 //add nr_switch
836 sns_des.nr_switch = sensor_desc.nr_switch;
837
838 sns_des.sensor_output_width = sensor_desc.sensor_output_width;
839 sns_des.sensor_output_height = sensor_desc.sensor_output_height;
840 sns_des.sensor_pixelformat = sensor_desc.sensor_pixelformat;
841
842 LOGD_CAMHW_SUBM(SENSOR_SUBM, "vts-hts-pclk: %d-%d-%d-%f, rect: [%dx%d]\n",
843 sns_des.frame_length_lines,
844 sns_des.line_length_pck,
845 sns_des.vt_pix_clk_freq_hz,
846 sns_des.pixel_clock_freq_mhz,
847 sns_des.sensor_output_width,
848 sns_des.sensor_output_height);
849
850 return XCAM_RETURN_NO_ERROR;
851 }
852
853 // sof_id: the sof_id which new exp is set
854 XCamReturn
split_locked(SmartPtr<RkAiqSensorExpParamsProxy> & exp_param,uint32_t sof_id)855 SensorHw::split_locked(SmartPtr<RkAiqSensorExpParamsProxy>& exp_param, uint32_t sof_id) {
856 ENTER_CAMHW_FUNCTION();
857 XCamReturn ret = XCAM_RETURN_NO_ERROR;
858
859 uint32_t dst_id = 0, max_dst_id = 0;
860 // custom mode
861 RKAiqExpI2cParam_t* i2c_param = exp_param->data()->exp_i2c_params;
862 if (i2c_param->bValid) {
863 unsigned int num_regs = i2c_param->nNumRegs;
864 LOG1_CAMHW_SUBM(SENSOR_SUBM, "i2c_exp_res num_regs %d!", num_regs);
865 for (uint32_t i = 0; i < num_regs; i++) {
866 dst_id = sof_id + i2c_param->DelayFrames[i];
867 LOG1_CAMHW_SUBM(SENSOR_SUBM, "i2c_exp_res delay: %d, dst_id %d",
868 i2c_param->DelayFrames[i], dst_id);
869 if (max_dst_id < dst_id)
870 max_dst_id = dst_id;
871 if (_pending_spilt_map.count(dst_id) == 0) {
872 pending_split_exps_t new_exps;
873 memset(&new_exps, 0, sizeof(pending_split_exps_t));
874 new_exps.is_rk_exp_res = false;
875 new_exps.i2c_exp_res.RegAddr[0] = i2c_param->RegAddr[i];
876 new_exps.i2c_exp_res.RegValue[0] = i2c_param->RegValue[i];
877 new_exps.i2c_exp_res.AddrByteNum[0] = i2c_param->AddrByteNum[i];
878 new_exps.i2c_exp_res.ValueByteNum[0] = i2c_param->ValueByteNum[i];
879 new_exps.i2c_exp_res.nNumRegs = 1;
880 _pending_spilt_map[dst_id] = new_exps;
881 } else {
882 pending_split_exps_t* tmp = &_pending_spilt_map[dst_id];
883 unsigned int num_regs = tmp->i2c_exp_res.nNumRegs;
884 if (num_regs >= MAX_I2CDATA_LEN) {
885 LOGE_CAMHW_SUBM(SENSOR_SUBM, "i2c_exp_res array overflow for frame %d!", dst_id);
886 return XCAM_RETURN_ERROR_FAILED;
887 }
888 tmp->i2c_exp_res.RegAddr[num_regs] = i2c_param->RegAddr[i];
889 tmp->i2c_exp_res.RegValue[num_regs] = i2c_param->RegValue[i];
890 tmp->i2c_exp_res.AddrByteNum[num_regs] = i2c_param->AddrByteNum[i];
891 tmp->i2c_exp_res.ValueByteNum[num_regs] = i2c_param->ValueByteNum[i];
892 tmp->i2c_exp_res.nNumRegs++;
893 }
894 }
895
896 if (max_dst_id < sof_id)
897 max_dst_id = sof_id + 1;
898
899 _effecting_exp_map[max_dst_id + 1] = exp_param;
900
901 LOGD_CAMHW_SUBM(SENSOR_SUBM,"cid: %d, num_reg:%d, efid:%d, isp_dgain:%0.3f \n",
902 num_regs, mCamPhyId, max_dst_id + 1,
903 exp_param->data()->aecExpInfo.LinearExp.exp_real_params.isp_dgain);
904 } else {
905 RKAiqAecExpInfo_t* exp_info = &exp_param->data()->aecExpInfo;
906
907 uint32_t dst_time_id = sof_id;
908 uint32_t dst_gain_id = sof_id + _time_delay - _gain_delay;
909 uint32_t dst_dcg_id = sof_id + _time_delay - _dcg_gain_mode_delay;
910
911 pending_split_exps_t new_exps;
912 pending_split_exps_t* p_new_exps = NULL;
913 bool is_id_exist = true;
914 max_dst_id = sof_id + _time_delay;
915
916 struct {
917 uint32_t dst_id;
918 uint32_t type;
919 } update_exps[3] = {
920 {dst_time_id, RK_EXP_UPDATE_TIME},
921 {dst_gain_id, RK_EXP_UPDATE_GAIN},
922 {dst_dcg_id, RK_EXP_UPDATE_DCG}
923 };
924
925 for (auto& update_exp : update_exps) {
926 dst_id = update_exp.dst_id;
927 pending_split_exps_t* p_new_exps = &new_exps;
928
929 if (_pending_spilt_map.count(dst_id) == 0) {
930 memset(p_new_exps, 0, sizeof(pending_split_exps_t));
931 is_id_exist = false;
932 } else {
933 p_new_exps = &_pending_spilt_map[dst_id];
934 is_id_exist = true;
935 }
936
937 p_new_exps->is_rk_exp_res = true;
938 p_new_exps->rk_exp_res.update_bits |= 1 << update_exp.type;
939 p_new_exps->rk_exp_res.line_length_pixels =
940 exp_info->line_length_pixels;
941 p_new_exps->rk_exp_res.frame_length_lines =
942 exp_info->frame_length_lines;
943 p_new_exps->rk_exp_res.pixel_clock_freq_mhz =
944 exp_info->pixel_clock_freq_mhz;
945
946 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
947 if (update_exp.type == RK_EXP_UPDATE_TIME) {
948 p_new_exps->rk_exp_res.sensor_params[0].coarse_integration_time =
949 exp_info->LinearExp.exp_sensor_params.coarse_integration_time;
950 p_new_exps->rk_exp_res.sensor_params[0].fine_integration_time =
951 exp_info->LinearExp.exp_sensor_params.fine_integration_time;
952 } else if (update_exp.type == RK_EXP_UPDATE_GAIN) {
953 p_new_exps->rk_exp_res.sensor_params[0].analog_gain_code_global =
954 exp_info->LinearExp.exp_sensor_params.analog_gain_code_global;
955 p_new_exps->rk_exp_res.sensor_params[0].digital_gain_global =
956 exp_info->LinearExp.exp_sensor_params.digital_gain_global;
957 } else if (update_exp.type == RK_EXP_UPDATE_DCG) {
958 p_new_exps->rk_exp_res.dcg_mode[0] =
959 exp_info->LinearExp.exp_real_params.dcg_mode;
960 } else {
961 LOGE_CAMHW_SUBM(SENSOR_SUBM, "wrong exposure params type %d!", update_exp.type);
962 return XCAM_RETURN_ERROR_FAILED;
963 }
964 } else {
965 if (update_exp.type == RK_EXP_UPDATE_TIME) {
966 p_new_exps->rk_exp_res.sensor_params[0].coarse_integration_time =
967 exp_info->HdrExp[0].exp_sensor_params.coarse_integration_time;
968 p_new_exps->rk_exp_res.sensor_params[0].fine_integration_time =
969 exp_info->HdrExp[0].exp_sensor_params.fine_integration_time;
970
971 p_new_exps->rk_exp_res.sensor_params[1].coarse_integration_time =
972 exp_info->HdrExp[1].exp_sensor_params.coarse_integration_time;
973 p_new_exps->rk_exp_res.sensor_params[1].fine_integration_time =
974 exp_info->HdrExp[1].exp_sensor_params.fine_integration_time;
975
976 p_new_exps->rk_exp_res.sensor_params[2].coarse_integration_time =
977 exp_info->HdrExp[2].exp_sensor_params.coarse_integration_time;
978 p_new_exps->rk_exp_res.sensor_params[2].fine_integration_time =
979 exp_info->HdrExp[2].exp_sensor_params.fine_integration_time;
980 } else if (update_exp.type == RK_EXP_UPDATE_GAIN) {
981 p_new_exps->rk_exp_res.sensor_params[0].analog_gain_code_global =
982 exp_info->HdrExp[0].exp_sensor_params.analog_gain_code_global;
983 p_new_exps->rk_exp_res.sensor_params[0].digital_gain_global =
984 exp_info->HdrExp[0].exp_sensor_params.digital_gain_global;
985
986 p_new_exps->rk_exp_res.sensor_params[1].analog_gain_code_global =
987 exp_info->HdrExp[1].exp_sensor_params.analog_gain_code_global;
988 p_new_exps->rk_exp_res.sensor_params[1].digital_gain_global =
989 exp_info->HdrExp[1].exp_sensor_params.digital_gain_global;
990
991 p_new_exps->rk_exp_res.sensor_params[2].analog_gain_code_global =
992 exp_info->HdrExp[2].exp_sensor_params.analog_gain_code_global;
993 p_new_exps->rk_exp_res.sensor_params[2].digital_gain_global =
994 exp_info->HdrExp[2].exp_sensor_params.digital_gain_global;
995 } else if (update_exp.type == RK_EXP_UPDATE_DCG) {
996 p_new_exps->rk_exp_res.dcg_mode[0] =
997 exp_info->HdrExp[0].exp_real_params.dcg_mode;
998 p_new_exps->rk_exp_res.dcg_mode[1] =
999 exp_info->HdrExp[1].exp_real_params.dcg_mode;
1000 p_new_exps->rk_exp_res.dcg_mode[2] =
1001 exp_info->HdrExp[2].exp_real_params.dcg_mode;
1002 } else {
1003 LOGE_CAMHW_SUBM(SENSOR_SUBM, "wrong exposure params type %d!", update_exp.type);
1004 return XCAM_RETURN_ERROR_FAILED;
1005 }
1006 }
1007
1008 if (!is_id_exist)
1009 _pending_spilt_map[dst_id] = *p_new_exps;
1010
1011 }
1012 _effecting_exp_map[max_dst_id] = exp_param;
1013 }
1014
1015 EXIT_CAMHW_FUNCTION();
1016 return ret;
1017 }
1018
1019 XCamReturn
handle_sof(int64_t time,uint32_t frameid)1020 SensorHw::handle_sof(int64_t time, uint32_t frameid)
1021 {
1022 ENTER_CAMHW_FUNCTION();
1023 int effecting_frame_id = 0;
1024 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1025
1026 // TODO: only i2c exps using new handler now
1027 if (_is_i2c_exp) {
1028 return handle_sof_internal(time, frameid);
1029 }
1030
1031 _mutex.lock();
1032 if (_frame_sequence != (uint32_t)(-1) && frameid - _frame_sequence > 1)
1033 LOGE_CAMHW_SUBM(SENSOR_SUBM, "!!!!frame losed,last frameid:%u,current farmeid:%u!!!!\n", _frame_sequence, frameid);
1034
1035 _frame_sequence = frameid;
1036 LOGV_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d frameid=%u, exp_list size=%d, gain_list size=%d",
1037 __FUNCTION__, mCamPhyId, frameid, _exp_list.size(), _delayed_gain_list.size());
1038
1039 SmartPtr<RkAiqSensorExpParamsProxy> exp_time = nullptr;
1040 SmartPtr<RkAiqSensorExpParamsProxy> exp_gain = nullptr;
1041 SmartPtr<RkAiqSensorExpParamsProxy> dcg_gain_mode = nullptr;
1042 bool set_time = false, set_gain = false, set_dcg_gain_mode = false;
1043
1044 while (_effecting_exp_map.size() > 10)
1045 _effecting_exp_map.erase(_effecting_exp_map.begin());
1046
1047 if(!_exp_list.empty()) {
1048 exp_time = _last_exp_time = _exp_list.front().first;
1049 set_time = true;
1050 _exp_list.pop_front();
1051 } else {
1052 exp_time = _last_exp_time;
1053 }
1054
1055 if(!_delayed_gain_list.empty()) {
1056 exp_gain = _last_exp_gain = _delayed_gain_list.front();
1057 set_gain = true;
1058 _delayed_gain_list.pop_front();
1059 } else {
1060 exp_gain = _last_exp_gain;
1061 }
1062
1063 if(!_delayed_dcg_gain_mode_list.empty()) {
1064 dcg_gain_mode = _last_dcg_gain_mode = _delayed_dcg_gain_mode_list.front();
1065 set_dcg_gain_mode = true;
1066 _delayed_dcg_gain_mode_list.pop_front();
1067 } else {
1068 dcg_gain_mode = _last_dcg_gain_mode;
1069 }
1070 // update flip, skip _frame_sequence
1071 if (_update_mirror_flip) {
1072 _set_mirror_flip();
1073 _update_mirror_flip = false;
1074 }
1075
1076 _mutex.unlock();
1077 LOGD_CAMHW_SUBM(SENSOR_SUBM, "%s: cam%d working_mode=%d,frameid=%u, status: set_time=%d,set_gain=%d\n",
1078 __FUNCTION__, mCamPhyId, _working_mode, frameid, set_time, set_gain);
1079
1080 if (set_time || set_gain || set_dcg_gain_mode) {
1081 RKAiqAecExpInfo_t *ptr_new_exp = NULL, new_exp;
1082 if (_dcg_gain_mode_delayed) {
1083 // _gain_delayed should be false
1084 composeExpParam(&exp_time->data()->aecExpInfo,
1085 &exp_time->data()->aecExpInfo,
1086 &dcg_gain_mode->data()->aecExpInfo,
1087 &new_exp);
1088 ptr_new_exp = &new_exp;
1089 } else {
1090 if (_gain_delayed) {
1091 if (_dcg_gain_mode_with_time)
1092 dcg_gain_mode = exp_time;
1093 else
1094 dcg_gain_mode = exp_gain;
1095 composeExpParam(&exp_time->data()->aecExpInfo,
1096 &exp_gain->data()->aecExpInfo,
1097 &dcg_gain_mode->data()->aecExpInfo,
1098 &new_exp);
1099 ptr_new_exp = &new_exp;
1100 } else {
1101 ptr_new_exp = &exp_time->data()->aecExpInfo;
1102 }
1103 }
1104
1105 if(_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
1106 ret = setLinearSensorExposure(ptr_new_exp);
1107 } else {
1108 ret = setHdrSensorExposure(ptr_new_exp);
1109 }
1110
1111 setSensorDpcc(&exp_time->data()->SensorDpccInfo);
1112 }
1113
1114 if (ret != XCAM_RETURN_NO_ERROR) {
1115 LOGE_CAMHW_SUBM(SENSOR_SUBM, "%s: sof_id[%u]: set exposure failed!!!\n",
1116 __FUNCTION__,
1117 frameid);
1118 }
1119
1120 if(set_time) {
1121 _mutex.lock();
1122
1123 if(_gain_delayed) {
1124 _delayed_gain_list.push_back(exp_time);
1125 }
1126
1127 if(_dcg_gain_mode_delayed) {
1128 _delayed_dcg_gain_mode_list.push_back(exp_time);
1129 }
1130 effecting_frame_id = frameid + _time_delay;
1131 _effecting_exp_map[effecting_frame_id] = exp_time;
1132
1133 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
1134 LOGV_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d sof_id[%d], _effecting_exp_map: add %d, a-gain: %d, time: %d, snr: %d\n",
1135 __FUNCTION__, mCamPhyId, frameid, effecting_frame_id,
1136 exp_time->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
1137 exp_time->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time,
1138 exp_time->data()->aecExpInfo.CISFeature.SNR);
1139 } else {
1140 LOGV_CAMHW_SUBM(SENSOR_SUBM, "%s:cam%d sof_id[%d], _effecting_exp_map: add %d, lexp: 0x%x-0x%x, mexp: 0x%x-0x%x, sexp: 0x%x-0x%x\n",
1141 __FUNCTION__, mCamPhyId, frameid, effecting_frame_id,
1142 exp_time->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
1143 exp_time->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
1144 exp_time->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
1145 exp_time->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
1146 exp_time->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global,
1147 exp_time->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time);
1148 }
1149
1150 _mutex.unlock();
1151 }
1152
1153 EXIT_CAMHW_FUNCTION();
1154 return ret;
1155 }
1156
1157 XCamReturn
handle_sof_internal(int64_t time,uint32_t frameid)1158 SensorHw::handle_sof_internal(int64_t time, uint32_t frameid)
1159 {
1160 ENTER_CAMHW_FUNCTION();
1161 int effecting_frame_id = 0;
1162 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1163
1164 _mutex.lock();
1165 if (_frame_sequence != (uint32_t)(-1) && (frameid - _frame_sequence > 1))
1166 LOGE_CAMHW_SUBM(SENSOR_SUBM,
1167 "cam%d !!!!frame losed,last frameid:%u,current farmeid:%u!!!!\n", mCamPhyId,
1168 _frame_sequence, frameid);
1169
1170 _frame_sequence = frameid;
1171 LOGD_CAMHW_SUBM(SENSOR_SUBM, "%s: cam%d frameid=%u, exp_list size=%d, gain_list size=%d",
1172 __FUNCTION__, mCamPhyId, frameid, _exp_list.size(), _delayed_gain_list.size());
1173
1174 SmartPtr<RkAiqSensorExpParamsProxy> new_exp = nullptr;
1175
1176 while (_effecting_exp_map.size() > 10)
1177 _effecting_exp_map.erase(_effecting_exp_map.begin());
1178
1179 if(!_exp_list.empty()) {
1180 new_exp = _exp_list.front().first;
1181 _exp_list.pop_front();
1182 split_locked(new_exp, frameid);
1183 }
1184
1185 // update flip, skip _frame_sequence
1186 if (_update_mirror_flip && !_is_i2c_exp) {
1187 _set_mirror_flip();
1188 _update_mirror_flip = false;
1189 }
1190
1191 bool set_new_exp = false;
1192 pending_split_exps_t pending_exp;
1193
1194 std::map<uint32_t, pending_split_exps_t>::iterator it, it_end;
1195 it = it_end = _pending_spilt_map.begin();
1196 for (; it != _pending_spilt_map.end(); it++) {
1197 if (it->first <= (uint32_t)frameid) {
1198 pending_exp = _pending_spilt_map[frameid];
1199 _mutex.unlock();
1200
1201 if (pending_exp.is_rk_exp_res) {
1202 if(_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
1203 ret = setLinearSensorExposure(&pending_exp);
1204 } else {
1205 ret = setHdrSensorExposure(&pending_exp);
1206 }
1207 } else {
1208 setI2cDAta(&pending_exp);
1209 }
1210 it_end = it;
1211 it_end++;
1212 _mutex.lock();
1213 } else {
1214 break;
1215 }
1216 }
1217
1218 _pending_spilt_map.erase(_pending_spilt_map.begin(), it_end);
1219 if (_pending_spilt_map.size() > 100) {
1220 LOGW_CAMHW_SUBM(SENSOR_SUBM, "cam%d _pending_spilt_map size %d > 100, may be error",
1221 mCamPhyId, _pending_spilt_map.size());
1222 }
1223 _mutex.unlock();
1224
1225 if (!_is_i2c_exp && new_exp.ptr())
1226 setSensorDpcc(&new_exp->data()->SensorDpccInfo);
1227
1228 EXIT_CAMHW_FUNCTION();
1229 return ret;
1230 }
1231
1232 uint32_t
get_v4l2_pixelformat(uint32_t pixelcode)1233 BaseSensorHw::get_v4l2_pixelformat(uint32_t pixelcode)
1234 {
1235 uint32_t pixelformat = -1;
1236
1237 switch (pixelcode) {
1238 case MEDIA_BUS_FMT_SRGGB8_1X8:
1239 pixelformat = V4L2_PIX_FMT_SRGGB8;
1240 break;
1241 case MEDIA_BUS_FMT_SBGGR8_1X8:
1242 pixelformat = V4L2_PIX_FMT_SBGGR8;
1243 break;
1244 case MEDIA_BUS_FMT_SGBRG8_1X8:
1245 pixelformat = V4L2_PIX_FMT_SGBRG8;
1246 break;
1247 case MEDIA_BUS_FMT_SGRBG8_1X8:
1248 pixelformat = V4L2_PIX_FMT_SGRBG8;
1249 break;
1250 case MEDIA_BUS_FMT_SBGGR10_1X10:
1251 pixelformat = V4L2_PIX_FMT_SBGGR10;
1252 break;
1253 case MEDIA_BUS_FMT_SRGGB10_1X10:
1254 pixelformat = V4L2_PIX_FMT_SRGGB10;
1255 break;
1256 case MEDIA_BUS_FMT_SGBRG10_1X10:
1257 pixelformat = V4L2_PIX_FMT_SGBRG10;
1258 break;
1259 case MEDIA_BUS_FMT_SGRBG10_1X10:
1260 pixelformat = V4L2_PIX_FMT_SGRBG10;
1261 break;
1262 case MEDIA_BUS_FMT_SRGGB12_1X12:
1263 pixelformat = V4L2_PIX_FMT_SRGGB12;
1264 break;
1265 case MEDIA_BUS_FMT_SBGGR12_1X12:
1266 pixelformat = V4L2_PIX_FMT_SBGGR12;
1267 break;
1268 case MEDIA_BUS_FMT_SGBRG12_1X12:
1269 pixelformat = V4L2_PIX_FMT_SGBRG12;
1270 break;
1271 case MEDIA_BUS_FMT_SGRBG12_1X12:
1272 pixelformat = V4L2_PIX_FMT_SGRBG12;
1273 break;
1274 case MEDIA_BUS_FMT_Y8_1X8:
1275 pixelformat = V4L2_PIX_FMT_GREY;
1276 break;
1277 case MEDIA_BUS_FMT_Y10_1X10:
1278 pixelformat = V4L2_PIX_FMT_Y10;
1279 break;
1280 case MEDIA_BUS_FMT_Y12_1X12:
1281 pixelformat = V4L2_PIX_FMT_Y12;
1282 break;
1283 default:
1284 //TODO add other
1285 LOGD_CAMHW_SUBM(SENSOR_SUBM, "%s no support pixelcode:0x%x\n",
1286 __func__, pixelcode);
1287 }
1288 return pixelformat;
1289 }
1290
1291 XCamReturn
set_sync_mode(uint32_t mode)1292 SensorHw::set_sync_mode(uint32_t mode)
1293 {
1294 if (io_control(RKMODULE_SET_SYNC_MODE, &mode) < 0) {
1295 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set sync mode %d", mode);
1296 //return XCAM_RETURN_ERROR_IOCTL;
1297 }
1298
1299 LOGI_CAMHW_SUBM(SENSOR_SUBM, "set sync mode %d", mode);
1300
1301 return XCAM_RETURN_NO_ERROR;
1302 }
1303
1304 XCamReturn
set_working_mode(int mode)1305 SensorHw::set_working_mode(int mode)
1306 {
1307 rkmodule_hdr_cfg hdr_cfg;
1308 __u32 hdr_mode = NO_HDR;
1309
1310 xcam_mem_clear(hdr_cfg);
1311 if (mode == RK_AIQ_WORKING_MODE_NORMAL) {
1312 hdr_mode = NO_HDR;
1313 } else if (mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
1314 mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
1315 hdr_mode = HDR_X2;
1316 } else if (mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
1317 mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
1318 hdr_mode = HDR_X3;
1319 } else {
1320 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set hdr mode to %d", mode);
1321 return XCAM_RETURN_ERROR_FAILED;
1322 }
1323 hdr_cfg.hdr_mode = hdr_mode;
1324 if (io_control(RKMODULE_SET_HDR_CFG, &hdr_cfg) < 0) {
1325 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set hdr mode %d", hdr_mode);
1326 //return XCAM_RETURN_ERROR_IOCTL;
1327 }
1328
1329 _working_mode = mode;
1330
1331 LOGD_CAMHW_SUBM(SENSOR_SUBM, "%s _working_mode: %d\n",
1332 __func__, _working_mode);
1333
1334 return XCAM_RETURN_NO_ERROR;
1335 }
1336
1337 XCamReturn
_set_mirror_flip()1338 SensorHw::_set_mirror_flip() {
1339 struct v4l2_control ctrl;
1340
1341 memset(&ctrl, 0, sizeof(ctrl));
1342 ctrl.id = V4L2_CID_HFLIP;
1343 ctrl.value = _mirror ? 1 : 0;
1344 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
1345 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set hflip (val: %d)", ctrl.value);
1346 return XCAM_RETURN_ERROR_IOCTL;
1347 }
1348
1349 ctrl.id = V4L2_CID_VFLIP;
1350 ctrl.value = _flip ? 1 : 0;
1351 if (io_control(VIDIOC_S_CTRL, &ctrl) < 0) {
1352 LOGE_CAMHW_SUBM(SENSOR_SUBM, "failed to set vflip (val: %d)", ctrl.value);
1353 }
1354
1355 LOGD_CAMHW_SUBM(SENSOR_SUBM, "set mirror %d, flip %d", _mirror, _flip);
1356
1357 return XCAM_RETURN_NO_ERROR;
1358
1359 }
1360
1361 XCamReturn
set_mirror_flip(bool mirror,bool flip,int32_t & skip_frame_sequence)1362 SensorHw::set_mirror_flip(bool mirror, bool flip, int32_t& skip_frame_sequence)
1363 {
1364 _mutex.lock();
1365
1366 if (!is_activated()) {
1367 _flip = flip;
1368 _mirror = mirror;
1369 _set_mirror_flip();
1370 goto end;
1371 }
1372
1373 if (_mirror != mirror || _flip != flip) {
1374 _flip = flip;
1375 _mirror = mirror;
1376 // will be set at _frame_sequence + 1
1377 _update_mirror_flip = true;
1378 // skip pre and current frame
1379 skip_frame_sequence = _frame_sequence;
1380 if (skip_frame_sequence < 0)
1381 skip_frame_sequence = 0;
1382 } else
1383 skip_frame_sequence = -1;
1384
1385 end:
1386 _mutex.unlock();
1387
1388 return XCAM_RETURN_NO_ERROR;
1389 }
1390
1391 XCamReturn
get_mirror_flip(bool & mirror,bool & flip)1392 SensorHw::get_mirror_flip(bool& mirror, bool& flip)
1393 {
1394 struct v4l2_control ctrl;
1395
1396 memset(&ctrl, 0, sizeof(ctrl));
1397 ctrl.id = V4L2_CID_HFLIP;
1398 if (io_control(VIDIOC_G_CTRL, &ctrl) < 0) {
1399 LOGW_CAMHW_SUBM(SENSOR_SUBM, "failed to set hflip (val: %d)", ctrl.value);
1400 return XCAM_RETURN_ERROR_IOCTL;
1401 }
1402
1403 mirror = ctrl.value ? true : false;
1404
1405 ctrl.id = V4L2_CID_VFLIP;
1406 if (io_control(VIDIOC_G_CTRL, &ctrl) < 0) {
1407 LOGW_CAMHW_SUBM(SENSOR_SUBM, "failed to set vflip (val: %d)", ctrl.value);
1408 return XCAM_RETURN_ERROR_IOCTL;
1409 }
1410
1411 flip = ctrl.value ? true : false;
1412
1413 return XCAM_RETURN_NO_ERROR;
1414 }
1415
1416 XCamReturn
set_exp_delay_info(int time_delay,int gain_delay,int hcg_lcg_mode_delay)1417 SensorHw::set_exp_delay_info(int time_delay, int gain_delay, int hcg_lcg_mode_delay)
1418 {
1419 _time_delay = time_delay;
1420 _gain_delay = gain_delay;
1421 _dcg_gain_mode_delay = hcg_lcg_mode_delay;
1422
1423 LOG1_CAMHW_SUBM(SENSOR_SUBM, "%s _time_delay: %d, _gain_delay:%d, _dcg_delay:%d\n",
1424 __func__, _time_delay, _gain_delay, _dcg_gain_mode_delay);
1425 if (_time_delay > _gain_delay) {
1426 _gain_delayed = true;
1427 } else if (_time_delay == _gain_delay) {
1428 _gain_delayed = false;
1429 } else {
1430 LOGE_CAMHW_SUBM(SENSOR_SUBM, "Not support gain's delay greater than time's delay!");
1431 return XCAM_RETURN_ERROR_PARAM;
1432 }
1433
1434 if (_dcg_gain_mode_delay > time_delay) {
1435 LOGE_CAMHW_SUBM(SENSOR_SUBM, "Not support dcg gain's delay %d, greater than time_delay %d!",
1436 _dcg_gain_mode_delay, time_delay);
1437 return XCAM_RETURN_ERROR_PARAM;
1438 }
1439
1440 if (_dcg_gain_mode_delay > 0 &&
1441 _dcg_gain_mode_delay != time_delay &&
1442 _dcg_gain_mode_delay != _gain_delay) {
1443 _dcg_gain_mode_delayed = true;
1444 } else {
1445 if (_dcg_gain_mode_delay == time_delay)
1446 _dcg_gain_mode_with_time = true;
1447 else
1448 _dcg_gain_mode_with_time = false;
1449 }
1450
1451 return XCAM_RETURN_NO_ERROR;
1452 }
1453
1454 XCamReturn
start(bool prepared)1455 SensorHw::start(bool prepared)
1456 {
1457 ENTER_CAMHW_FUNCTION();
1458 V4l2SubDevice::start(prepared);
1459 EXIT_CAMHW_FUNCTION();
1460 return XCAM_RETURN_NO_ERROR;
1461 }
1462
1463 XCamReturn
stop()1464 SensorHw::stop()
1465 {
1466 ENTER_CAMHW_FUNCTION();
1467 SmartLock locker (_mutex);
1468 _exp_list.clear();
1469 _last_exp_time = nullptr;
1470 _last_exp_gain = nullptr;
1471 _last_dcg_gain_mode = nullptr;
1472 _effecting_exp_map.clear();
1473 _delayed_gain_list.clear();
1474 _delayed_dcg_gain_mode_list.clear();
1475 _pending_spilt_map.clear();
1476 _frame_sequence = -1;
1477 _first = true;
1478 set_sync_mode(NO_SYNC_MODE);
1479 V4l2SubDevice::stop();
1480 EXIT_CAMHW_FUNCTION();
1481 return XCAM_RETURN_NO_ERROR;
1482 }
1483
1484 XCamReturn
composeExpParam(RKAiqAecExpInfo_t * timeValid,RKAiqAecExpInfo_t * gainValid,RKAiqAecExpInfo_t * dcgGainModeValid,RKAiqAecExpInfo_t * newExp)1485 SensorHw::composeExpParam
1486 (
1487 RKAiqAecExpInfo_t* timeValid,
1488 RKAiqAecExpInfo_t* gainValid,
1489 RKAiqAecExpInfo_t* dcgGainModeValid,
1490 RKAiqAecExpInfo_t* newExp
1491 )
1492 {
1493 *newExp = *timeValid;
1494 if(_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
1495 newExp->LinearExp.exp_sensor_params.analog_gain_code_global =
1496 gainValid->LinearExp.exp_sensor_params.analog_gain_code_global;
1497 newExp->LinearExp.exp_sensor_params.coarse_integration_time =
1498 timeValid->LinearExp.exp_sensor_params.coarse_integration_time;
1499 newExp->LinearExp.exp_real_params.dcg_mode =
1500 dcgGainModeValid->LinearExp.exp_real_params.dcg_mode;
1501 } else {
1502 newExp->HdrExp[2].exp_sensor_params.analog_gain_code_global =
1503 gainValid->HdrExp[2].exp_sensor_params.analog_gain_code_global;
1504 newExp->HdrExp[2].exp_sensor_params.coarse_integration_time =
1505 timeValid->HdrExp[2].exp_sensor_params.coarse_integration_time;
1506 newExp->HdrExp[2].exp_real_params.dcg_mode =
1507 dcgGainModeValid->HdrExp[2].exp_real_params.dcg_mode;
1508 newExp->HdrExp[1].exp_sensor_params.analog_gain_code_global =
1509 gainValid->HdrExp[1].exp_sensor_params.analog_gain_code_global;
1510 newExp->HdrExp[1].exp_sensor_params.coarse_integration_time =
1511 timeValid->HdrExp[1].exp_sensor_params.coarse_integration_time;
1512 newExp->HdrExp[1].exp_real_params.dcg_mode =
1513 dcgGainModeValid->HdrExp[1].exp_real_params.dcg_mode;
1514 newExp->HdrExp[0].exp_sensor_params.analog_gain_code_global =
1515 gainValid->HdrExp[0].exp_sensor_params.analog_gain_code_global;
1516 newExp->HdrExp[0].exp_sensor_params.coarse_integration_time =
1517 timeValid->HdrExp[0].exp_sensor_params.coarse_integration_time;
1518 newExp->HdrExp[0].exp_real_params.dcg_mode =
1519 dcgGainModeValid->HdrExp[0].exp_real_params.dcg_mode;
1520 }
1521 return XCAM_RETURN_NO_ERROR;
1522 }
1523
1524 XCamReturn
set_offline_effecting_exp_map(uint32_t sequence,rk_aiq_frame_info_t * offline_finfo)1525 SensorHw::set_offline_effecting_exp_map(uint32_t sequence, rk_aiq_frame_info_t *offline_finfo)
1526 {
1527 while (_effecting_exp_map.size() > 4)
1528 _effecting_exp_map.erase(_effecting_exp_map.begin());
1529
1530 SmartPtr<RkAiqSensorExpParamsProxy> exp_param_prx = _expParamsPool->get_item();
1531 rk_aiq_frame_info_t off_finfo;
1532 memcpy(&off_finfo, offline_finfo, sizeof(off_finfo));
1533 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global = (uint32_t)off_finfo.normal_gain_reg;
1534 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time = (uint32_t)off_finfo.normal_exp_reg;
1535 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.analog_gain = (float)off_finfo.normal_gain;
1536 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.integration_time = (float)off_finfo.normal_exp;
1537 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.digital_gain_global = 1;
1538 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.isp_digital_gain = 1;
1539 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.digital_gain = 1.0f;
1540 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.isp_dgain = 1.0f;
1541
1542 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global = (uint32_t)off_finfo.hdr_gain_l;
1543 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time = (uint32_t)off_finfo.hdr_exp_l;
1544 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain = (float)off_finfo.hdr_gain_l_reg;
1545 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time = (float)off_finfo.hdr_exp_l_reg;
1546 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.digital_gain_global = 1;
1547 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.isp_digital_gain = 1;
1548 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.digital_gain = 1.0f;
1549 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.isp_dgain = 1.0f;
1550
1551 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global = (uint32_t)off_finfo.hdr_gain_m;
1552 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time = (uint32_t)off_finfo.hdr_exp_m;
1553 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain = (float)off_finfo.hdr_gain_m_reg;
1554 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time = (float)off_finfo.hdr_exp_m_reg;
1555 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.digital_gain_global = 1;
1556 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.isp_digital_gain = 1;
1557 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.digital_gain = 1.0f;
1558 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.isp_dgain = 1.0f;
1559
1560
1561 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global = (uint32_t)off_finfo.hdr_gain_s;
1562 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time = (uint32_t)off_finfo.hdr_exp_s;
1563 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain = (float)off_finfo.hdr_gain_s_reg;
1564 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time = (float)off_finfo.hdr_exp_s_reg;
1565 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.digital_gain_global = 1;
1566 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.isp_digital_gain = 1;
1567 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.digital_gain = 1.0f;
1568 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.isp_dgain = 1.0f;
1569
1570 _effecting_exp_map[sequence] = exp_param_prx;
1571
1572 return XCAM_RETURN_NO_ERROR;
1573 }
1574
1575 } //namespace RkCam
1576